Selenium: Locating & Interacting

import org.openqa.selenium.support.pagefactory.ByAll;
import org.openqa.selenium.support.pagefactory.ByChained;

@Test
void chainedAndAllLocators() {
  driver.get(BASE_URL + "/books");
  WebElement title = driver.findElement(new ByChained(By.cssSelector("[data-testid=book-list]"), By.tagName("h3")));
  assertFalse(title.getText().isEmpty());
  driver.get(BASE_URL + "/signin");
  List<WebElement> fields = driver.findElements(new ByAll(By.id("username"), By.id("password")));
  assertEquals(2, fields.size());
}

import static org.openqa.selenium.support.locators.RelativeLocator.with;

@Test
void relativeLocators() {
  driver.get(BASE_URL + "/signin");
  WebElement above = driver.findElement(with(By.tagName("input")).above(By.id("password")));
  WebElement below = driver.findElement(with(By.tagName("input")).below(By.id("username")));
  WebElement near = driver.findElement(with(By.tagName("input")).near(By.cssSelector("label[for=username]")));
  assertEquals("username", above.getDomAttribute("id"));
  assertEquals("password", below.getDomAttribute("id"));
  assertEquals("username", near.getDomAttribute("id"));
  WebElement button = driver.findElement(with(By.tagName("button")).below(below).toLeftOf(By.id("theme-toggle")));
  assertEquals("Sign in", button.getText());
}

from selenium.webdriver.support.relative_locator import locate_with

def test_relative_locators(driver, base_url):
    driver.get(f"{base_url}/signin")
    above = driver.find_element(locate_with(By.TAG_NAME, "input").above({By.ID: "password"}))
    below = driver.find_element(locate_with(By.TAG_NAME, "input").below({By.ID: "username"}))
    near = driver.find_element(locate_with(By.TAG_NAME, "input").near({By.CSS_SELECTOR: "label[for=username]"}))
    assert above.get_attribute("id") == "username"
    assert below.get_attribute("id") == "password"
    assert near.get_attribute("id") == "username"
    # The button sits below the password field: chain two constraints
    button = driver.find_element(locate_with(By.TAG_NAME, "button").below(below).to_left_of({By.ID: "theme-toggle"}))
    assert button.text == "Sign in"

var emailLocator = RelativeBy.WithLocator(By.TagName("input")).Above(By.Id("password"));

driver.find_element({relative: {tag_name: 'input', above: {id: 'password'}}})

const { locateWith } = require('selenium-webdriver');
const emailLocator = locateWith(By.tagName('input')).above(By.id('password'));

@Test
void findersScopingAndActiveElement() {
  driver.get(BASE_URL + "/books");
  List<WebElement> cards = driver.findElements(By.cssSelector("[data-testid=book-card]"));
  assertEquals(6, cards.size());
  assertFalse(cards.get(0).findElement(By.tagName("h3")).getText().isEmpty());
  assertTrue(driver.findElements(By.id("does-not-exist")).isEmpty());
  assertThrows(NoSuchElementException.class, () -> driver.findElement(By.id("does-not-exist")));
  driver.findElement(By.id("q")).click();
  assertEquals("q", driver.switchTo().activeElement().getDomAttribute("id"));
}

def test_finders_scoping_and_active_element(driver, base_url):
    driver.get(f"{base_url}/books")
    cards = driver.find_elements(By.CSS_SELECTOR, "[data-testid=book-card]")
    assert len(cards) == 6
    titles = [c.find_element(By.TAG_NAME, "h3").text for c in cards]
    assert titles[0]
    assert driver.find_elements(By.ID, "does-not-exist") == []  # plural finders never raise
    driver.find_element(By.ID, "q").click()
    assert driver.switch_to.active_element.get_attribute("id") == "q"

@Test
void shadowDom() {
  driver.get(dataUrl("""
      <div id=host></div><script>
      const r = document.getElementById('host').attachShadow({mode: 'open'});
      r.innerHTML = '<button id=inner class=pill>Inside</button><input name=q>';
      </script>"""));
  SearchContext root = driver.findElement(By.id("host")).getShadowRoot();
  assertEquals("Inside", root.findElement(By.cssSelector("#inner")).getText());
  assertEquals(2, root.findElements(By.cssSelector("button, input")).size());
  // since 4.50 relative locators also work from a shadow root
  WebElement input = root.findElement(with(By.tagName("input")).near(By.id("inner")));
  assertEquals("q", input.getDomAttribute("name"));
}

