Site Settings Desktop: Implement the 'Clear on exit' menu for Cookies.

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 200 matching lines @@
             {
               embeddingOrigin: 'https://foo-block.com:443',
               origin: 'https://foo-block.com:443',
               setting: 'block',
               source: 'preference',
             },
           ]
         }
       };
 
+      /**
+       * An example Cookies pref with 1 in each of the three categories.
+       * @type {SiteSettingsPref}
+       */
+      var prefsSessionOnly = {
+        exceptions: {
+          cookies: [
+            {
+              embeddingOrigin: 'http://foo-block.com',
+              origin: 'http://foo-block.com',
+              setting: 'block',
+              source: 'preference',
+            },
+            {
+              embeddingOrigin: 'http://foo-allow.com',
+              origin: 'http://foo-allow.com',
+              setting: 'allow',
+              source: 'preference',
+            },
+            {
+              embeddingOrigin: 'http://foo-session.com',
+              origin: 'http://foo-session.com',
+              setting: 'session_only',
+              source: 'preference',
+            },
+          ]
+        }
+      };
+
       // Import necessary html before running suite.
       suiteSetup(function() {
         CrSettingsPrefs.setInitialized();
         return PolymerTest.importHtml(
             'chrome://md-settings/site_settings/site_list.html');
       });
 
       suiteTeardown(function() {
         CrSettingsPrefs.resetForTesting();
       });
 
       // Initialize a site-list before each test.
       setup(function() {
         browserProxy = new TestSiteSettingsPrefsBrowserProxy();
         settings.SiteSettingsPrefsBrowserProxyImpl.instance_ = browserProxy;
         PolymerTest.clearBody();
         testElement = document.createElement('settings-site-list');
         document.body.appendChild(testElement);
       });
 
       /**
-       * Asserts if a menu action is incorrectly hidden.
+       * Asserts the menu looks as expected.
+       * @param {Array<string>} items The items expected to show in the menu.
        * @param {!HTMLElement} parentElement The parent node to start looking
        *     in.
-       * @param {string} textForHiddenAction Text content of the only node that
-       *     should be hidden.
        */
-      function assertMenuActionHidden(parentElement, textForHiddenAction) {
+      function assertMenu(items, parentElement) {
         var listItem = parentElement.$.listContainer.children[0];
         var menuItems =
             listItem.querySelectorAll('paper-menu-button paper-item');

[michaelpg, 2016/06/09 18:43:43]

Use the platform, Luke!

var menuItems = listItem.querySelectorAll(
    'paper-menu-button paper-item:not([hidden])');
assertEquals(items.length, menuItems.length);
for (var i = 0; i < items.length; i++)
  assertEquals(items[i], menuItems[i].textContent.trim());

[Finnur, 2016/06/10 14:20:46]

Hey, neat. :)

-        assertNotEquals(0, menuItems.length);
-
-        var found = false;
+        var i = 0;
         menuItems.forEach(function(item) {
           var text = item.textContent.trim();
-          if (text == textForHiddenAction)
-            found = true;
-          assertEquals(text == textForHiddenAction, item.hidden);
+          if (!item.hidden) {
+            assertEquals(items[i], text);
+            ++i;
+          }
         });
-        assertTrue(found);
+        assertEquals(items.length, i);
       }
 
       /**
-       * Configures the test element as a location category.
-       * @param {settings.PermissionValues} subtype Type of list to use: ALLOW
-       *     or BLOCK.
-       * @param Array<dictionary> prefs The prefs to use.
+       * Configures the test element for a particular category.
+       * @param {settings.ContentSettingsTypes} category The category to setup.
+       * @param {settings.PermissionValues} subtype Type of list to use.
+       * @param {Array<dictionary>} prefs The prefs to use.
        */
