MD Settings: Certificate manager, populate UI.

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

 // Copyright 2016 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.
 
 cr.define('certificate_manager_page', function() {
   /**
    * A test version of CertificatesBrowserProxy. Provides helper methods
    * for allowing tests to know when a method was called, as well as
    * specifying mock responses.
    *
    * @constructor
    * @implements {settings.CertificatesBrowserProxy}
    * @extends {settings.TestBrowserProxy}
    */
   var TestCertificatesBrowserProxy = function() {
     settings.TestBrowserProxy.call(this, [
       'deleteCertificate',
       'editCaCertificateTrust',
       'exportPersonalCertificatePasswordSelected',
       'getCaCertificateTrust',
       'importPersonalCertificatePasswordSelected',
+      'refreshCertificates',
     ]);
 
     /** @private {!CaTrustInfo} */
     this.caTrustInfo_ = {ssl: true, email: true, objSign: true};
   };
 
   TestCertificatesBrowserProxy.prototype = {
     __proto__: settings.TestBrowserProxy.prototype,
 
     /**
@@ skipping 29 matching lines @@
           'exportPersonalCertificatePasswordSelected').resolve(password);
       return Promise.resolve();
     },
 
     /** @override */
     importPersonalCertificatePasswordSelected: function(password) {
       this.resolverMap_.get(
           'importPersonalCertificatePasswordSelected').resolve(password);
       return Promise.resolve();
     },
+
+    /** @override */
+    refreshCertificates: function() {
+      this.methodCalled('refreshCertificates');
+    },
   };
 
+  /** @return {!Certificate} */
+  function createSampleCertificate() {
+    return {
+      id: 'dummyCertificateId',
+      name: 'dummyCertificateName',
+      subnodes: [
+        createSampleCertificateSubnode()
+      ],
+    };
+  }
+
   /** @return {!CertificateSubnode} */
   function createSampleCertificateSubnode() {
     return {
       extractable: false,
-      id: 'dummyId',
-      name: 'dummyName',
+      id: 'dummySubnodeId',
+      name: 'dummySubnodeName',
       policy: false,
       readonly: false,
       untrusted: false,
       urlLocked: false,
     };
   }
 
   /**
    * Triggers an 'input' event on the given text input field (which triggers
    * validation to occur for password fields being tested in this file).
@@ skipping 205 matching lines @@
         var methodName = 'importPersonalCertificatePasswordSelected';
         return browserProxy.whenCalled(methodName).then(function(password) {
           assertEquals(passwordInputElement.value, password);
           // Check that the dialog is closed.
           assertFalse(dialog.$.dialog.opened);
         });
       });
     });
   }
 
+  function registerPageTests() {
+    /** @type {?SettingsCertificateManagerPage} */
+    var page = null;
+
+    /** @type {?TestCertificatesBrowserProxy} */
+    var browserProxy = null;
+
+    /** @enum {number} */
+    var CertificateCategoryIndex = {
+      PERSONAL: 0,
+      SERVER: 1,
+      CA: 2,
+      OTHER: 3,
+    };
+
+    suite('CertificateManagerPageTests', function() {
+      setup(function() {
+        browserProxy = new TestCertificatesBrowserProxy();
+        settings.CertificatesBrowserProxyImpl.instance_ = browserProxy;
+        PolymerTest.clearBody();
+        page = document.createElement('settings-certificate-manager-page');
+        document.body.appendChild(page);
+      });
+
+      teardown(function() { page.remove(); });
+
+      /**
+       * Test that the page requests information from the browser on startup and
+       * that it gets populated accordingly.
+       */
+      test('Initialization', function() {
+        // Trigger all category tabs to be added to the DOM.
+        var paperTabsElement = page.shadowRoot.querySelector('paper-tabs');
+        paperTabsElement.selected = CertificateCategoryIndex.PERSONAL;
+        Polymer.dom.flush();
+        paperTabsElement.selected = CertificateCategoryIndex.SERVER;
+        Polymer.dom.flush();
+        paperTabsElement.selected = CertificateCategoryIndex.CA;
+        Polymer.dom.flush();
+        paperTabsElement.selected = CertificateCategoryIndex.OTHER;
+        Polymer.dom.flush();
+        var certificateLists = page.shadowRoot.querySelectorAll(
+            'settings-certificate-list');
+        assertEquals(4, certificateLists.length);
+
+        var assertCertificateListLength = function(
+            listIndex, expectedSize) {
+          var certificateEntries =
+              certificateLists[listIndex].shadowRoot.querySelectorAll(
+                  'settings-certificate-entry');
+          assertEquals(expectedSize, certificateEntries.length);
+        };
+
+        assertCertificateListLength(CertificateCategoryIndex.PERSONAL, 0);
+        assertCertificateListLength(CertificateCategoryIndex.SERVER, 0);
+        assertCertificateListLength(CertificateCategoryIndex.CA, 0);
+        assertCertificateListLength(CertificateCategoryIndex.OTHER, 0);
+
+        return browserProxy.whenCalled('refreshCertificates').then(
+            function() {
+              // Simulate response for personal and CA certificates.
+              cr.webUIListenerCallback(
+                  'certificates-changed', 'personalCerts',
+                  [createSampleCertificate()]);
+              cr.webUIListenerCallback(
+                  'certificates-changed', 'caCerts',
+                  [createSampleCertificate(), createSampleCertificate()]);
+              Polymer.dom.flush();
+
+              assertCertificateListLength(CertificateCategoryIndex.PERSONAL, 1);
+              assertCertificateListLength(CertificateCategoryIndex.SERVER, 0);
+              assertCertificateListLength(CertificateCategoryIndex.CA, 2);
+              assertCertificateListLength(CertificateCategoryIndex.OTHER, 0);
+            });
+      });
+    });
+  }
+
   return {
     registerTests: function() {
       registerCaTrustEditDialogTests();
       registerDeleteDialogTests();
       registerPasswordEncryptDialogTests();
       registerPasswordDecryptDialogTests();
+      registerPageTests();
     },
   };
 });