Better support for patterns.

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 69 matching lines @@
               embeddingOrigin: 'bar-allow.com',
               origin: 'bar-allow.com',
               setting: 'allow',
               source: 'preference',
             },
           ]
         }
       };
 
       /**
+       * An example pref with mixed origin and pattern.
+       * @type {SiteSettingsPref}
+       */
+      var prefsMixedOriginAndPattern = {
+        exceptions: {
+          media_stream_camera: [],
+          cookies: [],
+          fullscreen: [],
+          geolocation: [
+            {
+              origin: 'https://foo.com',
+              embeddingOrigin: '*',
+              setting: 'allow',
+              source: 'preference',
+            },
+          ],
+          javascript: [
+            {
+              origin: 'https://[*.]foo.com',
+              embeddingOrigin: '*',
+              setting: 'allow',
+              source: 'preference',
+            },
+          ],
+          images: [],
+          media_stream_mic: [],
+          notifications: [],
+          popups: [],
+        }
+      };
+
+      /**
        * An example pref with multiple categories and multiple allow/block
        * state.
        * @type {SiteSettingsPref}
        */
       var prefsVarious = {
         exceptions: {
           media_stream_camera: [],
           cookies: [],
           fullscreen: [],
           geolocation: [
@@ skipping 386 matching lines @@
               assertNotEquals(undefined, clickable);
               MockInteractions.tap(clickable);
               assertEquals(prefsVarious.exceptions.geolocation[0].origin,
                   testElement.selectedSite.origin);
 
               done();
           });
         });
       });
 
+      test('All sites mixed pattern and origin', function(done) {
+        // Prefs: One site, represented as origin and pattern.
+        setupAllSitesCategory(prefsMixedOriginAndPattern);
+
+        browserProxy.whenCalled('getExceptionList').then(
+          function(contentType) {
+            testElement.async(function() {
+              // All Sites calls getExceptionList for all categories, starting
+              // with Cookies.
+              assertEquals(settings.ContentSettingsTypes.COOKIES, contentType);
+
+              // Required for firstItem to be found below.
+              Polymer.dom.flush();
+
+              assertTrue(testElement.$.category.opened);
+              assertFalse(testElement.$.category.hidden);
+              // Validate that the sites gets populated from pre-canned prefs.
+              // If this fails with 2 instead of the expected 1, then the

[michaelpg, 2016/04/11 03:55:35]

nit: move comment to assert message :-)

[Finnur, 2016/04/11 11:45:33]

It doesn't really do anything because all asserts failing in this test result in
an error like this:

Error: Script error. (:0)
", source: mocha_adapter.js (44)

(which has been hugely frustrating in debugging efforts).

[michaelpg, 2016/04/11 14:09:55]

This is because the error is being thrown asynchronously so mocha doesn't know
about it, it's a JS limitation unfortunately.

Mocha gives us two options: call done(error) or return a promise.

1. use try/catch to call "done" with the error:

  browserProxy.whenCalled('foo').then(function(value) {
    testElement.async(function() {
      var error;
      try {
        assertFalse(true);
      } catch (e) {
        error = e;
      }
      done(error);
    });
  });

2. remove "done" and return a promise instead:
  return browserProxy.whenCalled('foo').then(function(value) {
    var resolver = new PromiseResolver();
    testElement.async(resolver.resolve);
    return resolver.promise.then(function() {
      assertFalse(true);
    });
  });

(PromiseResolver is just a helper function to create a promise that can be
resolved by calling resolve(). The point here is to throw *inside* the promise
and return the promise to mocha so it knows what's up.)

+              // de-duping of sites is not working for site_list.
+              assertEquals(1, testElement.sites.length);
+              assertEquals(
+                  prefsMixedOriginAndPattern.exceptions.geolocation[0].origin,
+                  testElement.sites[0].originForDisplay);
+
+              assertEquals(undefined, testElement.selectedOrigin);
+              // Validate that the sites are shown in UI and can be selected.
+              var firstItem = testElement.$.listContainer.items[0];
+              var clickable = firstItem.querySelector('.flex paper-item-body');
+              assertNotEquals(undefined, clickable);
+              MockInteractions.tap(clickable);
+              assertEquals(
+                  prefsMixedOriginAndPattern.exceptions.geolocation[0].origin,
+                  testElement.selectedSite.originForDisplay);
+
+              done();
+          });
+        });
+      });
+
+
       test('Mixed schemes (present and absent)', function() {
         // Prefs: One item with scheme and one without.
         setupLocationCategory(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,
   };
 });