Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

gaia/apps/calendar/test/unit/models/account_test.js

@@ -0,0 +1,65 @@
+define(function(require) {
+'use strict';
+
+var Account = require('models/account');
+
+suite('Models.Account', function() {
+  var subject;
+
+  setup(function() {
+    subject = new Account({ user: 'foo', providerType: 'Local' });
+  });
+
+  test('initialization', function() {
+    assert.equal(subject.user, 'foo');
+  });
+
+  suite('fullUrl', function() {
+    test('get', function() {
+      subject.domain = 'http://google.com';
+      subject.entrypoint = '/foo';
+
+      assert.equal(subject.fullUrl, 'http://google.com/foo');
+    });
+
+    test('set', function() {
+      subject.fullUrl = 'http://google.com/foo/bar';
+
+      assert.equal(subject.domain, 'http://google.com');
+      assert.equal(subject.entrypoint, '/foo/bar');
+    });
+  });
+
+  suite('#toJSON', function() {
+    setup(function() {
+      subject._id = '1';
+      subject.entrypoint = 'url';
+      subject.domain = 'domain';
+      subject.password = 'pass';
+      subject.user = 'user';
+      subject.providerType = 'local';
+      subject.preset = 'google';
+      subject.calendarHome = '/foo/home';
+      subject.oauth = { code: 'xxx' };
+    });
+
+    test('output', function() {
+      var expected = {
+        _id: subject._id,
+        entrypoint: subject.entrypoint,
+        domain: subject.domain,
+        password: subject.password,
+        user: subject.user,
+        providerType: subject.providerType,
+        calendarHome: '/foo/home',
+        preset: 'google',
+        oauth: { code: 'xxx' },
+        error: undefined
+      };
+
+      assert.deepEqual(subject.toJSON(), expected);
+    });
+  });
+});
+
+});

gaia/apps/calendar/test/unit/models/calendar_test.js

@@ -0,0 +1,120 @@
+define(function(require) {
+'use strict';
+
+var Calendar = require('models/calendar');
+
+suite('Models.Calendar', function() {
+  var subject;
+  var remoteCalendar;
+  var CalendarModel;
+
+  suiteSetup(function() {
+    CalendarModel = Calendar;
+  });
+
+  setup(function() {
+    remoteCalendar = {
+      id: 'one',
+      syncToken: 'xxx'
+    };
+
+    subject = new Calendar({
+      name: 'foo',
+      remote: remoteCalendar
+    });
+  });
+
+  suite('initialization', function() {
+
+    test('when given a remote', function() {
+      var date = new Date();
+
+      subject = new CalendarModel({
+        remote: remoteCalendar,
+        lastEventSyncToken: '0',
+        lastEventSyncDate: date
+      });
+
+      assert.deepEqual(
+        subject.remote,
+        remoteCalendar
+      );
+
+      assert.equal(subject.lastEventSyncDate, date);
+    });
+
+    test('when given remote', function() {
+      subject = new CalendarModel({
+        remote: remoteCalendar
+      });
+
+      assert.deepEqual(subject.remote, remoteCalendar);
+    });
+  });
+
+  test('#updateRemote', function() {
+    remoteCalendar.id = 'foo';
+    subject.updateRemote(remoteCalendar);
+    assert.equal(subject.remote.id, 'foo');
+  });
+
+  suite('#eventSyncNeeded', function() {
+
+    test('when remote and local match', function() {
+      subject.remote.syncToken = 'foo';
+      subject.lastEventSyncToken = 'foo';
+
+      assert.isFalse(subject.eventSyncNeeded());
+    });
+
+    test('when remote and local differ', function() {
+      subject.remote.syncToken = 'foo';
+      subject.lastEventSyncToken = 'bar';
+
+      assert.isTrue(subject.eventSyncNeeded());
+    });
+  });
+
+  test('#toJSON', function() {
+    subject._id = '1';
+
+    var expected = {
+      error: undefined,
+      lastEventSyncToken: subject.lastEventSyncToken,
+      lastEventSyncDate: subject.lastEventSyncDate,
+      localDisplayed: subject.localDisplayed,
+      firstEventSyncDate: subject.firstEventSyncDate,
+      accountId: subject.accountId,
+      _id: subject._id,
+      remote: subject.remote
+    };
+
+    assert.deepEqual(subject.toJSON(), expected);
+  });
+
+  test('#name', function() {
+    subject.remote.name = 'foo';
+    assert.equal(subject.name, 'foo');
+  });
+
+  suite('#color', function() {
+
+    test('basic getter', function() {
+      subject.remote.color = '#ccc';
+      assert.equal(subject.color, '#ccc');
+    });
+
+    test('filter hex value', function() {
+      subject.remote.color = '#7BD148FF';
+      assert.equal(subject.color, '#7BD148');
+    });
+
+  });
+
+  test('#description', function() {
+    subject.remote.description = 'foo';
+    assert.equal(subject.description, 'foo');
+  });
+});
+
+});

