Attachment #551444 for bug #668036

View | Details | Raw Unified | Return to bug 668036
Collapse All | Expand All

Lines 12-19 else Link Here

(-)a/comm/calendar/lightning/versions.mk (-2 lines)
12	LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(word 1,$(MOZ_PKG_VERSION) $(THUNDERBIRD_VERSION)))	12	LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(word 1,$(MOZ_PKG_VERSION) $(THUNDERBIRD_VERSION)))
13	endif	13	endif
14		14
15	#GDATA_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/providers/gdata/makeversion.py $(LIGHTNING_VERSION))
16
17	# For extensions we require a max version that is compatible across security releases.	15	# For extensions we require a max version that is compatible across security releases.
18	# THUNDERBIRD_MAXVERSION and SEAMONKEY_MAXVERSION is our method for doing that.	16	# THUNDERBIRD_MAXVERSION and SEAMONKEY_MAXVERSION is our method for doing that.
19	# Alpha versions 10.0a1 and 10.0a2 aren't affected	17	# Alpha versions 10.0a1 and 10.0a2 aren't affected




# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

XPI_NAME = gdata-provider
XPI_PKGNAME = gdata-provider-$(GDATA_VERSION).$(AB_CD)
XPI_EM_ID = {a62ef8ec-5fdc-40c2-873c-223b8a6925cc}
XPI_INSTALL_EXTENSION = $(XPI_EM_ID)

ifdef MOZ_SUITE
LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(THUNDERBIRD_VERSION))
else
LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(word 1,$(MOZ_PKG_VERSION) $(THUNDERBIRD_VERSION)))
           -DGDATA_VERSION=$(GDATA_VERSION) \
           $(NULL)

ifeq (cocoa,$(MOZ_WIDGET_TOOLKIT))
# If the macbundle dist dir was already created, sync the gdata provider here to avoid
# the need to make -C objdir/mail/app each time
tools repackage::
	[ -d $(DIST)/$(MOZ_MACBUNDLE_NAME) ] && rsync -a $(FINAL_TARGET)/ $(DIST)/$(MOZ_MACBUNDLE_NAME)/Contents/Resources/extensions/$(XPI_EM_ID) || true
endif

GDATA_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/providers/gdata/makeversion.py $(LIGHTNING_VERSION))
THUNDERBIRD_VERSION := $(shell cat $(commtopsrcdir)/mail/config/version.txt)
SEAMONKEY_VERSION := $(shell cat $(commtopsrcdir)/suite/config/version.txt)

DEFINES += -DSEAMONKEY_VERSION=$(SEAMONKEY_VERSION) \
           -DTHUNDERBIRD_VERSION=$(THUNDERBIRD_VERSION) \
           -DGDATA_VERSION=$(GDATA_VERSION) \
           $(NULL)

include $(moztopsrcdir)/config/rules.mk
include $(commtopsrcdir)/calendar/lightning/versions.mk
include $(commtopsrcdir)/calendar/lightning/lightning-packager.mk

Lines 4-9 Link Here

(-)a/comm/calendar/providers/gdata/moz.build (+4 lines)
4	# file, You can obtain one at http://mozilla.org/MPL/2.0/.	4	# file, You can obtain one at http://mozilla.org/MPL/2.0/.
5		5
6	XPI_NAME = 'gdata-provider'	6	XPI_NAME = 'gdata-provider'
		7	export('XPI_NAME')
7		8
8	FINAL_TARGET_PP_FILES += ['install.rdf']	9	FINAL_TARGET_PP_FILES += ['install.rdf']
9		10
Lines 26-31 EXTRA_COMPONENTS += [ Link Here
26	'components/calGoogleCalendar.manifest',	27	'components/calGoogleCalendar.manifest',
27	]	28	]
28		29
		30	USE_EXTENSION_MANIFEST = True
		31	export('USE_EXTENSION_MANIFEST')
		32
29	JAR_MANIFESTS += ['jar.mn']	33	JAR_MANIFESTS += ['jar.mn']
30		34
31	JS_PREFERENCE_FILES += [	35	JS_PREFERENCE_FILES += [




    });
}

