File: test_autocomplete_basic_form.html

package info (click to toggle)
thunderbird 1%3A91.13.0-1~deb11u1
links: PTS, VCS
area: main
in suites: bullseye
size: 2,953,400 kB
sloc: cpp: 6,084,049; javascript: 4,790,441; ansic: 3,341,496; python: 862,958; asm: 366,542; xml: 204,277; java: 152,477; sh: 111,436; makefile: 21,388; perl: 15,312; yacc: 4,583; objc: 3,026; lex: 1,720; exp: 762; pascal: 635; awk: 564; sql: 453; php: 436; lisp: 432; ruby: 99; sed: 69; csh: 45
file content (1057 lines) | stat: -rw-r--r-- 37,790 bytes
parent folder | download | duplicates (4)
<!DOCTYPE HTML>
<html>
<head>
  <meta charset="utf-8">
  <title>Test basic login autocomplete</title>
  <script src="/tests/SimpleTest/SimpleTest.js"></script>
  <script src="/tests/SimpleTest/EventUtils.js"></script>
  <script type="text/javascript" src="../../../satchel/test/satchel_common.js"></script>
  <script type="text/javascript" src="pwmgr_common.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
Login Manager test: multiple login autocomplete

<script>
var chromeScript = runChecksAfterCommonInit();

// Temporarily allow use of eval() in this test.
SpecialPowers.pushPrefEnv({"set": [["security.allow_eval_with_system_principal", true]]});

function addLoginsInParent(...aLogins) {
  let script = runInParent(function addLoginsInParentInner() {
    let loginsMap = {};

    let initialCount = 5;

    addMessageListener("initLogins", logins => {
      // eslint-disable-next-line no-shadow
      const { Services } = ChromeUtils.import(
        "resource://gre/modules/Services.jsm"
      );

      let nsLoginInfo = Components.Constructor(
        "@mozilla.org/login-manager/loginInfo;1",
        Ci.nsILoginInfo,
        "init"
      );

      for (let login of logins) {
        let loginInfo = new nsLoginInfo(...login[1]);

        // Only add the first 'initialCount' number of logins.
        if (initialCount-- > 0) {
          try {
            Services.logins.addLogin(loginInfo);
          } catch (e) {
            assert.ok(false, "addLogin threw: " + e);
          }
        }
        loginsMap[login[0]] = loginInfo;
      }
    });

    addMessageListener("addLogin", loginVariableName => {
      let login = loginsMap[loginVariableName];
      assert.ok(!!login, "Login to add is defined: " + loginVariableName);
      Services.logins.addLogin(login);
    });
    addMessageListener("removeLogin", loginVariableName => {
      let login = loginsMap[loginVariableName];
      assert.ok(!!login, "Login to delete is defined: " + loginVariableName);
      Services.logins.removeLogin(login);
    });
  });
  script.sendQuery("initLogins", aLogins);
  return script;
}


let origin = window.location.origin;
let setupScript = addLoginsInParent(
  // login0 has no username, so should be filtered out from the autocomplete list.
  ["login0", [origin, "https://autocomplete:8888", null,
              "", "user0pass", "", "pword"]],

  ["login1", [origin, "https://autocomplete:8888", null,
              "tempuser1", "temppass1", "uname", "pword"]],

  ["login2", [origin, "https://autocomplete:8888", null,
              "testuser2", "testpass2", "uname", "pword"]],

  ["login3", [origin, "https://autocomplete:8888", null,
              "testuser3", "testpass3", "uname", "pword"]],

  ["login4", [origin, "https://autocomplete:8888", null,
              "zzzuser4", "zzzpass4", "uname", "pword"]],

  ["login5", [origin, "https://autocomplete2", null,
              "singleuser5", "singlepass5", "uname", "pword"]],

  ["login6A", [origin, "https://autocomplete3", null,
               "form7user1", "form7pass1", "uname", "pword"]],
  ["login6B", [origin, "https://autocomplete3", null,
               "form7user2", "form7pass2", "uname", "pword"]],

  ["login7", [origin, "https://autocomplete4", null,
              "form8user", "form8pass", "uname", "pword"]],

  ["login8A", [origin, "https://autocomplete5", null,
               "form9userAB", "form9pass", "uname", "pword"]],
  ["login8B", [origin, "https://autocomplete5", null,
               "form9userAAB", "form9pass", "uname", "pword"]],
  ["login8C", [origin, "https://autocomplete5", null,
               "form9userAABzz", "form9pass", "uname", "pword"]],

  ["login10", [origin, "https://autocomplete7", null,
               "testuser10", "testpass10", "uname", "pword"]],

  ["login11", [origin, origin, null, "testuser11", "testpass11", "uname", "pword"]],

  ["login12", [origin, "https://autocomplete8", null,
               "testuser12", "testpass12", "uname", "pword"]]);
