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/settings/test/unit/panels/homescreens/homescreen_cols_test.js

@@ -0,0 +1,91 @@
+'use strict';
+
+suite('homescreens > homescreen_cols', () => {
+  var modules = [
+    'modules/mvvm/observable',
+    'unit/mock_homescreen_settings',
+    'panels/homescreens/homescreen_cols'
+  ];
+
+  var maps = {
+    '*': {
+      'shared/homescreens/homescreen_settings': 'unit/mock_homescreen_settings'
+    }
+  };
+
+  const DEFAULT_SELECTED_OPTION = '3';
+
+  var homescreenCols;
+  var mockHomescreenSettings;
+
+  setup(done => {
+    define('MockHomescreenSettings', () => {
+      return {
+        addEventListener: function(key, callback) {
+          if (!this._eventHandlers) {
+            this._eventHandlers = {};
+          }
+          this._eventHandlers[key] = callback;
+        },
+        put: () => {
+        },
+        get: () => {
+          return Promise.resolve(DEFAULT_SELECTED_OPTION);
+        },
+        setStoreName: () => {}
+      };
+    });
+
+    testRequire(modules, maps, (Observable,
+                                MockHomescreenSettings,
+                                HomescreenCols) => {
+      mockHomescreenSettings = MockHomescreenSettings;
+      homescreenCols = HomescreenCols();
+      done();
+    });
+  });
+
+  test('We will update cols to default value after init', done => {
+    setTimeout(() => {
+      assert.equal(homescreenCols.cols, DEFAULT_SELECTED_OPTION);
+      done();
+    });
+  });
+
+  test('When HomescreenSettings is updated, cols is updated too', () => {
+    var fakeGridCols = 4;
+    mockHomescreenSettings._eventHandlers.updated({
+      target: {
+        name: 'grid.cols',
+        value: fakeGridCols
+      }
+    });
+    assert.equal(homescreenCols.cols, fakeGridCols);
+  });
+
+  test('The last value will eventually be set', done => {
+    var lastValue = 9;
+    var resolveFunc;
+    var promise = new Promise(resolve => {
+      resolveFunc = resolve;
+    });
+    this.sinon.stub(mockHomescreenSettings, 'put', () => {
+      return promise;
+    });
+
+    homescreenCols.observe('cols', newValue => {
+      if (newValue === lastValue) {
+        done();
+      }
+    });
+
+    homescreenCols.setCols(3);
+    homescreenCols.setCols(4);
+    homescreenCols.setCols(5);
+    homescreenCols.setCols(6);
+    homescreenCols.setCols(7);
+    homescreenCols.setCols(8);
+    homescreenCols.setCols(lastValue);
+    resolveFunc();
+  });
+});

gaia/apps/settings/test/unit/panels/homescreens/homescreen_name_test.js

@@ -0,0 +1,71 @@
+/* global MockNavigatorSettings */
+'use strict';
+
+require('/shared/test/unit/mocks/mock_navigator_moz_settings.js');
+
+suite('homescreens > homescreen name', () => {
+  var modules = [
+    'shared_mocks/mock_settings_listener',
+    'unit/mock_apps_cache',
+    'panels/homescreens/homescreen_name'
+  ];
+
+  var map = {
+    '*': {
+      'shared/settings_listener': 'shared_mocks/mock_settings_listener',
+      'modules/apps_cache': 'unit/mock_apps_cache'
+    }
+  };
+
+  var homescreenName;
+
+  var realNavigatorSettings;
+  var realSettingsListener;
+
+  var mockAppsCache;
+
+  suiteSetup(() => {
+    realNavigatorSettings = navigator.mozSettings;
+    navigator.mozSettings = MockNavigatorSettings;
+  });
+
+  suiteTeardown(() => {
+    navigator.mozSettings = realNavigatorSettings;
+    realNavigatorSettings = null;
+
+    window.SettingsListener = realSettingsListener;
+  });
+
+  setup(done => {
+    var requireCtx = testRequire([], map, () => {});
+    requireCtx(modules, (MockSettingsListener, MockAppsCache,
+                         HomescreenName) => {
+      homescreenName = HomescreenName();
+      realSettingsListener = window.SettingsListener;
+      window.SettingsListener = MockSettingsListener;
+      mockAppsCache = MockAppsCache;
+      done();
+    });
+  });
+
+  test('_init() should watch name property changes', () => {
+    sinon.stub(homescreenName, '_watchNameChange');
+    homescreenName._init();
+    assert.isTrue(homescreenName._watchNameChange.calledOnce);
+  });
+
+  test('Name is set to a default value', () => {
+    assert.equal(homescreenName.name, '');
+  });
+
+  test('Getting Homescreen.name must call _updateManifestName()', done => {
+    var updateManifestNameStub = sinon.stub(homescreenName,
+      '_updateManifestName');
+    homescreenName.getName();
+    setTimeout(() => {
+      assert.isTrue(updateManifestNameStub.calledOnce);
+      updateManifestNameStub.restore();
+      done();
+    });
+  });
+});

