@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/locator/locator-actions.test.ts

@@ -1,355 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import Locator from "./locator.js";
-import { ActionTimeoutError } from "./action-timeout-error.js";
-import type { ElementState } from "./element-state.js";
-import { remote, stubConnector, type StubResponse } from "../testing/stub-connector.js";
-
-const BOX = { x: 10, y: 20, width: 100, height: 40 };
-
-/** Element state response; defaults describe an element ready for any action */
-function state(overrides: Partial<ElementState> = {}): StubResponse {
-  return remote({
-    attached: true,
-    visible: true,
-    enabled: true,
-    editable: true,
-    box: BOX,
-    hitTarget: "self",
-    ...overrides,
-  });
-}
-
-const detached = state({
-  attached: false,
-  visible: false,
-  enabled: false,
-  editable: false,
-  box: null,
-  hitTarget: null,
-});
-
-function locatorWith(xpath: string, ...responses: StubResponse[]) {
-  const stub = stubConnector(...responses);
-  return { locator: new Locator(xpath, stub.connector, "ctx"), ...stub };
-}
-
-type Performed = {
-  actions: Array<{
-    type: string;
-    actions: Array<{ type: string; x?: number; y?: number; value?: string }>;
-  }>;
-};
-type Sent = Array<{ method: string; params: unknown }>;
-
-function performed(sent: Sent, sourceType: string) {
-  return sent
-    .filter(({ method }) => method === "input.performActions")
-    .map(({ params }) => (params as Performed).actions[0]!)
-    .filter((source) => source.type === sourceType);
-}
-
-/** [x, y] of the pointerMove of every pointer click sent */
-function pointerClicks(sent: Sent) {
-  return performed(sent, "pointer").map((source) => [source.actions[0]!.x, source.actions[0]!.y]);
-}
-
-function keysTyped(sent: Sent) {
-  return performed(sent, "key")
-    .flatMap((source) => source.actions.map((action) => action.value))
-    .join("");
-}
-
-test("click() retries through every check, then clicks the latest box centre once", async () => {
-  const { locator, sent, calls, expressions } = locatorWith(
-    "button",
-    detached, // attached ✗
-    state({ visible: false }), // visible ✗
-    state({ box: { ...BOX, x: 0 } }), // stable ✗ (moved)
-    state(), // stable ✗ (moved back)
-    state({ enabled: false }), // enabled ✗
-    state({ hitTarget: "div#overlay" }), // hit target ✗
-    state(), // actionable
-  );
-  assert.equal(await locator.click({ timeout: 3000 }), undefined);
-  assert.equal(expressions.length, 7);
-  assert.deepEqual(calls[0]!.args[1], { scroll: true, hitTest: true });
-  assert.deepEqual(pointerClicks(sent), [[60, 40]]);
-});
-
-test("click() needs the same box on two probes, so a ready element is probed twice", async () => {
-  const { locator, expressions } = locatorWith("button", state());
-  await locator.click({ timeout: 3000 });
-  assert.equal(expressions.length, 2);
-});
-
-test("click() timeout lists the checks of the last probe", async () => {
-  const { locator, sent } = locatorWith("button", state({ enabled: false }));
-  await assert.rejects(locator.click({ timeout: 250 }), (err) => {
-    assert.ok(err instanceof ActionTimeoutError);
-    assert.equal(err.reason, "not-actionable");
-    assert.equal(
-      err.message,
-      "click(): //button was not actionable within 250ms\n" +
-        "  attached ✓  visible ✓  stable ✓  enabled ✗  hit target —",
-    );
-    return true;
-  });
-  assert.deepEqual(pointerClicks(sent), []);
-});
-
-test("click() timeout names a covering element", async () => {
-  const { locator } = locatorWith("button", state({ hitTarget: "div#cookie-banner.overlay" }));
-  await assert.rejects(
-    locator.click({ timeout: 250 }),
-    new ActionTimeoutError({
-      action: "click",
-      selector: "//button",
-      timeout: 250,
-      reason: "not-actionable",
-      checks: {
-        attached: "pass",
-        visible: "pass",
-        stable: "pass",
-        enabled: "pass",
-        "hit target": "fail",
-      },
-      coveredBy: "div#cookie-banner.overlay",
-    }),
-  );
-});
-
-test("click() with timeout 0 probes once and skips the stability check", async () => {
-  const { locator, sent, expressions } = locatorWith("button", state());
-  assert.equal(await locator.click({ timeout: 0 }), undefined);
-  assert.equal(expressions.length, 1);
-  assert.deepEqual(pointerClicks(sent), [[60, 40]]);
-});
-
-test("click() with timeout 0 on a disabled element reports no stable entry", async () => {
-  const { locator, sent } = locatorWith("button", state({ enabled: false }));
-  await assert.rejects(locator.click({ timeout: 0 }), (err) => {
-    assert.ok(err instanceof ActionTimeoutError);
-    assert.equal(
-      err.message,
-      "click(): //button was not actionable within 0ms\n" +
-        "  attached ✓  visible ✓  enabled ✗  hit target —",
-    );
-    return true;
-  });
-  assert.deepEqual(pointerClicks(sent), []);
-});
-
-test("click() timeout on a hidden element does not report a covering element", async () => {
-  const { locator } = locatorWith("button", state({ visible: false, hitTarget: "html" }));
-  await assert.rejects(locator.click({ timeout: 250 }), (err) => {
-    assert.ok(err instanceof ActionTimeoutError);
-    assert.equal(err.coveredBy, undefined);
-    return true;
-  });
-});
-
-test("click() on an element that never appears reports it was not attached", async () => {
-  const { locator } = locatorWith("button", detached);
-  await assert.rejects(
-    locator.click({ timeout: 250 }),
-    /^ActionTimeoutError: click\(\): \/\/button was not attached within 250ms$/,
-  );
-});
-
-test("click() when no probe completes reports it could not read the element", async () => {
-  const { locator } = locatorWith("button", { hang: true });
-  await assert.rejects(locator.click({ timeout: 250 }), (err) => {
-    assert.ok(err instanceof ActionTimeoutError);
-    assert.equal(err.reason, "unreadable");
-    assert.equal(err.message, "click(): could not read //button within 250ms");
-    return true;
-  });
-});
-
-test("force skips every check except attached", async () => {
-  const { locator, sent, expressions } = locatorWith(
-    "button",
-    state({ visible: false, enabled: false, hitTarget: "div#overlay" }),
-  );
-  await locator.click({ force: true, timeout: 1000 });
-  assert.equal(expressions.length, 1);
-  assert.ok(expressions[0]!.includes("scrollIntoView"));
-  assert.deepEqual(pointerClicks(sent), [[60, 40]]);
-});
-
-test("force still waits for the element to be attached", async () => {
-  const { locator } = locatorWith("button", detached);
-  await assert.rejects(
-    locator.click({ force: true, timeout: 250 }),
-    /was not attached within 250ms/,
-  );
-});
-
-test("fill() waits until the field is editable, then clicks, selects and types", async () => {
-  const { locator, sent, expressions } = locatorWith(
-    "input",
-    state({ editable: false }),
-    state(),
-    { type: "undefined" },
-  );
-  await locator.fill("ab", { timeout: 3000 });
-  assert.equal(expressions.length, 3);
-  assert.match(expressions[2]!, /\.select\(\)/);
-  assert.deepEqual(pointerClicks(sent), [[60, 40]]);
-  assert.equal(keysTyped(sent), "aabb");
-});
-
-test("fill() timeout lists the fill checks", async () => {
-  const { locator } = locatorWith("input", state({ editable: false }));
-  await assert.rejects(
-    locator.fill("x", { timeout: 250 }),
-    (err) =>
-      err instanceof ActionTimeoutError &&
-      err.message ===
-        "fill(): //input was not actionable within 250ms\n" +
-          "  attached ✓  visible ✓  enabled ✓  editable ✗  hit target —",
-  );
-});
-
-test("focus() waits only for the element to be attached", async () => {
-  const { locator, expressions, calls } = locatorWith(
-    "input",
-    detached,
-    state({ visible: false, enabled: false }),
-    { type: "undefined" },
-  );
-  assert.equal(await locator.focus({ timeout: 3000 }), undefined);
-  assert.equal(expressions.length, 3);
-  assert.deepEqual(calls[0]!.args[1], { scroll: false, hitTest: false });
-  assert.match(expressions[2]!, /el\.focus\(\)/);
-});
-
-test("isEnabled() and isEditable() read the state without waiting", async () => {
-  assert.equal(await locatorWith("button", state()).locator.isEnabled(), true);
-  assert.equal(await locatorWith("button", state({ enabled: false })).locator.isEnabled(), false);
-  assert.equal(await locatorWith("button", detached).locator.isEnabled(), false);
-  assert.equal(await locatorWith("input", state()).locator.isEditable(), true);
-  assert.equal(await locatorWith("input", state({ editable: false })).locator.isEditable(), false);
-  assert.equal(await locatorWith("input", detached).locator.isEditable(), false);
-});
-
-test("waitFor() waits for visible by default, without scrolling", async () => {
-  const { locator, expressions, calls } = locatorWith("div", state({ visible: false }), state());
-  await locator.waitFor({ timeout: 3000 });
-  assert.equal(expressions.length, 2);
-  assert.deepEqual(calls[0]!.args[1], { scroll: false, hitTest: false });
-});
-
-test("waitFor({ state: \"hidden\" }) resolves once the element is gone or invisible", async () => {
-  const gone = locatorWith("div", state(), detached);
-  await gone.locator.waitFor({ state: "hidden", timeout: 3000 });
-  assert.equal(gone.expressions.length, 2);
-
-  const invisible = locatorWith("div", state(), state({ visible: false }));
-  await invisible.locator.waitFor({ state: "hidden", timeout: 3000 });
-  assert.equal(invisible.expressions.length, 2);
-});
-
-test("waitFor() for attached and detached", async () => {
-  const appears = locatorWith("div", detached, state({ visible: false }));
-  await appears.locator.waitFor({ state: "attached", timeout: 3000 });
-  assert.equal(appears.expressions.length, 2);
-
-  const disappears = locatorWith("div", state(), detached);
-  await disappears.locator.waitFor({ state: "detached", timeout: 3000 });
-  assert.equal(disappears.expressions.length, 2);
-});
-
-test("waitFor() timeout names the state it waited for", async () => {
-  const { locator } = locatorWith("div", state({ visible: false }));
-  await assert.rejects(locator.waitFor({ timeout: 250 }), (err) => {
-    assert.ok(err instanceof ActionTimeoutError);
-    assert.equal(err.reason, "wrong-state");
-    assert.equal(err.state, "visible");
-    assert.equal(err.message, "waitFor(): //div did not become visible within 250ms");
-    return true;
-  });
-});
-
-test("waitFor() when no probe completes reports it could not read the element", async () => {
-  const { locator } = locatorWith("div", { hang: true });
-  await assert.rejects(
-    locator.waitFor({ state: "hidden", timeout: 250 }),
-    /^ActionTimeoutError: waitFor\(\): could not read \/\/div within 250ms$/,
-  );
-});
-
-/** Helper installer that records how often it was asked to (re)install */
-function fakeHelpers() {
-  const log: string[] = [];
-  return {
-    log,
-    helpers: {
-      async ensureInstalled() {
-        log.push("ensure");
-      },
-      async reinstall() {
-        log.push("reinstall");
-      },
-    },
-  };
-}
-
-function locatorWithHelpers(xpath: string, ...responses: StubResponse[]) {
-  const stub = stubConnector(...responses);
-  const { log, helpers } = fakeHelpers();
-  return { locator: new Locator(xpath, stub.connector, "ctx", helpers), log, ...stub };
-}
-
-const HELPERS_MISSING: StubResponse = { type: "string", value: "samurai:helpers-missing" };
-
-test("with helpers the probe runs in the samurai sandbox after ensuring the install", async () => {
-  const { locator, log, sent, calls } = locatorWithHelpers("button", state());
-  assert.equal(await locator.isEnabled(), true);
-  assert.deepEqual(log, ["ensure"]);
-  const params = sent.find(({ method }) => method === "script.callFunction")!.params as { target: unknown };
-  assert.deepEqual(params.target, { context: "ctx", sandbox: "samurai" });
-  assert.match(calls[0]!.functionDeclaration, /__samurai/);
-  assert.deepEqual(calls[0]!.args, [{ sharedId: "stub-node-0" }, { scroll: false, hitTest: false }]);
-});
-
-test("without helpers the probe source is sent to the page realm as before", async () => {
-  const { locator, sent, calls } = locatorWith("button", state());
-  await locator.isEnabled();
-  const call = sent.find(({ method }) => method === "script.callFunction")!;
-  assert.deepEqual((call.params as { target: unknown }).target, { context: "ctx" });
-  assert.match(calls[0]!.functionDeclaration, /^\(el, options\) =>/);
-});
-
-test("a missing helper triggers one reinstall and a retry", async () => {
-  const { locator, log, expressions } = locatorWithHelpers("button", HELPERS_MISSING, state());
-  assert.equal(await locator.isEnabled(), true);
-  assert.deepEqual(log, ["ensure", "reinstall"]);
-  assert.equal(expressions.length, 2);
-});
-
-test("helpers still missing after the reinstall is an error, not a loop", async () => {
-  const { locator, log, expressions } = locatorWithHelpers("button", HELPERS_MISSING);
-  await assert.rejects(locator.isEnabled(), /helpers are missing/);
-  assert.deepEqual(log, ["ensure", "reinstall"]);
-  assert.equal(expressions.length, 2);
-});
-
-test("ensureInstalled runs once per poll, so a click polls and clicks with the same setup", async () => {
-  const { locator, log, sent } = locatorWithHelpers("button", state());
-  await locator.click({ timeout: 3000 });
-  assert.ok(log.every((entry) => entry === "ensure"));
-  assert.equal(pointerClicks(sent).length, 1);
-});
-
-test("all() items keep using the helpers", async () => {
-  const stub = stubConnector(state());
-  stub.nodeCounts(2, 1);
-  const { log, helpers } = fakeHelpers();
-  const items = await new Locator("li", stub.connector, "ctx", helpers).all();
-  await items[1]!.isEnabled();
-  assert.ok(log.includes("ensure"));
-  const probe = stub.sent.find(({ method }) => method === "script.callFunction")!;
-  assert.deepEqual((probe.params as { target: unknown }).target, { context: "ctx", sandbox: "samurai" });
-});