def test_shadow_dom(driver):
    driver.get(data_url("""<div id=host></div><script>
      const r = document.getElementById('host').attachShadow({mode: 'open'});
      r.innerHTML = '<button id=inner class=pill>Inside</button><input name=q>';
    </script>"""))
    host = driver.find_element(By.ID, "host")
    root = host.shadow_root
    assert root.find_element(By.CSS_SELECTOR, "#inner").text == "Inside"
    assert len(root.find_elements(By.CSS_SELECTOR, "button, input")) == 2
    assert root.find_element(By.CSS_SELECTOR, "input").get_attribute("name") == "q"

@Test
void keyboard() {
  driver.get(dataUrl(PAGE));
  WebElement field = driver.findElement(By.id("field"));
  new Actions(driver).sendKeys(field, "selenium").keyDown(Keys.SHIFT).sendKeys("a").keyUp(Keys.SHIFT).perform();
  assertEquals("seleniumA", field.getDomProperty("value"));
  Keys cmd = System.getProperty("os.name").toLowerCase().contains("mac") ? Keys.COMMAND : Keys.CONTROL;
  new Actions(driver).keyDown(cmd).sendKeys("a").sendKeys("x").keyUp(cmd).perform(); // select all, cut
  assertEquals("", field.getDomProperty("value"));
}

from selenium.webdriver import ActionChains, Keys

def test_keyboard(driver):
    driver.get(data_url(PAGE))
    field = driver.find_element(By.ID, "field")
    ActionChains(driver).send_keys_to_element(field, "selenium").key_down(Keys.SHIFT).send_keys("a").key_up(Keys.SHIFT).perform()
    assert field.get_attribute("value") == "seleniumA"
    cmd = Keys.COMMAND if driver.capabilities["platformName"].lower().startswith("mac") else Keys.CONTROL
    ActionChains(driver).key_down(cmd).send_keys("a").key_down("x").key_up("x").key_up(cmd).perform()  # select all + cut
    assert field.get_attribute("value") == ""

@Test
void mouse() {
  driver.get(dataUrl(PAGE));
  WebElement a = driver.findElement(By.id("a"));
  new Actions(driver).click(a).contextClick(a).doubleClick(a).perform();
  assertTrue(log().contains("click") && log().contains("ctx") && log().contains("dbl"));
  new Actions(driver).dragAndDrop(driver.findElement(By.id("drag")), driver.findElement(By.id("drop"))).perform();
  assertTrue(log().contains("dropped"));
  new Actions(driver).moveToElement(a).pause(Duration.ofMillis(100)).moveByOffset(5, 5).perform();
  new Actions(driver).moveToElement(a, 10, 10).clickAndHold().release().perform();
}

def test_mouse(driver):
    driver.get(data_url(PAGE))
    a = driver.find_element(By.ID, "a")
    ActionChains(driver).click(a).context_click(a).double_click(a).perform()
    assert "click" in log(driver) and "ctx" in log(driver) and "dbl" in log(driver)
    drag, drop = driver.find_element(By.ID, "drag"), driver.find_element(By.ID, "drop")
    ActionChains(driver).drag_and_drop(drag, drop).perform()
    assert "dropped" in log(driver)
    ActionChains(driver).move_to_element(a).pause(0.1).move_by_offset(5, 5).perform()  # hover, then relative move
    ActionChains(driver).move_to_element_with_offset(a, 10, 10).click_and_hold().release().perform()

@Test
void penAndReleaseAll() {
  driver.get(dataUrl(PAGE));
  WebElement a = driver.findElement(By.id("a"));
  new Actions(driver)
      .setActivePointer(PointerInput.Kind.PEN, "default pen")
      .moveToElement(a)
      .clickAndHold()
      .moveByOffset(2, 2)
      .release()
      .perform();
  assertTrue(log().contains("over"));
  new Actions(driver).keyDown(Keys.SHIFT).perform();
  ((RemoteWebDriver) driver).resetInputState(); // release every depressed key and pointer button
}

from selenium.webdriver.common.actions.action_builder import ActionBuilder
from selenium.webdriver.common.actions.pointer_input import PointerInput

