Replace own callback handling with Promises.

chrome/browser/ui/webui/options/manage_profile_browsertest.js

 // Copyright 2013 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.
 
 // None of these tests is relevant for Chrome OS.
 GEN('#if !defined(OS_CHROMEOS)');
 
 GEN('#include "base/command_line.h"');
 GEN('#include "chrome/common/chrome_switches.h"');
 
 /**
  * TestFixture for ManageProfileOverlay and CreateProfileOverlay WebUI testing.
  * @extends {testing.Test}
  * @constructor
  */
 function ManageProfileUITest() {}
 
 ManageProfileUITest.prototype = {
   __proto__: testing.Test.prototype,
 
   /** @override */
   browsePreload: 'chrome://settings-frame/manageProfile',
 
+  isAsync: true,
+
   /**
    * No need to run these for every OptionsPage test, since they'll cover the
    * whole consolidated page each time.
    * @override
    */
   runAccessibilityChecks: false,
 
   /** @override */
   testGenPreamble: function() {
     GEN('CommandLine::ForCurrentProcess()->' +
@@ skipping 55 matching lines @@
              $('manage-profile-cancel'));
   checkFocus('createProfile',
              $('create-profile-name'),
              $('create-profile-cancel'));
   checkFocus('managedUserLearnMore',
              $('managed-user-learn-more-done'),
              $('managed-user-learn-more-done'));
   checkFocus('managedUserLearnMore',
              document.querySelector('#managed-user-learn-more-text a'),
              document.querySelector('#managed-user-learn-more-text a'));
+  testDone();

[Bernhard Bauer, 2014/01/13 17:18:47]

Alternatively, you could make a subclass for the async test. Up to you, really.

[Adrian Kuegel, 2014/01/15 14:15:35]

Ok, this seems to be the better solution, since we only need the async behavior
in one test. So I changed it.

 });
 
 // The default options should be reset each time the creation overlay is shown.
 TEST_F('ManageProfileUITest', 'DefaultCreateOptions', function() {
   OptionsPage.showPageByName('createProfile');
   var shortcutsAllowed = loadTimeData.getBoolean('profileShortcutsEnabled');
   var createShortcut = $('create-shortcut');
   var createManaged = $('create-profile-managed');
   assertEquals(shortcutsAllowed, createShortcut.checked);
   assertFalse(createManaged.checked);
 
   createShortcut.checked = !shortcutsAllowed;
   createManaged.checked = true;
   OptionsPage.closeOverlay();
   OptionsPage.showPageByName('createProfile');
   assertEquals(shortcutsAllowed, createShortcut.checked);
   assertFalse(createManaged.checked);
+  testDone();
 });
 
 // The checkbox label should change depending on whether the user is signed in.
 TEST_F('ManageProfileUITest', 'CreateManagedUserText', function() {
   var signedInText =  $('create-profile-managed-signed-in');
   var notSignedInText = $('create-profile-managed-not-signed-in');
 
   ManageProfileOverlay.getInstance().initializePage();
 
   var custodianEmail = 'chrome.playpen.test@gmail.com';
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   assertEquals(custodianEmail,
                CreateProfileOverlay.getInstance().signedInEmail_);
   assertFalse(signedInText.hidden);
   assertTrue(notSignedInText.hidden);
   // Make sure the email is in the string somewhere, without depending on the
   // exact details of the message.
   assertNotEquals(-1, signedInText.textContent.indexOf(custodianEmail));
 
   CreateProfileOverlay.updateSignedInStatus('');
   assertEquals('', CreateProfileOverlay.getInstance().signedInEmail_);
   assertTrue(signedInText.hidden);
   assertFalse(notSignedInText.hidden);
   assertFalse($('create-profile-managed').checked);
   assertTrue($('create-profile-managed').disabled);
+  testDone();
 });
 
 // The import link should show up if the user tries to create a profile with the
 // same name as an existing managed user profile.
 TEST_F('ManageProfileUITest', 'CreateExistingManagedUser', function() {
   ManageProfileOverlay.getInstance().initializePage();
   var custodianEmail = 'chrome.playpen.test@gmail.com';
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   assertEquals(custodianEmail,
                CreateProfileOverlay.getInstance().signedInEmail_);
   this.setProfileManaged_(false, 'create');
 
   // Initialize the list of existing managed users.
-  var managedUserListData = options.ManagedUserListData.getInstance();
-  managedUserListData.managedUsers_ = [
+  var managedUsers = [
     {
       id: 'managedUser1',
       name: 'Rosalie',
       iconURL: 'chrome://path/to/icon/image',
       onCurrentDevice: false,
+      nameConflict: false,
       needAvatar: false
     },
     {
       id: 'managedUser2',
       name: 'Fritz',
       iconURL: 'chrome://path/to/icon/image',
       onCurrentDevice: false,
+      nameConflict: false,
       needAvatar: true
     },
     {
       id: 'managedUser3',
       name: 'Test',
       iconURL: 'chrome://path/to/icon/image',
       onCurrentDevice: true,
+      nameConflict: true,
       needAvatar: false
     }];
+  var promise = Promise.resolve(managedUsers);
+  options.ManagedUserListData.getInstance().promise_ = promise;
   // Also add the name 'Test' to |profileNames_| to simulate that the profile
   // exists on the device.
   ManageProfileOverlay.getInstance().profileNames_.Test = true;
 
   // Initially, the ok button should be enabled and the import link should not
   // exist.
   assertFalse($('create-profile-ok').disabled);
   assertTrue($('supervised-user-import') == null);
 
   // Now try to create profiles with the names of existing supervised users.
   $('create-profile-managed').checked = true;
   var nameField = $('create-profile-name');
   // A profile which already has an avatar.
   nameField.value = 'Rosalie';
   ManageProfileOverlay.getInstance().onNameChanged_('create');
-  assertTrue($('create-profile-ok').disabled);
-  assertFalse($('supervised-user-import') == null);
-  // A profile which doesn't have an avatar yet.
-  nameField.value = 'Fritz';
-  ManageProfileOverlay.getInstance().onNameChanged_('create');
-  assertTrue($('create-profile-ok').disabled);
-  assertFalse($('supervised-user-import') == null);
-  // A profile which already exists on the device.
-  nameField.value = 'Test';
-  ManageProfileOverlay.getInstance().onNameChanged_('create');
-  assertTrue($('create-profile-ok').disabled);
-  assertTrue($('supervised-user-import') == null);
+  // Need to wait until the promise resolves.
+  promise.then(function() {
+    assertTrue($('create-profile-ok').disabled);
+    assertFalse($('supervised-user-import') == null);
 
-  // A profile which does not exist yet.
-  nameField.value = 'NewProfileName';
-  ManageProfileOverlay.getInstance().onNameChanged_('create');
-  assertFalse($('create-profile-ok').disabled);
-  assertTrue($('supervised-user-import') == null);
+    // A profile which doesn't have an avatar yet.
+    nameField.value = 'Fritz';
+    ManageProfileOverlay.getInstance().onNameChanged_('create');
+    promise.then(function() {

[Bernhard Bauer, 2014/01/13 17:18:47]

You're waiting on the same promise, which is already fulfilled. If the test
currently succeeds, that tells me that you're relying on the fact that the
promise hasn't been reset in the mean time. I'm not sure if that's a good
assumption...

In any case, you can get rid of the nested calls (regardless of which promise
you end up waiting on) by returning the promise from the callback here.

[Adrian Kuegel, 2014/01/15 14:15:35]

You are right, in a normal execution it could have been reset in the mean time.
Good idea. Done.

+      assertTrue($('create-profile-ok').disabled);
+      assertFalse($('supervised-user-import') == null);
+
+      // A profile which already exists on the device.
+      nameField.value = 'Test';
+      ManageProfileOverlay.getInstance().onNameChanged_('create');
+      promise.then(function() {
+        assertTrue($('create-profile-ok').disabled);
+        assertTrue($('supervised-user-import') == null);
+
+        // A profile which does not exist yet.
+        nameField.value = 'NewProfileName';
+        ManageProfileOverlay.getInstance().onNameChanged_('create');
+        promise.then(function() {
+          assertFalse($('create-profile-ok').disabled);
+          assertTrue($('supervised-user-import') == null);
+          testDone();
+        });
+      });
+    });
+  });
 });
 
 // Managed users should not be able to edit their profile names, and the initial
 // focus should be adjusted accordingly.
 TEST_F('ManageProfileUITest', 'EditManagedUserNameAllowed', function() {
   var nameField = $('manage-profile-name');
 
   this.setProfileManaged_(false, 'manage');
   ManageProfileOverlay.showManageDialog();
   expectFalse(nameField.disabled);
   expectEquals(nameField, document.activeElement);
 
   OptionsPage.closeOverlay();
 
   this.setProfileManaged_(true, 'manage');
   ManageProfileOverlay.showManageDialog();
   expectTrue(nameField.disabled);
   expectEquals($('manage-profile-ok'), document.activeElement);
+  testDone();
 });
 
 // Setting profile information should allow the confirmation to be shown.
 TEST_F('ManageProfileUITest', 'ShowCreateConfirmation', function() {
   var testProfile = this.testProfileInfo_(true);
   testProfile.custodianEmail = 'foo@bar.example.com';
   ManagedUserCreateConfirmOverlay.setProfileInfo(testProfile);
   assertTrue(ManagedUserCreateConfirmOverlay.getInstance().canShowPage());
   OptionsPage.showPageByName('managedUserCreateConfirm', false);
   assertEquals('managedUserCreateConfirm',
                OptionsPage.getTopmostVisiblePage().name);
+  testDone();
 });
 
 // Trying to show a confirmation dialog with no profile information should fall
 // back to the default (main) settings page.
 TEST_F('ManageProfileUITest', 'NoEmptyConfirmation', function() {
   assertEquals('manageProfile', OptionsPage.getTopmostVisiblePage().name);
   assertFalse(ManagedUserCreateConfirmOverlay.getInstance().canShowPage());
   OptionsPage.showPageByName('managedUserCreateConfirm', true);
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
+  testDone();
 });
 
 // A confirmation dialog should be shown after creating a new managed user.
 TEST_F('ManageProfileUITest', 'ShowCreateConfirmationOnSuccess', function() {
   OptionsPage.showPageByName('createProfile');
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
   CreateProfileOverlay.onSuccess(this.testProfileInfo_(false));
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
 
   OptionsPage.showPageByName('createProfile');
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
   CreateProfileOverlay.onSuccess(this.testProfileInfo_(true));
   assertEquals('managedUserCreateConfirm',
                OptionsPage.getTopmostVisiblePage().name);
   expectEquals($('managed-user-created-switch'), document.activeElement);
+  testDone();
 });
 
 // An error should be shown if creating a new managed user fails.
 TEST_F('ManageProfileUITest', 'NoCreateConfirmationOnError', function() {
   OptionsPage.showPageByName('createProfile');
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
   var errorBubble = $('create-profile-error-bubble');
   assertTrue(errorBubble.hidden);
 
   CreateProfileOverlay.onError('An Error Message!');
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
   assertFalse(errorBubble.hidden);
+  testDone();
 });
 
 // The name and email sould be inserted into the confirmation dialog.
 TEST_F('ManageProfileUITest', 'CreateConfirmationText', function () {
   var self = this;
   var custodianEmail = 'foo@example.com';
 
   // Checks the strings in the confirmation dialog. If |expectedNameText| is
   // given, it should be present in the dialog's textContent; otherwise the name
   // is expected. If |expectedNameHtml| is given, it should be present in the
@@ skipping 33 matching lines @@
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
 
   checkDialog('OneWord');
   checkDialog('Multiple Words');
   checkDialog('It\'s "<HTML> injection" & more!',
               'It\'s "<HTML> injection" & more!',
               // The innerHTML getter doesn't escape quotation marks,
               // independent of whether they were escaped in the setter.
               'It\'s "&lt;HTML&gt; injection" &amp; more!');
 
-  // Test elision. MAX_LENGTH = 50, minus 3 for the ellipsis.
-  var name47Characters = '01234567890123456789012345678901234567890123456';
-  var name60Characters = name47Characters + '0123456789012';
-  checkDialog(name60Characters, name47Characters + '...');
+  // Test elision. MAX_LENGTH = 50, minus 1 for the ellipsis.
+  var name49Characters = '0123456789012345678901234567890123456789012345678';
+  var name50Characters = name49Characters + '9';
+  var name51Characters = name50Characters + '0';
+  var name60Characters = name51Characters + '123456789';
+  checkDialog(name49Characters, name49Characters);
+  checkDialog(name50Characters, name50Characters);
+  checkDialog(name51Characters, name49Characters + '\u2026');
+  checkDialog(name60Characters, name49Characters + '\u2026');
 
   // Test both elision and HTML escaping. The allowed string length is the
   // visible length, not the length including the entity names.
-  name47Characters = name47Characters.replace('0', '&').replace('1', '>');
+  name49Characters = name49Characters.replace('0', '&').replace('1', '>');
   name60Characters = name60Characters.replace('0', '&').replace('1', '>');
-  var escaped = name47Characters.replace('&', '&amp;').replace('>', '&gt;');
-  checkDialog(name60Characters, name47Characters + '...', escaped + '...');
+  var escaped = name49Characters.replace('&', '&amp;').replace('>', '&gt;');
+  checkDialog(
+      name60Characters, name49Characters + '\u2026', escaped + '\u2026');
+  testDone();
 });
 
 // An additional warning should be shown when deleting a managed user.
 TEST_F('ManageProfileUITest', 'DeleteManagedUserWarning', function() {
   var addendum = $('delete-managed-profile-addendum');
 
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(true));
   assertFalse(addendum.hidden);
 
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(false));
   assertTrue(addendum.hidden);
+  testDone();
 });
 
 // The policy prohibiting managed users should update the UI dynamically.
 TEST_F('ManageProfileUITest', 'PolicyDynamicRefresh', function() {
   ManageProfileOverlay.getInstance().initializePage();
 
   var custodianEmail = 'chrome.playpen.test@gmail.com';
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   CreateProfileOverlay.updateManagedUsersAllowed(true);
   var checkbox = $('create-profile-managed');
@@ skipping 27 matching lines @@
   assertEquals('inline-block', window.getComputedStyle(indicator, null).display,
                'disallowed, signed in');
   assertEquals('policy', indicator.getAttribute('controlled-by'));
 
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   CreateProfileOverlay.updateManagedUsersAllowed(true);
   assertFalse(checkbox.disabled, 're-allowed and signed in');
   assertFalse(link.hidden, 're-allowed and signed in');
   assertEquals('none', window.getComputedStyle(indicator, null).display,
                're-allowed and signed in');
+  testDone();
 });
 
 // The managed user checkbox should correctly update its state during profile
 // creation and afterwards.
 TEST_F('ManageProfileUITest', 'CreateInProgress', function() {
   ManageProfileOverlay.getInstance().initializePage();
 
   var custodianEmail = 'chrome.playpen.test@gmail.com';
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   CreateProfileOverlay.updateManagedUsersAllowed(true);
@@ skipping 10 matching lines @@
   CreateProfileOverlay.updateCreateInProgress(true);
   assertTrue(checkbox.disabled, 'creation in progress');
 
   // A no-op update to the sign-in status should not change the UI.
   CreateProfileOverlay.updateSignedInStatus(custodianEmail);
   CreateProfileOverlay.updateManagedUsersAllowed(true);
   assertTrue(checkbox.disabled, 'creation in progress');
 
   CreateProfileOverlay.updateCreateInProgress(false);
   assertFalse(checkbox.disabled, 'creation finished');
+  testDone();
 });
 
 // Managed users shouldn't be able to open the delete or create dialogs.
 TEST_F('ManageProfileUITest', 'ManagedShowDeleteAndCreate', function() {
   this.setProfileManaged_(false, 'create');
 
   ManageProfileOverlay.showCreateDialog();
   assertEquals('createProfile', OptionsPage.getTopmostVisiblePage().name);
   OptionsPage.closeOverlay();
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(false));
   assertEquals('manageProfile', OptionsPage.getTopmostVisiblePage().name);
   assertFalse($('manage-profile-overlay-delete').hidden);
   OptionsPage.closeOverlay();
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
 
   this.setProfileManaged_(true, 'create');
   ManageProfileOverlay.showCreateDialog();
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(false));
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
+  testDone();
 });
 
 // Only non-managed users should be able to delete profiles.
 TEST_F('ManageProfileUITest', 'ManagedDelete', function() {
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(false));
   assertEquals('manageProfile', OptionsPage.getTopmostVisiblePage().name);
   assertFalse($('manage-profile-overlay-delete').hidden);
 
   // Clicks the "Delete" button, after overriding chrome.send to record what
   // messages were sent.
   function clickAndListen() {
     var originalChromeSend = chrome.send;
     var chromeSendMessages = [];
     chrome.send = function(message) {
       chromeSendMessages.push(message);
     };
     $('delete-profile-ok').onclick();
     // Restore the original function so the test framework can use it.
     chrome.send = originalChromeSend;
     return chromeSendMessages;
   }
 
   this.setProfileManaged_(false, 'manage');
   var messages = clickAndListen();
-  assertEquals(2, messages.length);
+  assertEquals(1, messages.length);
   assertEquals('deleteProfile', messages[0]);
-  assertEquals('requestManagedUserImportUpdate', messages[1]);
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
 
   ManageProfileOverlay.showDeleteDialog(this.testProfileInfo_(false));
   this.setProfileManaged_(true, 'manage');
   messages = clickAndListen();
   assertEquals(0, messages.length);
   assertEquals('settings', OptionsPage.getTopmostVisiblePage().name);
+  testDone();
 });
 
 GEN('#endif  // OS_CHROMEOS');