[MD settings] certificate manager closure compilation

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.
    *
@@ skipping 288 matching lines @@
     var model = createSampleCertificateSubnode();
 
     suite('CertificateDeleteConfirmationDialogTests', function() {
       setup(function() {
         browserProxy = new TestCertificatesBrowserProxy();
         settings.CertificatesBrowserProxyImpl.instance_ = browserProxy;
         PolymerTest.clearBody();
         dialog = document.createElement(
             'settings-certificate-delete-confirmation-dialog');
         dialog.model = model;
-        dialog.certificateType = settings.CertificateType.PERSONAL;
+        dialog.certificateType = CertificateType.PERSONAL;
         document.body.appendChild(dialog);
       });
 
       teardown(function() { dialog.remove(); });
 
       test('DeleteSuccess', function() {
         assertTrue(dialog.$.dialog.opened);
         // Check that the dialog title includes the certificate name.
         var titleEl = Polymer.dom(dialog.$.dialog).querySelector('.title');
         assertTrue(titleEl.textContent.includes(model.name));
@@ skipping 180 matching lines @@
       return eventToPromise(settings.CertificateActionEvent, subentry);
     };
 
     suite('CertificateManagerPageTests', function() {
       setup(function() {
         browserProxy = new TestCertificatesBrowserProxy();
         settings.CertificatesBrowserProxyImpl.instance_ = browserProxy;
         PolymerTest.clearBody();
         subentry = document.createElement('settings-certificate-subentry');
         subentry.model = createSampleCertificateSubnode();
-        subentry.certificateType = settings.CertificateType.PERSONAL;
+        subentry.certificateType = CertificateType.PERSONAL;
         document.body.appendChild(subentry);
 
         // Bring up the popup menu for the following tests to use.
         MockInteractions.tap(subentry.$.dots);
         Polymer.dom.flush();
       });
 
       teardown(function() { subentry.remove(); });
 
       // Test case where 'View' option is tapped.
       test('MenuOptions_View', function() {
         var viewButton = subentry.shadowRoot.querySelector('#view');
         MockInteractions.tap(viewButton);
         return browserProxy.whenCalled('viewCertificate').then(function(id) {
           assertEquals(subentry.model.id, id);
         });
       });
 
       // Test that the 'Edit' option is only shown when appropriate and that
       // once tapped the correct event is fired.
       test('MenuOptions_Edit', function() {
         var editButton = subentry.shadowRoot.querySelector('#edit');
         assertTrue(!!editButton);
         // Should be disabled for any certificate type other than
         // CertificateType.CA
         assertTrue(editButton.hidden);
-        subentry.certificateType = settings.CertificateType.CA;
+        subentry.certificateType = CertificateType.CA;
         assertFalse(editButton.hidden);
 
         // Should be disabled if |policy| is true.
         var model = createSampleCertificateSubnode();
         model.policy = true;
         subentry.model = model;
         assertTrue(editButton.hidden);
 
         subentry.model = createSampleCertificateSubnode();
         var waitForActionEvent = actionEventToPromise();
         MockInteractions.tap(editButton);
         return waitForActionEvent.then(function(event) {
           var detail = /** @type {!CertificateActionEventDetail} */ (
               event.detail);
-          assertEquals(settings.CertificateAction.EDIT, detail.action);
+          assertEquals(CertificateAction.EDIT, detail.action);
           assertEquals(subentry.model.id, detail.subnode.id);
           assertEquals(subentry.certificateType, detail.certificateType);
         });
       });
 
       // Test that the 'Delete' option is only shown when appropriate and that
       // once tapped the correct event is fired.
       test('MenuOptions_Delete', function() {
         var deleteButton = subentry.shadowRoot.querySelector('#delete');
         assertTrue(!!deleteButton);
 
         // Should be disabled when 'model.readonly' is true.
         var model = createSampleCertificateSubnode();
         model.readonly = true;
         subentry.model = model;
         assertTrue(deleteButton.hidden);
 
         // Should be disabled when 'model.policy' is true.
         var model = createSampleCertificateSubnode();
         model.policy = true;
         subentry.model = model;
         assertTrue(deleteButton.hidden);
 
         subentry.model = createSampleCertificateSubnode();
         var waitForActionEvent = actionEventToPromise();
         MockInteractions.tap(deleteButton);
         return waitForActionEvent.then(function(event) {
           var detail = /** @type {!CertificateActionEventDetail} */ (
               event.detail);
-          assertEquals(settings.CertificateAction.DELETE, detail.action);
+          assertEquals(CertificateAction.DELETE, detail.action);
           assertEquals(subentry.model.id, detail.subnode.id);
         });
       });
 
       // Test that the 'Export' option is always shown when the certificate type
       // is not PERSONAL and that once tapped the correct event is fired.
       test('MenuOptions_Export', function() {
-        subentry.certificateType = settings.CertificateType.SERVER;
+        subentry.certificateType = CertificateType.SERVER;
         var exportButton = subentry.shadowRoot.querySelector('#export');
         assertTrue(!!exportButton);
         assertFalse(exportButton.hidden);
         MockInteractions.tap(exportButton);
         return browserProxy.whenCalled('exportCertificate').then(function(id) {
           assertEquals(subentry.model.id, id);
         });
       });
 
       // Test case of exporting a PERSONAL certificate.
@@ skipping 16 matching lines @@
               assertEquals(subentry.model.id, id);
 
               // A promise firing once |settings.CertificateActionEvent| is
               // fired.
               return waitForActionEvent;
             }).then(
             function(event) {
               var detail = /** @type {!CertificateActionEventDetail} */ (
                   event.detail);
               assertEquals(
-                  settings.CertificateAction.EXPORT_PERSONAL,
+                  CertificateAction.EXPORT_PERSONAL,
                   detail.action);
               assertEquals(subentry.model.id, detail.subnode.id);
             });
       });
     });
   }
 
   function registerPageTests() {
     /** @type {?SettingsCertificateManagerPageElement} */
     var page = null;
@@ skipping 80 matching lines @@
         assertFalse(!!page.shadowRoot.querySelector(dialogTagName));
         page.fire(settings.CertificateActionEvent, eventDetail);
         Polymer.dom.flush();
         assertTrue(!!page.shadowRoot.querySelector(dialogTagName));
       }
 
       test('OpensDialog_DeleteConfirmation', function() {
         testDialogOpensOnAction(
             'settings-certificate-delete-confirmation-dialog',
             /** @type {!CertificateActionEventDetail} */ ({
-              action: settings.CertificateAction.DELETE,
+              action: CertificateAction.DELETE,
               subnode: createSampleCertificateSubnode(),
-              certificateType: settings.CertificateType.PERSONAL
+              certificateType: CertificateType.PERSONAL
             }));
       });
 
       test('OpensDialog_PasswordEncryption', function() {
         testDialogOpensOnAction(
             'settings-certificate-password-encryption-dialog',
             /** @type {!CertificateActionEventDetail} */ ({
-              action: settings.CertificateAction.EXPORT_PERSONAL,
+              action: CertificateAction.EXPORT_PERSONAL,
               subnode: createSampleCertificateSubnode(),
-              certificateType: settings.CertificateType.PERSONAL
+              certificateType: CertificateType.PERSONAL
             }));
       });
 
       test('OpensDialog_PasswordDecryption', function() {
         testDialogOpensOnAction(
             'settings-certificate-password-decryption-dialog',
             /** @type {!CertificateActionEventDetail} */ ({
-              action: settings.CertificateAction.IMPORT,
+              action: CertificateAction.IMPORT,
               subnode: createSampleCertificateSubnode(),
-              certificateType: settings.CertificateType.PERSONAL
+              certificateType: CertificateType.PERSONAL
             }));
       });
 
       test('OpensDialog_CaTrustEdit', function() {
         testDialogOpensOnAction(
             'settings-ca-trust-edit-dialog',
             /** @type {!CertificateActionEventDetail} */ ({
-              action: settings.CertificateAction.EDIT,
+              action: CertificateAction.EDIT,
               subnode: createSampleCertificateSubnode(),
-              certificateType: settings.CertificateType.CA
+              certificateType: CertificateType.CA
             }));
       });
 
       test('OpensDialog_CaTrustImport', function() {
         testDialogOpensOnAction(
             'settings-ca-trust-edit-dialog',
             /** @type {!CertificateActionEventDetail} */ ({
-              action: settings.CertificateAction.IMPORT,
+              action: CertificateAction.IMPORT,
               subnode: {name: 'Dummy Certificate Name', id: null},
-              certificateType: settings.CertificateType.CA
+              certificateType: CertificateType.CA
             }));
       });
     });
   }
 
   function registerCertificateListTests() {
     /** @type {?SettingsCertificateListElement} */
     var element = null;
 
     /** @type {?TestCertificatesBrowserProxy} */
     var browserProxy = null;
 
     suite('CertificateListTests', function() {
       setup(function() {
         browserProxy = new TestCertificatesBrowserProxy();
         settings.CertificatesBrowserProxyImpl.instance_ = browserProxy;
         PolymerTest.clearBody();
         element = document.createElement('settings-certificate-list');
         document.body.appendChild(element);
       });
 
       teardown(function() { element.remove(); });
 
       /**
        * Tests the "Import" button functionality.
-       * @param {!settings.CertificateType} certificateType
+       * @param {!CertificateType} certificateType
        * @param {string} proxyMethodName The name of the proxy method expected
        *     to be called.
        * @param {boolean} actionEventExpected Whether a
        *     settings.CertificateActionEvent is expected to fire as a result
        *     tapping the Import button.
        */
       function testImportForCertificateType(
           certificateType, proxyMethodName, actionEventExpected) {
         element.certificateType = certificateType
         Polymer.dom.flush();
 
         var importButton = element.$$('paper-button');
         assertTrue(!!importButton);
 
         var waitForActionEvent = actionEventExpected ?
             eventToPromise(settings.CertificateActionEvent, element) :
             Promise.resolve(null);
 
         MockInteractions.tap(importButton);
         return browserProxy.whenCalled(proxyMethodName).then(function() {
           return waitForActionEvent;
         }).then(function(event) {
           if (actionEventExpected) {
             assertEquals(
-                settings.CertificateAction.IMPORT, event.detail.action);
+                CertificateAction.IMPORT, event.detail.action);
             assertEquals(certificateType, event.detail.certificateType);
           }
         });
       }
 
       test('ImportButton_Personal', function() {
         return testImportForCertificateType(
-            settings.CertificateType.PERSONAL,
+            CertificateType.PERSONAL,
             'importPersonalCertificate', true);
       });
 
       test('ImportButton_Server', function() {
         return testImportForCertificateType(
-            settings.CertificateType.SERVER, 'importServerCertificate',
+            CertificateType.SERVER, 'importServerCertificate',
             false);
       });
 
       test('ImportButton_CA', function() {
         return testImportForCertificateType(
-            settings.CertificateType.CA, 'importCaCertificate', true);
+            CertificateType.CA, 'importCaCertificate', true);
       });
     });
   }
 
   return {
     registerTests: function() {
       registerCaTrustEditDialogTests();
       registerDeleteDialogTests();
       registerPasswordEncryptDialogTests();
       registerPasswordDecryptDialogTests();
       registerPageTests();
       registerCertificateSubentryTests();
       registerCertificateListTests();
     },
   };
 });