MD Settings: About page, show regulatory info, if available.

chrome/test/data/webui/settings/about_page_tests.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('settings_about_page', function() {
   /**
    * @constructor
    * @implements {settings.AboutPageBrowserProxy}
    * @extends {settings.TestBrowserProxy}
    */
   var TestAboutPageBrowserProxy = function() {
-    settings.TestBrowserProxy.call(this, [
+    var methodNames = [
       'pageReady',
       'refreshUpdateStatus',
       'openHelpPage',
       'openFeedbackDialog',
-      'getCurrentChannel',
-      'getTargetChannel',
-      'getVersionInfo',
-    ]);
+    ];
 
-    /** @type {!VersionInfo} */
-    this.versionInfo_ = {
-      arcVersion: '',
-      osFirmware: '',
-      osVersion: '',
-    };
+    if (cr.isChromeOS) {
+      methodNames.push(
+        'getCurrentChannel',
+        'getTargetChannel',
+        'getVersionInfo',
+        'getRegulatoryInfo');
+    }
+
+    settings.TestBrowserProxy.call(this, methodNames);
 
     /** @private {!UpdateStatus} */
     this.updateStatus_ = UpdateStatus.UPDATED;
 
     if (cr.isChromeOS) {
+      /** @type {!VersionInfo} */
+      this.versionInfo_ = {
+        arcVersion: '',
+        osFirmware: '',
+        osVersion: '',
+      };
+
       /** @private {!BrowserChannel} */
       this.currentChannel_ = BrowserChannel.BETA;
 
       /** @private {!BrowserChannel} */
       this.targetChannel_ = BrowserChannel.BETA;
+
+      /** @private {?RegulatoryInfo} */
+      this.regulatoryInfo_ = null;
     }
   };
 
   TestAboutPageBrowserProxy.prototype = {
     __proto__: settings.TestBrowserProxy.prototype,
 
-    /** @param {!VersionInfo} */
-    setVersionInfo: function(versionInfo) {
-      this.versionInfo_ = versionInfo;
-    },
-
     /** @param {!UpdateStatus} updateStatus */
     setUpdateStatus: function(updateStatus) {
       this.updateStatus_ = updateStatus;
     },
 
     /** @override */
     pageReady: function() {
       this.methodCalled('pageReady');
     },
 
     /** @override */
     refreshUpdateStatus: function() {
       cr.webUIListenerCallback(
           'update-status-changed', {status: this.updateStatus_});
       this.methodCalled('refreshUpdateStatus');
     },
 
     /** @override */
     openFeedbackDialog: function() {
       this.methodCalled('openFeedbackDialog');
     },
 
     /** @override */
     openHelpPage: function() {
       this.methodCalled('openHelpPage');
     },
   };
 
   if (cr.isChromeOS) {
+    /** @param {!VersionInfo} */
+    TestAboutPageBrowserProxy.prototype.setVersionInfo = function(versionInfo) {
+      this.versionInfo_ = versionInfo;
+    };
+
     /**
      * @param {!BrowserChannel} current
      * @param {!BrowserChannel} target
      */
     TestAboutPageBrowserProxy.prototype.setChannels = function(
         current, target) {
       this.currentChannel_ = current;
       this.targetChannel_ = target;
     };
 
+
+    /** @param {?RegulatoryInfo} regulatoryInfo */
+    TestAboutPageBrowserProxy.prototype.setRegulatoryInfo = function(
+        regulatoryInfo) {
+      this.regulatoryInfo_ = regulatoryInfo;
+    };
+
     /** @override */
     TestAboutPageBrowserProxy.prototype.getCurrentChannel = function() {
       this.methodCalled('getCurrentChannel');
       return Promise.resolve(this.currentChannel_);
     };
 
     /** @override */
     TestAboutPageBrowserProxy.prototype.getTargetChannel = function() {
       this.methodCalled('getTargetChannel');
       return Promise.resolve(this.targetChannel_);
     };
 
     /** @override */
     TestAboutPageBrowserProxy.prototype.getVersionInfo = function() {
       this.methodCalled('getVersionInfo');
       return Promise.resolve(this.versionInfo_);
     };
+
+    /** @override */
+    TestAboutPageBrowserProxy.prototype.getRegulatoryInfo = function() {
+      this.methodCalled('getRegulatoryInfo');
+      return Promise.resolve(this.regulatoryInfo_);
+    };
   }
 
 
   function registerAboutPageTests() {
     /** @param {!UpdateStatus} status */
     function fireStatusChanged(status) {
       cr.webUIListenerCallback('update-status-changed', {status: status});
     }
 
     suite('AboutPageTest', function() {
       var page = null;
       var browserProxy = null;
 
       setup(function() {
         browserProxy = new TestAboutPageBrowserProxy();
         settings.AboutPageBrowserProxyImpl.instance_ = browserProxy;
         return initNewPage();
       });
 
       /** @return {!Promise} */
       function initNewPage() {
-        browserProxy.resetResolver('refreshUpdateStatus');
+        browserProxy.reset();
         PolymerTest.clearBody();
         page = document.createElement('settings-about-page');
         document.body.appendChild(page);
         return browserProxy.whenCalled('refreshUpdateStatus');
       }
 
       /**
        * Test that the status icon updates according to incoming
        * 'update-status-changed' events.
        */
@@ skipping 114 matching lines @@
           browserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
 
           return initNewPage().then(function() {
             assertTrue(!!page.$.relaunch);
             assertTrue(!!page.$.relaunchAndPowerwash);
 
             assertFalse(page.$.relaunch.hidden);
             assertTrue(page.$.relaunchAndPowerwash.hidden);
           });
         });
+
+        test('RegulatoryInfo', function() {
+          var regulatoryInfo = null;
+
+          /**
+           * Checks the visibility of the "regulatory info" section.
+           * @param {boolean} isShowing Whether the section is expected to be
+           *     visible.
+           * @return {!Promise}
+           */
+          function checkRegulatoryInfo(isShowing) {
+            return browserProxy.whenCalled('getRegulatoryInfo').then(
+                function() {
+                  var regulatoryInfoEl = page.$.regulatoryInfo;
+                  assertTrue(!!regulatoryInfoEl);
+                  assertEquals(isShowing, !regulatoryInfoEl.hidden);
+
+                  if (isShowing) {
+                    var img = regulatoryInfoEl.querySelector('img');
+                    assertTrue(!!img);
+                    assertEquals(regulatoryInfo.text, img.getAttribute('alt'));
+                    assertEquals(regulatoryInfo.url, img.getAttribute('src'));
+                  }
+                });
+          }
+
+          return checkRegulatoryInfo(false).then(function() {
+            regulatoryInfo = {text: 'foo', url: 'bar'};
+            browserProxy.setRegulatoryInfo(regulatoryInfo);
+            return initNewPage();
+          }).then(function() {
+            return checkRegulatoryInfo(true);
+          });
+        });
       }
 
       if (!cr.isChromeOS) {
         /*
          * Test that the "Check for updates" button updates according to
          * incoming 'update-status-changed' events.
          */
         test('ButtonsUpdate', function() {
           var relaunch = page.$.relaunch;
           assertTrue(!!relaunch);
@@ skipping 92 matching lines @@
   return {
     registerTests: function() {
       if (cr.isChromeOS) {
         registerDetailedBuildInfoTests();
       }
       registerAboutPageTests();
     },
     registerOfficialBuildTests: registerOfficialBuildTests,
   };
 });