add_task(async function test_migrate_cache() {
    let uriString = "googleapi://xpcshell/?calendar=xpcshell%40example.com";
    let uri = Services.io.newURI(uriString);
    let client = cal.getCalendarManager().createCalendar("gdata", uri);

    });

    // No version, should not reset
    equal(await migrateStorageCache(), false);
    equal(client.getProperty("cache.version"), 3);

    // Check migrate 1 -> 2
    unwrapped.CACHE_DB_VERSION = 2;
    client.setProperty("cache.version", 1);
    equal(await migrateStorageCache(), true);
    equal(client.getProperty("cache.version"), 2);

    // Check migrate 2 -> 3 normal calendar
    unwrapped.CACHE_DB_VERSION = 3;
    client.setProperty("cache.version", 2);
    equal(await migrateStorageCache(), false);

    // Check migrate 2 -> 3 birthday calendar
    unwrapped.CACHE_DB_VERSION = 3;
    uri = "googleapi://xpcshell/?calendar=%23contacts%40group.v.calendar.google.com";
    unwrapped.uri = Services.io.newURI(uri);
    client.setProperty("cache.version", 2);
    equal(await migrateStorageCache(), true);
});

add_test(function test_migrate_uri() {

    run_next_test();
});

add_task(async function test_dateToJSON() {
    function _createDateTime(tzid, offset=0) {
        let offsetFrom = offset <= 0 ? "-0" + (offset - 1) : "+0" + (offset - 1) + "00";
        let offsetTo = "+0" + offset + "00";

    deepEqual(dateToJSON(date), { date: "2015-01-30" });
});

add_task(async function test_JSONToDate() {
    function convert(aEntry, aTimezone="Europe/Berlin") {
        let tzs = cal.getTimezoneService();
        let calendarTz = tzs.getTimezone(aTimezone);

    equal(convert({ dateTime: "2015-01-02T03:04:05+05:00" }), "20150102T030405 in Antarctica/Mawson");
});

add_task(async function test_organizerCN() {
    gServer.events = [];
    let client = await gServer.getClient();
    equal(client.getProperty("organizerCN"), null);
    gServer.resetClient(client);


        end: { dateTime: "2006-06-10T20:00:00+02:00" },
        iCalUID: "go6ijb0b46hlpbu4eeu92njevo@google.com"
    }];
    client = await gServer.getClient();
    equal(client.getProperty("organizerCN"), gServer.creator.displayName);
    gServer.resetClient(client);
});

add_task(async function test_always_readOnly() {
    gServer.events = [{
        kind: "calendar#event",
        etag: "\"2299601498276000\"",

        iCalUID: "go6ijb0b46hlpbu4eeu92njevo@google.com"
    }];
    gServer.calendarListData.accessRole = "freeBusyReader";
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client);
    ok(client.readOnly);
    client.readOnly = false;
    ok(client.readOnly);

    let items = await pclient.getAllItems();
    equal(items.length, 1);
    notEqual(items[0].title, "New Event");
    gServer.resetClient(client);

    gServer.calendarListData.accessRole = "reader";
    client = await gServer.getClient();
    ok(client.readOnly);
    client.readOnly = false;
    ok(client.readOnly);
    gServer.resetClient(client);
});

add_task(async function test_reset_sync() {
    gServer.tasks = [{
        kind: "tasks#task",
        id: "MTEyMDE2MDE5NzE0NjYzMDk4ODI6MDo0MDI1NDg2NjU",

        end: { dateTime: "2006-06-10T20:00:00+02:00" },
        iCalUID: "fepf8uf6n7n04w7feukucs9n8e@google.com"
    }];
    let client = await gServer.getClient();
    let uncached = client.wrappedJSObject.mUncachedCalendar.wrappedJSObject;
    let pclient = cal.async.promisifyCalendar(client);

    let items = await pclient.getAllItems();
    equal(items.length, 4);

    notEqual(client.getProperty("syncToken.events"), "");
    notEqual(client.getProperty("lastUpdated.tasks"), "");

    await uncached.resetSync();
    items = await pclient.getAllItems();
    equal(items.length, 0);

    equal(client.getProperty("syncToken.events"), "");

    gServer.resetClient(client);
});

add_task(async function test_basicItems() {
    gServer.events = [{
        kind: "calendar#event",
        etag: "\"2299601498276000\"",

        }]
    }];

    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client);

    let items = await pclient.getAllItems();
    equal(items.length, 2);

    let event = cal.item.isEvent(items[0]) ? items[0] : items[1];

    gServer.resetClient(client);
});