package/src/locator/locator-chain.test.ts

@@ -1,292 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import Page from "../browser/page.js";
-import { remote, stubConnector, type StubResponse } from "../testing/stub-connector.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import { ActionTimeoutError } from "./action-timeout-error.js";
-import Locator, { InvalidSelectorError, UnsupportedOperationError } from "./locator.js";
-import { cssSelector, textSelector, xpathSelector } from "./selector.js";
-
-type Sent = Array<{ method: string; params: unknown }>;
-interface LocateParams {
-  context: string;
-  locator: unknown;
-  maxNodeCount?: number;
-  startNodes?: Array<{ sharedId: string }>;
-}
-const locateCommands = (sent: Sent) =>
-  sent.filter(({ method }) => method === "browsingContext.locateNodes").map(({ params }) => params as LocateParams);
-
-const READY: StubResponse = remote({
-  attached: true,
-  visible: true,
-  enabled: true,
-  editable: true,
-  box: { x: 0, y: 0, width: 10, height: 10 },
-  hitTarget: "self",
-});
-
-function chainWith(steps: ConstructorParameters<typeof Locator>[0], ...responses: StubResponse[]) {
-  const stub = stubConnector(...(responses.length ? responses : [remote(null)]));
-  return { locator: new Locator(steps, stub.connector, "ctx"), ...stub };
-}
-
-describe("chained locators", () => {
-  it("search inside the previous step's matches, with scoped xpaths", async () => {
-    const { locator, sent, nodeCounts } = chainWith("//form");
-    nodeCounts(1, 2);
-    const child = locator.locator("input").getByCss("span.x");
-    assert.equal(child.selector, "//form >> .//input >> css=span.x");
-    assert.equal(await child.count(), 2);
-    const [first, second, third] = locateCommands(sent);
-    assert.deepEqual(first!.locator, { type: "xpath", value: "//form" });
-    assert.equal(first!.startNodes, undefined);
-    assert.deepEqual(second!.locator, { type: "xpath", value: ".//input" });
-    assert.deepEqual(second!.startNodes, [{ sharedId: "stub-node-0" }]);
-    assert.deepEqual(third!.locator, { type: "css", value: "span.x" });
-    assert.deepEqual(third!.startNodes, [{ sharedId: "stub-node-0" }, { sharedId: "stub-node-1" }]);
-  });
-
-  it("make // relative to the parent match", async () => {
-    const { locator, sent } = chainWith("//form");
-    await locator.locator("//input").count();
-    assert.deepEqual(locateCommands(sent)[1]!.locator, { type: "xpath", value: ".//input" });
-  });
-
-  it("stop at the first empty step", async () => {
-    const { locator, sent, nodeCounts } = chainWith("//form");
-    nodeCounts(0);
-    assert.equal(await locator.getByCss("input").count(), 0);
-    assert.equal(locateCommands(sent).length, 1);
-  });
-
-  it("limit only the final step to one node when a single element is needed", async () => {
-    const { locator, sent } = chainWith("//form", remote("x"));
-    await locator.getByCss("input").textContent();
-    const [first, second] = locateCommands(sent);
-    assert.equal(first!.maxNodeCount, undefined);
-    assert.equal(second!.maxNodeCount, 1);
-  });
-
-  it("send the element found last to the page function", async () => {
-    const { locator, calls } = chainWith("//form", remote("x"));
-    await locator.getByCss("input").textContent();
-    assert.deepEqual(calls[0]!.args[0], { sharedId: "stub-node-0" });
-  });
-});
-
-describe("selector kinds", () => {
-  it("getByCss, getByText and getByRole send the matching BiDi locators", async () => {
-    const stub = stubConnector(remote(null));
-    const page = new Page(stub.connector, "ctx");
-    await page.getByCss("form.login input").count();
-    await page.getByText("Sign in").count();
-    await page.getByText("in", { match: "partial", ignoreCase: true }).count();
-    await page.getByRole("button", { name: "Submit" }).count();
-    await page.getByRole("link").count();
-    assert.deepEqual(
-      locateCommands(stub.sent).map((command) => command.locator),
-      [
-        { type: "css", value: "form.login input" },
-        { type: "innerText", value: "Sign in", matchType: "full", ignoreCase: false },
-        { type: "innerText", value: "in", matchType: "partial", ignoreCase: true },
-        { type: "accessibility", value: { role: "button", name: "Submit" } },
-        { type: "accessibility", value: { role: "link" } },
-      ],
-    );
-  });
-
-  it("are described in messages", () => {
-    const stub = stubConnector(remote(null));
-    const page = new Page(stub.connector, "ctx");
-    assert.equal(page.getByCss("a.b").selector, "css=a.b");
-    assert.equal(page.getByText("Hi").selector, 'text="Hi"');
-    assert.equal(page.getByRole("button", { name: "Go" }).selector, 'role=button[name="Go"]');
-    assert.equal(page.locator("h1").getByRole("link").selector, "//h1 >> role=link");
-  });
-
-  it("reject empty arguments when built", () => {
-    const stub = stubConnector(remote(null));
-    const page = new Page(stub.connector, "ctx");
-    assert.throws(() => page.getByCss(""), TypeError);
-    assert.throws(() => page.getByText(""), TypeError);
-    assert.throws(() => page.getByRole(""), TypeError);
-  });
-
-  it("actions report the described selector when they time out", async () => {
-    const { locator, nodeCounts } = chainWith([cssSelector("form"), textSelector("Save")]);
-    nodeCounts(0);
-    await assert.rejects(locator.click({ timeout: 100 }), (err) => {
-      assert.ok(err instanceof ActionTimeoutError);
-      assert.match(err.message, /click\(\): css=form >> text="Save" was not attached within 100ms/);
-      return true;
-    });
-  });
-});
-
-describe("all() on non-xpath locators", () => {
-  it("returns n-th locators that re-resolve the whole chain", async () => {
-    const { locator, nodeCounts, sent } = chainWith([cssSelector("li")], READY);
-    nodeCounts(3);
-    const items = await locator.all();
-    assert.deepEqual(
-      items.map((item) => item.selector),
-      ["css=li >> nth=0", "css=li >> nth=1", "css=li >> nth=2"],
-    );
-    nodeCounts(3, 3);
-    await items[2]!.isEnabled();
-    const last = locateCommands(sent).pop()!;
-    assert.deepEqual(last.locator, { type: "css", value: "li" });
-    assert.equal(last.maxNodeCount, undefined, "the step before nth must not be limited");
-  });
-
-  it("an n-th locator whose index no longer exists is not attached", async () => {
-    const { locator, nodeCounts } = chainWith([cssSelector("li")], READY);
-    nodeCounts(3);
-    const items = await locator.all();
-    nodeCounts(1);
-    assert.equal(await items[2]!.isEnabled(), false);
-  });
-
-  it("chained xpath locators use n-th too, xpath-only ones keep positional xpaths", async () => {
-    const { locator, nodeCounts } = chainWith("//ul");
-    nodeCounts(1, 2);
-    const items = await locator.locator("li").all();
-    assert.deepEqual(
-      items.map((item) => item.selector),
-      ["//ul >> .//li >> nth=0", "//ul >> .//li >> nth=1"],
-    );
-  });
-});
-
-describe("elements that are not there", () => {
-  it("reads answer null or false without running a script", async () => {
-    const { locator, nodeCounts, expressions } = chainWith([cssSelector("p")]);
-    nodeCounts(0);
-    assert.equal(await locator.textContent(), null);
-    assert.equal(await locator.inputValue(), null);
-    assert.equal(await locator.getAttribute("href"), null);
-    assert.equal(await locator.isVisible(), false);
-    assert.equal(await locator.isEnabled(), false);
-    assert.equal(await locator.isEditable(), false);
-    assert.equal(await locator.count(), 0);
-    assert.equal(expressions.length, 0);
-  });
-
-  it("getBoundingClientRect and focus need the element", async () => {
-    const { locator, nodeCounts } = chainWith([cssSelector("p")]);
-    nodeCounts(0);
-    await assert.rejects(locator.getBoundingClientRect(), /Failed to locate element css=p/);
-    await assert.rejects(locator.focus({ force: true, timeout: 50 }), ActionTimeoutError);
-  });
-
-  it("a node that went away between the search and the read counts as missing", async () => {
-    const { locator } = chainWith([cssSelector("p")], { error: "no such node" });
-    assert.equal(await locator.textContent(), null);
-    assert.equal(await locator.isVisible(), false);
-  });
-
-  it("a node that went away between the search and the probe is not attached", async () => {
-    const { locator } = chainWith([cssSelector("p")], { error: "no such node" });
-    assert.equal(await locator.isEnabled(), false);
-  });
-
-  it("other script errors from a read still surface", async () => {
-    const { locator } = chainWith([cssSelector("p")], { error: "unknown error" });
-    await assert.rejects(locator.textContent(), BiDiError);
-  });
-});
-
-describe("locate errors", () => {
-  it("an invalid selector is thrown immediately with the selector in the message", async () => {
-    const { locator, failLocate, sent } = chainWith([cssSelector("a[")]);
-    failLocate(new BiDiError("browsingContext.locateNodes", "invalid selector", "bad css"));
-    await assert.rejects(locator.click({ timeout: 2000 }), (err) => {
-      assert.ok(err instanceof InvalidSelectorError);
-      assert.equal(err.selector, "css=a[");
-      assert.match(err.message, /Invalid selector css=a\[: .*bad css/);
-      return true;
-    });
-    assert.equal(locateCommands(sent).length, 1, "not retried");
-  });
-
-  it("an unsupported locator type says so", async () => {
-    const { locator, failLocate } = chainWith([xpathSelector("//a")]);
-    failLocate(new BiDiError("browsingContext.locateNodes", "unsupported operation", "no accessibility"));
-    await assert.rejects(locator.count(), UnsupportedOperationError);
-  });
-
-  it("other locate failures are rethrown as they are", async () => {
-    const { locator, failLocate } = chainWith("//a");
-    failLocate(new BiDiError("browsingContext.locateNodes", "no such frame", "gone"));
-    await assert.rejects(locator.count(), { code: "no such frame" });
-  });
-
-  it("expect-style reads rethrow an invalid selector without waiting for the timeout", async () => {
-    const { locator, failLocate } = chainWith([cssSelector("a[")]);
-    failLocate(new BiDiError("browsingContext.locateNodes", "invalid selector", "bad css"));
-    const started = Date.now();
-    await assert.rejects(locator.waitFor({ timeout: 3000 }), InvalidSelectorError);
-    assert.ok(Date.now() - started < 1000);
-  });
-});
-
-describe("text locators in a browser without the innerText locator", () => {
-  const nodesOf = (...ids: string[]): StubResponse => ({
-    type: "array",
-    value: ids.map((sharedId) => ({ type: "node", sharedId }) as never),
-  });
-
-  it("try the native locator once, then search in the page", async () => {
-    const { locator, unsupportedLocators, sent, calls } = chainWith([textSelector("Sign in")], nodesOf("t1", "t2"));
-    unsupportedLocators("innerText");
-    assert.equal(await locator.count(), 2);
-    assert.equal(locateCommands(sent).length, 1, "the native attempt");
-    assert.equal(calls.length, 1);
-    assert.deepEqual(calls[0]!.args, [[], "Sign in", "full", false]);
-    assert.match(calls[0]!.functionDeclaration, /^\(starts, value, match, ignoreCase\) =>/);
-  });
-
-  it("remember the answer for the connection, across locators", async () => {
-    const stub = stubConnector(nodesOf("t1"));
-    stub.unsupportedLocators("innerText");
-    const page = new Page(stub.connector, "ctx");
-    await page.getByText("a").count();
-    await page.getByText("b", { match: "partial", ignoreCase: true }).count();
-    assert.equal(locateCommands(stub.sent).length, 1, "only the first locator asked the browser");
-    assert.deepEqual(stub.calls[1]!.args, [[], "b", "partial", true]);
-  });
-
-  it("pass the parent's matches as start nodes and honour the limit", async () => {
-    const stub = stubConnector(nodesOf("t1", "t2", "t3"), remote("hello"));
-    stub.unsupportedLocators("innerText");
-    const parent = new Locator([xpathSelector("//form"), textSelector("x")], stub.connector, "ctx");
-    assert.equal(await parent.textContent(), "hello");
-    // the text step ran in the page with the form as its start node; only one element is needed
-    assert.deepEqual(stub.calls[0]!.args[0], [{ sharedId: "stub-node-0" }]);
-    assert.deepEqual(stub.calls[1]!.args[0], { sharedId: "t1" });
-  });
-
-  it("do not affect css, xpath or role locators", async () => {
-    const stub = stubConnector(remote(null));
-    stub.unsupportedLocators("innerText");
-    const page = new Page(stub.connector, "ctx");
-    await page.getByCss("a").count();
-    await page.getByRole("button").count();
-    assert.equal(locateCommands(stub.sent).length, 2);
-    assert.equal(stub.calls.length, 0);
-  });
-
-  it("an unsupported role locator is reported, not searched for elsewhere", async () => {
-    const stub = stubConnector(remote(null));
-    stub.unsupportedLocators("accessibility");
-    const page = new Page(stub.connector, "ctx");
-    await assert.rejects(page.getByRole("button").count(), UnsupportedOperationError);
-  });
-
-  it("a text search that throws in the page reads as a locate failure", async () => {
-    const { locator, unsupportedLocators } = chainWith([textSelector("x")], { exception: "TypeError: boom" });
-    unsupportedLocators("innerText");
-    await assert.rejects(locator.count(), /Failed to locate element text="x"\. Details: TypeError: boom/);
-  });
-});