// 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_people_page_quick_unlock', function() {
  let testElement = null;
  let quickUnlockPrivateApi = null;
  const QuickUnlockMode = chrome.quickUnlockPrivate.QuickUnlockMode;
  let fakeUma = null;

  /**
   * Returns if the element is visible.
   * @param {!Element} element
   */
  function isVisible(element) {
    while (element) {
      if (element.offsetWidth <= 0 || element.offsetHeight <= 0 ||
          element.hidden ||
          window.getComputedStyle(element).visibility === 'hidden') {
        return false;
      }

      element = element.parentElement;

      if (element) {
        // cr-dialog itself will always be 0x0. It's the inner native <dialog>
        // that has actual dimensions.
        // (The same about PIN-KEYBOARD.)
        if (element.tagName === 'CR-DIALOG') {
          element = element.getNative();
        } else if (element.tagName === 'PIN-KEYBOARD') {
          element = element.$.root;
        }
      }
    }

    return true;
  }

  /**
   * Returns true if the given |element| has class |className|.
   * @param {!Element} element
   * @param {string} className
   */
  function assertHasClass(element, className) {
    assertTrue(element.classList.contains(className));
  }

  /**
   * Returns the result of running |selector| on testElement.
   * @param {string} selector
   * @return {Element}
   */
  function getFromElement(selector) {
    let childElement = testElement.$$(selector);
    if (!childElement && testElement.$.pinKeyboard) {
      childElement = testElement.$.pinKeyboard.$$(selector);
    }

    assertTrue(!!childElement);
    return childElement;
  }

  /**
   * Sets the active quick unlock modes and raises a mode change event.
   * @param {!Array<chrome.quickUnlockPrivate.QuickUnlockMode>} modes
   */
  function setActiveModes(modes) {
    quickUnlockPrivateApi.activeModes = modes;
    quickUnlockPrivateApi.onActiveModesChanged.callListeners(modes);
  }

  function registerAuthenticateTests() {
    suite('authenticate', function() {
      let passwordPromptDialog = null;
      let passwordElement = null;
      let authTokenObtainedFired = false;

      setup(function() {
        PolymerTest.clearBody();

        quickUnlockPrivateApi = new settings.FakeQuickUnlockPrivate();
        fakeUma = new settings.FakeQuickUnlockUma();

        testElement = document.createElement(
            'settings-lock-screen-password-prompt-dialog');
        testElement.writeUma_ = fakeUma.recordProgress.bind(fakeUma);
        testElement.addEventListener('auth-token-obtained', (e) => {
          authTokenObtainedFired = true;
        });
        document.body.appendChild(testElement);

        passwordPromptDialog = getFromElement('#passwordPrompt');
        passwordPromptDialog.quickUnlockPrivate = quickUnlockPrivateApi;

        Polymer.dom.flush();

        passwordElement = passwordPromptDialog.$$('#passwordInput');
      });

      test('PasswordCheckDoesNotChangeActiveMode', function() {
        // No active modes.
        quickUnlockPrivateApi.activeModes = [];
        passwordElement.value = 'foo';
        passwordPromptDialog.submitPassword_();
        assertDeepEquals([], quickUnlockPrivateApi.activeModes);
        assertDeepEquals([], quickUnlockPrivateApi.credentials);

        // PIN is active.
        quickUnlockPrivateApi.activeModes = [QuickUnlockMode.PIN];
        passwordElement.value = 'foo';
        passwordPromptDialog.submitPassword_();
        assertDeepEquals(
            [QuickUnlockMode.PIN], quickUnlockPrivateApi.activeModes);
        assertDeepEquals([], quickUnlockPrivateApi.credentials);
      });

      test('InvalidPasswordInteractions', function() {
        const confirmButton = passwordPromptDialog.$$('#confirmButton');
        quickUnlockPrivateApi.accountPassword = 'bar';
        passwordElement.value = 'foo';
        Polymer.dom.flush();

        passwordPromptDialog.$$('cr-button[class="action-button"]').click();
        Polymer.dom.flush();

        assertEquals(0, passwordElement.inputElement.selectionStart);
        assertEquals(
            passwordElement.value.length,
            passwordElement.inputElement.selectionEnd);
        assertTrue(passwordElement.invalid);
        assertTrue(confirmButton.disabled);

        // Changing value should reset invalid state.
        passwordElement.value = 'bar';
        Polymer.dom.flush();
        assertFalse(passwordElement.invalid);
        assertFalse(confirmButton.disabled);
      });

      test('TapConfirmButtonWithWrongPasswordRestoresFocus', function() {
        const confirmButton = passwordPromptDialog.$$('#confirmButton');
        quickUnlockPrivateApi.accountPassword = 'bar';
        passwordElement.value = 'foo';
        passwordPromptDialog.$$('cr-button[class="action-button"]').click();

        assertTrue(passwordElement.hasAttribute('focused_'));
      });

      // A bad password does not provide an authenticated setModes object, and a
      // entered password correctly uma should not be recorded.
      test('InvalidPasswordDoesNotProvideAuthentication', function() {
        quickUnlockPrivateApi.accountPassword = 'bar';

        passwordElement.value = 'foo';
        passwordPromptDialog.submitPassword_();

        assertEquals(
            0,
            fakeUma.getHistogramValue(
                settings.LockScreenProgress.ENTER_PASSWORD_CORRECTLY));
        assertFalse(authTokenObtainedFired);
      });

      // A valid password provides an authenticated setModes object, and a
      // entered password correctly uma should be recorded.
      test('ValidPasswordProvidesAuthentication', function() {
        quickUnlockPrivateApi.accountPassword = 'foo';

        passwordElement.value = 'foo';
        passwordPromptDialog.submitPassword_();

        assertEquals(
            1,
            fakeUma.getHistogramValue(
                settings.LockScreenProgress.ENTER_PASSWORD_CORRECTLY));
        assertTrue(authTokenObtainedFired);
      });

      // The setModes objects times out after a delay.
      test('AuthenticationTimesOut', function(done) {
        quickUnlockPrivateApi.accountPassword = 'foo';

        passwordElement.value = 'foo';
        passwordPromptDialog.submitPassword_();
        // Fake lifetime is 0 so setModes should be reset in next frame.
        setTimeout(function() {
          assertFalse(!!testElement.setModes);
          done();
        }, 0);
      });

      test('ConfirmButtonDisabledWhenEmpty', function() {
        // Confirm button is diabled when there is nothing entered.
        const confirmButton = passwordPromptDialog.$$('#confirmButton');
        assertTrue(!!confirmButton);
        assertTrue(confirmButton.disabled);

        passwordElement.value = 'foo';
        assertFalse(!!confirmButton.disabled);
        passwordElement.value = '';
        assertTrue(confirmButton.disabled);
      });
    });
  }

  function registerLockScreenTests() {
    suite('lock-screen', function() {
      const ENABLE_LOCK_SCREEN_PREF = 'settings.enable_screen_lock';
      const ENABLE_PIN_AUTOSUBMIT_PREF = 'pin_unlock_autosubmit_enabled';

      let fakeSettings = null;
      let passwordRadioButton = null;
      let pinPasswordRadioButton = null;
      const noneRadioButton = null;

      /**
       * Asserts that only the given radio button is checked and all of the
       * others are unchecked.
       * @param {Element} radioButton
       */
      function assertRadioButtonChecked(radioButton) {
        function doAssert(element, name) {
          if (radioButton === element) {
            assertTrue(element.checked, 'Expected ' + name + ' to be checked');
          } else {
            assertFalse(
                element.checked, 'Expected ' + name + ' to be unchecked');
          }
        }

        doAssert(passwordRadioButton, 'passwordButton');
        doAssert(pinPasswordRadioButton, 'pinPasswordButton');
      }

      /**
       * Returns the lock screen pref value.
       * @return {boolean}
       */
      function getLockScreenPref() {
        let result;
        fakeSettings.getPref(ENABLE_LOCK_SCREEN_PREF, function(value) {
          result = value;
        });
        assertNotEquals(undefined, result);
        return result.value;
      }

      /**
       * Changes the lock screen pref value using the settings API; this is like
       * the pref got changed from an unknown source such as another tab.
       * @param {boolean} value
       */
      function setLockScreenPref(value) {
        fakeSettings.setPref(ENABLE_LOCK_SCREEN_PREF, value, '', assertTrue);
      }

      function isSetupPinButtonVisible() {
        Polymer.dom.flush();
        const setupPinButton = testElement.$$('#setupPinButton');
        return isVisible(setupPinButton);
      }

      function isEnablePinAutosubmitToggleVisible() {
        Polymer.dom.flush();
        const autosubmitToggle = testElement.$$('#enablePinAutoSubmit');
        return autosubmitToggle && isVisible(autosubmitToggle);
      }

      setup(function() {
        PolymerTest.clearBody();

        CrSettingsPrefs.deferInitialization = true;

        // Build pref fakes.
        const fakePrefs = [
          {
            key: ENABLE_LOCK_SCREEN_PREF,
            type: chrome.settingsPrivate.PrefType.BOOLEAN,
            value: true
          },
          {
            key: 'ash.message_center.lock_screen_mode',
            type: chrome.settingsPrivate.PrefType.STRING,
            value: 'hide'
          },
          {
            key: ENABLE_PIN_AUTOSUBMIT_PREF,
            type: chrome.settingsPrivate.PrefType.BOOLEAN,
            value: false
          }
        ];
        fakeSettings = new settings.FakeSettingsPrivate(fakePrefs);
        fakeUma = new settings.FakeQuickUnlockUma();
        setLockScreenPref(true);
        const prefElement = document.createElement('settings-prefs');
        prefElement.initialize(fakeSettings);
        document.body.appendChild(prefElement);

        // Wait for prefElement to finish initializing; it takes some time for
        // the prefs element to get allocated.
        return test_util.eventToPromise('prefs-changed', prefElement)
            .then(function() {
              quickUnlockPrivateApi = new settings.FakeQuickUnlockPrivate();

              // Create choose-method element.
              testElement = document.createElement('settings-lock-screen');
              testElement.settingsPrivate_ = fakeSettings;
              testElement.quickUnlockPrivate = quickUnlockPrivateApi;
              testElement.prefs = prefElement.prefs;
              testElement.writeUma_ = fakeUma.recordProgress.bind(fakeUma);

              document.body.appendChild(testElement);
              Polymer.dom.flush();

              testElement.setModes = quickUnlockPrivateApi.setModes.bind(
                  quickUnlockPrivateApi,
                  quickUnlockPrivateApi.getFakeToken().token, [], [], () => {
                    return true;
                  });

              return test_util.waitBeforeNextRender(testElement);
            })
            .then(() => {
              passwordRadioButton =
                  getFromElement('cr-radio-button[name="password"]');
              pinPasswordRadioButton =
                  getFromElement('cr-radio-button[name="pin+password"]');
            });
      });

      teardown(function() {
        settings.Router.getInstance().resetRouteForTesting();
      });

      // Showing the choose method screen does not make any destructive pref or
      // quickUnlockPrivate calls.
      test('ShowingScreenDoesNotModifyPrefs', function() {
        assertTrue(getLockScreenPref());
        assertRadioButtonChecked(passwordRadioButton);
        assertDeepEquals([], quickUnlockPrivateApi.activeModes);
      });

      // Toggling the lock screen preference calls setLockScreenEnabled.
      test('SetLockScreenEnabled', function() {
        testElement.authToken = quickUnlockPrivateApi.getFakeToken();
        const toggle = getFromElement('#enableLockScreen');
        const lockScreenEnabled = toggle.checked;
        quickUnlockPrivateApi.lockScreenEnabled = lockScreenEnabled;

        toggle.click();
        assertEquals(toggle.checked, !lockScreenEnabled);
        assertEquals(
            quickUnlockPrivateApi.lockScreenEnabled, !lockScreenEnabled);

        toggle.click();
        assertEquals(toggle.checked, lockScreenEnabled);
        assertEquals(
            quickUnlockPrivateApi.lockScreenEnabled, lockScreenEnabled);
      });

      test('Deep link to enable lock screen', async () => {
        loadTimeData.overrideValues({isDeepLinkingEnabled: true});

        const params = new URLSearchParams;
        params.append('settingId', '303');
        settings.Router.getInstance().navigateTo(
            settings.routes.LOCK_SCREEN, params);

        const deepLinkElement =
            getFromElement('#enableLockScreen').$$('cr-toggle');
        assert(!!deepLinkElement);
        await test_util.waitAfterNextRender(deepLinkElement);
        assertEquals(
            deepLinkElement, getDeepActiveElement(),
            'Lock screen toggle should be focused for settingId=303.');
      });

      // The various radio buttons update internal state and do not modify
      // prefs.
      test('TappingButtonsChangesUnderlyingState', function() {
        function togglePin() {
          assertRadioButtonChecked(passwordRadioButton);

          // Tap pin+password button.
          pinPasswordRadioButton.click();
          assertRadioButtonChecked(pinPasswordRadioButton);
          assertTrue(isSetupPinButtonVisible());
          assertDeepEquals([], quickUnlockPrivateApi.activeModes);

          // Enable quick unlock so that we verify tapping password disables it.
          setActiveModes([QuickUnlockMode.PIN]);

          // Tap password button and verify quick unlock is disabled.
          passwordRadioButton.click();
          assertRadioButtonChecked(passwordRadioButton);
          assertFalse(isSetupPinButtonVisible());
          assertDeepEquals([], quickUnlockPrivateApi.activeModes);
        }
        testElement.authToken = quickUnlockPrivateApi.getFakeToken();

        // Verify toggling PIN on/off does not disable screen lock.
        setLockScreenPref(true);
        togglePin();
        assertTrue(getLockScreenPref());

        // Verify toggling PIN on/off does not enable screen lock.
        setLockScreenPref(false);
        togglePin();
        assertFalse(getLockScreenPref());
      });

      // If quick unlock is changed by another settings page the radio button
      // will update to show quick unlock is active.
      test('EnablingQuickUnlockChangesButtonState', function() {
        setActiveModes([QuickUnlockMode.PIN]);
        assertRadioButtonChecked(pinPasswordRadioButton);
        assertTrue(isSetupPinButtonVisible());

        setActiveModes([]);
        assertRadioButtonChecked(passwordRadioButton);
        assertDeepEquals([], quickUnlockPrivateApi.activeModes);
      });

      // Tests correct UI conflict resolution in the event of a race condition
      // that may occur when:
      // (1) User selects PIN_PASSSWORD, and successfully sets a pin, adding
      //     QuickUnlockMode.PIN to active modes.
      // (2) User selects PASSWORD, QuickUnlockMode.PIN capability is cleared
      //     from the active modes, notifying LockStateBehavior to call
      //     updateUnlockType to fetch the active modes asynchronously.
      // (3) User selects PIN_PASSWORD, but the process from step 2 has
      //     not yet completed.
      // See https://crbug.com/1054327 for details.
      test('UserSelectsPinBeforePasswordOnlyStateSet', function() {
        setActiveModes([QuickUnlockMode.PIN]);
        assertRadioButtonChecked(pinPasswordRadioButton);
        assertTrue(isSetupPinButtonVisible());
        Polymer.dom.flush();
        assertEquals(testElement.$$('#setupPinButton').innerText, 'Change PIN');

        // Clicking will trigger an async call which setActiveModes([]) fakes.
        passwordRadioButton.click();
        assertFalse(isSetupPinButtonVisible());

        pinPasswordRadioButton.click();
        assertTrue(isSetupPinButtonVisible());

        // Simulate the state change to PASSWORD after selecting PIN radio.
        setActiveModes([]);

        Polymer.dom.flush();
        assertRadioButtonChecked(pinPasswordRadioButton);
        assertTrue(isSetupPinButtonVisible());
        assertEquals(testElement.$$('#setupPinButton').innerText, 'Set up PIN');
      });

      // Tapping the PIN configure button opens up the setup PIN dialog, and
      // records a chose pin or password uma.
      test('TappingConfigureOpensSetupPin', function() {
        assertEquals(
            0,
            fakeUma.getHistogramValue(
                settings.LockScreenProgress.CHOOSE_PIN_OR_PASSWORD));
        assertRadioButtonChecked(passwordRadioButton);

        pinPasswordRadioButton.click();
        assertTrue(isSetupPinButtonVisible());
        assertRadioButtonChecked(pinPasswordRadioButton);

        Polymer.dom.flush();
        getFromElement('#setupPinButton').click();
        Polymer.dom.flush();
        const setupPinDialog = getFromElement('#setupPin');
        assertTrue(setupPinDialog.$$('#dialog').open);
        assertEquals(
            1,
            fakeUma.getHistogramValue(
                settings.LockScreenProgress.CHOOSE_PIN_OR_PASSWORD));
      });

      test('TappingEnableAutoSubmitPinOpensDialog', function() {
        testElement.authToken = quickUnlockPrivateApi.getFakeToken();
        // No PIN is set yet.
        assertFalse(testElement.hasPin);
        testElement.hasPin = true;
        // Must be visible when there is a PIN set.
        assertTrue(isEnablePinAutosubmitToggleVisible());

        getFromElement('#enablePinAutoSubmit').click();
        Polymer.dom.flush();
        const autosubmitDialog = getFromElement('#pinAutosubmitDialog');
        assertTrue(autosubmitDialog.$$('#dialog').open);

        // Cancel button closes the dialog.
        autosubmitDialog.$$('#cancelButton').click();
        assertFalse(autosubmitDialog.$$('#dialog').open);
      });
    });
  }

  function registerAutosubmitDialogTests() {
    suite('autosubmit-dialog', function() {
      let confirmButton = null;
      let cancelButton = null;
      let pinKeyboard = null;
      let errorDiv = null;
      let errorMsg = null;

      setup(function() {
        PolymerTest.clearBody();
        quickUnlockPrivateApi = new settings.FakeQuickUnlockPrivate();

        // Create auto submit dialog.
        testElement = document.createElement('settings-pin-autosubmit-dialog');
        testElement.quickUnlockPrivate = quickUnlockPrivateApi;
        testElement.authToken = quickUnlockPrivateApi.getFakeToken();
        document.body.appendChild(testElement);
        Polymer.dom.flush();

        // Prepare the quick unlock private API.
        quickUnlockPrivateApi.credentials[0] = '123456';
        assertFalse(quickUnlockPrivateApi.pinAutosubmitEnabled);

        // Get the elements.
        pinKeyboard = getFromElement('#pinKeyboard');
        errorDiv = getFromElement('#errorDiv');
        cancelButton = getFromElement('#cancelButton');
        confirmButton = getFromElement('#confirmButton');
        errorMsg = getFromElement('#errorMessage');

        assertTrue(isVisible(cancelButton));
        assertTrue(isVisible(confirmButton));
      });

      test('WrongPinShowsError', function() {
        assertFalse(isVisible(errorDiv));
        pinKeyboard.value = '1234';
        assertFalse(confirmButton.disabled);
        confirmButton.click();
        assertFalse(quickUnlockPrivateApi.pinAutosubmitEnabled);
        assertTrue(isVisible(errorDiv));
        assertEquals(errorMsg.innerText, 'Incorrect PIN');
        assertTrue(confirmButton.disabled);
      });

      // PINs longer than 12 digits are not supported and cannot activate
      // auto submit.
      test('LongPinShowsError', function() {
        assertFalse(isVisible(errorDiv));
        pinKeyboard.value = '123456789012';  // 12 digits still ok
        assertFalse(confirmButton.disabled);
        pinKeyboard.value = '1234567890123';  // 13 digits - Not ok
        assertTrue(confirmButton.disabled);
        assertTrue(isVisible(errorDiv));
        assertEquals(errorMsg.innerText, 'PIN must be 12 digits or less');
      });

      test('RightPinActivatesAutosubmit', function() {
        pinKeyboard.value = '123456';
        assertFalse(confirmButton.disabled);
        confirmButton.click();
        assertTrue(quickUnlockPrivateApi.pinAutosubmitEnabled);
      });

      // Tests that the dialog fires an event to invalidate the auth token
      // to trigger a password prompt.
      test('FireInvalidateTokenRequestWhenPinAuthNotPossible', async () => {
        // Simulate too many wrong PIN attempts.
        quickUnlockPrivateApi.pinAuthenticationPossible = false;
        pinKeyboard.value = '1234';
        const invalidateTokenEvent = test_util.eventToPromise(
            'invalidate-auth-token-requested', testElement);
        confirmButton.click();
        await invalidateTokenEvent;
      });
    });
  }

  function registerSetupPinDialogTests() {
    suite('setup-pin-dialog', function() {
      let titleDiv = null;
      let problemDiv = null;
      let pinKeyboard = null;
      let pinInput = null;
      let backButton = null;
      let continueButton = null;

      setup(function() {
        PolymerTest.clearBody();

        quickUnlockPrivateApi = new settings.FakeQuickUnlockPrivate();
        fakeUma = new settings.FakeQuickUnlockUma();

        // Create setup-pin element.
        testElement = document.createElement('settings-setup-pin-dialog');
        testElement.quickUnlockPrivate = quickUnlockPrivateApi;
        document.body.appendChild(testElement);

        const testPinKeyboard = testElement.$.pinKeyboard;
        testPinKeyboard.setModes = (modes, credentials, onComplete) => {
          quickUnlockPrivateApi.setModes(
              quickUnlockPrivateApi.getFakeToken().token, modes, credentials,
              () => {
                onComplete(true);
              });
        };
        testPinKeyboard.writeUma = fakeUma.recordProgress.bind(fakeUma);

        Polymer.dom.flush();

        titleDiv = getFromElement('div[slot=title]');
        problemDiv = getFromElement('#problemDiv');
        pinKeyboard = getFromElement('pin-keyboard');
        pinInput = pinKeyboard.$.pinInput;
        backButton = getFromElement('cr-button[class="cancel-button"]');
        continueButton = getFromElement('cr-button[class="action-button"]');

        assertTrue(isVisible(backButton));
        assertTrue(isVisible(continueButton));
      });

      test('Text input blocked', () => {
        const event = new KeyboardEvent(
            'keydown', {cancelable: true, key: 'a', keyCode: 65});
        pinInput.dispatchEvent(event);
        assertTrue(event.defaultPrevented);
      });

      test('Numeric input not blocked', () => {
        const event = new KeyboardEvent(
            'keydown', {cancelable: true, key: '1', keyCode: 49});
        pinInput.dispatchEvent(event);
        assertFalse(event.defaultPrevented);
      });

      test('System keys not blocked', () => {
        const event = new KeyboardEvent(
            'keydown', {cancelable: true, key: 'BrightnessUp', keyCode: 217});
        pinInput.dispatchEvent(event);
        assertFalse(event.defaultPrevented);
      });

      // The continue button and title change text between the setup and confirm
      // steps.
      test('TextChangesBetweenSetupAndConfirmStep', function() {
        const initialContinue = continueButton.textContent;
        const initialTitle = titleDiv.textContent;

        pinKeyboard.value = '1111';
        continueButton.click();

        assertNotEquals(initialContinue, continueButton.textContent);
        assertNotEquals(initialTitle, titleDiv.textContent);
      });

      // The continue button is disabled unless the user has entered a >= 4
      // digit PIN.
      test('CanOnlyContinueAfterEnteringAtLeastFourDigitPin', function() {
        pinKeyboard.value = '111';
        assertTrue(continueButton.disabled);

        pinKeyboard.value = '1111';
        assertFalse(continueButton.disabled);

        pinKeyboard.value = '111';
        assertTrue(continueButton.disabled);

        pinKeyboard.value = '';
        assertTrue(continueButton.disabled);

        pinKeyboard.value = '1111111';
        assertFalse(continueButton.disabled);
      });

      // Problem message is always shown.
      test('ProblemShownEvenWithEmptyPin', function() {
        pinKeyboard.value = '11';
        assertTrue(isVisible(problemDiv));

        pinKeyboard.value = '';
        assertTrue(isVisible(problemDiv));
      });

      // If the PIN is too short a problem is shown.
      test('WarningShownForShortPins', function() {
        // Verify initially when the PIN is less than 4 digits, the problem will
        // be a warning.
        pinKeyboard.value = '';
        assertTrue(isVisible(problemDiv));
        assertHasClass(problemDiv, 'warning');
        assertTrue(continueButton.disabled);

        // Verify that once the PIN is 4 digits (do not use 1111 since that will
        // bring up a easy to guess warning) the warning disappears.
        pinKeyboard.value = '1321';
        assertFalse(isVisible(problemDiv));
        assertFalse(continueButton.disabled);

        // Verify that after we pass 4 digits once, but delete some digits, the
        // problem will be an error.
        pinKeyboard.value = '11';
        assertHasClass(problemDiv, 'error');
        assertTrue(continueButton.disabled);
      });

      // If the PIN is too long an error problem is shown.
      test('WarningShownForLongPins', function() {
        // By default, there is no max length on pins.
        quickUnlockPrivateApi.credentialRequirements.maxLength = 5;

        // A pin of length five should be valid when max length is five.
        pinKeyboard.value = '11111';
        assertFalse(isVisible(problemDiv));
        assertFalse(continueButton.disabled);

        // A pin of length six should not be valid when max length is five.
        pinKeyboard.value = '111111';
        assertTrue(isVisible(problemDiv));
        assertHasClass(problemDiv, 'error');
        assertTrue(continueButton.disabled);
      });

      // If the PIN is weak a warning problem is shown.
      test('WarningShownForWeakPins', function() {
        pinKeyboard.value = '1111';

        assertTrue(isVisible(problemDiv));
        assertHasClass(problemDiv, 'warning');
      });

      // Show a error if the user tries to submit a PIN that does not match the
      // initial PIN. The error disappears once the user edits the wrong PIN.
      test('WarningThenErrorShownForMismatchedPins', function() {
        pinKeyboard.value = '1118';
        continueButton.click();

        // Entering a mismatched PIN shows a warning.
        pinKeyboard.value = '1119';
        assertFalse(isVisible(problemDiv));

        // Submitting a mismatched PIN shows an error. Directly call the button
        // event since a tap on the disabled button does nothing.
        testElement.onPinSubmit_();
        assertHasClass(problemDiv, 'error');

        // Changing the PIN changes the error to a warning.
        pinKeyboard.value = '111';
        assertFalse(isVisible(problemDiv));
      });

      // Hitting cancel at the setup step dismisses the dialog.
      test('HittingBackButtonResetsState', function() {
        backButton.click();
        assertFalse(testElement.$$('#dialog').open);
      });

      // Hitting cancel at the confirm step dismisses the dialog.
      test('HittingBackButtonResetsState', function() {
        pinKeyboard.value = '1111';
        continueButton.click();
        backButton.click();
        assertFalse(testElement.$$('#dialog').open);
      });

      // User has to re-enter PIN for confirm step.
      test('PinKeyboardIsResetForConfirmStep', function() {
        pinKeyboard.value = '1111';
        continueButton.click();
        assertEquals('', pinKeyboard.value);
      });

      // Completing the flow results in a call to the quick unlock private API.
      // Check that uma stats are called as expected.
      test('SubmittingPinCallsQuickUnlockApi', function() {
        // Entering the same (even weak) pin twice calls the quick unlock API
        // and sets up a PIN.
        assertEquals(
            0,
            fakeUma.getHistogramValue(settings.LockScreenProgress.ENTER_PIN));
        assertEquals(
            0,
            fakeUma.getHistogramValue(settings.LockScreenProgress.CONFIRM_PIN));
        pinKeyboard.value = '1111';
        continueButton.click();
        assertEquals(
            1,
            fakeUma.getHistogramValue(settings.LockScreenProgress.ENTER_PIN));

        pinKeyboard.value = '1111';
        continueButton.click();

        assertEquals(
            1,
            fakeUma.getHistogramValue(settings.LockScreenProgress.CONFIRM_PIN));
        assertDeepEquals(['PIN'], quickUnlockPrivateApi.activeModes);
        assertDeepEquals(['1111'], quickUnlockPrivateApi.credentials);
      });

      // Submitting a new pin disables the 'Confirm' continue button and the pin
      // field until the asynchronous update completes.
      test('SubmittingPinDisablesConfirmButtonAndPinInput', function() {
        pinKeyboard.value = '1111';
        continueButton.click();
        pinKeyboard.value = '1111';
        assertFalse(continueButton.disabled);

        let isPinInputDisabled = pinInput.disabled;
        assertFalse(isPinInputDisabled);

        return new Promise(resolve => {
          getFromElement('setup-pin-keyboard')
              .addEventListener(
                  'is-set-modes-call-pending_-changed', function() {
                    assertNotEquals(isPinInputDisabled, pinInput.disabled);
                    isPinInputDisabled = pinInput.disabled;
                    resolve();
                  });

          continueButton.click();
          assertTrue(continueButton.disabled);
        });
      });

      test('TestContinueButtonState', function() {
        pinKeyboard.value = '1111';
        continueButton.click();

        // Verify the button is disabled when we first enter the confirm step,
        // since the PIN value is empty.
        assertEquals('', pinKeyboard.value);
        assertTrue(continueButton.disabled);

        // Verify the button is enabled after we enter one digit.
        pinKeyboard.value = '1';
        assertFalse(continueButton.disabled);

        // Verify the button is disabled after we try to submit a wrong PIN.
        continueButton.click();
        assertTrue(continueButton.disabled);

        // Verify the button is enabled after we enter one digit again.
        pinKeyboard.value = '11';
        assertFalse(continueButton.disabled);
      });

      // Verify that the backspace button is disabled when there is nothing
      // entered.
      test('BackspaceDisabledWhenNothingEntered', function() {
        const backspaceButton = pinKeyboard.$$('#backspaceButton');
        assertTrue(!!backspaceButton);
        assertTrue(backspaceButton.disabled);

        pinKeyboard.$$('cr-input').value = '11';
        assertFalse(backspaceButton.disabled);

        pinKeyboard.$$('cr-input').value = '';
        assertTrue(backspaceButton.disabled);
      });
    });
  }

  return {
    registerAuthenticateTests: registerAuthenticateTests,
    registerLockScreenTests: registerLockScreenTests,
    registerAutosubmitDialogTests: registerAutosubmitDialogTests,
    registerSetupPinDialogTests: registerSetupPinDialogTests
  };
});