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/about/factory_reset_test.js

@@ -0,0 +1,127 @@
+'use strict';
+
+suite('about > factory_reset', function() {
+  var factoryReset;
+  var realNavigatorPower;
+  var modules = [
+    'panels/about/factory_reset'
+  ];
+  var maps = {};
+
+  var MockPower = {
+    factoryReset: function() {}
+  };
+
+  var elements = {
+    resetButton: document.createElement('button'),
+    resetDialog: document.createElement('form'),
+    resetConfirm: document.createElement('button'),
+    resetCancel: document.createElement('button')
+  };
+
+  setup(function(done) {
+    testRequire(modules, maps,
+      function(FactoryReset) {
+        realNavigatorPower = navigator.mozPower;
+        navigator.mozPower = MockPower;
+
+        factoryReset = FactoryReset();
+        elements.resetDialog.hidden = true;
+        factoryReset._elements = elements;
+        done();
+    });
+  });
+
+  suiteTeardown(function() {
+    navigator.mozPower = realNavigatorPower;
+    realNavigatorPower = null;
+  });
+
+  suite('initiation', function() {
+    setup(function() {
+      this.sinon.stub(factoryReset, '_resetClick');
+    });
+
+    test('resetButton is enabled when mozPower exist', function() {
+      factoryReset.init(elements);
+      assert.equal(factoryReset._elements.resetButton.disabled, false);
+    });
+
+    test('resetButton is disabled when mozPower does not exist', function() {
+      navigator.mozPower = null;
+      factoryReset.init(elements);
+      assert.equal(factoryReset._elements.resetButton.disabled, true);
+    });
+
+    test('resetButton is enabled when mozPower exist', function() {
+      factoryReset.init(elements);
+      factoryReset._elements.resetButton.click();
+      assert.ok(factoryReset._resetClick.called);
+    });
+  });
+
+  suite('resetClick', function() {
+    setup(function() {
+      this.sinon.stub(factoryReset, '_factoryReset');
+      factoryReset.init(elements);
+    });
+
+    test('resetDialog is shown when calling resetClick', function() {
+      assert.equal(factoryReset._elements.resetDialog.hidden, true);
+      factoryReset._resetClick();
+      assert.equal(factoryReset._elements.resetDialog.hidden, false);
+    });
+
+    test('resetDialog is hidden when cancel button is clicked', function() {
+      factoryReset._resetClick();
+      assert.equal(factoryReset._elements.resetDialog.hidden, false);
+      factoryReset._elements.resetCancel.click();
+      assert.equal(factoryReset._elements.resetDialog.hidden, true);
+    });
+
+    test('factoryReset is called when confirm button is clicked', function() {
+      factoryReset._resetClick();
+      assert.equal(factoryReset._elements.resetDialog.hidden, false);
+      factoryReset._elements.resetConfirm.click();
+      assert.ok(factoryReset._factoryReset.called);
+      assert.equal(factoryReset._elements.resetDialog.hidden, true);
+    });
+
+    test('if mozPower is not defined, dialog is still hidden ' +
+      'when confirm button is clicked', function() {
+        navigator.mozPower = null;
+        factoryReset._resetClick();
+        assert.equal(factoryReset._elements.resetDialog.hidden, false);
+        factoryReset._elements.resetConfirm.click();
+        assert.ok(factoryReset._factoryReset.called);
+        assert.equal(factoryReset._elements.resetDialog.hidden, true);
+    });
+  });
+
+  suite('factoryReset', function() {
+    setup(function() {
+      this.sinon.spy(navigator.mozPower, 'factoryReset');
+      this.sinon.stub(console, 'error');
+    });
+
+    test('mozPower factoryReset is called', function() {
+      factoryReset._factoryReset();
+      assert.ok(navigator.mozPower.factoryReset.called);
+    });
+
+    test('if mozPower is not defined, return error',
+      function() {
+        navigator.mozPower = null;
+        factoryReset._factoryReset();
+        assert.ok(console.error.calledWith('Cannot get mozPower'));
+    });
+
+    test('if mozPower factoryReset is not defined, ' +
+      'mozPower factoryReset should not be called', function() {
+        navigator.mozPower.factoryReset = null;
+        factoryReset._factoryReset();
+        assert.ok(
+          console.error.calledWith('Cannot invoke mozPower.factoryReset()'));
+    });
+  });
+});

gaia/apps/settings/test/unit/panels/about/hardware_info_test.js

