chrome/browser/ui/webui/extensions/extension_settings_browsertest.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // TODO(dbeam): test for loading upacked extensions?
   6
   7 GEN('#include "chrome/browser/ui/webui/extensions/' +
   8     'extension_settings_browsertest.h"');
   9
  10 // The id of the extension from |InstallGoodExtension|.
  11 var GOOD_EXTENSION_ID = 'ldnnhddmnhbkjipkidpdiheffobcpfmf';
  12
  13 // The id of the extension from |InstallErrorsExtension|.
  14 var ERROR_EXTENSION_ID = 'pdlpifnclfacjobnmbpngemkalkjamnf';
  15
  16 /**
  17  * Test C++ fixture for settings WebUI testing.
  18  * @constructor
  19  * @extends {testing.Test}
  20  */
  21 function ExtensionSettingsUIBrowserTest() {}
  22
  23 /**
  24  * TestFixture for extension settings WebUI testing.
  25  * @extends {testing.Test}
  26  * @constructor
  27  */
  28 function ExtensionSettingsWebUITest() {}
  29
  30 ExtensionSettingsWebUITest.prototype = {
  31   __proto__: testing.Test.prototype,
  32
  33   /** @override */
  34   isAsync: true,
  35
  36   /** @override */
  37   runAccessibilityChecks: true,
  38
  39   /** @override */
  40   accessibilityIssuesAreErrors: true,
  41
  42   /**
  43    * A URL to load before starting each test.
  44    * @type {string}
  45    * @const
  46    */
  47   browsePreload: 'chrome://extensions-frame/',
  48
  49   /** @override */
  50   typedefCppFixture: 'ExtensionSettingsUIBrowserTest',
  51
  52   /** @override */
  53   setUp: function() {
  54     testing.Test.disableAnimationsAndTransitions();
  55   },
  56
  57   /**
  58    * Holds an array of steps that should happen in order during a test.
  59    * The last step should be |testDone|.
  60    * @protected {Array<!Function>}
  61    * */
  62   steps: [],
  63
  64   /**
  65    * Advances to the next step in the test. Every step should call this.
  66    * @protected
  67    * */
  68   nextStep: function() {
  69     assertTrue(this.steps.length > 0);
  70     this.steps.shift().call(this);
  71   },
  72
  73   /**
  74    * Will wait for the page to load before calling the next step. This should be
  75    * the first step in every test.
  76    * @protected
  77    * */
  78   waitForPageLoad: function() {
  79     assertEquals(this.browsePreload, document.location.href);
  80     var extensionList = getRequiredElement('extension-settings-list');
  81     extensionList.loadFinished.then(this.nextStep.bind(this));
  82   },
  83
  84   /** @protected */
  85   enableDeveloperMode: function() {
  86     var next = this.nextStep.bind(this);
  87     extensions.ExtensionSettings.getInstance().testingDeveloperModeCallback =
  88         function() {
  89       chrome.developerPrivate.getProfileConfiguration(function(profileInfo) {
  90         assertTrue(extensionSettings.classList.contains('dev-mode'));
  91         assertTrue(profileInfo.inDeveloperMode);
  92         next();
  93
  94         // This event isn't thrown because transitions are disabled.
  95         // Ensure transition here so that any dependent code does not break.
  96         ensureTransitionEndEvent($('dev-controls'), 0);
  97       });
  98     };
  99
 100     var extensionSettings = getRequiredElement('extension-settings');
 101     assertFalse(extensionSettings.classList.contains('dev-mode'));
 102     $('toggle-dev-on').click();
 103   },
 104
 105   /** @protected */
 106   testDeveloperMode: function() {
 107     var next = this.nextStep.bind(this);
 108     var checkDevModeIsOff = function() {
 109       chrome.developerPrivate.getProfileConfiguration(function(profileInfo) {
 110         assertFalse(profileInfo.inDeveloperMode);
 111         next();
 112       });
 113     };
 114     this.steps = [this.waitForPageLoad,
 115                   checkDevModeIsOff,
 116                   this.enableDeveloperMode,
 117                   testDone];
 118     this.nextStep();
 119   },
 120 };
 121
 122 // Verify that developer mode doesn't change behavior when the number of
 123 // extensions changes.
 124 TEST_F('ExtensionSettingsWebUITest', 'testDeveloperModeNoExtensions',
 125        function() {
 126   this.testDeveloperMode();
 127 });
 128
 129 TEST_F('ExtensionSettingsWebUITest', 'testEmptyExtensionList', function() {
 130   var verifyListIsHiddenAndEmpty = function() {
 131     assertTrue($('extension-list-wrapper').hidden);
 132     assertFalse($('no-extensions').hidden);
 133     assertEquals(0, $('extension-settings-list').childNodes.length);
 134     this.nextStep();
 135   };
 136
 137   this.steps = [this.waitForPageLoad, verifyListIsHiddenAndEmpty, testDone];
 138   this.nextStep();
 139 });
 140
 141 TEST_F('ExtensionSettingsWebUITest', 'testChromeSendHandled', function() {
 142   var testPackExtenion = function() {
 143     // This dialog should be hidden at first.
 144     assertFalse($('pack-extension-overlay').classList.contains('showing'));
 145
 146     // Show the dialog, which triggers a chrome.send() for metrics purposes.
 147     cr.dispatchSimpleEvent($('pack-extension'), 'click');
 148     assertTrue($('pack-extension-overlay').classList.contains('showing'));
 149     this.nextStep();
 150   };
 151
 152   this.steps = [this.waitForPageLoad, testPackExtenion, testDone];
 153   this.nextStep();
 154 });
 155
 156 /**
 157  * @param {chrome.developerPrivate.EventType} eventType
 158  * @param {function():void} callback
 159  * @constructor
 160  */
 161 function UpdateListener(eventType, callback) {
 162   this.callback_ = callback;
 163   this.eventType_ = eventType;
 164   this.onItemStateChangedListener_ = this.onItemStateChanged_.bind(this);
 165   chrome.developerPrivate.onItemStateChanged.addListener(
 166       this.onItemStateChangedListener_);
 167 }
 168
 169 UpdateListener.prototype = {
 170   /** @private */
 171   onItemStateChanged_: function(data) {
 172     if (this.eventType_ == data.event_type) {
 173       window.setTimeout(function() {
 174         chrome.developerPrivate.onItemStateChanged.removeListener(
 175             this.onItemStateChangedListener_);
 176         this.callback_();
 177       }.bind(this), 0);
 178     }
 179   }
 180 };
 181
 182 function BasicExtensionSettingsWebUITest() {}
 183
 184 BasicExtensionSettingsWebUITest.prototype = {
 185   __proto__: ExtensionSettingsWebUITest.prototype,
 186
 187   /** @override */
 188   testGenPreamble: function() {
 189     // Install multiple types of extensions to ensure we handle each type.
 190     // TODO(devlin): There are more types to add here.
 191     GEN('  InstallGoodExtension();');
 192     GEN('  InstallErrorsExtension();');
 193     GEN('  InstallSharedModule();');
 194     GEN('  InstallPackagedApp();');
 195
 196     GEN('  SetAutoConfirmUninstall();');
 197   },
 198
 199   /** @protected */
 200   verifyDisabledWorks: function() {
 201     var listener = new UpdateListener(
 202         chrome.developerPrivate.EventType.UNLOADED,
 203         function() {
 204       var node = getRequiredElement(GOOD_EXTENSION_ID);
 205       assertTrue(node.classList.contains('inactive-extension'));
 206       this.nextStep();
 207     }.bind(this));
 208     chrome.management.setEnabled(GOOD_EXTENSION_ID, false);
 209   },
 210
 211   /** @protected */
 212   verifyEnabledWorks: function() {
 213     var listener = new UpdateListener(
 214         chrome.developerPrivate.EventType.LOADED,
 215         function() {
 216       var node = getRequiredElement(GOOD_EXTENSION_ID);
 217       assertFalse(node.classList.contains('inactive-extension'));
 218       this.nextStep();
 219     }.bind(this));
 220     chrome.management.setEnabled(GOOD_EXTENSION_ID, true);
 221   },
 222
 223   /** @protected */
 224   verifyUninstallWorks: function() {
 225     var listener = new UpdateListener(
 226         chrome.developerPrivate.EventType.UNINSTALLED,
 227         function() {
 228       assertEquals(null, $(GOOD_EXTENSION_ID));
 229       this.nextStep();
 230     }.bind(this));
 231     chrome.test.runWithUserGesture(function() {
 232       chrome.management.uninstall(GOOD_EXTENSION_ID);
 233     });
 234   },
 235 };
 236
 237 // Verify that developer mode doesn't change behavior when the number of
 238 // extensions changes.
 239 TEST_F('BasicExtensionSettingsWebUITest', 'testDeveloperModeManyExtensions',
 240        function() {
 241   this.testDeveloperMode();
 242 });
 243
 244
 245 TEST_F('BasicExtensionSettingsWebUITest', 'testDisable', function() {
 246   this.steps = [this.waitForPageLoad, this.verifyDisabledWorks, testDone];
 247   this.nextStep();
 248 });
 249
 250 TEST_F('BasicExtensionSettingsWebUITest', 'testEnable', function() {
 251   this.steps = [this.waitForPageLoad,
 252                 this.verifyDisabledWorks,
 253                 this.verifyEnabledWorks,
 254                 testDone];
 255   this.nextStep();
 256 });
 257
 258 TEST_F('BasicExtensionSettingsWebUITest', 'testUninstall', function() {
 259   this.steps = [this.waitForPageLoad, this.verifyUninstallWorks, testDone];
 260   this.nextStep();
 261 });
 262
 263 TEST_F('BasicExtensionSettingsWebUITest', 'testNonEmptyExtensionList',
 264        function() {
 265   var verifyListIsNotHiddenAndEmpty = function() {
 266     assertFalse($('extension-list-wrapper').hidden);
 267     assertTrue($('no-extensions').hidden);
 268     assertGT($('extension-settings-list').childNodes.length, 0);
 269     this.nextStep();
 270   };
 271
 272   this.steps = [this.waitForPageLoad, verifyListIsNotHiddenAndEmpty, testDone];
 273   this.nextStep();
 274 });
 275
 276 function ErrorConsoleExtensionSettingsWebUITest() {}
 277
 278 ErrorConsoleExtensionSettingsWebUITest.prototype = {
 279   __proto__: ExtensionSettingsWebUITest.prototype,
 280
 281   /** @override */
 282   testGenPreamble: function() {
 283     GEN('  EnableErrorConsole();');
 284     GEN('  InstallGoodExtension();');
 285     GEN('  InstallErrorsExtension();');
 286   },
 287 };
 288
 289 TEST_F('ErrorConsoleExtensionSettingsWebUITest',
 290        'testErrorListButtonVisibility', function() {
 291   var testButtonVisibility = function() {
 292     var extensionList = $('extension-list-wrapper');
 293
 294     var visibleButtons = extensionList.querySelectorAll(
 295         '.errors-link:not([hidden])');
 296     expectEquals(1, visibleButtons.length);
 297
 298     if (visibleButtons.length > 0) {
 299       var errorLink = $(ERROR_EXTENSION_ID).querySelector('.errors-link');
 300       expectEquals(visibleButtons[0], errorLink);
 301
 302       var errorIcon = errorLink.querySelector('img');
 303       expectTrue(errorIcon.classList.contains('extension-error-warning-icon'));
 304     }
 305
 306     var hiddenButtons = extensionList.querySelectorAll('.errors-link[hidden]');
 307     expectEquals(1, hiddenButtons.length);
 308
 309     this.nextStep();
 310   };
 311
 312   this.steps = [this.waitForPageLoad,
 313                 this.enableDeveloperMode,
 314                 testButtonVisibility,
 315                 testDone];
 316   this.nextStep();
 317 });
 318
 319 /**
 320  * TestFixture for extension settings WebUI testing (commands config edition).
 321  * @extends {testing.Test}
 322  * @constructor
 323  */
 324 function SettingsCommandsExtensionSettingsWebUITest() {}
 325
 326 SettingsCommandsExtensionSettingsWebUITest.prototype = {
 327   __proto__: ExtensionSettingsWebUITest.prototype,
 328
 329   /**
 330    * A URL to load before starting each test.
 331    * @type {string}
 332    * @const
 333    */
 334   browsePreload: 'chrome://extensions-frame/configureCommands',
 335 };
 336
 337 TEST_F('SettingsCommandsExtensionSettingsWebUITest', 'testChromeSendHandler',
 338     function() {
 339   // Just navigating to the page should trigger the chrome.send().
 340   var assertOverlayVisible = function() {
 341     assertTrue($('extension-commands-overlay').classList.contains('showing'));
 342     this.nextStep();
 343   };
 344
 345   this.steps = [this.waitForPageLoad, assertOverlayVisible, testDone];
 346   this.nextStep();
 347 });
 348
 349 /**
 350  * @constructor
 351  * @extends {ExtensionSettingsWebUITest}
 352  */
 353 function InstallGoodExtensionSettingsWebUITest() {}
 354
 355 InstallGoodExtensionSettingsWebUITest.prototype = {
 356   __proto__: ExtensionSettingsWebUITest.prototype,
 357
 358   /** @override */
 359   testGenPreamble: function() {
 360     GEN('  InstallGoodExtension();');
 361   },
 362
 363   emptyTestForAccessibility() {
 364     this.steps = [this.waitForPageLoad, testDone];
 365     this.nextStep();
 366   },
 367 };
 368
 369 TEST_F('InstallGoodExtensionSettingsWebUITest', 'testAccessibility',
 370        function() {
 371   this.emptyTestForAccessibility();
 372 });
 373
 374 TEST_F('InstallGoodExtensionSettingsWebUITest', 'showOptions', function() {
 375   var showExtensionOptions = function() {
 376     var optionsOverlay = extensions.ExtensionOptionsOverlay.getInstance();
 377     optionsOverlay.setExtensionAndShow(GOOD_EXTENSION_ID, 'GOOD!', '',
 378                                        this.nextStep.bind(this));
 379
 380     // Preferred size changes don't happen in browser tests. Just fake it.
 381     document.querySelector('extensionoptions').onpreferredsizechanged(
 382         {width: 500, height: 500});
 383   };
 384
 385   this.steps = [this.waitForPageLoad, showExtensionOptions, testDone];
 386   this.nextStep();
 387 });
 388
 389 /**
 390  * @constructor
 391  * @extends {InstallGoodExtensionSettingsWebUITest}
 392  */
 393 function ManagedExtensionSettingsWebUITest() {}
 394
 395 ManagedExtensionSettingsWebUITest.prototype = {
 396   __proto__: InstallGoodExtensionSettingsWebUITest.prototype,
 397
 398   /** @override */
 399   testGenPreamble: function() {
 400     GEN('  AddManagedPolicyProvider();');
 401     InstallGoodExtensionSettingsWebUITest.prototype.testGenPreamble.call(this);
 402   },
 403 };
 404
 405 TEST_F('ManagedExtensionSettingsWebUITest', 'testAccessibility', function() {
 406   this.emptyTestForAccessibility();
 407 });
 408
 409 /**
 410  * @constructor
 411  * @extends {InstallGoodExtensionSettingsWebUITest}
 412  */
 413 function OptionsDialogExtensionSettingsWebUITest() {}
 414
 415 OptionsDialogExtensionSettingsWebUITest.prototype = {
 416   __proto__: InstallGoodExtensionSettingsWebUITest.prototype,
 417
 418   /** @override */
 419   browsePreload: ExtensionSettingsWebUITest.prototype.browsePreload +
 420       '?options=' + GOOD_EXTENSION_ID,
 421 };
 422
 423 TEST_F('OptionsDialogExtensionSettingsWebUITest', 'testAccessibility',
 424        function() {
 425   this.emptyTestForAccessibility();
 426 });