add_task(async function test_addModifyDeleteItem() {
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    equal(gServer.events.length, 0);
    equal(gServer.tasks.length, 0);

    ].join("\r\n"));

    // Add an event
    let addedEvent = await pclient.adoptItem(event);
    notEqual(addedEvent.id, null);
    equal(addedEvent.organizer.id, "mailto:xpcshell@example.com");

    let items = await pclient.getAllItems();
    equal(items.length, 1);
    equal(items[0].id, addedEvent.id);
    equal(items[0].organizer.id, "mailto:xpcshell@example.com");

    equal(gServer.tasks.length, 0);

    // Add a task
    let addedTask = await pclient.adoptItem(task);
    notEqual(addedTask.id, null);

    items = await pclient.getAllItems();
    equal(items.length, 2);
    equal(items[1].id, addedTask.id);


    let newEvent = items[0].clone();
    newEvent.title = "changed";

    let modifiedEvent = await pclient.modifyItem(newEvent, items[0]);
    equal(modifiedEvent.title, "changed");
    notEqual(modifiedEvent.getProperty("LAST-MODIFIED"), addedEvent.getProperty("LAST-MODIFIED"));
    items = await pclient.getAllItems();
    equal(items.length, 2);
    equal(items[0].title, "changed");
    equal(items[0].id, addedEvent.id);

    let newTask = items[1].clone();
    newTask.title = "changed";

    let modifiedTask = await pclient.modifyItem(newTask, items[1]);
    equal(modifiedTask.title, "changed");
    notEqual(modifiedTask.getProperty("LAST-MODIFIED"), addedTask.getProperty("LAST-MODIFIED"));
    items = await pclient.getAllItems();
    equal(items.length, 2);
    equal(items[1].title, "changed");
    equal(items[1].id, addedTask.id);

    equal(gServer.tasks.length, 1);

    // Delete an event
    await pclient.deleteItem(modifiedEvent);
    items = await pclient.getAllItems();
    equal(items.length, 1);
    equal(gServer.events.length, 0);
    equal(gServer.tasks.length, 1);

    // Delete a task
    await pclient.deleteItem(modifiedTask);
    items = await pclient.getAllItems();
    equal(items.length, 0);
    equal(gServer.events.length, 0);
    equal(gServer.tasks.length, 0);

    gServer.resetClient(client);
});

add_task(async function test_recurring_event() {
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    let event = cal.createEvent([

        "END:VEVENT"
    ].join("\r\n"));

    event = await pclient.addItem(event);
    equal(gServer.events.length, 1);
    equal(gServer.events[0].recurrence.length, 1);
    equal(gServer.events[0].recurrence[0], "RRULE:FREQ=WEEKLY");

    changedOcc.title = "changed";
    event.recurrenceInfo.modifyException(occ, true);

    event = await pclient.modifyItem(changedOcc, occ);
    occ = event.recurrenceInfo.getNextOccurrence(event.startDate);
    equal(occ.title, "changed");
    equal(gServer.events.length, 2);

    gServer.resetClient(client);
});

add_task(async function test_recurring_exception() {
    gServer.syncs = [{
        token: "1",
        events: [{

        }]
    }];

    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    let items = await pclient.getAllItems();
    equal(items.length, 1);

    let exIds = items[0].recurrenceInfo.getExceptionIds({});

    equal(ex.title, "New Event changed");

    client.refresh();
    await gServer.waitForLoad(client);

    items = await pclient.getAllItems();
    equal(items.length, 1);

    exIds = items[0].recurrenceInfo.getExceptionIds({});

    gServer.resetClient(client);
});

add_task(async function test_recurring_cancelled_exception() {
    gServer.syncs = [{
        token: "1",
        events: [{

        }]
    }];

    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    let items = await pclient.getAllItems();
    equal(items.length, 0);

    gServer.resetClient(client);
});

add_task(async function test_import_invitation() {
    Preferences.set("calendar.google.enableAttendees", true);
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    let event = cal.createEvent([
        "BEGIN:VEVENT",

        "END:VEVENT"
    ].join("\r\n"));

    let addedItem = await pclient.adoptItem(event);
    equal(gServer.events.length, 1);
    equal(addedItem.icalString, event.icalString);
    gServer.resetClient(client);
    Preferences.set("calendar.google.enableAttendees", false);
});