@@ -0,0 +1,227 @@
+/* global MockNavigatorMozMobileConnections, MockNavigatorMozIccManager */
+
+'use strict';
+
+require('/shared/test/unit/mocks/mock_navigator_moz_icc_manager.js');
+require('/shared/test/unit/mocks/mock_navigator_moz_mobile_connections.js');
+
+suite('about > hardware_info', function() {
+  var hardwareInfo;
+  var realL10n;
+  var realNavigatorSettings;
+  var realMobileConnections;
+  var realIccManager;
+
+  var modules = [
+    'shared_mocks/mock_l20n',
+    'shared_mocks/mock_navigator_moz_settings',
+    'panels/about/hardware_info'
+  ];
+  var maps = {};
+
+  var elements = {
+    updateStatus: document.createElement('li'),
+    deviceInfoPhoneNum: document.createElement('li'),
+    deviceInfoMsisdns: document.createElement('li')
+  };
+
+  setup(function(done) {
+    testRequire(modules, maps,
+      function(MockL10n, MockNavigatorSettings, HardwareInfo) {
+        realL10n = document.l10n;
+        document.l10n = MockL10n;
+
+        realIccManager = navigator.mozIccManager;
+        navigator.mozIccManager = MockNavigatorMozIccManager;
+
+        realMobileConnections = navigator.mozMobileConnections;
+        navigator.mozMobileConnections = MockNavigatorMozMobileConnections;
+
+        realNavigatorSettings = navigator.mozSettings;
+        navigator.mozSettings = MockNavigatorSettings;
+
+        hardwareInfo = HardwareInfo();
+        hardwareInfo._elements = elements;
+        done();
+    });
+  });
+
+  suiteTeardown(function() {
+    document.l10n = realL10n;
+    realL10n = null;
+
+    navigator.mozSettings = realNavigatorSettings;
+    realNavigatorSettings = null;
+
+    navigator.mozMobileConnections = realMobileConnections;
+    realMobileConnections = null;
+
+    navigator.mozIccManager = realIccManager;
+    realIccManager = null;
+  });
+
+  suite('initiation', function() {
+    setup(function() {
+      this.sinon.stub(hardwareInfo, '_loadHardwareInfo');
+      hardwareInfo.init(elements);
+    });
+
+    test('_loadHardwareInfo and _loadLastUpdated are called while initiate',
+      function() {
+        assert.ok(hardwareInfo._loadHardwareInfo.called);
+    });
+  });
+
+  suite('loadHardwareInfo >', function() {
+    var iccIds = ['12345', '22345'];
+
+    setup(function() {
+      MockNavigatorMozIccManager.addIcc(iccIds[0]);
+      MockNavigatorMozMobileConnections[0].iccId = iccIds[0];
+      this.sinon.spy(hardwareInfo, '_renderPhoneNumberElement');
+    });
+
+    suite('single sim', function() {
+      test('the list item should be hidden when without iccinfo',
+        function() {
+          MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo = null;
+          hardwareInfo.init(elements);
+          assert.isTrue(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+
+      test('should show unknown phone number when no msisdn and mdn',
+        function() {
+          MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo = {};
+          hardwareInfo._loadHardwareInfo();
+          assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+            {}, 0, false));
+          assert.isFalse(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+
+      test('should show correct value when with mdn', function() {
+        MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo =
+          { mdn: 'mdn' };
+        hardwareInfo._loadHardwareInfo();
+        assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+          { mdn: 'mdn' }, 0, false));
+        assert.isFalse(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+
+      test('should show correct value when with msisdn', function() {
+        MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo =
+          { msisdn: 'msisdn' };
+        hardwareInfo._loadHardwareInfo();
+        assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+          { msisdn: 'msisdn' }, 0, false));
+        assert.isFalse(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+    });
+
+    suite('multiple sim', function() {
+      setup(function() {
+        MockNavigatorMozIccManager.addIcc(iccIds[1]);
+        MockNavigatorMozMobileConnections.mAddMobileConnection();
+        MockNavigatorMozMobileConnections[1].iccId = iccIds[1];
+        MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo =
+          { mdn: 'mdn1' };
+        MockNavigatorMozIccManager.getIccById(iccIds[1]).iccInfo =
+          { mdn: 'mdn2' };
+      });
+
+      test('the list item should be hidden when without iccinfo',
+        function() {
+          MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo = null;
+          MockNavigatorMozIccManager.getIccById(iccIds[1]).iccInfo = null;
+          hardwareInfo._loadHardwareInfo();
+          assert.isTrue(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+
+      test('should show the list item when there are iccinfos', function() {
+        MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo = null;
+        MockNavigatorMozIccManager.getIccById(iccIds[1]).iccInfo = {};
+        hardwareInfo._loadHardwareInfo();
+        assert.isFalse(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+      });
+
+      test('should show unknown phone number when no msisdn and mdn',
+        function() {
+          MockNavigatorMozIccManager.getIccById(iccIds[0]).iccInfo = {};
+          MockNavigatorMozIccManager.getIccById(iccIds[1]).iccInfo = {};
+          hardwareInfo._loadHardwareInfo();
+          assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+            {}, 0, true));
+          assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+            {}, 1, true));
+      });
+
+      test('should show correct sim indicator', function() {
+        hardwareInfo._loadHardwareInfo();
+        assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+          { mdn: 'mdn1' }, 0, true));
+        assert.ok(hardwareInfo._renderPhoneNumberElement.calledWith(
+          { mdn: 'mdn2' }, 1, true));
+      });
+    });
+  });
+
+  suite('_renderPhoneNumberElement >', function() {
+    suite('single sim', function() {
+      test('should show unknown phone number when no msisdn and mdn',
+        function() {
+          var span = hardwareInfo._renderPhoneNumberElement({}, 0, false);
+          assert.ok(span.getAttribute('data-l10n-id', 'unknown-phoneNumber'));
+      });
+
+      test('should show correct value when with mdn', function() {
+        var span = hardwareInfo._renderPhoneNumberElement(
+          { mdn: 'mdn' }, 0, false);
+        assert.equal(span.textContent, 'mdn');
+      });
+
+      test('should show correct value when with msisdn', function() {
+        var span = hardwareInfo._renderPhoneNumberElement(
+          { msisdn: 'msisdn' }, 0, false);
+        assert.isFalse(hardwareInfo._elements.deviceInfoPhoneNum.hidden);
+        assert.equal(span.textContent, 'msisdn');
+      });
+    });
+
+    suite('multiple sim', function() {
+      test('should show unknown phone number when no msisdn and mdn',
+        function() {
+          this.sinon.spy(document.l10n, 'setAttributes');
+          var spans0 = hardwareInfo._renderPhoneNumberElement({}, 0, true);
+          assert.equal(document.l10n.setAttributes.args[0][0], spans0);
+          assert.equal(document.l10n.setAttributes.args[0][1],
+            'unknown-phoneNumber-sim');
+          assert.equal(document.l10n.setAttributes.args[0][2].index,
+            1);
+          var spans1 = hardwareInfo._renderPhoneNumberElement({}, 1, true);
+          assert.equal(document.l10n.setAttributes.args[1][0], spans1);
+          assert.equal(document.l10n.setAttributes.args[1][1],
+            'unknown-phoneNumber-sim');
+          assert.equal(document.l10n.setAttributes.args[1][2].index,
+            2);
+      });
+
+      test('should show correct sim indicator', function() {
+        hardwareInfo._loadHardwareInfo();
+        var spans0 = hardwareInfo._renderPhoneNumberElement(
+          { mdn: 'mdn1' }, 0, true);
+        var spans1 = hardwareInfo._renderPhoneNumberElement(
+          { mdn: 'mdn2' }, 1, true);
+
+        var sim1Args = JSON.parse(spans0.getAttribute('data-l10n-args'));
+        var sim2Args = JSON.parse(spans1.getAttribute('data-l10n-args'));
+        assert.equal(spans0.getAttribute('data-l10n-id'),
+          'deviceInfo-MSISDN-with-index');
+        assert.equal(spans1.getAttribute('data-l10n-id'),
+          'deviceInfo-MSISDN-with-index');
+        assert.equal(sim1Args.index, 1);
+        assert.equal(sim1Args.msisdn, 'mdn1');
+        assert.equal(sim2Args.index, 2);
+        assert.equal(sim2Args.msisdn, 'mdn2');
+      });
+    });
+  });
+});

gaia/apps/settings/test/unit/panels/about/update_check_test.js

@@ -0,0 +1,266 @@
+'use strict';
+
+suite('about > update_check', function() {
+  var updateCheck;
+  var realNavigatorSettings;
+  var geckoUpdateSetting = 'gecko.updateStatus';
+  var appsUpdateSetting = 'apps.updateStatus';
+
+  var modules = [
+    'shared_mocks/mock_navigator_moz_settings',
+    'panels/about/update_check'
+  ];
+  var maps = {};
+
+  var elements = {
+    updateStatus: document.createElement('li'),
+    checkUpdateNow: document.createElement('button'),
+    lastUpdateDate: document.createElement('small'),
+    systemStatus: document.createElement('li'),
+    generalInfo: document.createElement('p')
+  };
+
+  setup(function(done) {
+    this.clock = this.sinon.useFakeTimers();
+
+    testRequire(modules, maps,
+      function(MockNavigatorSettings, module) {
+        realNavigatorSettings = navigator.mozSettings;
+        navigator.mozSettings = MockNavigatorSettings;
+
+        updateCheck = module();
+        updateCheck._elements = elements;
+        done();
+    });
+  });
+
+  suiteTeardown(function() {
+    navigator.mozSettings = realNavigatorSettings;
+    realNavigatorSettings = null;
+  });
+
+  suite('initiation', function() {
+    setup(function() {
+      this.sinon.stub(updateCheck, '_loadLastUpdated');
+      this.sinon.stub(updateCheck, '_checkForUpdates');
+
+      updateCheck.init(elements);
+    });
+
+    test('_loadHardwareInfo and _loadLastUpdated are called while initiate',
+      function() {
+        assert.ok(updateCheck._loadLastUpdated.called);
+    });
+
+    test('_checkForUpdates is called when initiate', function() {
+      updateCheck._elements.checkUpdateNow.dispatchEvent(
+        new CustomEvent('click'));
+      assert.ok(updateCheck._checkForUpdates.called);
+    });
+  });
+
+  suite('checkForUpdates >', function() {
+    setup(function() {
+      this.sinon.stub(updateCheck, '_onUpdateStatus');
+      updateCheck._checkForUpdates();
+    });
+
+    test('triggers the updates', function() {
+      var setting = 'gaia.system.checkForUpdates';
+      assert.isTrue(navigator.mozSettings.mSettings[setting]);
+    });
+
+    test('register handlers', function() {
+      assert.isFunction(updateCheck._checkStatus[geckoUpdateSetting].cb);
+      assert.isFunction(updateCheck._checkStatus[appsUpdateSetting].cb);
+    });
+
+    test('displays the checking updates text', function() {
+      assert.isTrue(updateCheck._elements.updateStatus
+        .classList.contains('checking'));
+      assert.isTrue(updateCheck._elements.updateStatus
+        .classList.contains('visible'));
+      assert.equal(updateCheck._elements.systemStatus.textContent.length, 0);
+    });
+
+    suite('getting response for system update >', function() {
+      suite('successful >', function() {
+        setup(function() {
+          navigator.mozSettings.mTriggerObservers(geckoUpdateSetting, {
+            settingValue: 'check-complete'
+          });
+        });
+
+        test('does not hide the status', function() {
+          assert.isTrue(updateCheck._elements.updateStatus.classList
+            .contains('visible'));
+        });
+
+        test('does not hide the checking updates text', function() {
+          assert.isTrue(updateCheck._elements.updateStatus.classList
+            .contains('checking'));
+        });
+      });
+    });
+
+    suite('getting response for app update >', function() {
+      suite('successful >', function() {
+        setup(function() {
+          navigator.mozSettings.mTriggerObservers(appsUpdateSetting, {
+            settingValue: 'check-complete'
+          });
+        });
+
+        test('does not hide the status', function() {
+          assert.isTrue(updateCheck._elements.updateStatus.classList
+            .contains('visible'));
+        });
+
+        test('does not hide the checking updates text', function() {
+          assert.isTrue(updateCheck._elements.updateStatus.classList
+            .contains('checking'));
+        });
+      });
+    });
+  });
+
+  suite('onUpdateStatus >', function() {
+    setup(function() {
+      this.sinon.stub(updateCheck, '_statusCompleteUpdater');
+    });
+
+    teardown(function() {
+      navigator.mozSettings.mTeardown();
+    });
+
+    test('system update _checkStatus value is updated', function(){
+      updateCheck._onUpdateStatus(geckoUpdateSetting,
+        {settingValue: 'check-complete'});
+
+      assert.equal(updateCheck._checkStatus[geckoUpdateSetting].value,
+        'check-complete');
+    });
+
+    test('app update _checkStatus value is updated', function(){
+      updateCheck._onUpdateStatus(appsUpdateSetting,
+        {settingValue: 'check-complete'});
+
+      assert.equal(updateCheck._checkStatus[appsUpdateSetting].value,
+        'check-complete');
+    });
+
+    test('no-updates', function() {
+      updateCheck._onUpdateStatus(appsUpdateSetting,
+        {settingValue: 'no-updates'});
+
+      assert.equal(updateCheck._elements.systemStatus
+        .getAttribute('data-l10n-id'), 'no-updates');
+    });
+
+    test('already-latest-version', function() {
+      updateCheck._onUpdateStatus(appsUpdateSetting,
+        {settingValue: 'already-latest-version'});
+
+      assert.equal(updateCheck._elements.systemStatus
+        .getAttribute('data-l10n-id'), 'already-latest-version');
+    });
+
+    test('retry-when-online', function() {
+      updateCheck._onUpdateStatus(appsUpdateSetting,
+        {settingValue: 'retry-when-online'});
+
+      assert.equal(updateCheck._elements.systemStatus
+        .getAttribute('data-l10n-id'), 'retry-when-online');
+    });
+
+    test('check-error', function() {
+      var errors = ['check-error-http-200', 'check-error-http-403',
+                    'check-error-http-404', 'check-error-http-500',
+                    'check-error-2152398878'];
+      for (var i = 0; i < errors.length; i++) {
+        updateCheck._onUpdateStatus(appsUpdateSetting,
+          {settingValue: errors[i]});
+
+        assert.equal(updateCheck._elements.systemStatus
+          .getAttribute('data-l10n-id'), 'check-error');
+      }
+    });
+
+    test('remove the system update handler', function() {
+      this.sinon.spy(navigator.mozSettings, 'removeObserver');
+      updateCheck._checkForUpdates();
+      navigator.mozSettings.mTriggerObservers(geckoUpdateSetting, {
+        settingValue: 'check-complete'
+      });
+
+      var removedObserver = navigator.mozSettings
+        .mRemovedObservers[geckoUpdateSetting][0];
+      assert.isFunction(removedObserver);
+      assert.ok(navigator.mozSettings.removeObserver.calledWith(
+        geckoUpdateSetting));
+    });
+  });
+
+  suite('_statusCompleteUpdater >', function() {
+    suite('both successful >', function() {
+      setup(function() {
+        updateCheck._elements.updateStatus.classList
+          .add('checking', 'visible');
+        updateCheck._checkStatus[geckoUpdateSetting].value = 'check-complete';
+        updateCheck._checkStatus[appsUpdateSetting].value = 'check-complete';
+        updateCheck._statusCompleteUpdater();
+      });
+
+      test('hides the status', function() {
+        assert.isTrue(updateCheck._elements.updateStatus.classList
+          .contains('visible'));
+        this.clock.tick(5001);
+        assert.isFalse(updateCheck._elements.updateStatus.classList
+          .contains('visible'));
+      });
+
+      test('removes the text in the system description', function() {
+        assert.equal(updateCheck._elements.systemStatus.textContent.length, 0);
+      });
+
+      test('hide the checking updates text', function() {
+        assert.isFalse(updateCheck._elements.updateStatus.classList
+          .contains('checking'));
+      });
+    });
+
+    suite('not both successful >', function() {
+      setup(function() {
+        updateCheck._elements.updateStatus.classList
+          .add('checking', 'visible');
+        updateCheck._checkStatus[geckoUpdateSetting].value = 'no-updates';
+        updateCheck._checkStatus[appsUpdateSetting].value = 'check-complete';
+        updateCheck._statusCompleteUpdater();
+      });
+
+      test('hide the status', function() {
+        assert.isTrue(updateCheck._elements.updateStatus.classList
+          .contains('visible'));
+        this.clock.tick(5001);
+        assert.isFalse(updateCheck._elements.updateStatus.classList
+          .contains('visible'));
+      });
+
+      test('hide the checking updates text', function() {
+        assert.isFalse(updateCheck._elements.updateStatus.classList
+          .contains('checking'));
+      });
+
+      suite('starting an update again >', function() {
+        setup(function() {
+          updateCheck._statusCompleteUpdater();
+        });
+
+        test('should remove the text', function() {
+          assert.equal(updateCheck._elements.systemStatus
+            .textContent.length, 0);
+        });
+      });
+    });
+  });
+});