def test_pen_and_release(driver):
    driver.get(data_url(PAGE))
    a = driver.find_element(By.ID, "a")
    pen = PointerInput("pen", "default pen")
    builder = ActionBuilder(driver, mouse=pen)
    builder.pointer_action.move_to(a).pointer_down().move_by(2, 2).pointer_up()
    builder.perform()
    assert "over" in log(driver)
    ActionChains(driver).key_down(Keys.SHIFT).perform()
    ActionChains(driver).reset_actions()  # release every depressed key and pointer button

@Test
void wheel() {
  driver.get(dataUrl(PAGE));
  WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
  new Actions(driver).scrollByAmount(0, 500).perform();
  wait.until(d -> scrollY() == 500);
  new Actions(driver).scrollFromOrigin(ScrollOrigin.fromViewport(10, 10), 0, -200).perform();
  wait.until(d -> scrollY() == 300);
  new Actions(driver).scrollToElement(driver.findElement(By.id("tall"))).perform();
}

from selenium.webdriver.common.actions.wheel_input import ScrollOrigin

def scroll_y(driver):
    return driver.execute_script("return Math.round(window.scrollY)")

def test_wheel(driver):
    driver.get(data_url(PAGE))
    wait = WebDriverWait(driver, 5)
    ActionChains(driver).scroll_by_amount(0, 500).perform()
    wait.until(lambda d: scroll_y(d) == 500)
    ActionChains(driver).scroll_from_origin(ScrollOrigin.from_viewport(10, 10), 0, -200).perform()
    wait.until(lambda d: scroll_y(d) == 300)
    ActionChains(driver).scroll_to_element(driver.find_element(By.ID, "tall")).perform()

@Test
void navigation() {
  driver.get(BASE_URL + "/books");
  assertTrue(driver.getTitle().contains("Bookshelf"));
  driver.findElement(By.cssSelector("[data-testid=brand]")).click();
  assertEquals(BASE_URL + "/", driver.getCurrentUrl());
  driver.navigate().back();
  assertEquals(BASE_URL + "/books", driver.getCurrentUrl());
  driver.navigate().forward();
  assertEquals(BASE_URL + "/", driver.getCurrentUrl());
  driver.navigate().refresh();
  driver.navigate().to(BASE_URL + "/signin");
  assertTrue(driver.getCurrentUrl().endsWith("/signin"));
}

def test_navigation(driver, base_url):
    driver.get(f"{base_url}/books")
    assert "Bookshelf" in driver.title
    driver.find_element(By.CSS_SELECTOR, "[data-testid=brand]").click()
    assert driver.current_url == f"{base_url}/"
    driver.back()
    assert driver.current_url == f"{base_url}/books"
    driver.forward()
    assert driver.current_url == f"{base_url}/"
    driver.refresh()
    driver.execute_script("window.location.href = arguments[0]", f"{base_url}/books")
    WebDriverWait(driver, 5).until(EC.url_contains("/books"))

@Test
void alerts() {
  driver.get(dataUrl("""
      <button id=a onclick="alert('Hi')">alert</button>
      <button id=c onclick="document.title=confirm('Sure?')">confirm</button>
      <button id=p onclick="document.title=prompt('Name?','x')">prompt</button>"""));
  driver.findElement(By.id("a")).click();
  Alert alert = waitFor().until(ExpectedConditions.alertIsPresent());
  assertEquals("Hi", alert.getText());
  alert.accept();
  driver.findElement(By.id("c")).click();
  waitFor().until(ExpectedConditions.alertIsPresent()).dismiss();
  assertEquals("false", driver.getTitle());
  driver.findElement(By.id("p")).click();
  Alert prompt = waitFor().until(ExpectedConditions.alertIsPresent());
  prompt.sendKeys("Alberto");
  prompt.accept();
  assertEquals("Alberto", driver.getTitle());
  assertThrows(NoAlertPresentException.class, () -> driver.switchTo().alert());
}