-      function setupLocationCategory(subtype, prefs) {
+      function setupCategory(category, subtype, prefs) {
         browserProxy.setPrefs(prefs);
-        testElement.categorySubtype = subtype;
-        testElement.categoryEnabled = true;
-        testElement.allSites = false;
+        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 = settings.ContentSettingsTypes.GEOLOCATION;
-      }
-
-      /**
-       * Configures the test element as the all sites category.
-       * @param {dictionary} prefs The prefs to use.
-       */
-      function setupAllSitesCategory(prefs) {
-        browserProxy.setPrefs(prefs);
-        testElement.categorySubtype = settings.INVALID_CATEGORY_SUBTYPE;
-        testElement.categoryEnabled = true;
-        testElement.allSites = true;
-        testElement.prefs = prefs;
-        testElement.currentRoute = {
-          page: 'dummy',
-          section: 'privacy',
-          subpage: ['site-settings', 'site-settings-category-location'],
-        };
-        testElement.category = settings.ALL_SITES;
+        testElement.category = category;
       }
 
       test('getExceptionList API used', function() {
-        setupLocationCategory(settings.PermissionValues.ALLOW, prefsEmpty);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.ALLOW, prefsEmpty);
         return browserProxy.whenCalled('getExceptionList').then(
             function(contentType) {
               assertEquals(
                   settings.ContentSettingsTypes.GEOLOCATION, contentType);
             });
       });
 
       test('Empty list', function() {
-        setupLocationCategory(settings.PermissionValues.ALLOW, prefsEmpty);
+        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);
             assertEquals('Allow - 0', testElement.$.header.innerText.trim());
 
             // Site list should not show, no matter what category default is set
             // to.
             assertTrue(testElement.$.category.hidden);
             browserProxy.resetResolver('getExceptionList');
             testElement.categoryEnabled = false;
             return browserProxy.whenCalled('getExceptionList').then(
               function(contentType) {
                 assertTrue(testElement.$.category.hidden);
                 assertEquals('Exceptions - 0',
                     testElement.$.header.innerText.trim());
             });
           });
       });
 
       test('initial ALLOW state is correct', function() {
-        setupLocationCategory(settings.PermissionValues.ALLOW, prefs);
+        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.
-            assertMenuActionHidden(testElement, 'Allow');
+            assertMenu(['Block', 'Reset to ask'], testElement);
             assertEquals('Allow - 2', testElement.$.header.innerText.trim());
 
             // 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);
                 assertEquals('Exceptions - 2', testElement.$.header.innerText);
             });
           });
       });
 
       test('initial BLOCK state is correct', function() {
-        setupLocationCategory(settings.PermissionValues.BLOCK, prefs);
+        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.
-            assertMenuActionHidden(testElement, 'Block');
+            assertMenu(['Allow', 'Reset to ask'], testElement);
             assertEquals('Block - 2', testElement.$.header.innerText.trim());
 
             // 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,
+            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.
+            assertMenu(['Allow', 'Block', 'Reset to ask'], testElement);
+            assertEquals('Clear on exit - 1',
+                testElement.$.header.innerText.trim());
+
+            // 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) {

[michaelpg, 2016/06/09 18:43:43]

nit: 4-space indent

[Finnur, 2016/06/10 14:20:46]

Done.

+                assertFalse(testElement.$.category.hidden);
+                assertEquals('Clear on exit - 1',
+                    testElement.$.header.innerText);
+            });
+          });
+      });
+
       test('list items shown and clickable when data is present', function() {
-        setupLocationCategory(settings.PermissionValues.ALLOW, prefs);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             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.
-        setupLocationCategory(settings.PermissionValues.BLOCK,
-                              prefsOneDisabled);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.BLOCK, prefsOneDisabled);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertFalse(testElement.$.category.hidden);
             assertTrue(testElement.$.category.opened);
         }).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.
-        setupLocationCategory(settings.PermissionValues.BLOCK, prefs);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.BLOCK, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertFalse(testElement.$.category.hidden);
             assertFalse(testElement.$.category.opened);
             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.
-        setupLocationCategory(
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.ALLOW, prefsOneEnabled);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertFalse(testElement.$.category.hidden);
             assertTrue(testElement.$.category.opened);
         }).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.
-        setupLocationCategory(settings.PermissionValues.ALLOW, prefs);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.ALLOW, prefs);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertFalse(testElement.$.category.hidden);
             assertTrue(testElement.$.category.opened);
         }).then(function() {
             assertNotEquals(0, testElement.$.listContainer.offsetHeight);
         });
       });
 
       test('Block list hidden when empty', function() {
         // Prefs: One item in Allow list, nothing in Block list.
-        setupLocationCategory(
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
             settings.PermissionValues.BLOCK, prefsOneEnabled);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertTrue(testElement.$.category.hidden);
         });
       });
 
       test('Allow list hidden when empty', function() {
         // Prefs: One item in Block list, nothing in Allow list.
-        setupLocationCategory(settings.PermissionValues.ALLOW,
-                              prefsOneDisabled);
+        setupCategory(settings.ContentSettingsTypes.GEOLOCATION,
+            settings.PermissionValues.ALLOW, prefsOneDisabled);
         return browserProxy.whenCalled('getExceptionList').then(
           function(contentType) {
             assertEquals(
                 settings.ContentSettingsTypes.GEOLOCATION, contentType);
 
             assertTrue(testElement.$.category.hidden);
         });
       });
 
       test('All sites category', function() {
         // Prefs: Multiple and overlapping sites.
-        setupAllSitesCategory(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() {
               // All Sites calls getExceptionList for all categories, starting
               // with Cookies.
@@ skipping 22 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.
-        setupAllSitesCategory(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() {
               // All Sites calls getExceptionList for all categories, starting
               // with Cookies.
@@ skipping 20 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.
-        setupLocationCategory(settings.PermissionValues.ALLOW,
-                              prefsMixedSchemes);
+        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.
         });
       });
     });
   }
   return {
     registerTests: registerTests,
   };
 });