add_task(async function test_modify_invitation() {
    Preferences.set("calendar.google.enableAttendees", true);
    let organizer = {
        displayName: "organizer name",

    }];

    // Case #1: User is attendee
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    let items = await pclient.getAllItems();
    equal(items.length, 1);

    let item = items[0];

    att.participationStatus = "ACCEPTED";
    newItem.addAttendee(att);

    await pclient.modifyItem(newItem, items[0]);
    equal(gServer.lastMethod, "PATCH");

    // Case #2: User is organizer

    gServer.events[0].creator = gServer.creator;
    gServer.events[0].attendees = [organizer, attendee];

    client = await gServer.getClient();
    pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    items = await pclient.getAllItems();
    equal(items.length, 1);

    item = items[0];

    org.participationStatus = "TENTATIVE";
    newItem.addAttendee(org);

    modifiedItem = await pclient.modifyItem(newItem, items[0]);
    equal(gServer.lastMethod, "PUT");

    gServer.resetClient(client);
});

add_task(async function test_metadata() {
    gServer.events = [{
        kind: "calendar#event",
        etag: "\"1\"",

        notes: "description"
    }];

    let client = await gServer.getClient();
    let offline = client.wrappedJSObject.mCachedCalendar;
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    // Check initial metadata
    let items = await pclient.getAllItems();
    let meta = getAllMeta(offline);
    let [event, task] = items;
    ok(cal.item.isEvent(event));

    gServer.nextEtag = '"3"';
    let newEvent = event.clone();
    newEvent.title = "changed";
    await pclient.modifyItem(newEvent, event);

    items = await pclient.getAllItems();
    meta = getAllMeta(offline);
    [event, task] = items;
    ok(cal.item.isEvent(event));

    gServer.nextEtag = '"4"';
    let newTask = task.clone();
    newTask.title = "changed";
    await pclient.modifyItem(newTask, task);

    items = await pclient.getAllItems();
    meta = getAllMeta(offline);
    [event, task] = items;
    equal(meta.size, 2);

    equal(meta.get(task.hashId), ['"4"', "MTEyMDE2MDE5NzE0NjYzMDk4ODI6MDo0MDI1NDg2NjU", false].join("\u001A"));

    // Delete an event
    await pclient.deleteItem(event);
    meta = getAllMeta(offline);
    equal(meta.size, 1);
    equal(meta.get(task.hashId), ['"4"', "MTEyMDE2MDE5NzE0NjYzMDk4ODI6MDo0MDI1NDg2NjU", false].join("\u001A"));

    // Delete a task
    await pclient.deleteItem(task);
    meta = getAllMeta(offline);
    equal(meta.size, 0);

    // Add an event
    gServer.nextEtag = '"6"';
    newEvent = await pclient.addItem(event);
    meta = getAllMeta(offline);
    equal(meta.size, 1);
    equal(gServer.events.length, 1);


    // Add a task
    gServer.nextEtag = '"7"';
    newTask = await pclient.addItem(task);
    meta = getAllMeta(offline);
    equal(meta.size, 2);
    equal(gServer.events.length, 1);

    gServer.resetClient(client);
});

add_task(async function test_metadata_recurring() {
    gServer.events = [{
        kind: "calendar#event",
        etag: "\"1\"",

        originalStartTime: { dateTime: "2006-06-17T18:00:00+02:00" }
    }];

    let client = await gServer.getClient();
    let offline = client.wrappedJSObject.mCachedCalendar;
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    let items = await pclient.getAllItems();

    let meta = getAllMeta(offline);
    equal(meta.size, 3);

    let newEx = ex.clone();
    newEx.title = "New Event changed again";
    gServer.nextEtag = '"4"';
    await pclient.modifyItem(newEx, ex);
    meta = getAllMeta(offline);
    equal(meta.size, 3);
    equal(meta.get(newEx.hashId), ['"4"', "go6ijb0b46hlpbu4eeu92njevo_20060610T160000Z", false].join("\u001A"));

    // Deleting an exception should delete the metadata, as it turns into an EXDATE
    let newItem = items[0].clone();
    newItem.recurrenceInfo.removeOccurrenceAt(exIds[0]);
    await pclient.modifyItem(newItem, items[0]);

    meta = getAllMeta(offline);
    equal(meta.size, 2);

    // Deleting the master item should remove all metadata entries
    await pclient.deleteItem(items[0]);
    meta = getAllMeta(offline);
    equal(meta.size, 0);

    gServer.resetClient(client);
});