def test_alerts(driver):
    driver.get(data_url("""<button id=a onclick="alert('Hi')">alert</button>
      <button id=c onclick="document.title=confirm('Sure?')">confirm</button>
      <button id=p onclick="document.title=prompt('Name?','x')">prompt</button>"""))
    driver.find_element(By.ID, "a").click()
    alert = WebDriverWait(driver, 5).until(EC.alert_is_present())
    assert alert.text == "Hi"
    alert.accept()
    driver.find_element(By.ID, "c").click()
    WebDriverWait(driver, 5).until(EC.alert_is_present()).dismiss()
    assert driver.title == "false"
    driver.find_element(By.ID, "p").click()
    prompt = WebDriverWait(driver, 5).until(EC.alert_is_present())
    prompt.send_keys("Alberto")
    prompt.accept()
    assert driver.title == "Alberto"
    with pytest.raises(NoAlertPresentException):
        driver.switch_to.alert.accept()

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.setUnhandledPromptBehaviour(UnexpectedAlertBehaviour.IGNORE);
WebDriver d = new ChromeDriver(options);

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.unhandled_prompt_behavior = "ignore"
d = webdriver.Chrome(options=options)

@Test
void cookies() {
  driver.get(BASE_URL + "/signin");
  driver.manage().addCookie(new Cookie.Builder("theme-hint", "dark").sameSite("Strict").build());
  Cookie hint = driver.manage().getCookieNamed("theme-hint");
  assertEquals("dark", hint.getValue());
  assertEquals("Strict", hint.getSameSite());
  driver.findElement(By.id("username")).sendKeys("reader");
  driver.findElement(By.id("password")).sendKeys(READER_PASSWORD);
  driver.findElement(By.cssSelector("[data-testid=signin-submit]")).click();
  waitFor().until(ExpectedConditions.urlContains("/account"));
  Cookie session = driver.manage().getCookieNamed("bookshelf_session");
  assertTrue(session.isHttpOnly());
  assertEquals("Lax", session.getSameSite());
  Set<String> names = driver.manage().getCookies().stream().map(Cookie::getName).collect(Collectors.toSet());
  assertEquals(Set.of("theme-hint", "bookshelf_session"), names);
  driver.manage().deleteCookie(session);
  driver.get(BASE_URL + "/account");
  assertTrue(driver.getCurrentUrl().contains("/signin"));
  driver.manage().addCookie(new Cookie("bookshelf_session", session.getValue()));
  driver.get(BASE_URL + "/account");
  assertTrue(driver.getCurrentUrl().endsWith("/account"));
  driver.manage().deleteAllCookies();
  assertTrue(driver.manage().getCookies().isEmpty());
}

def test_cookies(driver, base_url):
    driver.get(f"{base_url}/signin")
    driver.add_cookie({"name": "theme-hint", "value": "dark", "sameSite": "Strict"})
    cookie = driver.get_cookie("theme-hint")
    assert cookie["value"] == "dark" and cookie["sameSite"] == "Strict" and cookie["path"] == "/"
    driver.find_element(By.ID, "username").send_keys("reader")
    driver.find_element(By.ID, "password").send_keys(READER_PASSWORD)
    driver.find_element(By.CSS_SELECTOR, "[data-testid=signin-submit]").click()
    WebDriverWait(driver, 5).until(EC.url_contains("/account"))
    session = driver.get_cookie("bookshelf_session")
    assert session["httpOnly"] is True and session["sameSite"] == "Lax"
    assert {c["name"] for c in driver.get_cookies()} == {"theme-hint", "bookshelf_session"}
    saved = session
    driver.delete_cookie("bookshelf_session")
    driver.get(f"{base_url}/account")
    assert "/signin" in driver.current_url          # anonymous again
    driver.add_cookie({"name": saved["name"], "value": saved["value"]})  # restore the session without the UI
    driver.get(f"{base_url}/account")
    assert driver.current_url.endswith("/account")
    driver.delete_all_cookies()
    assert driver.get_cookies() == []

@Test
void frames() {
  driver.get(dataUrl("""
      <h1 id=top>Top</h1><iframe id=inner name=inner-name srcdoc="<button id=b onclick=&quot;this.textContent='clicked'&quot;>Inside</button>"></iframe>
      <iframe srcdoc="<p id=second>Second</p>"></iframe>"""));
  assertThrows(NoSuchElementException.class, () -> driver.findElement(By.id("b")));
  driver.switchTo().frame(driver.findElement(By.id("inner")));   // by element
  driver.findElement(By.id("b")).click();
  assertEquals("clicked", driver.findElement(By.id("b")).getText());
  driver.switchTo().defaultContent();
  driver.switchTo().frame("inner-name");                         // by name or id
  driver.switchTo().parentFrame();
  driver.switchTo().frame(1);                                    // by index
  assertEquals("Second", driver.findElement(By.id("second")).getText());
  driver.switchTo().defaultContent();
  assertEquals("Top", driver.findElement(By.id("top")).getText());
}