</script>
<p id="display"></p>

<!-- we presumably can't hide the content for this test. -->
<div id="content">

  <!-- form1 tests multiple matching logins -->
  <!-- other forms test single logins, with autocomplete=off set -->
  <form id="form1" action="https://autocomplete:8888/formtest.js" onsubmit="return false;">
    <input  type="text"       name="uname">
    <input  type="password"   name="pword">
    <button type="submit">Submit</button>
  </form>

</div>

<pre id="test">
<script class="testbody" type="text/javascript">

/** Test for Login Manager: multiple login autocomplete. **/

var uname = $_(1, "uname");
var pword = $_(1, "pword");

// Restore the form to the default state.
function restoreForm() {
  uname.value = "";
  pword.value = "";
  uname.focus();
}

function sendFakeAutocompleteEvent(element) {
  var acEvent = document.createEvent("HTMLEvents");
  acEvent.initEvent("DOMAutoComplete", true, false);
  element.dispatchEvent(acEvent);
}

function spinEventLoop() {
  return Promise.resolve();
}

async function promiseACPopupClosed() {
  return SimpleTest.promiseWaitForCondition(async () => {
    let popupState = await getPopupState();
    return !popupState.open;
  }, "Wait for AC popup to be closed");
}

add_task(async function setup() {
  listenForUnexpectedPopupShown();
});

add_task(async function test_form1_initial_empty() {
  await SimpleTest.promiseFocus(window);

  // Make sure initial form is empty.
  checkLoginForm(uname, "", pword, "");
  let popupState = await getPopupState();
  is(popupState.open, false, "Check popup is initially closed");
});

add_task(async function test_form1_menuitems() {
  await SimpleTest.promiseFocus(window);
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  let results = await shownPromise;

  let popupState = await getPopupState();
  is(popupState.selectedIndex, -1, "Check no entries are selected upon opening");

  let expectedMenuItems = ["tempuser1",
                           "testuser2",
                           "testuser3",
                           "zzzuser4"];
  checkAutoCompleteResults(results, expectedMenuItems,
                           window.location.host, "Check all menuitems are displayed correctly.");

  let acEvents = await getTelemetryEvents({ process: "parent", filterProps: TelemetryFilterPropsAC, clear: true });
  is(acEvents.length, 1, "One autocomplete event");
  checkACTelemetryEvent(acEvents[0], uname, {
    "hadPrevious": "0",
    "login": expectedMenuItems.length + "",
    "loginsFooter": "1"
  });

  checkLoginForm(uname, "", pword, ""); // value shouldn't update just by opening
  synthesizeKey("KEY_Escape");
  await promiseACPopupClosed();
  checkLoginForm(uname, "", pword, "");
});

add_task(async function test_form1_first_entry() {
  await SimpleTest.promiseFocus(window);
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  let popupState = await getPopupState();
  is(popupState.selectedIndex, -1, "Check no entries are selected upon opening");

  synthesizeKey("KEY_ArrowDown"); // first
  checkLoginForm(uname, "", pword, ""); // value shouldn't update just by selecting
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "tempuser1", pword, "temppass1");
});

