Make the URLs in the password exceptions list clickable.

chrome/test/data/webui/settings/settings_passwords_section_browsertest.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 Runs the Polymer Password Settings tests. */
 
 /** @const {string} Path to root from chrome/test/data/webui/settings/. */
 var ROOT_PATH = '../../../../../';
 
 // Polymer BrowserTest fixture.
@@ skipping 28 matching lines @@
    * Creates a single item for the list of passwords.
    * @param {string} url
    * @param {string} username
    * @param {number} passwordLength
    * @return {chrome.passwordsPrivate.PasswordUiEntry}
    * @private
    */
   createPasswordItem_: function(url, username, passwordLength) {
     return {
       loginPair: {originUrl: url, username: username},
+      linkUrl: 'http://' + url + '/login',
       numCharactersInPassword: passwordLength
     };
   },
 
   /**
+   * Creates a single item for the list of password exceptions.
+   * @param {string} url
+   * @return {chrome.passwordsPrivate.ExceptionPair}
+   * @private
+   */
+  createExceptionItem_: function(url) {
+    return {
+      exceptionUrl: url,
+      linkUrl: 'http://' + url + '/login',
+    };
+  },
+
+  /**
    * Helper method that validates a that elements in the password list match
    * the expected data.
    * @param {!Array<!Element>} nodes The nodes that will be checked.
-   * @param {!Array<!Object>} passwordList The expected data.
+   * @param {!Array<!chrome.passwordsPrivate.PasswordUiEntry>} passwordList The
+   *     expected data.
    * @private
    */
   validatePasswordList: function(nodes, passwordList) {
     assertEquals(passwordList.length, nodes.length);
     for (var index = 0; index < passwordList.length; ++index) {
       var node = nodes[index];
       var passwordInfo = passwordList[index];
       assertEquals(passwordInfo.loginPair.originUrl,
                    node.querySelector('#originUrl').textContent);
+      assertEquals(passwordInfo.linkUrl,
+                   node.querySelector('#originUrl').href);
       assertEquals(passwordInfo.loginPair.username,
                    node.querySelector('#username').textContent);
       assertEquals(passwordInfo.numCharactersInPassword,
                    node.querySelector('#password').value.length);
     }
   },
 
   /**
    * Helper method that validates a that elements in the exception list match
    * the expected data.
    * @param {!Array<!Element>} nodes The nodes that will be checked.
-   * @param {!Array<!Object>} exceptionList The expected data.
+   * @param {!Array<!chrome.passwordsPrivate.ExceptionPair>} exceptionList The
+   *     expected data.
    * @private
    */
   validateExceptionList_: function(nodes, exceptionList) {
     assertEquals(exceptionList.length, nodes.length);
     for (var index = 0; index < exceptionList.length; ++index) {
       var node = nodes[index];
       var exception = exceptionList[index];
-      assertEquals(exception, node.querySelector('#exception').textContent);
+      assertEquals(exception.exceptionUrl,
+                   node.querySelector('#exception').textContent);
+      assertEquals(exception.linkUrl,
+                   node.querySelector('#exception').href);
     }
   },
 
   /**
    * Skips over the template and returns all visible children of an iron-list.
    * @param {!Element} ironList
    * @return {!Array<!Element>}
    * @private
    */
   getIronListChildren_: function(ironList) {
     return Polymer.dom(ironList).children.filter(function(child, i) {
       return i != 0 && !child.hidden;
     });
   },
 
   /**
    * Helper method used to create a password section for the given lists.
    * @param {!Array<!chrome.passwordsPrivate.PasswordUiEntry>} passwordList
-   * @param {!Array<!string>} exceptionList
+   * @param {!Array<!chrome.passwordsPrivate.ExceptionPair>} exceptionList
    * @return {!Object}
    * @private
    */
   createPasswordsSection_: function(passwordList, exceptionList) {
     // Create a passwords-section to use for testing.
     var passwordsSection = document.createElement('passwords-section');
     passwordsSection.savedPasswords = passwordList;
     passwordsSection.passwordExceptions = exceptionList;
     document.body.appendChild(passwordsSection);
     this.flushPasswordSection_(passwordsSection);
@@ skipping 21 matching lines @@
    */
   listContainsUrl(passwordList, url) {
     for (var i = 0; i < passwordList.length; ++i) {
       if (passwordList[i].loginPair.originUrl == url)
         return true;
     }
     return false;
   },
 
   /**
+   * Helper method used to test for a url in a list of passwords.
+   * @param {!Array<!chrome.passwordsPrivate.ExceptionPair>} exceptionList
+   * @param {!string} url The URL that is being searched for.
+   */
+  exceptionsListContainsUrl(exceptionList, url) {
+    for (var i = 0; i < exceptionList.length; ++i) {
+      if (exceptionList[i].exceptionUrl == url)
+        return true;
+    }
+    return false;
+  },
+
+  /**
    * Allow the iron-list to be sized properly.
    * @param {!Object} passwordsSection
    * @private
    */
   flushPasswordSection_: function(passwordsSection) {
     passwordsSection.$.passwordList.notifyResize();
     passwordsSection.$.passwordExceptionsList.notifyResize();
     Polymer.dom.flush();
   },
 };