gaia/apps/calendar/test/unit/models/event_test.js

@@ -0,0 +1,297 @@
+define(function(require) {
+'use strict';
+
+var Calc = require('common/calc');
+var Event = require('models/event');
+var Factory = require('test/support/factory');
+
+suite('Models.Event', function() {
+  var subject;
+  var rawEvent;
+  var remote;
+
+  var start;
+  var end;
+  var originalDates;
+
+  suiteSetup(function() {
+    start = new Date(2012, 0, 1);
+    end = new Date(2012, 0, 1, 12);
+
+    originalDates = {
+      start: start,
+      end: end
+    };
+  });
+
+  setup(function() {
+    rawEvent = Factory.create('event', {
+      remote: {
+        syncToken: '7ee',
+        startDate: start,
+        endDate: end,
+        start: Calc.dateToTransport(start),
+        end: Calc.dateToTransport(end)
+      }
+    });
+
+    remote = rawEvent.remote;
+    subject = new Event(rawEvent);
+  });
+
+
+  suite('initialization', function() {
+    test('from existing model', function() {
+      assert.equal(subject.data, rawEvent);
+    });
+
+    test('from existing "allday" model', function() {
+      var data = Factory.build('event', {
+        remote: {
+          startDate: new Date(2012, 1, 1),
+          endDate: new Date(2012, 1, 2)
+        }
+      });
+
+      var subject = new Event(data);
+      assert.isTrue(subject.isAllDay, 'is all day');
+    });
+
+    test('from existing model without .startDate/.endDate', function() {
+      var event = new Event();
+      var start = new Date(2012, 0, 1);
+      var end = new Date(2012, 0, 5);
+
+      event.startDate = start;
+      event.endDate = end;
+
+      var data = event.data;
+      delete data.remote.startDate;
+      delete data.remote.endDate;
+
+      var newEvent = new Event(data);
+      assert.deepEqual(newEvent.startDate, start);
+      assert.deepEqual(newEvent.endDate, end);
+    });
+
+    test('from new model', function() {
+      subject = new Event();
+      assert.ok(subject.data, 'has data');
+      assert.ok(subject.data.remote, 'has remote');
+
+      assert.instanceOf(
+        subject.startDate,
+        Date,
+        'pre-populates start date'
+      );
+
+      assert.instanceOf(
+        subject.endDate,
+        Date,
+        'pre-populates end date'
+      );
+    });
+  });
+
+  function remoteSetter(type) {
+    test('#' + type + ' setter/getter', function() {
+      var value = 'foo';
+      subject[type] = value;
+      assert.equal(rawEvent.remote[type], value, 'raw data ' + type);
+      assert.equal(subject[type], value, 'get ' + type);
+    });
+  }
+
+  // need a var for gjslint parse error?
+  var dateFields = ['start', 'end'];
+  dateFields.forEach(function(field) {
+    var remoteDateField = field + 'Date';
+
+    suite('#' + remoteDateField, function() {
+      test('initial value', function() {
+        assert.deepEqual(
+          originalDates[field],
+          subject[remoteDateField]
+        );
+      });
+
+      test('set value', function() {
+        var date = new Date(2012, 0, 1, 2);
+        var transport = Calc.dateToTransport(date);
+
+        subject[remoteDateField] = date;
+        assert.deepEqual(
+          remote[remoteDateField],
+          date,
+          remoteDateField
+        );
+
+        assert.deepEqual(
+          remote[field],
+          transport,
+          field
+        );
+      });
+
+      test('prevents non-date values when isAllDay', function() {
+        subject.isAllDay = true;
+
+        var date = new Date(2012, 1, 1, 1, 5);
+        var expected = new Date(2012, 1, 1);
+        var transport = Calc.dateToTransport(
+          expected, null, true
+        );
+
+        subject[remoteDateField] = date;
+
+        assert.deepEqual(
+          subject[remoteDateField],
+          expected,
+          'date'
+        );
+
+        assert.deepEqual(
+          subject.remote[field],
+          transport,
+          'trasport'
+        );
+      });
+
+      test('clears when is .allDay', function() {
+        subject.isAllDay = true;
+        assert.isTrue(
+          Calc.isOnlyDate(subject[remoteDateField]),
+          'is only date'
+        );
+
+        assert.isTrue(
+          subject.remote[field].isDate,
+          'is date'
+        );
+      });
+    });
+  });
+
+  test('#isAllDay', function() {
+    subject.isAllDay = true;
+
+    assert.isTrue(
+      Calc.isOnlyDate(subject.startDate),
+      'removes time from start'
+    );
+
+    assert.isTrue(
+      Calc.isOnlyDate(subject.endDate),
+      'removes time from end'
+    );
+
+    assert.isTrue(
+      subject.remote.start.isDate,
+      'sets start to date'
+    );
+
+    assert.isTrue(
+      subject.remote.end.isDate,
+      'sets end to date'
+    );
+  });
+
+  test('#calendarId', function() {
+    subject.calendarId = 7;
+    assert.equal(rawEvent.calendarId, 7);
+    assert.equal(subject.calendarId, 7);
+  });
+
+  test('#calendarId with string input', function() {
+    subject.calendarId = '7';
+    assert.strictEqual(rawEvent.calendarId, 7);
+    assert.strictEqual(subject.calendarId, 7);
+  });
+
+  test('#_id', function() {
+    rawEvent._id = 'foo';
+
+    assert.equal(subject._id, 'foo');
+  });
+
+  suite('#validationErrors', function() {
+    test('no errors', function() {
+      var event = new Event();
+      event.startDate = new Date(2012, 0, 1);
+      event.endDate = new Date(2012, 0, 2);
+
+      assert.ok(!event.validationErrors(), 'has no errors');
+    });
+
+    function hasError(event, type) {
+      var errors = event.validationErrors();
+      assert.lengthOf(errors, 1);
+      assert.deepEqual(
+        errors[0], {
+          name: type
+        },
+        'has error: "' + type + '"'
+      );
+    }
+
+    test('start date >(=) end date', function() {
+      var event = new Event();
+      event.startDate = new Date(2020, 0, 2);
+      event.endDate = new Date(2012, 0, 1);
+
+      // start date > end date
+      hasError(event, 'start-after-end');
+      // start date == end date
+      event.startDate = new Date(event.endDate.valueOf());
+      hasError(event, 'start-after-end');
+    });
+  });
+
+  suite('update attributes', function() {
+    var eventWithoutErrors;
+    var eventWithErrors;
+    var event;
+    var model;
+
+    setup(function() {
+      event = Factory.create('event', {
+        remote: {
+          syncToken: '7ee',
+          startDate: new Date(2019, 1, 2),
+          endDate: new Date(2020, 0, 2),
+          start: Calc.dateToTransport(start),
+          end: Calc.dateToTransport(end)
+        }
+      });
+      model = new Event(event);
+      eventWithoutErrors = {
+        startDate: new Date(2019, 1, 2),
+        endDate: new Date(2020, 1, 2)
+      };
+      eventWithErrors = {
+        startDate: new Date(2019, 1, 2),
+        endDate: new Date(2019, 0, 2)
+      };
+    });
+
+    test('does not update attributes', function() {
+      var errors = model.updateAttributes(eventWithErrors);
+      assert.ok(errors);
+      assert.deepEqual(errors[0].name, 'start-after-end');
+    });
+
+    test('will update attributes', function() {
+      var errors = model.updateAttributes(eventWithoutErrors);
+      assert.strictEqual(errors, true);
+      assert.deepEqual(model.endDate, eventWithoutErrors.endDate);
+    });
+  });
+
+  remoteSetter('syncToken');
+  remoteSetter('location');
+  remoteSetter('description');
+  remoteSetter('title');
+  remoteSetter('alarms');
+});
+
+});