MD Settings: About page, updating buttons based on current update status.

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, [
       'pageReady',
       'refreshUpdateStatus',
       'openHelpPage',
       'openFeedbackDialog',
       'getCurrentChannel',
       'getTargetChannel',
       'getVersionInfo',
     ]);
 
     /** @type {!VersionInfo} */
     this.versionInfo_ = {
       arcVersion: '',
       osFirmware: '',
       osVersion: '',
     };
+
+    /** @private {!UpdateStatus} */
+    this.updateStatus_ = UpdateStatus.UPDATED;
+
+    if (cr.isChromeOS) {
+      /** @private {!BrowserChannel} */
+      this.currentChannel_ = BrowserChannel.BETA;
+
+      /** @private {!BrowserChannel} */
+      this.targetChannel_ = BrowserChannel.BETA;
+    }
   };
 
   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 */
-    getCurrentChannel: function() {
-      this.methodCalled('getCurrentChannel');
-      return Promise.resolve(BrowserChannel.BETA);
-    },
-
-    /** @override */
-    getTargetChannel: function() {
-      this.methodCalled('getTargetChannel');
-      return Promise.resolve(BrowserChannel.BETA);
-    },
-
-    /** @override */
-    getVersionInfo: function() {
-      this.methodCalled('getVersionInfo');
-      return Promise.resolve(this.versionInfo_);
-    },
-
-    /** @override */
     openFeedbackDialog: function() {
       this.methodCalled('openFeedbackDialog');
     },
 
     /** @override */
     openHelpPage: function() {
       this.methodCalled('openHelpPage');
     },
   };
 
