[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);

[dpapad, 2016/11/10 22:22:45]

Does it still makes sense to assert() for both categoryEnabled true/false
values? If so, could we only remove the whenCalled() calls but preserve the
assertions that the still is showing for both true/false?

[dschuyler, 2016/11/10 22:34:38]

I think it made sense to have the prior testing when those two unrelated
things were linked together. It's something that would be easy to break
because the linking wouldn't be obvious to a newcomer. 

When there is no connection between them I think it's less helpful to 
test the (non-) relation. Creating a new relation between those pieces is
as unlikely as creating a relation between any other boolean and showing
the category.

iiuc the question is about doing something like this:

assertFalse(testElement.$.category.hidden);
testElement.categoryEnabled = false;
Polymer.dom.flush();
assertFalse(testElement.$.category.hidden);

I can add that. If that's desired, please let me know. My opinion is 
that it's not needed (doesn't hurt, just not needed).

-              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.
               assertFalse(testElement.$.category.hidden);
-              browserProxy.resetResolver('getExceptionList');
-              testElement.categoryEnabled = false;
-              return browserProxy.whenCalled('getExceptionList');
-            }).then(function(contentType) {
-              assertTrue(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,
   };
 });