add_task(async function test_conflict_modify() {
    // TODO task/event conflicts are handled in the same way so I'm going to
    // skip adding tests for tasks here, but it probably wouldn't hurt to
    // create them at some point.

        end: { dateTime: "2006-06-10T20:00:00+02:00" },
        iCalUID: "go6ijb0b46hlpbu4eeu92njevo@google.com"
    }];
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    let item = (await pclient.getAllItems())[0];

    // Case #1: Modified on server, modify locally, overwrite conflict
    MockConflictPrompt.overwrite = true;

    newItem.title = "local change";
    gServer.events[0].etag = '"2"';
    gServer.events[0].summary = "remote change";
    let modifiedItem = await pclient.modifyItem(newItem, item);
    item = (await pclient.getAllItems())[0];
    equal(gServer.events[0].summary, "local change");
    notEqual(gServer.events[0].etag, '"2"');
    equal(item.title, "local change");

    gServer.events[0].etag = '"3"';
    gServer.events[0].summary = "remote change";
    try {
        modifiedItem = await pclient.modifyItem(newItem, item);
        do_throw("Expected modifyItem to be cancelled");
    } catch (e) {
        // Swallow cancelling the request

        }
    }

    await gServer.waitForLoad(client);

    item = (await pclient.getAllItems())[0];
    equal(gServer.events[0].summary, "remote change");
    equal(gServer.events[0].etag, '"3"');
    equal(item.title, "remote change");

    gServer.events[0].etag = '"4"';
    gServer.events[0].summary = "remote change";
    try {
        await pclient.deleteItem(item);
        do_throw("Expected deleteItem to be cancelled");
    } catch (e) {
        // Swallow cancelling the request

        }
    }

    await gServer.waitForLoad(client);

    item = (await pclient.getAllItems())[0];
    equal(gServer.events[0].summary, "remote change");
    equal(gServer.events[0].etag, '"4"');
    equal(item.title, "remote change");

    MockConflictPrompt.overwrite = true;
    gServer.events[0].etag = '"5"';
    gServer.events[0].summary = "remote change";
    await pclient.deleteItem(item);
    item = (await pclient.getAllItems())[0];
    equal(gServer.events.length, 0);

    gServer.resetClient(client);
});

