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/system/test/unit/telephony_settings_test.js

@@ -0,0 +1,299 @@
+'use strict';
+/* global MocksHelper, MockSettingsHelper, BaseModule */
+
+requireApp('system/shared/test/unit/mocks/mock_settings_helper.js');
+requireApp('system/test/unit/mock_lazy_loader.js');
+requireApp('system/js/service.js');
+requireApp('system/js/base_module.js');
+requireApp('system/js/telephony_settings.js');
+
+var mocksForTelephonySettings = new MocksHelper([
+  'SettingsHelper', 'LazyLoader'
+]).init();
+
+suite('system/TelephonySettings', function() {
+  var subject;
+  mocksForTelephonySettings.attachTestHelpers();
+
+  var functionsUnderTest = [
+    'initVoicePrivacy',
+    'initRoaming',
+    'initCallerIdPreference',
+    'initPreferredNetworkType'
+  ];
+
+  var reqResponse = {
+    onerror: function() {}
+  };
+
+  var fakeConnections = [{
+    setVoicePrivacyMode: function() {},
+    setRoamingPreference: function() {},
+    getCallingLineIdRestriction: function() {},
+    setCallingLineIdRestriction: function() {},
+    setPreferredNetworkType: function() {},
+    supportedNetworkTypes: ['gsm', 'wcdma', 'cdma', 'evdo'],
+    addEventListener: function() {},
+    removeEventListener: function() {},
+    radioState: 'enabled',
+    voice: {
+      connected: true
+    }
+  }];
+
+  // Stub functions of the subject
+  var stubFunctions = function(subject, exceptions) {
+    exceptions = exceptions || [];
+    return functionsUnderTest.map(function(name) {
+      if (exceptions.indexOf(name) === -1) {
+        return sinon.stub(subject, name);
+      } else {
+        return null;
+      }
+    });
+  };
+
+  suite('constructor', function() {
+    test('sets connections', function() {
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: ['foo'] });
+      assert.deepEqual(subject.connections, ['foo']);
+    });
+
+    test('defaults to empty', function() {
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: null });
+      assert.deepEqual(subject.connections, []);
+    });
+  });
+
+  suite('start', function() {
+    test('calls init methods', function() {
+      navigator.mozMobileConnections = fakeConnections;
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: fakeConnections });
+      var stubs = stubFunctions(subject);
+      subject.start();
+      assert.ok(stubs.every(stub => stub.calledOnce));
+    });
+  });
+
+  suite('initVoicePrivacy', function() {
+    var stub, subject;
+    setup(function() {
+      navigator.mozMobileConnections = fakeConnections;
+      stub = this.sinon.stub(fakeConnections[0], 'setVoicePrivacyMode')
+        .returns(reqResponse);
+
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: fakeConnections });
+      stubFunctions(subject, 'initVoicePrivacy');
+    });
+
+    teardown(function() {
+      stub.restore();
+    });
+
+    test('setVoicePrivacyMode default value', function() {
+      subject.start();
+      assert.ok(stub.calledWith(false));
+    });
+
+    test('setVoicePrivacyMode from settings', function() {
+      MockSettingsHelper.instances['ril.voicePrivacy.enabled'] =
+        {value: ['custom-value']};
+      subject.start();
+      assert.ok(stub.calledWith('custom-value'));
+    });
+  });
+
+  suite('initRoaming', function() {
+    var stub, subject;
+    setup(function() {
+      navigator.mozMobileConnections = fakeConnections;
+      stub = this.sinon.stub(fakeConnections[0], 'setRoamingPreference')
+        .returns(reqResponse);
+
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: fakeConnections });
+      stubFunctions(subject, 'initRoaming');
+    });
+
+    teardown(function() {
+      stub.restore();
+    });
+
+    test('setRoamingPreference default value', function() {
+      subject.start();
+      assert.ok(stub.calledWith('any'));
+    });
+
+    test('setRoamingPreference from settings', function() {
+      MockSettingsHelper.instances['ril.roaming.preference'] =
+        {value: ['custom-value2']};
+      subject.start();
+      assert.ok(stub.calledWith('custom-value2'));
+    });
+  });
+
+  suite('initCallerIdPreference', function() {
+    var getStub, setStub, subject;
+    setup(function() {
+      navigator.mozMobileConnections = fakeConnections;
+      getStub = this.sinon.stub(fakeConnections[0],
+        'getCallingLineIdRestriction').returns(reqResponse);
+      setStub = this.sinon.stub(fakeConnections[0],
+        'setCallingLineIdRestriction').returns(reqResponse);
+      MockSettingsHelper.instances['ril.clirMode'] = {
+        value: ['custom-value-clir']
+      };
+
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: fakeConnections });
+      stubFunctions(subject, 'initCallerIdPreference');
+      sinon.spy(subject, '_registerListenerForCallerIdPreference');
+    });
+
+    teardown(function() {
+      getStub.restore();
+      setStub.restore();
+    });
+
+    test('_registerListenerForCallerIdPreference is called when init',
+      function() {
+        subject.start();
+        reqResponse.onsuccess();
+        assert.ok(subject._registerListenerForCallerIdPreference
+          .calledWith(fakeConnections[0], 0));
+    });
+
+    test('setCallingLineIdRestriction from settings', function() {
+      subject.start();
+      assert.ok(setStub.calledWith('custom-value-clir'));
+    });
+
+    test('setCallingLineIdRestriction should not be called when user ' +
+      'preference is not available', function() {
+        MockSettingsHelper.instances['ril.clirMode'] = {
+          value: null
+        };
+        subject.start();
+        assert.ok(setStub.notCalled);
+    });
+
+    test('_syncCallerIdPreferenceWithCarrier should set a default value when ' +
+      'necessary', function() {
+        MockSettingsHelper.instances['ril.clirMode'] = {
+          value: null
+        };
+
+        var fakeValue = 1;
+        var mockSettingsHelper = MockSettingsHelper('ril.clirMode');
+
+        this.sinon.stub(subject, '_getCallerIdPreference',
+          function(conn, callback) {
+            callback(fakeValue);
+        });
+        this.sinon.stub(mockSettingsHelper, 'set');
+
+        subject._syncCallerIdPreferenceWithCarrier({}, 0, mockSettingsHelper);
+        assert.deepEqual(
+          mockSettingsHelper.set.getCall(0).args[0], [fakeValue]);
+    });
+  });
+
+  suite('initPreferredNetworkType', function() {
+    var stub, subject;
+    setup(function() {
+      navigator.mozMobileConnections = fakeConnections;
+      stub = this.sinon.stub(fakeConnections[0], 'setPreferredNetworkType')
+        .returns(reqResponse);
+
+      subject = BaseModule.instantiate('TelephonySettings',
+        { mobileConnections: fakeConnections });
+      stubFunctions(subject, 'initPreferredNetworkType');
+    });
+
+    teardown(function() {
+      stub.restore();
+      MockSettingsHelper.mTeardown();
+    });
+
+    test('setPreferredNetworkType default value', function() {
+      subject.start();
+      assert.ok(stub.calledWith('wcdma/gsm/cdma/evdo'));
+    });
+
+    test('setPreferredNetworkType from settings', function() {
+      MockSettingsHelper.instances['ril.radio.preferredNetworkType'] =
+        {value: ['custom-value3']};
+      subject.start();
+      assert.ok(stub.calledWith('custom-value3'));
+    });
+
+    test('setPreferredNetworkType is not called when radio state is not ' +
+      'enabled', function() {
+        var fakeConnection = fakeConnections[0];
+        var originalRadioState = fakeConnection.radioState;
+
+        fakeConnection.radioState = 'disabled';
+        subject.start();
+        assert.ok(stub.notCalled);
+        fakeConnection.radioState = originalRadioState;
+    });
+
+    test('setPreferredNetworkType is called when radio state becomes enabled',
+      function() {
+        var fakeConnection = fakeConnections[0];
+        var originalRadioState = fakeConnection.radioState;
+        var callbacks = {
+          'radiostatechange': []
+        };
+        sinon.stub(fakeConnection, 'addEventListener',
+          function(event, callback) {
+            if (callbacks[event]) {
+              callbacks[event].push(callback);
+            }
+        });
+        sinon.spy(fakeConnection, 'removeEventListener');
+
+        fakeConnection.radioState = 'disabled';
+        subject.start();
+        fakeConnection.radioState = 'enabled';
+        callbacks.radiostatechange.forEach(function(callback) {
+          callback();
+        });
+
+        assert.ok(stub.calledOnce);
+        // Ensure that the event listener is removed correctly
+        sinon.assert.calledWith(fakeConnection.removeEventListener,
+          'radiostatechange', callbacks.radiostatechange[0]);
+
+        fakeConnection.addEventListener.restore();
+        fakeConnection.removeEventListener.restore();
+        fakeConnection.radioState = originalRadioState;
+    });
+
+    test('should save a default value when ril.radio.preferredNetworkType is ' +
+      'empty', function() {
+        var fakeDefaultValue = ['fakeValue'];
+        sinon.stub(subject, '_getDefaultPreferredNetworkTypes')
+          .returns(fakeDefaultValue);
+
+        subject.start();
+        assert.deepEqual(fakeDefaultValue,
+          MockSettingsHelper.instances['ril.radio.preferredNetworkType'].value);
+    });
+
+    test('should migrate when ril.radio.preferredNetworkType is a string',
+      function() {
+        var fakeValue = 'fakeValue';
+        MockSettingsHelper.instances['ril.radio.preferredNetworkType'] =
+          { value: fakeValue };
+
+        subject.start();
+        assert.deepEqual([fakeValue],
+          MockSettingsHelper.instances['ril.radio.preferredNetworkType'].value);
+    });
+  });
+});