[MD settings] show blocked sites even when category is blocked

chrome/test/data/webui/settings/site_list_tests.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** @fileoverview Suite of tests for site-list. */
 cr.define('site_list', function() {
   function registerTests() {
     suite('SiteList', function() {
       /**
        * A site list element created before each test.
@@ skipping 346 matching lines @@
        */
       function assertMenu(items) {
         var menuItems = getMenuItems();
         assertEquals(items.length, menuItems.length);
         for (var i = 0; i < items.length; i++)
           assertEquals(items[i], menuItems[i].textContent.trim());
       }
 
       /**
        * Configures the test element for a particular category.
-       * @param {settings.ContentSettingsTypes} category The category to setup.
+       * @param {settings.ContentSettingsTypes} category The category to set up.
        * @param {settings.PermissionValues} subtype Type of list to use.
        * @param {Array<dictionary>} prefs The prefs to use.
        */
-      function setupCategory(category, subtype, prefs) {
+      function setUpCategory(category, subtype, prefs) {
         browserProxy.setPrefs(prefs);
         if (category == settings.ALL_SITES) {
           testElement.categorySubtype = settings.INVALID_CATEGORY_SUBTYPE;
           testElement.allSites = true;
         } else {
           testElement.categorySubtype = subtype;
           testElement.allSites = false;
         }
         // Some route is needed, but the actual route doesn't matter.
         testElement.currentRoute = {
           page: 'dummy',
           section: 'privacy',
           subpage: ['site-settings', 'site-settings-category-location'],
         };
         testElement.category = category;
       }
 
       test('getExceptionList API used', function() {
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsEmpty);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
             });
       });
 
       test('Empty list', function() {
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsEmpty);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
               assertEquals(0, testElement.sites.length);
 
               assertEquals(
                   settings.PermissionValues.ALLOW, testElement.categorySubtype);
 
               assertFalse(testElement.$.category.hidden);
               browserProxy.resetResolver('getExceptionList');
               testElement.categoryEnabled = false;
               return browserProxy.whenCalled('getExceptionList');
             }).then(function(contentType) {
               assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('initial ALLOW state is correct', function() {
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
               assertEquals(2, testElement.sites.length);
               assertEquals(prefs.exceptions.geolocation[1].origin,
                   testElement.sites[0].origin);
               assertEquals(
                   settings.PermissionValues.ALLOW, testElement.categorySubtype);
               Polymer.dom.flush();  // Populates action menu.
               openActionMenu(0);
               assertMenu(['Block', 'Remove'], testElement);
 
               // Site list should show, no matter what category default is set
               // to.
               assertFalse(testElement.$.category.hidden);
               browserProxy.resetResolver('getExceptionList');
               testElement.categoryEnabled = false;
               return browserProxy.whenCalled('getExceptionList');
             }).then(function(contentType) {
               assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('initial BLOCK state is correct', function() {
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.BLOCK, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
               assertEquals(2, testElement.sites.length);
               assertEquals(prefs.exceptions.geolocation[3].origin,
                   testElement.sites[0].origin);
 
               assertEquals(
                   settings.PermissionValues.BLOCK, testElement.categorySubtype);
               Polymer.dom.flush();  // Populates action menu.
               openActionMenu(0);
               assertMenu(['Allow', 'Remove'], testElement);
 
-              // Site list should only show when category default is enabled.
+              // Site list should show regardless of whether category the
+              // default is enabled.

[dpapad, 2016/11/07 21:59:35]

Seems that there is an extra "the", not sure.

[dschuyler, 2016/11/07 23:54:04]

Done.

               assertFalse(testElement.$.category.hidden);
               browserProxy.resetResolver('getExceptionList');
               testElement.categoryEnabled = false;
               return browserProxy.whenCalled('getExceptionList');
             }).then(function(contentType) {
-              assertTrue(testElement.$.category.hidden);
+              assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('initial SESSION ONLY state is correct', function() {
-        setupCategory(settings.ContentSettingsTypes.COOKIES,
+        setUpCategory(settings.ContentSettingsTypes.COOKIES,
             settings.PermissionValues.SESSION_ONLY, prefsSessionOnly);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.COOKIES, contentType);
 
               assertEquals(1, testElement.sites.length);
               assertEquals(prefsSessionOnly.exceptions.cookies[2].origin,
                   testElement.sites[0].origin);
 
               assertEquals(settings.PermissionValues.SESSION_ONLY,
                   testElement.categorySubtype);
               Polymer.dom.flush();  // Populates action menu.
               openActionMenu(0);
               assertMenu(['Allow', 'Block', 'Remove'], testElement);
 
               // Site list should show, no matter what category default is set
               // to.
               assertFalse(testElement.$.category.hidden);
               browserProxy.resetResolver('getExceptionList');
               testElement.categoryEnabled = false;
               return browserProxy.whenCalled('getExceptionList');
             }).then(function(contentType) {
               assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('initial INCOGNITO BLOCK state is correct', function() {
-        setupCategory(settings.ContentSettingsTypes.COOKIES,
+        setUpCategory(settings.ContentSettingsTypes.COOKIES,
             settings.PermissionValues.BLOCK, prefsIncognito);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(settings.ContentSettingsTypes.COOKIES, contentType);
 
               assertEquals(1, testElement.sites.length);
               assertEquals(prefsIncognito.exceptions.cookies[0].origin,
                   testElement.sites[0].origin);
 
               assertEquals(settings.PermissionValues.BLOCK,
@@ skipping 11 matching lines @@
                   'resetCategoryPermissionForOrigin');
             }).then(function(args) {
               assertEquals('http://foo.com', args[0]);
               assertEquals('http://foo.com', args[1]);
               assertEquals(settings.ContentSettingsTypes.COOKIES, args[2]);
               assertFalse(args[3]);  // Incognito.
             });
       });
 
       test('initial INCOGNITO ALLOW state is correct', function() {
-        setupCategory(settings.ContentSettingsTypes.COOKIES,
+        setUpCategory(settings.ContentSettingsTypes.COOKIES,
             settings.PermissionValues.ALLOW, prefsIncognito);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.COOKIES, contentType);
 
               assertEquals(2, testElement.sites.length);
               assertEquals(prefsIncognito.exceptions.cookies[2].origin,
                   testElement.sites[0].origin);
               assertEquals(prefsIncognito.exceptions.cookies[1].origin,
@@ skipping 16 matching lines @@
                   'resetCategoryPermissionForOrigin');
             }).then(function(args) {
               assertEquals('http://foo.com', args[0]);
               assertEquals('http://foo.com', args[1]);
               assertEquals(settings.ContentSettingsTypes.COOKIES, args[2]);
               assertTrue(args[3]);  // Incognito.
             });
       });
 
       test('list items shown and clickable when data is present', function() {
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               testElement.enableSiteSettings_ = true;
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
               // Required for firstItem to be found below.
               Polymer.dom.flush();
 
               // Validate that the sites gets populated from pre-canned prefs.
               assertEquals(2, testElement.sites.length);
               assertEquals(prefs.exceptions.geolocation[1].origin,
                   testElement.sites[0].origin);
               assertEquals(undefined, testElement.selectedOrigin);
 
               // Validate that the sites are shown in UI and can be selected.
               var firstItem = testElement.$.listContainer.children[0];
               var clickable = firstItem.querySelector('.middle');
               assertNotEquals(undefined, clickable);
               MockInteractions.tap(clickable);
               assertEquals(prefs.exceptions.geolocation[1].origin,
                   testElement.selectedSite.origin);
             });
       });
 
       test('Block list open when Allow list is empty', function() {
         // Prefs: One item in Block list, nothing in Allow list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.BLOCK, prefsOneDisabled);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
               assertFalse(testElement.$.category.hidden);
             }).then(function() {
               assertNotEquals(0, testElement.$.listContainer.offsetHeight);
             });
       });
 
       test('Block list closed when Allow list is not empty', function() {
         // Prefs: Items in both Block and Allow list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.BLOCK, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
               assertFalse(testElement.$.category.hidden);
               assertEquals(0, testElement.$.listContainer.offsetHeight);
             });
       });
 
       test('Allow list is always open (Block list empty)', function() {
         // Prefs: One item in Allow list, nothing in Block list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsOneEnabled);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
               assertFalse(testElement.$.category.hidden);
             }).then(function() {
               assertNotEquals(0, testElement.$.listContainer.offsetHeight);
             });
       });
 
       test('Allow list is always open (Block list non-empty)', function() {
         // Prefs: Items in both Block and Allow list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
               assertFalse(testElement.$.category.hidden);
             }).then(function() {
               assertNotEquals(0, testElement.$.listContainer.offsetHeight);
             });
       });
 
       test('Block list not hidden when empty', function() {
         // Prefs: One item in Allow list, nothing in Block list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.BLOCK, prefsOneEnabled);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
               assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('Allow list not hidden when empty', function() {
         // Prefs: One item in Block list, nothing in Allow list.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsOneDisabled);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
               assertFalse(testElement.$.category.hidden);
             });
       });
 
       test('All sites category', function() {
         // Prefs: Multiple and overlapping sites.
-        setupCategory(settings.ALL_SITES, '', prefsVarious);
+        setUpCategory(settings.ALL_SITES, '', prefsVarious);
 
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               // Use resolver to ensure asserts bubble up to the framework with
               // meaningful errors.
               var resolver = new PromiseResolver();
               testElement.async(resolver.resolve);
               return resolver.promise.then(function() {
                 testElement.enableSiteSettings_ = true;
                 // All Sites calls getExceptionList for all categories, starting
@@ skipping 23 matching lines @@
                 assertNotEquals(undefined, clickable);
                 MockInteractions.tap(clickable);
                 assertEquals(prefsVarious.exceptions.geolocation[0].origin,
                     testElement.selectedSite.origin);
               });
             });
       });
 
       test('All sites mixed pattern and origin', function() {
         // Prefs: One site, represented as origin and pattern.
-        setupCategory(settings.ALL_SITES, '', prefsMixedOriginAndPattern);
+        setUpCategory(settings.ALL_SITES, '', prefsMixedOriginAndPattern);
 
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               // Use resolver to ensure asserts bubble up to the framework with
               // meaningful errors.
               var resolver = new PromiseResolver();
               testElement.async(resolver.resolve);
               return resolver.promise.then(function() {
                 testElement.enableSiteSettings_ = true;
                 // All Sites calls getExceptionList for all categories, starting
@@ skipping 21 matching lines @@
                 MockInteractions.tap(clickable);
                 assertEquals(
                     prefsMixedOriginAndPattern.exceptions.geolocation[0].origin,
                     testElement.selectedSite.originForDisplay);
               });
             });
       });
 
       test('Mixed schemes (present and absent)', function() {
         // Prefs: One item with scheme and one without.
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsMixedSchemes);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               // No further checks needed. If this fails, it will hang the test.
             });
       });
 
       test('Select menu item', function() {
         // Test for error: "Cannot read property 'origin' of undefined".
-        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+        setUpCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(function(
             contentType) {
           Polymer.dom.flush();
           openActionMenu(0);
           var menuItems = getMenuItems();
           assertTrue(!!menuItems);
           MockInteractions.tap(menuItems[0]);
           return browserProxy.whenCalled('setCategoryPermissionForOrigin');
         });
       });
 
       test('Chrome Extension scheme', function() {
-        setupCategory(settings.ContentSettingsTypes.JAVASCRIPT,
+        setUpCategory(settings.ContentSettingsTypes.JAVASCRIPT,
             settings.PermissionValues.BLOCK, prefsChromeExtension);
         return browserProxy.whenCalled('getExceptionList').then(function(
             contentType) {
           Polymer.dom.flush();
           openActionMenu(0);
           assertMenu(['Allow', 'Remove'], testElement);
 
           var menuItems = getMenuItems();
           assertTrue(!!menuItems);
           MockInteractions.tap(menuItems[0]);  // Action: Allow.
           return browserProxy.whenCalled('setCategoryPermissionForOrigin');
         }).then(function(args) {
           assertEquals('chrome-extension://cfhgfbfpcbnnbibfphagcjmgjfjmojfa/',
               args[0]);
           assertEquals('', args[1]);
           assertEquals(settings.ContentSettingsTypes.JAVASCRIPT, args[2]);
           assertEquals('allow', args[3]);
         });
       });
     });
   }
   return {
     registerTests: registerTests,
   };
 });