Settings: About: Fix cros channel info.

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() {
     var methodNames = [
       'pageReady',
       'refreshUpdateStatus',
       'openHelpPage',
       'openFeedbackDialog',
     ];
 
     if (cr.isChromeOS) {
       methodNames.push(
-        'getCurrentChannel',
-        'getTargetChannel',
+        'getChannelInfo',
         'getVersionInfo',
         'getRegulatoryInfo',
         'setChannel');
     }
 
     settings.TestBrowserProxy.call(this, methodNames);
 
     /** @private {!UpdateStatus} */
     this.updateStatus_ = UpdateStatus.UPDATED;
 
     if (cr.isChromeOS) {
-      /** @type {!VersionInfo} */
+      /** @private {!VersionInfo} */
       this.versionInfo_ = {
         arcVersion: '',
         osFirmware: '',
         osVersion: '',
       };
 
-      /** @private {!BrowserChannel} */
-      this.currentChannel_ = BrowserChannel.BETA;
-
-      /** @private {!BrowserChannel} */
-      this.targetChannel_ = BrowserChannel.BETA;
+      /** @private {!ChannelInfo} */
+      this.channelInfo_ = {
+        currentChannel: BrowserChannel.BETA,
+        targetChannel: BrowserChannel.BETA,
+        canChangeChannel: true,
+      };
 
       /** @private {?RegulatoryInfo} */
       this.regulatoryInfo_ = null;
     }
   };
 
   TestAboutPageBrowserProxy.prototype = {
     __proto__: settings.TestBrowserProxy.prototype,
 
     /** @param {!UpdateStatus} updateStatus */
@@ skipping 25 matching lines @@
       this.methodCalled('openHelpPage');
     },
   };
 
   if (cr.isChromeOS) {
     /** @param {!VersionInfo} */
     TestAboutPageBrowserProxy.prototype.setVersionInfo = function(versionInfo) {
       this.versionInfo_ = versionInfo;
     };
 
+    /** @param {boolean} canChangeChannel */
+    TestAboutPageBrowserProxy.prototype.setCanChangeChannel = function(

[dpapad, 2016/12/07 01:42:23]

Nit: Can we combine the setCanChangeChannel() and setChannels() to a single
setChannelInfo() method?

[stevenjb, 2016/12/07 20:59:17]

I did that initially but it actually ends up being more awkward, because we want
to, e.g. set just 'canChangeChannel' without changing the current/target
channel.

+        canChangeChannel) {
+      this.channelInfo_.canChangeChannel = canChangeChannel;
+    };
+
     /**
      * @param {!BrowserChannel} current
      * @param {!BrowserChannel} target
      */
     TestAboutPageBrowserProxy.prototype.setChannels = function(
         current, target) {
-      this.currentChannel_ = current;
-      this.targetChannel_ = target;
+      this.channelInfo_.currentChannel = current;
+      this.channelInfo_.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_);
+    TestAboutPageBrowserProxy.prototype.getChannelInfo = function() {
+      this.methodCalled('getChannelInfo');
+      return Promise.resolve(this.channelInfo_);
     };
 
     /** @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_);
     };
@@ skipping 48 matching lines @@
       });
 
       /** @return {!Promise} */
       function initNewPage() {
         aboutBrowserProxy.reset();
         lifetimeBrowserProxy.reset();
         PolymerTest.clearBody();
         page = document.createElement('settings-about-page');
         settings.navigateTo(settings.Route.ABOUT);
         document.body.appendChild(page);
-        return aboutBrowserProxy.whenCalled('refreshUpdateStatus');
+        return Promise.all([
+          aboutBrowserProxy.whenCalled('getChannelInfo'),
+          aboutBrowserProxy.whenCalled('refreshUpdateStatus'),
+        ]);
       }
 
       /**
        * Test that the status icon and status message update according to
        * incoming 'update-status-changed' events.
        */
       test('IconAndMessageUpdates', function() {
         var icon = page.$$('iron-icon');
         assertTrue(!!icon);
         var statusMessageEl = page.$.updateStatusMessage;
@@ skipping 373 matching lines @@
             osVersion: 'dummyOsVersion',
           };
           browserProxy.setVersionInfo(versionInfo);
 
           page = document.createElement('settings-detailed-build-info');
           document.body.appendChild(page);
 
           return Promise.all([
             browserProxy.whenCalled('pageReady'),
             browserProxy.whenCalled('getVersionInfo'),
-            browserProxy.whenCalled('getCurrentChannel'),
+            browserProxy.whenCalled('getChannelInfo'),
           ]).then(function() {
             assertEquals(versionInfo.arcVersion, page.$.arcVersion.textContent);
             assertEquals(versionInfo.osVersion, page.$.osVersion.textContent);
             assertEquals(versionInfo.osFirmware, page.$.osFirmware.textContent);
           });
         });
 
         /**
          * Checks whether the "change channel" button state (enabled/disabled)
          * correctly reflects whether the user is allowed to change channel (as
          * dictated by the browser via loadTimeData boolean).
          * @param {boolean} canChangeChannel Whether to simulate the case where
          *     changing channels is allowed.
+         * @return {!Promise}
          */
         function checkChangeChannelButton(canChangeChannel) {
-          loadTimeData.overrideValues({
-            aboutCanChangeChannel: canChangeChannel
-          });
+          browserProxy.setCanChangeChannel(canChangeChannel);
           page = document.createElement('settings-detailed-build-info');
           document.body.appendChild(page);
-
-          var changeChannelButton = page.$$('paper-button');
-          assertTrue(!!changeChannelButton);
-          assertEquals(canChangeChannel, !changeChannelButton.disabled)
+          return browserProxy.whenCalled('getChannelInfo').then(function() {
+            var changeChannelButton = page.$$('paper-button');
+            assertTrue(!!changeChannelButton);
+            assertEquals(canChangeChannel, !changeChannelButton.disabled);
+          });
         }
 
         test('ChangeChannel_Enabled', function() {
-          checkChangeChannelButton(true);
+          return checkChangeChannelButton(true);
         });
 
         test('ChangeChannel_Disabled', function() {
-          checkChangeChannelButton(false);
+          return checkChangeChannelButton(false);
         });
       });
     }
 
     function registerChannelSwitcherDialogTests() {
       suite('ChannelSwitcherDialogTest', function() {
         var dialog = null;
         var radioButtons = null;
         var browserProxy = null;
         var currentChannel = BrowserChannel.BETA;
 
         setup(function() {
           browserProxy = new TestAboutPageBrowserProxy();
           browserProxy.setChannels(currentChannel, currentChannel);
           settings.AboutPageBrowserProxyImpl.instance_ = browserProxy;
           PolymerTest.clearBody();
           dialog = document.createElement('settings-channel-switcher-dialog');
           document.body.appendChild(dialog);
 
           radioButtons = dialog.shadowRoot.querySelectorAll(
               'paper-radio-button');
           assertEquals(3, radioButtons.length);
-          return browserProxy.whenCalled('getCurrentChannel');
+          return browserProxy.whenCalled('getChannelInfo');
         });
 
         teardown(function() { dialog.remove(); });
 
         test('Initialization', function() {
           var radioGroup = dialog.$$('paper-radio-group');
           assertTrue(!!radioGroup);
           assertTrue(!!dialog.$.warning);
           assertTrue(!!dialog.$.changeChannel);
           assertTrue(!!dialog.$.changeChannelAndPowerwash);
 
           // Check that upon initialization the radio button corresponding to
           // the current release channel is pre-selected.
           assertEquals(currentChannel, radioGroup.selected);
           assertTrue(dialog.$.warning.hidden);
 
           // Check that action buttons are hidden when current and target
           // channel are the same.
           assertTrue(dialog.$.changeChannel.hidden);
           assertTrue(dialog.$.changeChannelAndPowerwash.hidden);
         });
 
         // Test case where user switches to a less stable channel.
         test('ChangeChannel_LessStable', function() {
           assertEquals(BrowserChannel.DEV, radioButtons.item(2).name);
           MockInteractions.tap(radioButtons.item(2));
           Polymer.dom.flush();
 
-          assertFalse(dialog.$.warning.hidden);
-          // Check that only the "Change channel" button becomes visible.
-          assertTrue(dialog.$.changeChannelAndPowerwash.hidden);
-          assertFalse(dialog.$.changeChannel.hidden);
+          return browserProxy.whenCalled('getChannelInfo').then(function() {
+            assertFalse(dialog.$.warning.hidden);
+            // Check that only the "Change channel" button becomes visible.
+            assertTrue(dialog.$.changeChannelAndPowerwash.hidden);
+            assertFalse(dialog.$.changeChannel.hidden);
 
-          var whenTargetChannelChangedFired = test_util.eventToPromise(
-              'target-channel-changed', dialog);
+            var whenTargetChannelChangedFired = test_util.eventToPromise(
+                'target-channel-changed', dialog);
 
-          MockInteractions.tap(dialog.$.changeChannel);
-          return browserProxy.whenCalled('setChannel').then(function(args) {
-            assertEquals(BrowserChannel.DEV, args[0]);
-            assertFalse(args[1]);
-            return whenTargetChannelChangedFired;
-          }).then(function(event) {
-            assertEquals(BrowserChannel.DEV, event.detail);
+            MockInteractions.tap(dialog.$.changeChannel);
+            return browserProxy.whenCalled('setChannel').then(function(args) {
+              assertEquals(BrowserChannel.DEV, args[0]);
+              assertFalse(args[1]);
+              return whenTargetChannelChangedFired;
+            }).then(function(event) {
+              assertEquals(BrowserChannel.DEV, event.detail);
+            });
           });
         });
 
         // Test case where user switches to a more stable channel.
         test('ChangeChannel_MoreStable', function() {
           assertEquals(BrowserChannel.STABLE, radioButtons.item(0).name);
           MockInteractions.tap(radioButtons.item(0));
           Polymer.dom.flush();
 
-          assertFalse(dialog.$.warning.hidden);
-          // Check that only the "Change channel and Powerwash" button becomes
-          // visible.
-          assertFalse(dialog.$.changeChannelAndPowerwash.hidden);
-          assertTrue(dialog.$.changeChannel.hidden);
+          return browserProxy.whenCalled('getChannelInfo').then(function() {
+            assertFalse(dialog.$.warning.hidden);
+            // Check that only the "Change channel and Powerwash" button becomes
+            // visible.
+            assertFalse(dialog.$.changeChannelAndPowerwash.hidden);
+            assertTrue(dialog.$.changeChannel.hidden);
 
-          var whenTargetChannelChangedFired = test_util.eventToPromise(
-              'target-channel-changed', dialog);
+            var whenTargetChannelChangedFired = test_util.eventToPromise(
+                'target-channel-changed', dialog);
 
-          MockInteractions.tap(dialog.$.changeChannelAndPowerwash);
-          return browserProxy.whenCalled('setChannel').then(function(args) {
-            assertEquals(BrowserChannel.STABLE, args[0]);
-            assertTrue(args[1]);
-            return whenTargetChannelChangedFired;
-          }).then(function(event) {
-            assertEquals(BrowserChannel.STABLE, event.detail);
+            MockInteractions.tap(dialog.$.changeChannelAndPowerwash);
+            return browserProxy.whenCalled('setChannel').then(function(args) {
+              assertEquals(BrowserChannel.STABLE, args[0]);
+              assertTrue(args[1]);
+              return whenTargetChannelChangedFired;
+            }).then(function(event) {
+              assertEquals(BrowserChannel.STABLE, event.detail);
+            });
           });
         });
       });
     }
   }
 
   return {
     registerTests: function() {
       if (cr.isChromeOS) {
         registerDetailedBuildInfoTests();
         registerChannelSwitcherDialogTests();
       }
       registerAboutPageTests();
     },
     registerOfficialBuildTests: registerOfficialBuildTests,
   };
 });