add_task(async function test_form1_second_entry() {
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowDown"); // second
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_third_entry() {
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowDown"); // second
  synthesizeKey("KEY_ArrowDown"); // third
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser3", pword, "testpass3");
});

add_task(async function test_form1_fourth_entry() {
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowDown"); // second
  synthesizeKey("KEY_ArrowDown"); // third
  synthesizeKey("KEY_ArrowDown"); // fourth
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_wraparound_first_entry() {
  // Trigger autocomplete popup
  restoreForm();
  await spinEventLoop(); // let focus happen
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowDown"); // second
  synthesizeKey("KEY_ArrowDown"); // third
  synthesizeKey("KEY_ArrowDown"); // fourth
  synthesizeKey("KEY_ArrowDown"); // footer
  synthesizeKey("KEY_ArrowDown"); // deselects
  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "tempuser1", pword, "temppass1");
});

add_task(async function test_form1_wraparound_up_last_entry() {
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowUp"); // footer
  synthesizeKey("KEY_ArrowUp"); // last (fourth)
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_wraparound_down_up_up() {
  // Trigger autocomplete popup
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown"); // select first entry
  synthesizeKey("KEY_ArrowUp"); // selects nothing!
  synthesizeKey("KEY_ArrowUp"); // footer
  synthesizeKey("KEY_ArrowUp"); // select last entry
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_wraparound_up_last() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_ArrowUp"); // deselects
  synthesizeKey("KEY_ArrowUp"); // last entry
  synthesizeKey("KEY_ArrowUp");
  synthesizeKey("KEY_ArrowUp");
  synthesizeKey("KEY_ArrowUp");
  synthesizeKey("KEY_ArrowUp"); // first entry
  synthesizeKey("KEY_ArrowUp"); // deselects
  synthesizeKey("KEY_ArrowUp"); // footer
  synthesizeKey("KEY_ArrowUp"); // last entry
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_fill_username_without_autofill_right() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Set first entry w/o triggering autocomplete
  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowRight");
  await promiseACPopupClosed();
  checkLoginForm(uname, "tempuser1", pword, ""); // empty password
});

add_task(async function test_form1_fill_username_without_autofill_left() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Set first entry w/o triggering autocomplete
  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowLeft");
  await promiseACPopupClosed();
  checkLoginForm(uname, "tempuser1", pword, ""); // empty password
});

add_task(async function test_form1_pageup_first() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry (page up)
  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_ArrowDown"); // second
  synthesizeKey("KEY_PageUp"); // first
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "tempuser1", pword, "temppass1");
});

add_task(async function test_form1_pagedown_last() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  /* test 13 */
  // Check last entry (page down)
  synthesizeKey("KEY_ArrowDown"); // first
  synthesizeKey("KEY_PageDown"); // footer
  synthesizeKey("KEY_ArrowUp"); // last
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_untrusted_event() {
  restoreForm();
  await spinEventLoop();

  // Send a fake (untrusted) event.
  checkLoginForm(uname, "", pword, "");
  uname.value = "zzzuser4";
  sendFakeAutocompleteEvent(uname);
  await spinEventLoop();
  checkLoginForm(uname, "zzzuser4", pword, "");
});

add_task(async function test_form1_delete() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // XXX tried sending character "t" before/during dropdown to test
  // filtering, but had no luck. Seemed like the character was getting lost.
  // Setting uname.value didn't seem to work either. This works with a human
  // driver, so I'm not sure what's up.

  // Delete the first entry (of 4), "tempuser1"
  synthesizeKey("KEY_ArrowDown");
  let numLogins = await LoginManager.countLogins(origin, "https://autocomplete:8888", null);
  is(numLogins, 5, "Correct number of logins before deleting one");

  let countChangedPromise = notifyMenuChanged(4);
  var deletionPromise = promiseStorageChanged(["removeLogin"]);
  // On OS X, shift-backspace and shift-delete work, just delete does not.
  // On Win/Linux, shift-backspace does not work, delete and shift-delete do.
  synthesizeKey("KEY_Delete", {shiftKey: true});
  await deletionPromise;

  checkLoginForm(uname, "", pword, "");
  numLogins = await LoginManager.countLogins(origin, "https://autocomplete:8888", null);
  is(numLogins, 4, "Correct number of logins after deleting one");
  await countChangedPromise;
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_first_after_deletion() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check the new first entry (of 3)
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_delete_second() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Delete the second entry (of 3), "testuser3"
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Delete", {shiftKey: true});
  checkLoginForm(uname, "", pword, "");
  let numLogins = await LoginManager.countLogins(origin, "https://autocomplete:8888", null);
  is(numLogins, 3, "Correct number of logins after deleting one");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "zzzuser4", pword, "zzzpass4");
});