add_task(async function test_conflict_delete() {
    // TODO task/event conflicts are handled in the same way so I'm going to
    // skip adding tests for tasks here, but it probably wouldn't hurt to
    // create them at some point.


    // Load intial event to server
    gServer.events = [coreEvent];
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    let item = (await pclient.getAllItems())[0];

    // Case #1: Deleted on server, modify locally, overwrite conflict
    MockConflictPrompt.overwrite = true;
    gServer.events = [];
    let newItem = item.clone();
    newItem.title = "local change";
    let modifiedItem = await pclient.modifyItem(newItem, item);
    item = (await pclient.getAllItems())[0];
    equal(gServer.events[0].summary, "local change");
    notEqual(gServer.events[0].etag, '"2"');
    equal(item.title, "local change");

    MockConflictPrompt.overwrite = false;
    gServer.events = [];
    try {
        modifiedItem = await pclient.modifyItem(newItem, item);
        do_throw("Expected modifyItem to be cancelled");
    } catch (e) {
        // Swallow cancelling the request

    coreEvent.status = "cancelled";
    gServer.events = [coreEvent];

    await gServer.waitForLoad(client);

    let items = await pclient.getAllItems();
    equal(items.length, 0);
    equal(gServer.events.length, 1);

    // Put the event back in the calendar for the next run
    delete gServer.events[0].status;
    client.refresh();
    await gServer.waitForLoad(client);
    items = await pclient.getAllItems();
    equal(items.length, 1);

    // Case #3: Deleted on server, delete locally, don't overwrite conflict
    MockConflictPrompt.overwrite = false;
    gServer.events = [];
    try {
        await pclient.deleteItem(item);
        do_throw("Expected deleteItem to be cancelled");
    } catch (e) {
        // Swallow cancelling the request

    // The next synchronize should cause the event to be deleted locally.
    coreEvent.status = "cancelled";
    gServer.events = [coreEvent];
    await gServer.waitForLoad(client);

    items = await pclient.getAllItems();
    equal(items.length, 0);

    // Put the event back in the calendar for the next run
    delete gServer.events[0].status;
    client.refresh();
    await gServer.waitForLoad(client);
    items = await pclient.getAllItems();
    equal(items.length, 1);

    // Case #4: Deleted on server, delete locally, overwrite conflict
    MockConflictPrompt.overwrite = true;
    gServer.events = [];
    await pclient.deleteItem(item);
    items = await pclient.getAllItems();
    equal(items.length, 0);

    gServer.resetClient(client);
});

add_task(async function test_default_alarms() {
    let defaultReminders = [
        { method: "popup", minutes: 10 },
        { method: "email", minutes: 20 },

    }];

    // Case #1: read default alarms from event stream
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client.wrappedJSObject);
    equal(client.getProperty("settings.defaultReminders"), JSON.stringify(defaultReminders));

    let item = (await pclient.getAllItems())[0];
    let alarms = item.getAlarms({});

    equal(alarms.length, 2);

        "END:VEVENT"
    ].join("\r\n"));

    await pclient.addItem(event);
    ok(gServer.events[1].reminders.useDefault);
    equal(gServer.events[1].reminders.overrides.length, 0);


        "END:VEVENT"
    ].join("\r\n"));

    await pclient.addItem(event);
    ok(gServer.events[2].reminders.useDefault);
    equal(gServer.events[2].reminders.overrides.length, 1);
    equal(gServer.events[2].reminders.overrides[0].minutes, 5);

    // Case #4a: Empty default alarms
    gServer.calendarListData.defaultReminders = [];
    gServer.eventsData.defaultReminders = [];
    client = await gServer.getClient();
    pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    event = cal.createEvent([

        "END:VEVENT"
    ].join("\r\n"));

    await pclient.addItem(event);
    ok(gServer.events[0].reminders.useDefault);
    equal(gServer.events[0].reminders.overrides, undefined);



    // Case #4b: Read an item with empty default alarms
    gServer.events = events;
    client = await gServer.getClient();
    pclient = cal.async.promisifyCalendar(client.wrappedJSObject);

    item = (await pclient.getAllItems())[0];
    equal(item.getProperty("X-DEFAULT-ALARM"), "TRUE");

    gServer.resetClient(client);
});

