@workglow/test-contract 0.6.1

package/dist/browser-context.js

@@ -0,0 +1,567 @@
+// src/browser-context/ConformanceMockContext.ts
+function parseFixturePage(url) {
+  let html = "";
+  if (url.startsWith("data:text/html,")) {
+    html = decodeURIComponent(url.slice("data:text/html,".length));
+  }
+  const titleMatch = /<title>([^<]*)<\/title>/.exec(html);
+  const buttons = [];
+  const buttonRe = /<button[^>]*aria-label="([^"]*)"[^>]*>/g;
+  let m;
+  let idx = 0;
+  while ((m = buttonRe.exec(html)) !== null) {
+    const decoded = m[1].replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+    buttons.push({ idx, name: decoded });
+    idx++;
+  }
+  const fetchMatch = /fetch\("data:text\/plain,([^"]+)"/.exec(html);
+  const consoleMatch = /console\.log\("([^"]+)"\)/.exec(html);
+  return {
+    title: titleMatch ? titleMatch[1] : "",
+    ariaButtons: buttons,
+    networkMarker: fetchMatch?.[1],
+    consoleMarker: consoleMatch?.[1]
+  };
+}
+
+class ConformanceMockContext {
+  connected = false;
+  nextTabSeq = 1;
+  nextRefSeq = 1;
+  pages = [];
+  activeTabId;
+  refMap = new Map;
+  async connect(_options) {
+    this.connected = true;
+    if (this.pages.length === 0) {
+      const page = this.makePage("about:blank", "");
+      this.pages.push(page);
+      this.activeTabId = page.tabId;
+    }
+  }
+  async disconnect() {
+    this.connected = false;
+    this.pages = [];
+    this.activeTabId = undefined;
+    this.refMap.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  makePage(url, title) {
+    return {
+      tabId: `mock-tab-${this.nextTabSeq++}`,
+      url,
+      title,
+      ariaButtons: [],
+      sentinelClicked: "",
+      network: [],
+      console: []
+    };
+  }
+  active() {
+    const p = this.pages.find((p) => p.tabId === this.activeTabId);
+    if (!p)
+      throw new Error("ConformanceMockContext: no active tab");
+    return p;
+  }
+  async navigate(url, _options) {
+    const page = this.active();
+    page.url = url;
+    const parsed = parseFixturePage(url);
+    page.title = parsed.title;
+    page.ariaButtons = parsed.ariaButtons;
+    page.sentinelClicked = "";
+    if (parsed.networkMarker) {
+      page.network.push({
+        url: `data:text/plain,${parsed.networkMarker}`,
+        method: "GET",
+        status: 200,
+        headers: {}
+      });
+    }
+    if (parsed.consoleMarker) {
+      page.console.push({ type: "log", text: parsed.consoleMarker });
+    }
+  }
+  async goBack(_options) {}
+  async goForward(_options) {}
+  async reload(_options) {}
+  async currentUrl() {
+    return this.active().url;
+  }
+  async title() {
+    return this.active().title;
+  }
+  async snapshot(_options) {
+    const page = this.active();
+    const children = page.ariaButtons.map((b) => {
+      const ref = `e${this.nextRefSeq++}`;
+      this.refMap.set(ref, { tabId: page.tabId, name: b.name, idx: b.idx });
+      return { ref, role: "button", name: b.name };
+    });
+    const rootRef = `e${this.nextRefSeq++}`;
+    return {
+      root: { ref: rootRef, role: "document", name: page.title, children },
+      yaml: children.map((c) => `- button [${c.ref}]: ${c.name}`).join(`
+`)
+    };
+  }
+  async click(ref, _options) {
+    const entry = this.refMap.get(ref);
+    if (!entry)
+      throw new Error(`ConformanceMockContext: unknown ref "${ref}"`);
+    const page = this.pages.find((p) => p.tabId === entry.tabId);
+    if (!page)
+      throw new Error(`ConformanceMockContext: tab gone for ref "${ref}"`);
+    page.sentinelClicked = String(entry.idx);
+  }
+  async fill(_ref, _value, _options) {}
+  async selectOption(_ref, _values, _options) {}
+  async hover(_ref, _options) {}
+  async clickByRole(role, name, _options) {
+    if (role !== "button") {
+      throw new Error(`ConformanceMockContext: unsupported role "${role}"`);
+    }
+    const page = this.active();
+    const btn = page.ariaButtons.find((b) => b.name === name);
+    if (!btn)
+      throw new Error(`ConformanceMockContext: no button named ${JSON.stringify(name)}`);
+    page.sentinelClicked = String(btn.idx);
+  }
+  async fillByLabel(_label, _value, _options) {}
+  async content() {
+    return "";
+  }
+  async innerHTML(_ref) {
+    return "";
+  }
+  async textContent(ref) {
+    const entry = this.refMap.get(ref);
+    return entry ? entry.name : null;
+  }
+  async attribute(ref, name) {
+    if (name === "data-clicked" && ref.startsWith("sentinel-")) {
+      const tabId = ref.slice("sentinel-".length);
+      const page = this.pages.find((p) => p.tabId === tabId);
+      return page ? page.sentinelClicked : null;
+    }
+    return null;
+  }
+  async querySelector(selector) {
+    if (selector === "#sentinel") {
+      const page = this.active();
+      return `sentinel-${page.tabId}`;
+    }
+    return null;
+  }
+  async querySelectorAll(_selector) {
+    return [];
+  }
+  async evaluate(expression) {
+    if (expression.includes("readyState"))
+      return true;
+    return;
+  }
+  async screenshot(_options) {
+    return Buffer.alloc(0);
+  }
+  async pressKey(_key, _options) {}
+  async type(_text, _options) {}
+  async scroll(_x, _y, _ref) {}
+  async uploadFile(_ref, _paths) {}
+  async download(trigger, _options) {
+    await trigger();
+    return { path: "", suggestedFilename: "" };
+  }
+  onDialog(_handler) {}
+  async tabs() {
+    return this.pages.map((p) => ({ tabId: p.tabId, url: p.url, title: p.title }));
+  }
+  async switchTab(tabId) {
+    if (!this.pages.some((p) => p.tabId === tabId)) {
+      throw new Error(`ConformanceMockContext: no tab "${tabId}"`);
+    }
+    this.activeTabId = tabId;
+  }
+  async newTab(url) {
+    const page = this.makePage(url ?? "about:blank", "");
+    this.pages.push(page);
+    if (url) {
+      const prev = this.activeTabId;
+      this.activeTabId = page.tabId;
+      await this.navigate(url);
+      this.activeTabId = prev;
+    }
+    return { tabId: page.tabId, url: page.url, title: page.title };
+  }
+  async closeTab(tabId) {
+    const before = this.pages.length;
+    this.pages = this.pages.filter((p) => p.tabId !== tabId);
+    if (this.pages.length === before) {
+      throw new Error(`ConformanceMockContext: no tab "${tabId}"`);
+    }
+    if (this.activeTabId === tabId) {
+      this.activeTabId = this.pages[this.pages.length - 1]?.tabId;
+    }
+  }
+  async waitForNavigation(_options) {}
+  async waitForSelector(_selector, _options) {
+    return "e0";
+  }
+  async waitForIdle(_options) {}
+}
+// src/browser-context/fixtures.ts
+var ARIA_EDGE_CASE_NAMES = [
+  "Sign in",
+  "foo:bar",
+  "11:30",
+  "a",
+  "héllo→",
+  "x".repeat(200)
+];
+var NETWORK_MARKER = "fixture-network-marker";
+var CONSOLE_MARKER = "fixture-console-marker";
+function escapeForHtmlAttr(text) {
+  return text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildPageHtml() {
+  const buttons = ARIA_EDGE_CASE_NAMES.map((name, idx) => `<button type="button" aria-label="${escapeForHtmlAttr(name)}" ` + `onclick="document.getElementById('sentinel').setAttribute('data-clicked', '${idx}')">` + escapeForHtmlAttr(name) + `</button>`).join("");
+  const head = '<head><meta charset="utf-8"><title>IBrowserContext Conformance</title></head>';
+  const body = `<body>` + `<div id="sentinel" data-clicked=""></div>` + buttons + `<script>` + `console.log(${JSON.stringify(CONSOLE_MARKER)});` + `fetch("data:text/plain,${NETWORK_MARKER}").catch(function(){});` + `</script>` + `</body>`;
+  return `<!DOCTYPE html><html>${head}${body}</html>`;
+}
+var PAGE_URL = `data:text/html,${encodeURIComponent(buildPageHtml())}`;
+var DEFAULT_FIXTURE = {
+  pageUrl: PAGE_URL,
+  networkMarkerUrl: NETWORK_MARKER,
+  consoleMarker: CONSOLE_MARKER,
+  ariaEdgeCaseNames: ARIA_EDGE_CASE_NAMES
+};
+function resolveFixture(override) {
+  if (!override)
+    return DEFAULT_FIXTURE;
+  return { ...DEFAULT_FIXTURE, ...override };
+}
+// src/browser-context/runIBrowserContextConformance.ts
+import { describe as describe5 } from "vitest";
+
+// src/browser-context/assertions/ariaRoundTrip.ts
+import { afterAll, beforeAll, describe, expect, it as it2 } from "vitest";
+
+// src/browser-context/assertions/itExpectFail.ts
+import { it } from "vitest";
+var itExpectFail = (name, fn, timeout) => {
+  const native = it.fails;
+  if (typeof native === "function") {
+    native(name, fn, timeout);
+    return;
+  }
+  it(`${name} [expected-fail]`, async () => {
+    let passed = false;
+    try {
+      await fn();
+      passed = true;
+    } catch {}
+    if (passed) {
+      throw new Error(`Test "${name}" was marked as expected-fail but passed. Remove its name from opts.expectedFailures.`);
+    }
+  }, timeout);
+};
+
+// src/browser-context/assertions/ariaRoundTrip.ts
+function collectButtons(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (n.role === "button")
+      out.push(n);
+    if (n.children)
+      stack.push(...n.children);
+  }
+  return out;
+}
+function ariaRoundTripBlock(opts, fixture) {
+  if (!opts.capabilities.ariaSnapshot)
+    return;
+  describe("ARIA round-trip", () => {
+    const expectFail = (name) => opts.expectedFailures?.includes(name) ?? false;
+    let ctx;
+    let handle;
+    beforeAll(async () => {
+      handle = await opts.factory();
+      ctx = await handle.create();
+      await ctx.navigate(fixture.pageUrl);
+      await ctx.waitForIdle({ timeout: 5000 });
+    }, opts.timeout);
+    afterAll(async () => {
+      if (handle && ctx)
+        await handle.dispose(ctx);
+    });
+    for (let i = 0;i < fixture.ariaEdgeCaseNames.length; i++) {
+      const name = fixture.ariaEdgeCaseNames[i];
+      const isColonName = name.includes(":");
+      const title = `clickByRole('button', ${JSON.stringify(name)}) lands on the right node`;
+      const body = async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        const tree = await ctx.snapshot();
+        const buttons = collectButtons(tree.root);
+        const target = buttons.find((b) => b.name === name);
+        expect(target, `snapshot must include button with name ${JSON.stringify(name)}`).toBeDefined();
+        await ctx.clickByRole("button", name);
+        const sentinelRef = await ctx.querySelector("#sentinel");
+        expect(sentinelRef).not.toBeNull();
+        const clicked = await ctx.attribute(sentinelRef, "data-clicked");
+        expect(clicked).toBe(String(i));
+      };
+      const useExpectFail = isColonName && expectFail("aria.colonInName");
+      if (useExpectFail) {
+        itExpectFail(title, body, opts.timeout);
+      } else {
+        it2(title, body, opts.timeout);
+      }
+    }
+    it2("refs from snapshot N remain usable for textContent after snapshot N+1", async () => {
+      if (!ctx)
+        throw new Error("context not created");
+      const t1 = await ctx.snapshot();
+      const buttons1 = collectButtons(t1.root);
+      expect(buttons1.length).toBeGreaterThan(0);
+      const ref = buttons1[0].ref;
+      await ctx.snapshot();
+      const txt = await ctx.textContent(ref);
+      expect(txt, "ref from prior snapshot should still resolve").not.toBeNull();
+    }, opts.timeout);
+  });
+}
+
+// src/browser-context/assertions/capabilityHonesty.ts
+import { afterAll as afterAll2, beforeAll as beforeAll2, describe as describe2, expect as expect2, it as it3 } from "vitest";
+function capabilityHonestyBlock(opts, fixture) {
+  describe2("Capability honesty", () => {
+    const expectFail = (name) => opts.expectedFailures?.includes(name) ?? false;
+    let ctx;
+    let handle;
+    beforeAll2(async () => {
+      handle = await opts.factory();
+      ctx = await handle.create();
+    }, opts.timeout);
+    afterAll2(async () => {
+      if (handle && ctx)
+        await handle.dispose(ctx);
+    });
+    const runNegative = (methodName, assertionName) => {
+      const body = async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        expect2(typeof ctx[methodName]).toBe("undefined");
+      };
+      const title = `declares ${methodName}=false → ctx.${methodName} is undefined`;
+      if (expectFail(assertionName)) {
+        itExpectFail(title, body, opts.timeout);
+      } else {
+        it3(title, body, opts.timeout);
+      }
+    };
+    if (!opts.capabilities.networkRequests) {
+      runNegative("networkRequests", "capability.networkRequests.undefinedWhenFalse");
+    }
+    if (!opts.capabilities.consoleMessages) {
+      runNegative("consoleMessages", "capability.consoleMessages.undefinedWhenFalse");
+    }
+    if (opts.capabilities.networkRequests) {
+      it3("declares networkRequests=true → fixture fetch is observable", async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        if (typeof ctx.networkRequests !== "function") {
+          throw new Error("capability claims networkRequests=true but ctx.networkRequests is not a function");
+        }
+        await ctx.navigate(fixture.pageUrl);
+        await ctx.waitForIdle({ timeout: 5000 });
+        const entries = await ctx.networkRequests();
+        const found = entries.some((r) => r.url.includes(fixture.networkMarkerUrl));
+        expect2(found, `expected an entry containing ${fixture.networkMarkerUrl}`).toBe(true);
+      }, opts.timeout);
+    }
+    if (opts.capabilities.consoleMessages) {
+      it3("declares consoleMessages=true → fixture console.log is observable", async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        if (typeof ctx.consoleMessages !== "function") {
+          throw new Error("capability claims consoleMessages=true but ctx.consoleMessages is not a function");
+        }
+        await ctx.navigate(fixture.pageUrl);
+        await ctx.waitForIdle({ timeout: 5000 });
+        const entries = await ctx.consoleMessages();
+        const found = entries.some((m) => m.text.includes(fixture.consoleMarker));
+        expect2(found, `expected a console message containing ${fixture.consoleMarker}`).toBe(true);
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/browser-context/assertions/networkIntrospection.ts
+import { afterAll as afterAll3, beforeAll as beforeAll3, describe as describe3, expect as expect3, it as it4 } from "vitest";
+function networkIntrospectionBlock(opts, fixture) {
+  if (!opts.capabilities.networkRequests && !opts.capabilities.consoleMessages)
+    return;
+  describe3("Network/console introspection", () => {
+    let ctx;
+    let handle;
+    beforeAll3(async () => {
+      handle = await opts.factory();
+      ctx = await handle.create();
+      await ctx.navigate(fixture.pageUrl);
+      await ctx.waitForIdle({ timeout: 5000 });
+    }, opts.timeout);
+    afterAll3(async () => {
+      if (handle && ctx)
+        await handle.dispose(ctx);
+    });
+    if (opts.capabilities.networkRequests) {
+      it4("networkRequests() captures the fixture's outbound fetch", async () => {
+        if (!ctx || typeof ctx.networkRequests !== "function") {
+          throw new Error("networkRequests not available despite capability=true");
+        }
+        const entries = await ctx.networkRequests();
+        const found = entries.some((r) => r.url.includes(fixture.networkMarkerUrl));
+        expect3(found, `expected an entry containing ${fixture.networkMarkerUrl}`).toBe(true);
+      }, opts.timeout);
+      it4("networkRequests({ method }) filters by method", async () => {
+        if (!ctx || typeof ctx.networkRequests !== "function") {
+          throw new Error("networkRequests not available despite capability=true");
+        }
+        const all = await ctx.networkRequests();
+        const gets = await ctx.networkRequests({ method: "GET" });
+        expect3(gets.length).toBeLessThanOrEqual(all.length);
+      }, opts.timeout);
+    }
+    if (opts.capabilities.consoleMessages) {
+      it4("consoleMessages() captures the fixture's console.log", async () => {
+        if (!ctx || typeof ctx.consoleMessages !== "function") {
+          throw new Error("consoleMessages not available despite capability=true");
+        }
+        const entries = await ctx.consoleMessages();
+        const found = entries.some((m) => m.text.includes(fixture.consoleMarker));
+        expect3(found, `expected a console message containing ${fixture.consoleMarker}`).toBe(true);
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/browser-context/assertions/tabsLifecycle.ts
+import { afterAll as afterAll4, beforeAll as beforeAll4, describe as describe4, expect as expect4, it as it5 } from "vitest";
+function tabsLifecycleBlock(opts, fixture) {
+  describe4("Tabs lifecycle", () => {
+    const expectFail = (name) => opts.expectedFailures?.includes(name) ?? false;
+    let ctx;
+    let handle;
+    beforeAll4(async () => {
+      handle = await opts.factory();
+      ctx = await handle.create();
+    }, opts.timeout);
+    afterAll4(async () => {
+      if (handle && ctx)
+        await handle.dispose(ctx);
+    });
+    it5("tabs() returns at least one tab after connect", async () => {
+      if (!ctx)
+        throw new Error("context not created");
+      const tabs = await ctx.tabs();
+      expect4(tabs.length).toBeGreaterThanOrEqual(1);
+    }, opts.timeout);
+    if (opts.capabilities.multipleTabs) {
+      it5("newTab() increases tab count by 1", async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        const before = (await ctx.tabs()).length;
+        await ctx.newTab(fixture.pageUrl);
+        const after = (await ctx.tabs()).length;
+        expect4(after).toBe(before + 1);
+      }, opts.timeout);
+    }
+    if (opts.capabilities.multipleTabs) {
+      const title = "tabId remains valid for surviving tabs across concurrent close()";
+      const body = async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        const urls = [
+          "data:text/html,<title>A</title>",
+          "data:text/html,<title>B</title>",
+          "data:text/html,<title>C</title>",
+          "data:text/html,<title>D</title>"
+        ];
+        for (const t of await ctx.tabs()) {
+          try {
+            await ctx.closeTab(t.tabId);
+          } catch {}
+        }
+        if ((await ctx.tabs()).length === 0) {
+          await ctx.newTab(urls[0]);
+        }
+        const baseTabs = await ctx.tabs();
+        const opened = [];
+        for (let i = 0;i < urls.length; i++) {
+          if (i < baseTabs.length) {
+            await ctx.switchTab(baseTabs[i].tabId);
+            await ctx.navigate(urls[i]);
+            opened.push(baseTabs[i].tabId);
+          } else {
+            const t = await ctx.newTab(urls[i]);
+            opened.push(t.tabId);
+          }
+        }
+        const [aId, bId, cId, dId] = opened;
+        await Promise.all([ctx.closeTab(aId), ctx.closeTab(bId)]);
+        await ctx.switchTab(cId);
+        expect4(await ctx.currentUrl()).toBe(urls[2]);
+        await ctx.switchTab(dId);
+        expect4(await ctx.currentUrl()).toBe(urls[3]);
+      };
+      if (expectFail("tabs.concurrentCloseStable")) {
+        itExpectFail(title, body, opts.timeout);
+      } else {
+        it5(title, body, opts.timeout);
+      }
+    } else {
+      it5("single-view: closeTab on the sole tab disconnects or no-ops", async () => {
+        if (!ctx)
+          throw new Error("context not created");
+        const [t] = await ctx.tabs();
+        try {
+          await ctx.closeTab(t.tabId);
+        } catch {}
+        if (ctx.isConnected()) {
+          const after = await ctx.tabs();
+          expect4(after.length).toBeLessThanOrEqual(1);
+        }
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/browser-context/runIBrowserContextConformance.ts
+function runIBrowserContextConformance(opts) {
+  describe5.skipIf(opts.skip)(`IBrowserContext conformance: ${opts.name}`, () => {
+    const fixture = resolveFixture(opts.fixture);
+    capabilityHonestyBlock(opts, fixture);
+    tabsLifecycleBlock(opts, fixture);
+    ariaRoundTripBlock(opts, fixture);
+    networkIntrospectionBlock(opts, fixture);
+  });
+}
+export {
+  ConformanceMockContext,
+  DEFAULT_FIXTURE,
+  ariaRoundTripBlock,
+  capabilityHonestyBlock,
+  itExpectFail,
+  networkIntrospectionBlock,
+  resolveFixture,
+  runIBrowserContextConformance,
+  tabsLifecycleBlock
+};
+
+//# debugId=CFA08057753935AD64756E2164756E21