add_task(async function test_form1_first_after_deletion2() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check the new first entry (of 2)
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_delete_last() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  /* test 54 */
  // Delete the last entry (of 2), "zzzuser4"
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Delete", {shiftKey: true});
  checkLoginForm(uname, "", pword, "");
  let numLogins = await LoginManager.countLogins(origin, "https://autocomplete:8888", null);
  is(numLogins, 2, "Correct number of logins after deleting one");
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_first_after_3_deletions() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check the only remaining entry
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser2", pword, "testpass2");
});

add_task(async function test_form1_check_only_entry_remaining() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  /* test 56 */
  // Delete the only remaining entry, "testuser2"
  synthesizeKey("KEY_ArrowDown");
  let storageChanged = promiseStorageChanged(["removeLogin", "removeLogin", "addLogin"]);
  synthesizeKey("KEY_Delete", {shiftKey: true});
  checkLoginForm(uname, "", pword, "");
  let numLogins = await LoginManager.countLogins(origin, "https://autocomplete:8888", null);
  is(numLogins, 1, "Correct number of logins after deleting one");

  // remove the logins for the previous tests
  setupScript.sendAsyncMessage("removeLogin", "login0");
  setupScript.sendAsyncMessage("addLogin", "login5");
  await storageChanged;

  // ensure the popup is closed for the next test
  synthesizeKey("KEY_Escape");
  await promiseACPopupClosed();
});

/* Tests for single-user forms for ignoring autocomplete=off */
add_task(async function test_form2() {
  await setFormAndWaitForFieldFilled(`
    <form id="form2" action="https://autocomplete2" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword" autocomplete="off">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "singleuser5"});

  // Turn our attention to form2
  uname = $_(2, "uname");
  pword = $_(2, "pword");
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");

  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
});

add_task(async function test_form3() {
  await setFormAndWaitForFieldFilled(`
    <form id="form3" action="https://autocomplete2" onsubmit="return false;">
      <input  type="text"       name="uname" autocomplete="off">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "singleuser5"});

  uname = $_(3, "uname");
  pword = $_(3, "pword");
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
});

add_task(async function test_form4() {
  await setFormAndWaitForFieldFilled(`
    <form id="form4" action="https://autocomplete2" onsubmit="return false;" autocomplete="off">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "singleuser5"});

  uname = $_(4, "uname");
  pword = $_(4, "pword");
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
});

add_task(async function test_form5() {
  await setFormAndWaitForFieldFilled(`
    <form id="form5" action="https://autocomplete2" onsubmit="return false;">
      <input  type="text"       name="uname" autocomplete="off">
      <input  type="password"   name="pword" autocomplete="off">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "singleuser5"});

  uname = $_(5, "uname");
  pword = $_(5, "pword");
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
});