add_task(async function test_paginate() {
    gServer.events = [{
        kind: "calendar#event",
        etag: "\"1\"",


    Preferences.set("calendar.google.maxResultsPerRequest", 1);

    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client);

    // Make sure all pages were requested


    // ...and we have all items. Not checking props
    // because the other tests do this sufficiently.
    let items = await pclient.getAllItems();
    equal(items.length, 4);

    equal(client.getProperty("syncToken.events"), "next-sync-token");

    gServer.resetClient(client);
});

add_task(async function test_incremental_reset() {
    gServer.syncs = [{
        token: "1",
        events: [{

            iCalUID: "fepf8uf6n7n04w7feukucs9n8e@google.com"
        }]
    }];
    let client = await gServer.getClient();
    let pclient = cal.async.promisifyCalendar(client);

    let items = await pclient.getAllItems();
    equal(items.length, 1);
    equal(items[0].title, "New Event");

    client.refresh();
    await gServer.waitForLoad(client);

    items = await pclient.getAllItems();
    equal(items.length, 1);
    equal(items[0].title, "New Event 2");


Lines 29-36 Link Here

(-)a/comm/calendar/test/unit/xpcshell-shared.ini (-2 / +2 lines)
29	[test_email_utils.js]	29	[test_email_utils.js]
30	[test_freebusy.js]	30	[test_freebusy.js]
31	[test_freebusy_service.js]	31	[test_freebusy_service.js]
32	#[test_gdata_provider.js]	32	[test_gdata_provider.js]
33	#requesttimeoutfactor = 2	33	requesttimeoutfactor = 2
34	[test_hashedarray.js]	34	[test_hashedarray.js]
35	[test_ics.js]	35	[test_ics.js]
36	[test_ics_parser.js]	36	[test_ics_parser.js]

Lines 21-27 DIRS += ['/%s' % CONFIG['MOZ_BRANDING_DIRECTORY']] Link Here

(-)a/comm/mail/app.mozbuild (-1 / +2 lines)
21	if CONFIG['MOZ_CALENDAR']:	21	if CONFIG['MOZ_CALENDAR']:
22	DIRS += [	22	DIRS += [
23	'/%s/calendar/lightning' % CONFIG['commreltopsrcdir'],	23	'/%s/calendar/lightning' % CONFIG['commreltopsrcdir'],
24	'/%s/calendar/timezones' % CONFIG['commreltopsrcdir']	24	'/%s/calendar/providers/gdata' % CONFIG['commreltopsrcdir'],
		25	'/%s/calendar/timezones' % CONFIG['commreltopsrcdir'],
25	]	26	]
26		27
27	DIRS += [	28	DIRS += [

Return to bug 668036

Lines 2-33 Link Here

(-)a/comm/calendar/providers/gdata/Makefile.in (-21 / +13 lines)
2	# License, v. 2.0. If a copy of the MPL was not distributed with this	2	# License, v. 2.0. If a copy of the MPL was not distributed with this
3	# file, You can obtain one at http://mozilla.org/MPL/2.0/.	3	# file, You can obtain one at http://mozilla.org/MPL/2.0/.
4		4
5	XPI_PKGNAME = gdata-provider-$(GDATA_VERSION).$(AB_CD).$(MOZ_PKG_PLATFORM)	5	XPI_NAME = gdata-provider
6	XPI_VERSION = $(GDATA_VERSION)	6	XPI_PKGNAME = gdata-provider-$(GDATA_VERSION).$(AB_CD)
7	XPI_EM_ID = {a62ef8ec-5fdc-40c2-873c-223b8a6925cc}	7	XPI_EM_ID = {a62ef8ec-5fdc-40c2-873c-223b8a6925cc}
8	XPI_INSTALL_EXTENSION = $(XPI_EM_ID)	8	XPI_INSTALL_EXTENSION = $(XPI_EM_ID)
9		9
10	DEFINES += -DLIGHTNING_VERSION=$(LIGHTNING_VERSION) \	10	ifdef MOZ_SUITE
11	-DSEAMONKEY_VERSION=$(SEAMONKEY_VERSION) \	11	LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(THUNDERBIRD_VERSION))
12	-DTHUNDERBIRD_VERSION=$(THUNDERBIRD_VERSION) \	12	else
13	-DCOMM_BUILD=$(COMM_BUILD) \	13	LIGHTNING_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/lightning/build/makeversion.py $(word 1,$(MOZ_PKG_VERSION) $(THUNDERBIRD_VERSION)))
14	-DGDATA_VERSION=$(GDATA_VERSION) \
15	$(NULL)
16
17	ifeq (cocoa,$(MOZ_WIDGET_TOOLKIT))
18	# If the macbundle dist dir was already created, sync the gdata provider here to avoid
19	# the need to make -C objdir/mail/app each time
20	tools repackage::
21	[ -d $(DIST)/$(MOZ_MACBUNDLE_NAME) ] && rsync -a $(FINAL_TARGET)/ $(DIST)/$(MOZ_MACBUNDLE_NAME)/Contents/Resources/extensions/$(XPI_EM_ID) \|\| true
22	endif	14	endif
23		15
24	# stage the extension for use in packaged tests	16	GDATA_VERSION := $(shell $(PYTHON) $(commtopsrcdir)/calendar/providers/gdata/makeversion.py $(LIGHTNING_VERSION))
25	PKG_STAGE = $(DIST)/test-stage	17	THUNDERBIRD_VERSION := $(shell cat $(commtopsrcdir)/mail/config/version.txt)
		18	SEAMONKEY_VERSION := $(shell cat $(commtopsrcdir)/suite/config/version.txt)
26		19
27	stage-package:	20	DEFINES += -DSEAMONKEY_VERSION=$(SEAMONKEY_VERSION) \
28	$(NSINSTALL) -D $(PKG_STAGE)/extensions/$(XPI_EM_ID)	21	-DTHUNDERBIRD_VERSION=$(THUNDERBIRD_VERSION) \
29	(cd $(FINAL_TARGET) && tar $(TAR_CREATE_FLAGS) - *) \| (cd $(PKG_STAGE)/extensions/$(XPI_EM_ID) && tar -xf -)	22	-DGDATA_VERSION=$(GDATA_VERSION) \
		23	$(NULL)
30		24
31	include $(moztopsrcdir)/config/rules.mk
32	include $(commtopsrcdir)/calendar/lightning/versions.mk
33	include $(commtopsrcdir)/calendar/lightning/lightning-packager.mk	25	include $(commtopsrcdir)/calendar/lightning/lightning-packager.mk