@delacour/warden-e2e 0.1.1 → 0.3.1

package/index.mjs

@@ -1,33 +1,37 @@
 // @bun
 import {
-  BUN_TIMEOUT_MARGIN_MS,
-  E2eError,
-  WARDEN_E2E_VERSION,
-  attemptDir,
-  attemptSession,
-  callerFile,
+  E2eError2,
   canObserve,
-  createScope,
-  currentScope,
   fieldValue,
-  flowIdOf,
-  getSession,
-  hash6,
-  hooksFor,
-  isLocator,
-  markOnly,
-  matchesText,
   normalizeText,
-  pickOne,
-  registrationDefaults,
-  renderHeader,
+  matchesText,
   renderSnapshot,
+  renderHeader,
   resolve,
-  resolveUse,
-  runInScope,
+  isLocator,
+  pickOne,
+  textOf,
+  isHidLost,
   runStep,
-  textOf
-} from "./chunk-qtkmfjbq.mjs";
+  attemptSession,
+  getSession,
+  perfStartFor,
+  hash6,
+  attemptDir,
+  specIdOf,
+  captureNativeLog,
+  callerFile,
+  BUN_TIMEOUT_MARGIN_MS2,
+  ownHook,
+  currentScope,
+  createScope,
+  runInScope,
+  hooksFor,
+  resolveUse,
+  registrationDefaults,
+  markOnly,
+  WARDEN_E2E_VERSION2
+} from "./chunk-8em9kgsk.mjs";
 // ../../packages/e2e/src/expect/expect.ts
 import { expect as bunExpect } from "bun:test";
 