gaia/apps/settings/test/unit/panels/homescreens/panel_test.js

@@ -0,0 +1,137 @@
+/* global loadBodyHTML */
+'use strict';
+
+require('/shared/test/unit/load_body_html_helper.js');
+
+suite('homescreens > panel', () => {
+  var modules = [
+    'shared_mocks/mock_settings_listener',
+    'panels/homescreens/panel'
+  ];
+
+  var map = {
+    '*': {
+      'modules/settings_panel': 'MockSettingsPanel',
+      'panels/homescreens/wallpaper': 'MockWallpaper',
+      'panels/homescreens/homescreen_cols': 'MockHomescreenCols',
+      'panels/homescreens/homescreen_name': 'MockHomescreenName',
+      'shared/settings_listener': 'shared_mocks/mock_settings_listener'
+    }
+  };
+
+  var panel;
+  var mockWallpaper;
+  var mockWallpaperSrc;
+  var mockHomescreenCols;
+  var mockHomescreenName;
+  var mockHomescreenNameName;
+
+  suiteSetup(done => {
+    loadBodyHTML('_homescreens.html');
+
+    // Define MockSettingsPanel.
+    define('MockSettingsPanel', () => {
+      return options => {
+        return {
+          init: options.onInit.bind(options),
+          beforeShow: options.onBeforeShow.bind(options),
+          beforeHide: options.onBeforeHide.bind(options)
+        };
+      };
+    });
+
+    // Define MockWallpaper.
+    mockWallpaperSrc = 'mockSrc';
+    mockWallpaper = {
+      wallpaperSrc: mockWallpaperSrc,
+      selectWallpaper: () => {},
+      observe: () => {},
+      unobserve: () => {}
+    };
+    define('MockWallpaper', () => {
+      return () => {
+        return mockWallpaper;
+      };
+    });
+
+    // Define MockHomescreenCols.
+    mockHomescreenCols = {
+      cols: 3,
+      setCols: () => {},
+      observe: () => {},
+      unobserve: () => {}
+    };
+    define('MockHomescreenCols', () => {
+      return () => mockHomescreenCols;
+    });
+
+    // Define MockHomescreenName.
+    mockHomescreenNameName = 'New Home Screen';
+    mockHomescreenName = {
+      name: mockHomescreenNameName,
+      observe: () => {},
+      unobserve: () => {}
+    };
+    define('MockHomescreenName', () => {
+      return () => {
+        return mockHomescreenName;
+      };
+    });
+
+    testRequire(modules, map, (MockSettingsListener, Panel) => {
+      panel = Panel();
+      done();
+    });
+  });
+
+  test('observe wallpaperSrc when onBeforeShow', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockWallpaper, 'observe');
+    panel.beforeShow();
+    assert.ok(mockWallpaper.observe.calledWith('wallpaperSrc'));
+
+    var location = document.location;
+    assert.equal(
+      document.querySelector('.wallpaper-preview').src,
+      location.protocol + '//' + location.host +
+      location.pathname.replace('_sandbox.html', mockWallpaperSrc));
+  });
+
+  test('unobserve wallpaperSrc when onHide', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockWallpaper, 'unobserve');
+    panel.beforeHide();
+    assert.ok(mockWallpaper.unobserve.calledWith('wallpaperSrc'));
+  });
+
+  test('observe name when onBeforeShow', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockHomescreenName, 'observe');
+    panel.beforeShow();
+    assert.ok(mockHomescreenName.observe.calledWith('name'));
+
+    assert.equal(document.querySelector('.current-homescreen').textContent,
+      mockHomescreenNameName);
+  });
+
+  test('unobserve name when onHide', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockHomescreenName, 'unobserve');
+    panel.beforeHide();
+    assert.ok(mockHomescreenName.unobserve.calledWith('name'));
+  });
+
+  test('observe cols when onBeforeShow', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockHomescreenCols, 'observe');
+    panel.beforeShow();
+    assert.ok(mockHomescreenCols.observe.calledWith('cols'));
+  });
+
+  test('unobserve cols when onHide', () => {
+    panel.init(document.body);
+    this.sinon.stub(mockHomescreenCols, 'unobserve');
+    panel.beforeHide();
+    assert.ok(mockHomescreenCols.unobserve.calledWith('cols'));
+  });
+});

gaia/apps/settings/test/unit/panels/homescreens/wallpaper_test.js