add_task(async function test_form6() {
  await setFormAndWaitForFieldFilled(`
    <!-- control -->
    <form id="form6" action="https://autocomplete2" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "singleuser5"});

  // (this is a control, w/o autocomplete=off, to ensure the login
  // that was being suppressed would have been filled in otherwise)
  uname = $_(6, "uname");
  pword = $_(6, "pword");
  checkLoginForm(uname, "singleuser5", pword, "singlepass5");
});

add_task(async function test_form6_changeUsername() {
  // Test that the password field remains filled in after changing
  // the username.
  uname.focus();
  synthesizeKey("KEY_ArrowRight");
  synthesizeKey("X", {shiftKey: true});
  // Trigger the 'blur' event on uname
  pword.focus();
  await spinEventLoop();
  checkLoginForm(uname, "singleuser5X", pword, "singlepass5");
  uname.focus();

  let storageChanged = promiseStorageChanged(["removeLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login5");
  await storageChanged;
});

add_task(async function test_form7() {
  let storageChanged = promiseStorageChanged(["addLogin", "addLogin"]);
  setupScript.sendAsyncMessage("addLogin", "login6A");
  setupScript.sendAsyncMessage("addLogin", "login6B");
  await storageChanged;
  await setFormAndWaitForFieldFilled(`
    <!-- This form will be manipulated to insert a different username field. -->
    <form id="form7" action="https://autocomplete3" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: ""});

  uname = $_(7, "uname");
  pword = $_(7, "pword");
  checkLoginForm(uname, "", pword, "");

  // Insert a new username field into the form. We'll then make sure
  // that invoking the autocomplete doesn't try to fill the form.
  var newField = document.createElement("input");
  newField.setAttribute("type", "text");
  newField.setAttribute("name", "uname2");
  pword.parentNode.insertBefore(newField, pword);
  is($_(7, "uname2").value, "", "Verifying empty uname2");

  // Delete login6B. It was created just to prevent filling in a login
  // automatically, removing it makes it more likely that we'll catch a
  // future regression with form filling here.
  storageChanged = promiseStorageChanged(["removeLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login6B");
  await storageChanged;
});

add_task(async function test_form7_2() {
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  let results = await shownPromise;
  checkAutoCompleteResults(results,
                           ["form7user1"],
                           window.location.host,
                           "Check dropdown is showing all logins while field is blank");


  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  // The form changes, so we expect the old username field to get the
  // selected autocomplete value, but neither the new username field nor
  // the password field should have any values filled in.
  await SimpleTest.promiseWaitForCondition(() => uname.value == "form7user1",
                                           "Wait for username to get filled");
  await promiseACPopupClosed();
  checkLoginForm(uname, "form7user1", pword, "");
  is($_(7, "uname2").value, "", "Verifying empty uname2");
  restoreForm(); // clear field, so reloading test doesn't fail

  let storageChanged = promiseStorageChanged(["removeLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login6A");
  await storageChanged;
});

add_task(async function test_form8() {
  let storageChanged = promiseStorageChanged(["addLogin"]);
  setupScript.sendAsyncMessage("addLogin", "login7");
  await storageChanged;
  await setFormAndWaitForFieldFilled(`
    <!-- This form will be manipulated to insert a different username field. -->
    <form id="form7" action="https://autocomplete3" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>
    <!-- test for no autofill after onblur with blank username -->
    <form id="form8" action="https://autocomplete4" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "form8user", formId: "form8"});

  uname = $_(8, "uname");
  pword = $_(8, "pword");
  checkLoginForm(uname, "form8user", pword, "form8pass");
  restoreForm();
});

add_task(async function test_form8_blur() {
  checkLoginForm(uname, "", pword, "");
  // Focus the previous form to trigger a blur.
  $_(7, "uname").focus();
});

add_task(async function test_form8_2() {
  checkLoginForm(uname, "", pword, "");
  restoreForm();
});

add_task(async function test_form8_3() {
  checkLoginForm(uname, "", pword, "");
  let storageChanged = promiseStorageChanged(["removeLogin", "addLogin", "addLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login7");
  setupScript.sendAsyncMessage("addLogin", "login8A");
  setupScript.sendAsyncMessage("addLogin", "login8B");
  await storageChanged;
});

add_task(async function test_form9_filtering() {
  await setFormAndWaitForFieldFilled(`
    <!-- test autocomplete dropdown -->
    <form id="form9" action="https://autocomplete5" onsubmit="return false;">
      <input  type="text"       name="uname">
      <input  type="password"   name="pword">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: ""});

  // Turn our attention to form9 to test the dropdown - bug 497541
  let shownPromise = promiseACShown();
  uname = $_(9, "uname");
  pword = $_(9, "pword");
  uname.focus();
  let results = await shownPromise;
  checkAutoCompleteResults(results,
                           ["form9userAAB", "form9userAB"],
                           window.location.host,
                           "Check dropdown is showing all logins while field is blank");
  synthesizeKey("KEY_Escape"); // Need to close the popup so we can get another popupshown after sending the string below.

  shownPromise = promiseACShown();
  sendString("form9userAB");
  results = await shownPromise;
  checkAutoCompleteResults(results,
                           ["form9userAB"],
                           window.location.host,
                           "Check dropdown is showing login with only one 'A'");

  checkLoginForm(uname, "form9userAB", pword, "");
  uname.focus();
  synthesizeKey("KEY_ArrowLeft");
  shownPromise = promiseACShown();
  synthesizeKey("A", {shiftKey: true});
  results = await shownPromise;

  checkLoginForm(uname, "form9userAAB", pword, "");
  checkAutoCompleteResults(results, ["form9userAAB"],
                           window.location.host, "Check dropdown is updated after inserting 'A'");
  synthesizeKey("KEY_ArrowDown");
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "form9userAAB", pword, "form9pass");
});