+  if (cr.isChromeOS) {
+    /**
+     * @param {!BrowserChannel} current
+     * @param {!BrowserChannel} target
+     */
+    TestAboutPageBrowserProxy.prototype.setChannels = function(
+        current, target) {
+      this.currentChannel_ = current;
+      this.targetChannel_ = target;
+    };
+
+    /** @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_);
+    };
+  }
+
+
   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');
         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-chanhed' events.
+       * 'update-status-changed' events.
        */
       test('IconUpdates', function() {
-        function fireStatusChanged(status) {
-          cr.webUIListenerCallback('update-status-changed', {
-            status: status, message: '', progress: 0,
-          });
-        }
-
         var SPINNER_ICON = 'chrome://resources/images/throbber_small.svg';
 
         var icon = page.$$('iron-icon');
         assertTrue(!!icon);
-        assertEquals(null, icon.getAttribute('icon'));
 
         fireStatusChanged(UpdateStatus.CHECKING);
         assertEquals(SPINNER_ICON, icon.src);
         assertEquals(null, icon.getAttribute('icon'));
 
         fireStatusChanged(UpdateStatus.UPDATING);
         assertEquals(SPINNER_ICON, icon.src);
         assertEquals(null, icon.getAttribute('icon'));
 
         fireStatusChanged(UpdateStatus.NEARLY_UPDATED);
@@ skipping 10 matching lines @@
 
         fireStatusChanged(UpdateStatus.FAILED);
         assertEquals(null, icon.src);
         assertEquals('settings:error', icon.icon);
 
         fireStatusChanged(UpdateStatus.DISABLED);
         assertEquals(null, icon.src);
         assertEquals(null, icon.getAttribute('icon'));
       });
 
+      if (cr.isChromeOS) {
+        /**
+         * Test that all buttons update according to incoming
+         * 'update-status-changed' events for the case where target and current
+         * channel are the same.
+         */
+        test('ButtonsUpdate_SameChannel', function() {
+          var relaunch = page.$.relaunch;
+          var checkForUpdates = page.$.checkForUpdates;
+          var relaunchAndPowerwash = page.$.relaunchAndPowerwash;
+
+          assertTrue(!!relaunch);
+          assertTrue(!!relaunchAndPowerwash);
+          assertTrue(!!checkForUpdates);
+
+          function assertAllHidden() {
+            assertTrue(checkForUpdates.hidden);
+            assertTrue(relaunch.hidden);
+            assertTrue(relaunchAndPowerwash.hidden);
+          }
+
+          // Check that |UPDATED| status is ignored if the user has not
+          // explicitly checked for updates yet.
+          fireStatusChanged(UpdateStatus.UPDATED);
+          assertFalse(checkForUpdates.hidden);
+          assertTrue(relaunch.hidden);
+          assertTrue(relaunchAndPowerwash.hidden);
+
+          fireStatusChanged(UpdateStatus.CHECKING);
+          assertAllHidden();
+
+          fireStatusChanged(UpdateStatus.UPDATING);
+          assertAllHidden();
+
+          fireStatusChanged(UpdateStatus.NEARLY_UPDATED);
+          assertTrue(checkForUpdates.hidden);
+          assertFalse(relaunch.hidden);
+          assertTrue(relaunchAndPowerwash.hidden);
+
+          fireStatusChanged(UpdateStatus.UPDATED);
+          assertAllHidden();
+
+          fireStatusChanged(UpdateStatus.FAILED);
+          assertFalse(checkForUpdates.hidden);
+          assertTrue(relaunch.hidden);
+          assertTrue(relaunchAndPowerwash.hidden);
+
+          fireStatusChanged(UpdateStatus.DISABLED);
+          assertAllHidden();
+
+          fireStatusChanged(UpdateStatus.DISABLED_BY_ADMIN);
+          assertAllHidden();
+        });
+
+        /**
+         * Test that buttons update according to incoming
+         * 'update-status-changed' events for the case where the target channel
+         * is more stable than current channel.
+         */
+        test('ButtonsUpdate_BetaToStable', function() {
+          browserProxy.setChannels(BrowserChannel.BETA, BrowserChannel.STABLE);
+          browserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
+
+          return initNewPage().then(function() {
+            assertTrue(!!page.$.relaunch);
+            assertTrue(!!page.$.relaunchAndPowerwash);
+
+            assertTrue(page.$.relaunch.hidden);
+            assertFalse(page.$.relaunchAndPowerwash.hidden);
+          });
+        });
+
+        /**
+         * Test that buttons update according to incoming
+         * 'update-status-changed' events for the case where the target channel
+         * is less stable than current channel.
+         */
+        test('ButtonsUpdate_StableToBeta', function() {
+          browserProxy.setChannels(BrowserChannel.STABLE, BrowserChannel.BETA);
+          browserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
+
+          return initNewPage().then(function() {
+            assertTrue(!!page.$.relaunch);
+            assertTrue(!!page.$.relaunchAndPowerwash);
+
+            assertFalse(page.$.relaunch.hidden);
+            assertTrue(page.$.relaunchAndPowerwash.hidden);
+          });
+        });
+      }
+
+      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);
+
+          fireStatusChanged(UpdateStatus.CHECKING);
+          assertTrue(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.UPDATING);
+          assertTrue(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.NEARLY_UPDATED);
+          assertFalse(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.UPDATED);
+          assertTrue(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.FAILED);
+          assertTrue(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.DISABLED);
+          assertTrue(relaunch.hidden);
+
+          fireStatusChanged(UpdateStatus.DISABLED_BY_ADMIN);
+          assertTrue(relaunch.hidden);
+        });
+      }
+
       test('GetHelp', function() {
         assertTrue(!!page.$.help);
         MockInteractions.tap(page.$.help);
         return browserProxy.whenCalled('openHelpPage');
       });
     });
   }
 
   function registerOfficialBuildTests() {
     suite('AboutPageTest_OfficialBuild', function() {
@@ skipping 58 matching lines @@
   return {
     registerTests: function() {
       if (cr.isChromeOS) {
         registerDetailedBuildInfoTests();
       }
       registerAboutPageTests();
     },
     registerOfficialBuildTests: registerOfficialBuildTests,
   };
 });