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/app_permissions/app_permissions_detail_test.js

@@ -0,0 +1,203 @@
+/* global MockMozApps, MockPermissionSettings */
+'use strict';
+suite('app permission detail > ', function() {
+  var mockConfirmDialog, realConfirmDialog;
+  var PermissionDetail;
+
+  var mock_elements = {
+    detailTitle: {
+      textContent: false
+    },
+    uninstallButton: {
+      disabled: false
+    },
+    developerInfos: {
+      hidden: false
+    },
+    developerHeader: {
+      hidden: false
+    },
+    developerLink: {
+      href: 'testDeveloperLink'
+    },
+    developerName: {
+      textContent: 'testDeveloperName'
+    },
+    developerUrl: {
+      textContent: 'testDeveloperLink'
+    },
+    list: {
+      appendChild: function(item) {
+        mock_elements.list.children.push(item);
+      },
+      children: [],
+      innerHTML: 'listHTML'
+    },
+    header: {
+      hidden: false
+    }
+  };
+
+  var mockSelectEvent = {
+    target: {
+      dataset: {
+        perm: 'testComposedPermissions'
+      },
+      fakeAttributes: {},
+      setAttribute: function(attr, value) {
+        this.fakeAttributes[attr] = value;
+      },
+      value: null
+    }
+  };
+
+  var mock_app = {
+    manifest: {
+      name: 'testAppName',
+      developer: {
+        name: 'testDeveloperName',
+        url: 'testDeveloperUrl'
+      }
+    },
+    removable: true,
+    manifestURL: 'testManifestURL',
+    origin: 'testOrigin'
+  };
+
+  var mock_permissionsTable = {
+    composedPermissions: ['testComposedPermissions'],
+    accessModes: ['read', 'write', 'create'],
+    plainPermissions: [
+      'testPlainPermissions'
+    ]
+  };
+
+  mockConfirmDialog = function(value) {
+    return value;
+  };
+
+  suiteSetup(function(done) {
+    var modules = [
+      'panels/app_permissions_detail/app_permissions_detail'
+    ];
+
+    var maps = {
+      'panels/app_permissions_detail/app_permissions_detail': {
+        'shared/manifest_helper': 'shared_mocks/mock_manifest_helper',
+        'modules/settings_service': 'unit/mock_settings_service',
+        'modules/navigator/mozApps': 'unit/mock_moz_apps',
+        'modules/navigator/mozPermissionSettings':
+          'shared_mocks/mock_permission_settings'
+      }
+    };
+    testRequire(modules, maps,
+      function(PermissionDetailModule) {
+        realConfirmDialog = window.confirm;
+        window.confirm = mockConfirmDialog;
+
+        PermissionDetail = PermissionDetailModule;
+
+        done();
+    });
+  });
+
+  suiteTeardown(function() {
+    window.confirm = realConfirmDialog;
+  });
+
+  suite('Start test appPermissionDetail module', function() {
+    var permissionDetail;
+    var mock_perm_not_composed = 'testNotComposedPermission';
+    setup(function() {
+      MockPermissionSettings.set('testComposedPermissions-read', 'prompt');
+      MockPermissionSettings.set('testPlainPermissions', 'allow');
+      permissionDetail = PermissionDetail();
+      permissionDetail.init(mock_elements, mock_permissionsTable);
+    });
+
+    teardown(function() {
+      MockPermissionSettings.mTeardown();
+    });
+
+    test('selectValueChanged', function() {
+      permissionDetail.showAppDetails(mock_app);
+      mockSelectEvent.target.value = 'prompt';
+      permissionDetail.selectValueChanged(mockSelectEvent);
+      assert.equal(MockPermissionSettings.get('testComposedPermissions-read'),
+       'prompt', 'should display prompt permission value from' +
+       'mozPermissionSettings if user has selected');
+
+      mockSelectEvent.target.dataset.perm = mock_perm_not_composed;
+      mockSelectEvent.target.value = 'deny';
+      permissionDetail.selectValueChanged(mockSelectEvent);
+      assert.equal(MockPermissionSettings.get(mock_perm_not_composed),
+       'deny', 'should be able to set not composed permission all to deny');
+    });
+
+    test('showAppDetails, test the content of detail dialog', function() {
+      permissionDetail.showAppDetails(mock_app);
+
+      var selectOption = mock_elements.list.children[0];
+      var target = selectOption.querySelector('[selected="true"]');
+      var selectItem = selectOption.querySelector('select');
+      assert.equal(target.value, 'allow');
+      assert.equal(selectItem.dataset.perm, 'testPlainPermissions');
+
+      selectOption = mock_elements.list.children[1];
+      target = selectOption.querySelector('[selected="true"]');
+      selectItem = selectOption.querySelector('select');
+      assert.equal(target.value, 'prompt');
+      assert.equal(selectItem.dataset.perm, 'testComposedPermissions');
+
+      assert.equal(permissionDetail._elements.detailTitle.textContent,
+        mock_app.manifest.name);
+      assert.equal(permissionDetail._elements.uninstallButton.disabled,
+        !mock_app.removable);
+      assert.equal(permissionDetail._elements.developerName.textContent,
+        mock_app.manifest.developer.name);
+      assert.equal(permissionDetail._elements.developerInfos.hidden,
+        false);
+      assert.equal(permissionDetail._elements.developerHeader.hidden,
+        false);
+      assert.equal(permissionDetail._elements.developerUrl.hidden,
+        false);
+      assert.equal(permissionDetail._elements.developerLink.href,
+        mock_app.manifest.developer.url);
+      assert.equal(permissionDetail._elements.developerUrl.textContent,
+        mock_app.manifest.developer.url);
+      assert.equal(permissionDetail._elements.header.hidden,
+        false);
+
+      mock_app.manifest.developer.url = null;
+      permissionDetail.showAppDetails(mock_app);
+      assert.equal(permissionDetail._elements.developerLink.href,
+        undefined);
+      assert.equal(permissionDetail._elements.developerUrl.hidden,
+        true);
+
+      delete mock_app.manifest.developer;
+      permissionDetail.showAppDetails(mock_app);
+      assert.equal(permissionDetail._elements.developerInfos.hidden,
+        true);
+      assert.equal(permissionDetail._elements.developerHeader.hidden,
+        true);
+    });
+
+    test('uninstall', function() {
+      MockMozApps.mSetApps([mock_app]);
+      permissionDetail.showAppDetails(mock_app);
+      permissionDetail.uninstall();
+      assert.equal(MockMozApps.mApps.length, 0,
+        'should have no memeber in mozAppList if we remove it.');
+    });
+
+    test('would go back to previous panel when uninstalled', function() {
+      permissionDetail = PermissionDetail();
+      this.sinon.stub(permissionDetail, 'back');
+      permissionDetail.init(mock_elements, mock_permissionsTable);
+
+      window.dispatchEvent(new CustomEvent('applicationuninstall'));
+      assert.isTrue(permissionDetail.back.called);
+    });
+  });
+});