@@ skipping 97 matching lines @@
           done();
         }
       });
 
       // Start removing.
       clickRemoveButton();
     });
 
     test('verifyPasswordExceptions', function() {
       var exceptionList = [
-        'docs.google.com',
-        'mail.com',
-        'google.com',
-        'inbox.google.com',
-        'maps.google.com',
-        'plus.google.com',
+        self.createExceptionItem_('docs.google.com'),
+        self.createExceptionItem_('mail.com'),
+        self.createExceptionItem_('google.com'),
+        self.createExceptionItem_('inbox.google.com'),
+        self.createExceptionItem_('maps.google.com'),
+        self.createExceptionItem_('plus.google.com'),
       ];
 
       var passwordsSection = self.createPasswordsSection_([], exceptionList);
 
       // Assert that the data is passed into the iron list. If this fails,
       // then other expectations will also fail.
       assertEquals(exceptionList,
                    passwordsSection.$.passwordExceptionsList.items);
 
       self.validateExceptionList_(
           self.getIronListChildren_(passwordsSection.$.passwordExceptionsList),
           exceptionList);
     });
 
     // Test verifies that removing an exception will update the elements.
     test('verifyPasswordExceptionRemove', function() {
       var exceptionList = [
-        'docs.google.com',
-        'mail.com',
-        'google.com',
-        'inbox.google.com',
-        'maps.google.com',
-        'plus.google.com',
+        self.createExceptionItem_('docs.google.com'),
+        self.createExceptionItem_('mail.com'),
+        self.createExceptionItem_('google.com'),
+        self.createExceptionItem_('inbox.google.com'),
+        self.createExceptionItem_('maps.google.com'),
+        self.createExceptionItem_('plus.google.com'),
       ];
 
       var passwordsSection = self.createPasswordsSection_([], exceptionList);
 
       self.validateExceptionList_(
           self.getIronListChildren_(passwordsSection.$.passwordExceptionsList),
           exceptionList);
 
       // Simulate 'mail.com' being removed from the list.
       passwordsSection.splice('passwordExceptions', 1, 1);
-      assertEquals(-1, passwordsSection.passwordExceptions.indexOf('mail.com'));
-      assertEquals(-1, exceptionList.indexOf('mail.com'));
+      assertFalse(self.exceptionsListContainsUrl(
+            passwordsSection.passwordExceptions, 'mail.com'));
+      assertFalse(self.exceptionsListContainsUrl(exceptionList, 'mail.com'));
       self.flushPasswordSection_(passwordsSection);
 
       self.validateExceptionList_(
           self.getIronListChildren_(passwordsSection.$.passwordExceptionsList),
           exceptionList);
     });
 
     // Test verifies that pressing the 'remove' button will trigger a remove
     // event. Does not actually remove any exceptions.
     test('verifyPasswordExceptionRemoveButton', function(done) {
       var exceptionList = [
-        'docs.google.com',
-        'mail.com',
-        'google.com',
-        'inbox.google.com',
-        'maps.google.com',
-        'plus.google.com',
+        self.createExceptionItem_('docs.google.com'),
+        self.createExceptionItem_('mail.com'),
+        self.createExceptionItem_('google.com'),
+        self.createExceptionItem_('inbox.google.com'),
+        self.createExceptionItem_('maps.google.com'),
+        self.createExceptionItem_('plus.google.com'),
       ];
 
       var passwordsSection = self.createPasswordsSection_([], exceptionList);
 
       var exceptions =
           self.getIronListChildren_(passwordsSection.$.passwordExceptionsList);
 
       // The index of the button currently being checked.
       var index = 0;
 
       var clickRemoveButton = function() {
         MockInteractions.tap(
             exceptions[index].querySelector('#removeExceptionButton'));
       };
 
       // Listen for the remove event. If this event isn't received, the test
       // will time out and fail.
       passwordsSection.addEventListener('remove-password-exception',
                                         function(event) {
         // Verify that the event matches the expected value.
         assertTrue(index < exceptionList.length);
-        assertEquals(exceptionList[index], event.detail);
+        assertEquals(exceptionList[index].exceptionUrl, event.detail);
 
         if (++index < exceptionList.length)
           clickRemoveButton();  // Click 'remove' on all passwords, one by one.
         else
           done();
       });
 
       // Start removing.
       clickRemoveButton();
     });
@@ skipping 72 matching lines @@
         assertEquals(item.loginPair.username, event.detail.username);
         done();
       });
 
       MockInteractions.tap(passwordDialog.$.showPasswordButton);
     });
   });
 
   mocha.run();
 });