add_task(async function test_form9_autocomplete_cache() {
  // Note that this addLogin call will only be seen by the autocomplete
  // attempt for the synthesizeKey if we do not successfully cache the
  // autocomplete results.
  let storageChanged = promiseStorageChanged(["addLogin"]);
  setupScript.sendAsyncMessage("addLogin", "login8C");
  await storageChanged;
  uname.focus();
  let promise1 = notifyMenuChanged(1);
  sendString("z");
  let results = await promise1;
  checkAutoCompleteResults(results, [], window.location.host,
                           "Check popup does not have any login items");

  // check that empty results are cached - bug 496466
  promise1 = notifyMenuChanged(1);
  sendString("z");
  results = await promise1;
  checkAutoCompleteResults(results, [], window.location.host,
                           "Check popup only has the footer when it opens");
});

add_task(async function test_form11_formless() {
  let storageChanged = promiseStorageChanged(["removeLogin", "removeLogin", "removeLogin", "addLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login8A");
  setupScript.sendAsyncMessage("removeLogin", "login8B");
  setupScript.sendAsyncMessage("removeLogin", "login8C");
  setupScript.sendAsyncMessage("addLogin", "login11");
  await storageChanged;
  await setFormAndWaitForFieldFilled(`
    <!-- tests <form>-less autocomplete -->
    <div id="form11">
      <input  type="text"       name="uname" id="uname">
      <input  type="password"   name="pword" id="pword">
      <button type="submit">Submit</button>
    </div>`, {fieldSelector: `input[name="uname"]`, fieldValue: "testuser11"});

  // Test form-less autocomplete
  uname = $_(11, "uname");
  pword = $_(11, "pword");
  restoreForm();
  checkLoginForm(uname, "", pword, "");
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Trigger autocomplete
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  let processedPromise = promiseFormsProcessedInSameProcess();
  synthesizeKey("KEY_Enter");
  await processedPromise;
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser11", pword, "testpass11");
});

add_task(async function test_form11_open_on_trusted_focus() {
  uname = $_(11, "uname");
  pword = $_(11, "pword");
  uname.value = "";
  pword.value = "";

  // Move focus to the password field so we can test the first click on the
  // username field.
  pword.focus();
  checkLoginForm(uname, "", pword, "");
  const firePrivEventPromise = new Promise((resolve) => {
    uname.addEventListener("click", (e) => {
      ok(e.isTrusted, "Ensure event is trusted");
      resolve();
    });
  });
  const shownPromise = promiseACShown();
  synthesizeMouseAtCenter(uname, {});
  await firePrivEventPromise;
  await shownPromise;
  synthesizeKey("KEY_ArrowDown");
  const processedPromise = promiseFormsProcessedInSameProcess();
  synthesizeKey("KEY_Enter");
  await processedPromise;
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser11", pword, "testpass11");
  let storageChanged = promiseStorageChanged(["removeLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login11");
  await storageChanged;
});

add_task(async function test_form12_recipes() {
  let storageChanged = promiseStorageChanged(["addLogin"]);
  setupScript.sendAsyncMessage("addLogin", "login10");
  await storageChanged;
  await setFormAndWaitForFieldFilled(`
    <!-- test for onUsernameInput recipe testing -->
    <form id="form12" action="https://autocomplete7" onsubmit="return false;">
      <input  type="text"   name="1">
      <input  type="text"   name="2">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="1"]`, fieldValue: ""});

  await loadRecipes({
    siteRecipes: [{
      "hosts": [window.location.host],
      "usernameSelector": "input[name='1']",
      "passwordSelector": "input[name='2']",
    }],
  });
  uname = $_(12, "1");
  pword = $_(12, "2");

  // First test DOMAutocomplete
  // Switch the password field to type=password so _fillForm marks the username
  // field for autocomplete.
  pword.type = "password";
  await promiseFormsProcessedInSameProcess();
  restoreForm();
  checkLoginForm(uname, "", pword, "");
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseFormsProcessedInSameProcess();
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser10", pword, "testpass10");

  // Now test recipes with blur on the username field.
  restoreForm();
  checkLoginForm(uname, "", pword, "");
  uname.value = "testuser10";
  checkLoginForm(uname, "testuser10", pword, "");
  synthesizeKey("KEY_Tab");
  await promiseFormsProcessedInSameProcess();
  checkLoginForm(uname, "testuser10", pword, "testpass10");
  await resetRecipes();
});

add_task(async function test_form13_stays_open_upon_empty_search() {
  await setFormAndWaitForFieldFilled(`
    <!-- test not closing when the search string (.value) becomes empty -->
    <form id="form13" action="http://autocomplete:8888/formtest.js" onsubmit="return false;">
      <input  type="text"       name="uname" value="prefilled">
      <input  type="password"   name="pword" value="prefilled">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "prefilled"});

  uname = $_(13, "uname");
  pword = $_(13, "pword");
  checkLoginForm(uname, "prefilled", pword, "prefilled");

  uname.scrollIntoView();
  let shownPromise = promiseACShown();
  synthesizeMouseAtCenter(uname, {});
  await shownPromise;
  uname.select();
  synthesizeKey("KEY_Delete");

  await spinEventLoop();
  let popupState = await getPopupState();
  is(popupState.open, true, "Check popup is still open");
  checkLoginForm(uname, "", pword, "prefilled");

  info("testing password field");
  synthesizeMouseAtCenter(pword, {});
  pword.select();
  popupState = await getPopupState();
  is(popupState.open, false, "Check popup closed since password field isn't empty");
  shownPromise = promiseACShown();
  synthesizeKey("KEY_Delete");
  await shownPromise;
  checkLoginForm(uname, "", pword, "");

  // ensure the popup is closed for the next test
  synthesizeKey("KEY_Escape");
  await promiseACPopupClosed();
});

add_task(async function test_form14_username_only() {
  await SimpleTest.promiseFocus(window);
  let storageChanged = promiseStorageChanged(["removeLogin", "addLogin"]);
  setupScript.sendAsyncMessage("removeLogin", "login10");
  setupScript.sendAsyncMessage("addLogin", "login12");
  await storageChanged;

  await setFormAndWaitForFieldFilled(`
    <form id="form14" action="https://autocomplete8" onsubmit="return false;" autocomplete="off">
      <input  type="email"       name="uname" autocomplete="username" value="prefilled">
      <button type="submit">Submit</button>
    </form>`, {fieldSelector: `input[name="uname"]`, fieldValue: "prefilled"});

  uname = $_(14, "uname");
  pword = {value: ""};
  checkLoginForm(uname, "prefilled", pword, "");
  restoreForm();
  let shownPromise = promiseACShown();
  synthesizeKey("KEY_ArrowDown"); // open
  await shownPromise;

  // Check first entry
  synthesizeKey("KEY_ArrowDown");
  checkLoginForm(uname, "", pword, ""); // value shouldn't update
  synthesizeKey("KEY_Enter");
  await promiseACPopupClosed();
  checkLoginForm(uname, "testuser12", pword, "");
});
</script>
</pre>
</body>
</html>