gaia/apps/settings/test/unit/panels/app_permissions/app_permissions_list_test.js

@@ -0,0 +1,167 @@
+/* global MockPermissionSettings */
+
+'use strict';
+suite('app permission list > ', function() {
+  var permissionList;
+  var mockAppsCache;
+  var mockMozApps;
+
+  var modules = [
+    'unit/mock_apps_cache',
+    'unit/mock_moz_apps',
+    'panels/app_permissions_list/app_permissions_list'
+  ];
+
+  var maps = {
+    'panels/app_permissions_list/app_permissions_list': {
+      'shared/manifest_helper': 'shared_mocks/mock_manifest_helper',
+      'modules/settings_service': 'unit/mock_settings_service',
+      'shared/settings_listener': 'shared_mocks/mock_settings_listener',
+      'modules/navigator/mozApps': 'unit/mock_moz_apps',
+      'modules/apps_cache': 'unit/mock_apps_cache',
+      'modules/navigator/mozPermissionSettings':
+        'shared_mocks/mock_permission_settings'
+    }
+  };
+
+  var mock_listRoot;
+
+  var mock_app1 = {
+    manifest: {
+      name: 'testAppName1',
+      developer: {
+        name: 'testDeveloperName',
+        url: 'testDeveloperUrl'
+      },
+      icons: null
+    },
+    removable: true,
+    manifestURL: 'testManifestURL',
+    origin: 'testOrigin1'
+  };
+
+  var mock_app2 = {
+    manifest: {
+      // When we execute _sortApps, mock_app2 will be placed in front of
+      // mock_app1.
+      name: 'atestAppName2',
+      developer: {
+        name: 'testDeveloperName',
+        url: 'testDeveloperUrl'
+      },
+      type: 'certified',
+      icons: {
+        30: 'http://test30',
+        60: 'http://test60'
+      }
+    },
+    removable: true,
+    manifestURL: 'testManifestURL',
+    origin: 'testOrigin2'
+  };
+
+  var mock_permissionsTable = {
+    permissionsTable: ['testApp'],
+    composedPermissions: ['testComposedPermissions'],
+    accessModes: ['read', 'write', 'create'],
+    plainPermissions: ['testApp']
+  };
+
+  setup(function(done) {
+    // We have to make listRoot clean every round
+    mock_listRoot = {
+      children: [],
+      appendChild: function(item) {
+        this.children.push(item);
+      }
+    };
+
+    testRequire(modules, maps, function(MockAppsCache, MockMozApps,
+      PermissionListModule) {
+        mockAppsCache = MockAppsCache;
+        mockMozApps = MockMozApps;
+        permissionList = PermissionListModule();
+        done();
+    });
+  });
+
+  suite('Start test appPermissionList module', function() {
+    setup(function() {
+      this.sinon.stub(mockMozApps, 'getSelf', function() {
+        return Promise.resolve(mock_app2);
+      });
+
+      MockPermissionSettings.set('testComposedPermissions-read', true);
+      mockAppsCache._apps = [mock_app1, mock_app2];
+
+      permissionList.init(mock_listRoot);
+      permissionList.setPermissionsTable(mock_permissionsTable);
+      permissionList._permissionTableHaveProcessed = false;
+    });
+
+    test('the app list content when push mock_app1 to permission list',
+      function(done) {
+        permissionList.refresh().then(function() {
+          var list = permissionList._listRoot.children[0];
+          var deviceRatio = window.devicePixelRatio || 1;
+          var choosedIcon = deviceRatio * 30;
+
+          assert.equal(list.querySelector('li:nth-child(1) a')
+            .dataset.appIndex, 0, 'the appIndex of first app should be 0');
+
+          assert.equal(list.querySelector('li:nth-child(1) img').src,
+            mock_app2.manifest.icons[choosedIcon] + '/',
+            'should show the icon from app manifest if it has');
+
+          assert.equal(
+            list.querySelector('li:nth-child(2) a').dataset.appIndex, 1);
+
+          assert.include(list.querySelector('li:nth-child(2) img').src,
+            'test/style/images/default.png',
+            'should show default icon if it is not defined in its manifest');
+
+          assert.equal(permissionList._permissionTableHaveProcessed, true);
+        }, function() {
+          // This line should not be rejected
+          assert.isTrue(false);
+        }).then(done, done);
+    });
+  });
+
+  suite('_onApplicationInstall', function() {
+    setup(function() {
+      permissionList.init(mock_listRoot);
+      permissionList._apps = [];
+      permissionList._onApplicationInstall({
+        application: mock_app1
+      });
+    });
+
+    test('will render the images right', function() {
+      var list = permissionList._listRoot.children[0];
+      assert.include(list.querySelector('li:nth-child(1) img').src,
+        'test/style/images/default.png',
+        'should display info of mock_app1 after we install it');
+    });
+  });
+
+  suite('_onApplicationUninstall', function() {
+    setup(function() {
+      permissionList.init(mock_listRoot);
+      permissionList._apps = [mock_app1, mock_app2];
+      permissionList._onApplicationUninstall({
+        application: {
+          origin: mock_app2.origin
+        }
+      });
+    });
+
+    test('will render the images right', function() {
+      var list = permissionList._listRoot.children[0];
+      assert.equal(list.querySelector('li:nth-child(1) a').dataset.appIndex, 0);
+      assert.include(list.querySelector('li:nth-child(1) img').src,
+        'test/style/images/default.png',
+        'should display info of mock_app1 when we remove mock_app2');
+    });
+  });
+});