def test_frames(driver):
    driver.get(data_url(FRAMES))
    with pytest.raises(NoSuchElementException):
        driver.find_element(By.ID, "b")  # not in the top-level document
    driver.switch_to.frame(driver.find_element(By.ID, "inner"))   # by element
    driver.find_element(By.ID, "b").click()
    assert driver.find_element(By.ID, "b").text == "clicked"
    driver.switch_to.default_content()
    driver.switch_to.frame("inner-name")                          # by name or id
    driver.switch_to.parent_frame()
    driver.switch_to.frame(1)                                     # by index
    assert driver.find_element(By.ID, "second").text == "Second"
    driver.switch_to.default_content()
    assert driver.find_element(By.ID, "top").text == "Top"

@Test
void windowsAndTabs() {
  driver.get(BASE_URL + "/books");
  String original = driver.getWindowHandle();
  assertEquals(1, driver.getWindowHandles().size());
  ((JavascriptExecutor) driver).executeScript("window.open(arguments[0], '_blank')", BASE_URL + "/signin");
  waitFor().until(ExpectedConditions.numberOfWindowsToBe(2));
  for (String handle : driver.getWindowHandles()) {
    if (!handle.equals(original)) {
      driver.switchTo().window(handle);
    }
  }
  waitFor().until(ExpectedConditions.urlContains("/signin"));
  driver.close();
  driver.switchTo().window(original);   // forgetting this raises NoSuchWindowException
  assertTrue(driver.getCurrentUrl().endsWith("/books"));
  driver.switchTo().newWindow(WindowType.TAB);   // created and focused in one call
  driver.get(BASE_URL + "/");
  assertEquals(2, driver.getWindowHandles().size());
  driver.close();
  driver.switchTo().window(original);
  driver.switchTo().newWindow(WindowType.WINDOW);
  driver.close();
  driver.switchTo().window(original);
}

def test_windows_and_tabs(driver, base_url):
    driver.get(f"{base_url}/books")
    original = driver.current_window_handle
    assert len(driver.window_handles) == 1
    driver.execute_script("window.open(arguments[0], '_blank')", f"{base_url}/signin")
    WebDriverWait(driver, 5).until(EC.number_of_windows_to_be(2))
    new = [h for h in driver.window_handles if h != original][0]
    driver.switch_to.window(new)
    WebDriverWait(driver, 5).until(EC.url_contains("/signin"))
    driver.close()
    driver.switch_to.window(original)          # forgetting this raises NoSuchWindowException
    assert driver.current_url.endswith("/books")
    driver.switch_to.new_window("tab")        # created and focused in one call
    driver.get(f"{base_url}/")
    assert len(driver.window_handles) == 2
    driver.close()
    driver.switch_to.window(original)
    driver.switch_to.new_window("window")
    driver.close()
    driver.switch_to.window(original)

@Test
void printPage(@TempDir Path tmp) throws Exception {
  driver.get(BASE_URL + "/books");
  PrintOptions options = new PrintOptions();
  options.setOrientation(PrintOptions.Orientation.LANDSCAPE);
  options.setScale(0.8);
  options.setBackground(true);
  options.setShrinkToFit(true);
  options.setPageRanges("1");
  Pdf pdf = ((PrintsPage) driver).print(options);
  byte[] bytes = Base64.getDecoder().decode(pdf.getContent());
  Files.write(tmp.resolve("catalogue.pdf"), bytes);
  assertEquals("%PDF-", new String(bytes, 0, 5));
}

def test_print_page(driver, base_url, tmp_path):
    driver.get(f"{base_url}/books")
    options = PrintOptions()
    options.orientation = "landscape"
    options.scale = 0.8
    options.background = True
    options.shrink_to_fit = True
    options.page_ranges = ["1"]
    pdf = base64.b64decode(driver.print_page(options))
    out = tmp_path / "catalogue.pdf"
    out.write_bytes(pdf)
    assert pdf.startswith(b"%PDF-")
    assert len(re.findall(rb"/Type\s*/Page\b", pdf)) >= 1

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.setCapability("webSocketUrl", true);   // enable BiDi
WebDriver driver = new ChromeDriver(options);
BrowsingContext context = new BrowsingContext(driver, driver.getWindowHandle());
driver.get(BaseTest.BASE_URL + "/books");
String pdf = context.print(new PrintOptions());
assertEquals("%PDF-", new String(Base64.getDecoder().decode(pdf), 0, 5));