@@ -0,0 +1,142 @@
+/* global MockMozActivity */
+'use strict';
+
+require('/shared/test/unit/mocks/mock_moz_activity.js');
+
+suite('homescreens > wallpaper', () => {
+  var modules = [
+    'modules/mvvm/observable',
+    'shared_mocks/mock_settings_listener',
+    'shared_mocks/mock_settings_url',
+    'shared_mocks/mock_omadrm_fl',
+    'panels/homescreens/wallpaper'
+  ];
+
+  var maps = {
+    '*': {
+      'shared/settings_listener': 'shared_mocks/mock_settings_listener',
+      'shared/settings_url': 'shared_mocks/mock_settings_url',
+      'shared/omadrm/fl': 'shared_mocks/mock_omadrm_fl'
+    }
+  };
+
+  var mockSettingsListener;
+  var mockSettingsURL;
+  var mockForwardLock;
+  var wallpaper;
+  var realMozActivity;
+  var clock;
+
+  suiteSetup(done => {
+    testRequire(modules, maps, (Observable, MockSettingsListener,
+                                MockSettingsUrl, MockForwardLock,
+                                Wallpaper) => {
+      wallpaper = Wallpaper();
+      mockSettingsListener = MockSettingsListener;
+      mockSettingsURL = MockSettingsUrl;
+      mockForwardLock = MockForwardLock;
+      done();
+    });
+
+    realMozActivity = window.MozActivity;
+    window.MozActivity = MockMozActivity;
+  });
+
+  suiteTeardown(() => {
+    window.MozActivity = realMozActivity;
+  });
+
+  setup(() => {
+    MockMozActivity.mSetup();
+    clock = sinon.useFakeTimers();
+  });
+
+  teardown(() => {
+    MockMozActivity.mTeardown();
+    clock.restore();
+    // clear the lock so tests that write into settings would not read from
+    // other tests' locks
+    mockSettingsListener.getSettingsLock().clear();
+  });
+
+  test('_init', () => {
+    this.sinon.stub(wallpaper, '_watchWallpaperChange');
+    wallpaper._init();
+    assert.equal(wallpaper._watchWallpaperChange.calledOnce, true);
+  });
+
+  test('select wallpaper', function() {
+    this.sinon.stub(wallpaper, '_triggerActivity');
+    this.sinon.stub(mockForwardLock, 'getKey');
+    wallpaper.selectWallpaper();
+    assert.equal(mockForwardLock.getKey.calledOnce, true);
+    mockForwardLock.getKey.args[0][0]();
+    assert.equal(wallpaper._triggerActivity.calledOnce, true);
+  });
+
+  test('_watchWallpaperChange', () => {
+    var value = 'testlink';
+    wallpaper.wallpaperURL = new mockSettingsURL();
+    wallpaper._watchWallpaperChange();
+    mockSettingsListener.mTriggerCallback('wallpaper.image',
+      value);
+    assert.equal(wallpaper.wallpaperSrc, value);
+  });
+
+  test('_triggerActivity', function() {
+    this.sinon.stub(wallpaper, '_onPickSuccess');
+    this.sinon.stub(wallpaper, '_onPickError');
+    var secret = !null;
+    var testblob = 'testblob';
+
+    MockMozActivity.successResult = { blob: testblob };
+    wallpaper._triggerActivity(secret);
+
+    assert.equal(MockMozActivity.calls[0].name, 'pick');
+    assert.equal(MockMozActivity.calls[0].data.includeLocked, secret);
+    assert.deepEqual(MockMozActivity.calls[0].data.type,
+      ['wallpaper', 'image/*']);
+
+    // waiting for onsuccess. (50ms is defined in mock_moz_activity.js)
+    clock.tick(50);
+    assert.equal(wallpaper._onPickSuccess.calledOnce, true);
+    sinon.assert.calledWith(wallpaper._onPickSuccess, testblob, secret);
+
+    MockMozActivity.mTriggerOnError();
+    assert.equal(wallpaper._onPickError.calledOnce, true);
+  });
+
+  test('_onPickSuccess, blob type is mimeSubtype', () => {
+    var unlockBlobStub = this.sinon.stub(mockForwardLock, 'unlockBlob');
+    mockForwardLock.mSetupMimeSubtype('mimeSubtype');
+
+    var testBlob = {
+      type: 'test/mimeSubtype'
+    };
+    var testSecret = 'testSecret';
+
+    wallpaper._onPickSuccess(testBlob, testSecret);
+    assert.isTrue(unlockBlobStub.calledOnce);
+    assert.equal(unlockBlobStub.args[0][0], testSecret);
+    assert.equal(unlockBlobStub.args[0][1], testBlob);
+  });
+
+  test('_onPickSuccess, blob type is not mimeSubtype', function() {
+    this.sinon.stub(wallpaper, '_setWallpaper');
+    mockForwardLock.mSetupMimeSubtype('mimeSubtype');
+
+    var testBlob = {
+      type: 'test/notMimeSubtype'
+    };
+    wallpaper._onPickSuccess(testBlob);
+    sinon.assert.calledWith(wallpaper._setWallpaper, testBlob);
+  });
+
+  test('_setWallpaper', () => {
+    var blob = 'testblob';
+    wallpaper._setWallpaper(blob);
+    assert.deepEqual(mockSettingsListener.getSettingsLock().locks[0], {
+      'wallpaper.image': 'testblob'
+    });
+  });
+});