@@ -47,22 +51,22 @@ function show(match) {
 function assertOptions(matcher, options, allowed) {
   const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
   if (unknown.length > 0) {
-    throw new E2eError("INVALID_ARGUMENT", `${matcher} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
+    throw new E2eError2("INVALID_ARGUMENT", `${matcher} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
   }
   const bag = options;
   for (const key of ["checked", "exact", "ignoreCase"]) {
     if (bag[key] !== undefined && typeof bag[key] !== "boolean") {
-      throw new E2eError("INVALID_ARGUMENT", `${matcher}: "${key}" must be a boolean`);
+      throw new E2eError2("INVALID_ARGUMENT", `${matcher}: "${key}" must be a boolean`);
     }
   }
   const timeout = bag.timeout;
   if (timeout !== undefined && (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout < 0)) {
-    throw new E2eError("INVALID_ARGUMENT", `${matcher}: "timeout" must be a non-negative number of milliseconds`);
+    throw new E2eError2("INVALID_ARGUMENT", `${matcher}: "timeout" must be a non-negative number of milliseconds`);
   }
 }
 function failUnlessRetryable(error) {
   if (!error.retryable)
-    throw new E2eError("DRIVER", `snapshot failed: ${error.code}: ${error.message}`);
+    throw new E2eError2("DRIVER", `snapshot failed: ${error.code}: ${error.message}`);
 }
 function regexTest(pattern, value, ignoreCase = false) {
   const flags = pattern.flags.replaceAll(/[gy]/g, "");
@@ -144,7 +148,7 @@ class LocatorAssertions {
         if (entry === undefined)
           return missing();
         if (entry.secure) {
-          throw new E2eError("INVALID_ARGUMENT", "toHaveValue cannot judge a secure field: its value is withheld. Assert the outcome of the fill instead.");
+          throw new E2eError2("INVALID_ARGUMENT", "toHaveValue cannot judge a secure field: its value is withheld. Assert the outcome of the fill instead.");
         }
         const value = fieldValue(entry);
         const matches = typeof expected === "string" ? value === expected : regexTest(expected, value);
@@ -188,7 +192,7 @@ class LocatorAssertions {
   async toHaveCount(expected, options = {}) {
     assertOptions("toHaveCount", options, ["timeout"]);
     if (!Number.isInteger(expected) || expected < 0) {
-      throw new E2eError("INVALID_ARGUMENT", `toHaveCount takes a non-negative integer, got ${String(expected)}`);
+      throw new E2eError2("INVALID_ARGUMENT", `toHaveCount takes a non-negative integer, got ${String(expected)}`);
     }
     return this.assert({
       call: `toHaveCount(${expected})`,
@@ -203,7 +207,7 @@ class LocatorAssertions {
     try {
       await rt.step(`expect ${this.locator}.${spec.call}`, () => this.poll(spec, timeoutMs));
     } catch (error) {
-      if (this.context.soft !== undefined && error instanceof E2eError && error.code !== "TIMEOUT") {
+      if (this.context.soft !== undefined && error instanceof E2eError2 && error.code !== "TIMEOUT") {
         this.context.soft(error);
         return;
       }
@@ -255,7 +259,7 @@ class LocatorAssertions {
 `)}
 
 ${screen}`;
-    return new E2eError("ASSERTION", message, screen);
+    return new E2eError2("ASSERTION", message, screen);
   }
 }
 function conditionHold(negate, holdMs, now) {
@@ -311,9 +315,9 @@ function currentSoftSink() {
 }
 var valueExpect = bunExpect;
 function asAssertion(error) {
-  if (error instanceof E2eError)
+  if (error instanceof E2eError2)
     return error;
-  return new E2eError("ASSERTION", error instanceof Error ? error.message : String(error));
+  return new E2eError2("ASSERTION", error instanceof Error ? error.message : String(error));
 }
 function isThenable(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
@@ -469,6 +473,19 @@ async function captureDevtoolsArtifacts(facet, dir, timeoutMs = CAPTURE_TIMEOUT_
   }
   return capture;
 }
+function nativeTarget(env) {
+  return env.platform === "ios" ? { platform: "ios", udid: env.udid, bundleId: env.bundleId } : { platform: "android", serial: env.udid, pkg: env.bundleId };
+}
+async function captureNativeArtifacts(target, deps, win, timeoutMs = CAPTURE_TIMEOUT_MS, budget = unlimited) {
+  const ms = Math.min(timeoutMs, budget());
+  if (ms <= 0)
+    return { files: [], problems: [`native log: ${SPENT}`] };
+  try {
+    return await limited(captureNativeLog(target, deps, { ...win, nowMs: Date.now(), timeoutMs: ms }), ms);
+  } catch (cause) {
+    return { files: [], problems: [`native log: ${message(cause)}`] };
+  }
+}
 
 // ../../packages/e2e/src/runner/trace.ts
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
@@ -582,7 +599,7 @@ var POST_DEADLINE_RESERVE_MS = 5000;
 var DEFAULT_TIMING = {
   cleanupTimeoutMs: CLEANUP_TIMEOUT_MS,
   captureTimeoutMs: CAPTURE_TIMEOUT_MS,
-  bunMarginMs: BUN_TIMEOUT_MARGIN_MS,
+  bunMarginMs: BUN_TIMEOUT_MARGIN_MS2,
   reserveMs: POST_DEADLINE_RESERVE_MS
 };
 var timing = { ...DEFAULT_TIMING };
@@ -594,7 +611,7 @@ function unavailable(name) {
     get(_target, prop) {
       if (typeof prop === "symbol" || prop === "then")
         return;
-      throw new E2eError("SESSION", `the \`${name}\` fixture is not available: no fixture factory is registered on the session`);
+      throw new E2eError2("SESSION", `the \`${name}\` fixture is not available: no fixture factory is registered on the session`);
     }
   });
 }
@@ -627,12 +644,12 @@ async function startFixture(entry, bag) {
     return;
   };
   let used = false;
-  const value = new Promise((resolve2, reject) => {
-    provide = resolve2;
+  const value = new Promise((resolve, reject) => {
+    provide = resolve;
     fail = reject;
   });
-  const released = new Promise((resolve2) => {
-    release = resolve2;
+  const released = new Promise((resolve) => {
+    release = resolve;
   });
   const finished = entry.setup(bag, async (v) => {
     used = true;
@@ -640,7 +657,7 @@ async function startFixture(entry, bag) {
     await released;
   }).then(() => {
     if (!used)
-      fail(new E2eError("INVALID_ARGUMENT", `fixture \`${entry.name}\` finished without calling use()`));
+      fail(new E2eError2("INVALID_ARGUMENT", `fixture \`${entry.name}\` finished without calling use()`));
   }, (error) => {
     if (!used)
       fail(error);
@@ -666,7 +683,7 @@ function cleanupDeadline(startedAt, timeoutMs, bunTimeoutMs) {
 function limited2(label, ms, fn) {
   let timer;
   const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new E2eError("TIMEOUT", `${label} timed out after ${ms}ms`)), ms);
+    timer = setTimeout(() => reject(new E2eError2("TIMEOUT", `${label} timed out after ${ms}ms`)), ms);
   });
   return Promise.race([fn(), timeout]).finally(() => clearTimeout(timer));
 }
@@ -681,13 +698,17 @@ function errorInfo(error) {
   if (error instanceof Error) {
     return {
       message: error.message,
-      ...error instanceof E2eError ? { code: error.code } : {},
+      ...error instanceof E2eError2 ? { code: error.code } : {},
       ...error.stack !== undefined ? { stack: error.stack } : {}
     };
   }
   return { message: String(error) };
 }
 async function runAttempt(session, spec) {
+  if (await runAttemptOnce(session, spec) === "again")
+    await runAttemptOnce(session, { ...spec });
+}
+async function runAttemptOnce(session, spec) {
   const { env } = session;
   const use = resolveUse(spec.scope, { timeoutMs: env.timeoutMs, actionTimeoutMs: env.actionTimeoutMs, assertionTimeoutMs: env.assertionTimeoutMs }, spec.timeout);
   const startedAt = Date.now();
@@ -696,7 +717,7 @@ async function runAttempt(session, spec) {
   const device = { udid: env.udid, platform: env.platform };
   const clock = !env.logTimestamps;
   const short = shortName(spec.file);
-  const dir = attemptDir(session.out, flowIdOf(spec.file, env.flowsDir), spec.title, hash6(spec.file, ...spec.title));
+  const dir = attemptDir(session.out, specIdOf(spec.file, env.specsDir), spec.title, hash6(spec.file, ...spec.title));
   const print = (line) => {
     if (line !== undefined)
       session.log(line);
@@ -721,57 +742,61 @@ async function runAttempt(session, spec) {
   const bound = attemptSession(session, () => binding ?? { context: ctx, finished: false });
   print(formatConsoleLine({ type: "test-start", test: { file: spec.file, title: [...spec.title], startedAt, device } }, { clock }));
   session.enterAttempt(ctx);
+  const teardowns = [];
+  const state = {};
+  let outcome = await raceDeadline(controller, use.timeoutMs, () => setUpAndRun(bound, spec, use, controller.signal, state, teardowns));
+  outcome = failIf(outcome, ctx.softFailures.length > 0, () => softFailureError(ctx.softFailures));
+  if (outcome.failed)
+    await captureFailureArtifacts(session, ctx, budget, startedAt);
+  const cleanupErrors = await runCleanup(session, spec, ctx, state.bag, teardowns, budget, (context) => {
+    binding = { context, finished: false };
+  });
+  const finished = new E2eError2("SESSION", "attempt finished");
+  if (!controller.signal.aborted)
+    controller.abort(finished);
+  binding = { context: { ...ctx, signal: AbortSignal.abort(finished), depth: 0 }, finished: true };
+  session.leaveAttempt(ctx);
+  trace.flush();
+  outcome = failIf(outcome, cleanupErrors.length > 0, () => cleanupErrors[0]);
+  return concludeAttempt(session, spec, ctx, { startedAt, device }, outcome, print, clock);
+}
+async function raceDeadline(controller, timeoutMs, run) {
   let deadlineHit = false;
   const timer = setTimeout(() => {
     deadlineHit = true;
-    controller.abort(new E2eError("TIMEOUT", `test timed out after ${use.timeoutMs}ms`));
-  }, use.timeoutMs);
+    controller.abort(new E2eError2("TIMEOUT", `test timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
   const deadline = new Promise((_, reject) => {
     controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
   });
   deadline.catch(() => {
     return;
   });
-  const teardowns = [];
-  const state = {};
-  let failed = false;
-  let failure;
   try {
-    await Promise.race([setUpAndRun(bound, spec, use, controller.signal, state, teardowns), deadline]);
+    await Promise.race([run(), deadline]);
+    return { failed: false, failure: undefined, deadlineHit };
   } catch (error) {
-    failed = true;
-    failure = error;
+    return { failed: true, failure: error, deadlineHit };
   } finally {
     clearTimeout(timer);
   }
-  if (!failed && ctx.softFailures.length > 0) {
-    failed = true;
-    failure = softFailureError(ctx.softFailures);
-  }
-  if (failed)
-    await captureFailureArtifacts(session, ctx, budget);
-  const cleanupErrors = await runCleanup(session, spec, ctx, state.bag, teardowns, budget, (context) => {
-    binding = { context, finished: false };
-  });
-  const finished = new E2eError("SESSION", "attempt finished");
-  if (!controller.signal.aborted)
-    controller.abort(finished);
-  binding = { context: { ...ctx, signal: AbortSignal.abort(finished), depth: 0 }, finished: true };
-  session.leaveAttempt(ctx);
-  trace.flush();
-  if (!failed && cleanupErrors.length > 0) {
-    failed = true;
-    failure = cleanupErrors[0];
-  }
-  for (const shot of listScreenshots(dir))
-    files.add(shot);
-  const outcome = failed ? { failed: true, error: failure, timedOut: deadlineHit } : { failed: false };
-  const result = buildResult(spec, ctx, { startedAt, device }, outcome);
+}
+function failIf(outcome, present, failure) {
+  return outcome.failed || !present ? outcome : { ...outcome, failed: true, failure: failure() };
+}
+async function concludeAttempt(session, spec, ctx, run, outcome, print, clock) {
+  for (const shot of listScreenshots(ctx.dir))
+    ctx.files.add(shot);
+  const result = buildResult(spec, ctx, run, outcome.failed ? { failed: true, error: outcome.failure, timedOut: outcome.deadlineHit } : { failed: false });
   print(formatConsoleLine({ type: "test-end", result }, { clock }));
-  if (!failed || spec.final)
+  if (outcome.failed && session.recoverHid !== undefined && isHidLost(outcome.failure) && await session.recoverHid()) {
+    return "again";
+  }
+  if (!outcome.failed || spec.final)
     session.results.append(result);
-  if (failed)
-    throw failure instanceof Error ? failure : new Error(String(failure));
+  if (outcome.failed)
+    throw outcome.failure instanceof Error ? outcome.failure : new Error(String(outcome.failure));
+  return;
 }
 function softFailureError(failures) {
   if (failures.length === 1 && failures[0] !== undefined)
@@ -779,7 +804,7 @@ function softFailureError(failures) {
   const body = failures.map((failure, index) => `${index + 1}) ${failure.message}`).join(`
 
 `);
-  return new E2eError("ASSERTION", `${failures.length} soft assertions failed:
+  return new E2eError2("ASSERTION", `${failures.length} soft assertions failed:
 
 ${body}`, failures[0]?.screen);
 }
@@ -798,28 +823,43 @@ function buildResult(spec, ctx, run, outcome) {
   };
 }
 async function setUpAndRun(session, spec, use, signal, state, teardowns) {
-  const base2 = await buildBaseFixtures(session, signal, use);
-  const built = { ...base2 };
+  const base = await buildBaseFixtures(session, signal, use);
+  const built = { ...base };
   state.bag = built;
+  const perfNames = session.env.perf;
+  if (perfNames !== undefined) {
+    const { perf } = base.device;
+    await session.step("perf", "perf.start", () => perf.start(perfStartFor(perfNames)));
+    teardowns.push({
+      name: "perf",
+      run: async () => {
+        if (perf.active)
+          await perf.stop();
+      }
+    });
+  }
   if (use.launch === "fresh")
-    await session.step("app", "app.open", () => base2.app.open());
+    await session.step("app", "app.open", () => base.app.open());
   for (const entry of spec.fixtures) {
     const started = await session.step("fixture", entry.name, () => startFixture(entry, built));
     built[entry.name] = started.value;
     teardowns.push({ name: entry.name, run: started.teardown });
   }
-  for (const hook of hooksFor(spec.scope, "beforeEach")) {
+  for (const hook of hooksFor(spec.scope, "beforeEach", spec.fixtures)) {
     await session.step("hook", "beforeEach", async () => hook(built));
   }
   await spec.body(built);
 }
-async function captureFailureArtifacts(session, ctx, budget) {
+async function captureFailureArtifacts(session, ctx, budget, startedAt) {
   const driver = session.peekDriver();
   const facet = session.peekDevtools();
   const { captureTimeoutMs } = runnerTiming();
   const captures = [
     ...driver === undefined ? [] : [await captureFailure(driver, ctx.dir, captureTimeoutMs, budget)],
-    ...facet === undefined ? [] : [await captureDevtoolsArtifacts(facet, ctx.dir, captureTimeoutMs, budget)]
+    ...facet === undefined ? [] : [await captureDevtoolsArtifacts(facet, ctx.dir, captureTimeoutMs, budget)],
+    ...session.nativeLog === undefined ? [] : [
+      await captureNativeArtifacts(nativeTarget(session.env), session.nativeLog, { dir: ctx.dir, sinceMs: startedAt }, captureTimeoutMs, budget)
+    ]
   ];
   for (const capture of captures) {
     for (const file of capture.files)
@@ -840,21 +880,21 @@ async function runCleanup(session, spec, ctx, built, teardowns, budget, bind) {
     try {
       const left = budget();
       if (left <= 0)
-        throw new E2eError("TIMEOUT", `${label} skipped: the cleanup budget after the test is used up`);
+        throw new E2eError2("TIMEOUT", `${label} skipped: the cleanup budget after the test is used up`);
       await limited2(label, Math.min(timing.cleanupTimeoutMs, left), fn);
     } catch (error) {
       errors.push(error);
     }
   };
   if (built !== undefined) {
-    for (const hook of hooksFor(spec.scope, "afterEach")) {
+    for (const hook of hooksFor(spec.scope, "afterEach", spec.fixtures)) {
       await attempt("afterEach", () => step("hook", "afterEach", async () => hook(built)));
     }
   }
   for (const fixture of [...teardowns].reverse()) {
     await attempt(`fixture ${fixture.name} teardown`, () => step("fixture", `${fixture.name} teardown`, fixture.run));
   }
-  cleanup.abort(new E2eError("SESSION", "attempt finished"));
+  cleanup.abort(new E2eError2("SESSION", "attempt finished"));
   session.leaveAttempt(cleanupCtx);
   return errors;
 }
@@ -872,7 +912,7 @@ function registerTest(fixtures, mode, title, second, third) {
   const options = typeof second === "function" ? {} : second;
   const body = typeof second === "function" ? second : third;
   if (body === undefined) {
-    throw new E2eError("INVALID_ARGUMENT", `test("${title}"): the test body is missing`);
+    throw new E2eError2("INVALID_ARGUMENT", `test("${title}"): the test body is missing`);
   }
   const scope = currentScope();
   const file = callerFile();
@@ -910,7 +950,10 @@ function registerTest(fixtures, mode, title, second, third) {
     bunTest(title, run, bunOptions);
 }
 function eraseSetup(setup) {
-  return (base2, use) => setup(base2, use);
+  return (base, use) => setup(base, use);
+}
+function eraseHook(hook) {
+  return (fixtures) => hook(fixtures);
 }
 function isKeyOf(object, key) {
   return key in object;
@@ -919,21 +962,27 @@ function makeCallable(fixtures, mode) {
   return (title, second, third) => registerTest(fixtures, mode, title, second, third);
 }
 function makeTest(fixtures) {
-  const base2 = makeCallable(fixtures, "run");
-  return Object.assign(base2, {
+  const base = makeCallable(fixtures, "run");
+  return Object.assign(base, {
     skip: makeCallable(fixtures, "skip"),
     only: makeCallable(fixtures, "only"),
     todo(title) {
       bunTest.todo(title, () => {
-        throw new E2eError("INVALID_ARGUMENT", `test.todo("${title}") is not implemented`);
+        throw new E2eError2("INVALID_ARGUMENT", `test.todo("${title}") is not implemented`);
       });
     },
     skipIf(condition) {
       return makeCallable(fixtures, condition ? "skip" : "run");
     },
+    beforeEach(hook) {
+      currentScope().beforeEach.push(ownHook(eraseHook(hook), fixtures));
+    },
+    afterEach(hook) {
+      currentScope().afterEach.push(ownHook(eraseHook(hook), fixtures));
+    },
     use(options) {
       if (options.systemAlerts !== undefined && !SYSTEM_ALERTS.includes(options.systemAlerts)) {
-        throw new E2eError("INVALID_ARGUMENT", `test.use: systemAlerts must be one of ${SYSTEM_ALERTS.map((mode) => `"${mode}"`).join(", ")}, got ${JSON.stringify(options.systemAlerts)}`);
+        throw new E2eError2("INVALID_ARGUMENT", `test.use: systemAlerts must be one of ${SYSTEM_ALERTS.map((mode) => `"${mode}"`).join(", ")}, got ${JSON.stringify(options.systemAlerts)}`);
       }
       const scope = currentScope();
       if (options.timeout !== undefined && registered.has(scope)) {
@@ -957,7 +1006,7 @@ function describe(title, second, third) {
   const body = typeof second === "function" ? second : third;
   const options = typeof second === "function" ? {} : second;
   if (body === undefined)
-    throw new E2eError("INVALID_ARGUMENT", `describe("${title}"): the body is missing`);
+    throw new E2eError2("INVALID_ARGUMENT", `describe("${title}"): the body is missing`);
   const scope = createScope(title, options.serial === true);
   bunDescribe(title, () => runInScope(scope, body));
 }
@@ -986,13 +1035,13 @@ function afterAll(hook) {
   bunAfterAll(async () => hook(await sharedFixtures(scope)));
 }
 export {
-  test,
-  expect,
-  describe,
-  beforeEach,
-  beforeAll,
-  afterEach,
+  E2eError2 as E2eError,
+  WARDEN_E2E_VERSION2 as WARDEN_E2E_VERSION,
   afterAll,
-  WARDEN_E2E_VERSION,
-  E2eError
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delacour/warden-e2e",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "description": "TypeScript spec API for `warden e2e`: test, expect, screen, device, app",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "@delacour/warden": "0.1.1"
+    "@delacour/warden": "0.3.1"
   },
   "dependencies": {
     "zod": "^4.4.3"