@Test
void virtualAuthenticator() {
  driver.get(BASE_URL + "/");   // localhost is a secure context, so WebAuthn is available
  VirtualAuthenticatorOptions options = new VirtualAuthenticatorOptions()
      .setProtocol(VirtualAuthenticatorOptions.Protocol.CTAP2)
      .setHasResidentKey(true)
      .setHasUserVerification(true)
      .setIsUserVerified(true);
  VirtualAuthenticator authenticator = ((HasVirtualAuthenticator) driver).addVirtualAuthenticator(options);
  Object result = ((JavascriptExecutor) driver).executeAsyncScript("""
      const done = arguments[arguments.length - 1];
      navigator.credentials.create({publicKey: {
        rp: {name: 'Bookshelf'}, user: {id: new Uint8Array([1]), name: 'reader', displayName: 'Reader'},
        challenge: new Uint8Array([1, 2, 3]), pubKeyCredParams: [{type: 'public-key', alg: -7}],
        authenticatorSelection: {residentKey: 'required', userVerification: 'required'}}})
        .then(c => done(c.id), e => done('error: ' + e.name));""");
  assertFalse(result.toString().startsWith("error"));
  List<Credential> credentials = authenticator.getCredentials();
  assertEquals(1, credentials.size());
  assertTrue(credentials.get(0).isResidentCredential());
  Credential stored = credentials.get(0);
  authenticator.removeAllCredentials();
  assertTrue(authenticator.getCredentials().isEmpty());
  authenticator.addCredential(stored);   // a Credential read from the authenticator can be added back
  Object login = ((JavascriptExecutor) driver).executeAsyncScript("""
      const done = arguments[arguments.length - 1];
      navigator.credentials.get({publicKey: {challenge: new Uint8Array([4, 5, 6]), userVerification: 'required'}})
        .then(c => done('ok'), e => done('error: ' + e.name));""");
  assertEquals("ok", login);
  authenticator.setUserVerified(false);   // simulate a failed biometric check
  ((HasVirtualAuthenticator) driver).removeVirtualAuthenticator(authenticator);
}

from selenium.webdriver.common.virtual_authenticator import Credential, VirtualAuthenticatorOptions

def test_virtual_authenticator(driver, base_url):
    driver.get(f"{base_url}/")   # localhost is a secure context, so WebAuthn is available
    options = VirtualAuthenticatorOptions()
    options.protocol = VirtualAuthenticatorOptions.Protocol.CTAP2
    options.has_resident_key = True
    options.has_user_verification = True
    options.is_user_verified = True
    driver.add_virtual_authenticator(options)
    result = driver.execute_async_script("""
      const done = arguments[arguments.length - 1];
      navigator.credentials.create({publicKey: {
        rp: {name: 'Bookshelf'}, user: {id: new Uint8Array([1]), name: 'reader', displayName: 'Reader'},
        challenge: new Uint8Array([1, 2, 3]), pubKeyCredParams: [{type: 'public-key', alg: -7}],
        authenticatorSelection: {residentKey: 'required', userVerification: 'required'}}})
        .then(c => done(c.id), e => done('error: ' + e.name));""")
    assert not result.startswith("error")
    credentials = driver.get_credentials()
    assert len(credentials) == 1 and credentials[0].is_resident_credential
    stored = credentials[0]
    driver.remove_all_credentials()
    assert driver.get_credentials() == []
    driver.add_credential(stored)   # a Credential read from the authenticator can be added back
    assert driver.get_credentials()[0].id == stored.id
    login = driver.execute_async_script("""
      const done = arguments[arguments.length - 1];
      navigator.credentials.get({publicKey: {challenge: new Uint8Array([4, 5, 6]), userVerification: 'required'}})
        .then(c => done('ok'), e => done('error: ' + e.name));""")
    assert login == "ok"
    assert driver.get_credentials()[0].sign_count >= 1   # the authenticator signed the assertion
    driver.remove_virtual_authenticator()