@testspectra/matchers 1.1.11-rc.5 → 1.1.13

package/src/worker_config.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared worker-runtime configuration contract.
+ *
+ * This is the single source of truth for the shape of `globalThis.__TESTSPECTRA_CONFIG__`, the
+ * runtime config object every host injects before the shared DSL is exercised:
+ *
+ * - E2E: the Rust orchestrator writes it into the Bun worker script
+ *   (`core/orchestrator/src/worker_runtime.rs`) — one worker per spec batch.
+ * - Component testing: `@testspectra/react`'s browser prelude publishes it
+ *   (`tools/react/src/prelude.ts`) — one page per spec file.
+ *
+ * `core/worker-runtime/src/harness/config.ts`'s `getWorkerConfig()` reads it back with the
+ * priority: in-memory override → this global → `process.env.TESTSPECTRA_CONFIG` → hard defaults,
+ * so both hosts resolve runtime knobs (step delay, implicit wait, env vars, network monitoring)
+ * identically instead of each keeping a private config shape.
+ */
+
+/** Metadata for an auto-discovered Page Object class. */
+export interface PageObjectInfo {
+  name: string;
+  file_path: string;
+}
+
+/** Metadata for an auto-discovered Fixture data file. */
+export interface FixtureInfo {
+  name: string;
+  file_path: string;
+  is_json: boolean;
+}
+
+/** Metadata for an auto-discovered Step definition. */
+export interface StepInfo {
+  name: string;
+  file_path: string;
+}
+
+/** Metadata for an auto-discovered custom Action. */
+export interface ActionInfo {
+  name: string;
+  file_path: string;
+}
+
+/** Metadata for an auto-discovered lifecycle Hook. */
+export interface HookInfo {
+  hook_type: 'before' | 'after' | 'beforeEach' | 'afterEach' | string;
+  file_path: string;
+}
+
+/** Auto-import manifest containing all discovered support files. */
+export interface AutoImportManifestConfig {
+  page_objects?: PageObjectInfo[];
+  fixtures?: FixtureInfo[];
+  steps?: StepInfo[];
+  actions?: ActionInfo[];
+  global_hooks?: HookInfo[];
+  suite_hooks?: Record<string, HookInfo[]>;
+}
+
+/** One targeted test case inside a worker's batch. */
+export interface TestCaseTargetItem {
+  id: string;
+  title: string;
+  filePath: string;
+  suite: string;
+}
+
+/**
+ * Runtime configuration injected by a host (Rust orchestrator or `@testspectra/react`) via
+ * `globalThis.__TESTSPECTRA_CONFIG__`.
+ */
+export interface TestSpectraWorkerConfig {
+  workerId?: number;
+  rootDir: string;
+  testFilePath?: string;
+  testFiles?: TestCaseTargetItem[];
+  activePlatform: string;
+  configuredBaseUrl: string;
+  cdpWsUrl: string;
+  driverServerUrl: string;
+  manifest?: AutoImportManifestConfig;
+  /** Target app package (Android). Paired with androidSerial/adbPath for on-demand adb actions. */
+  appPackage?: string;
+  /** Target adb device serial for this worker (Android only). */
+  androidSerial?: string;
+  /** Resolved `adb` binary path (Android only), paired with androidSerial above. */
+  adbPath?: string;
+  /** Host port this worker's own MobileMockProxyServer should listen on (Android only). */
+  mockProxyPort?: number;
+  implicitWaitMs?: number;
+  timeoutMs?: number;
+  stepDelayMs?: number;
+  /** Video recording options or boolean toggle */
+  video?: boolean | Record<string, any>;
+  /** Configured host aliases (e.g. auth: 'http://auth.local'). */
+  hosts?: Record<string, string>;
+  /** Mirrors `spectra.config.ts`'s `executionConfig.networkMonitoringEnabled` (default: true). */
+  networkMonitoringEnabled?: boolean;
+  /** Mirrors `spectra.config.ts`'s `executionConfig.monitoredDomains`. Empty/absent = capture all. */
+  monitoredDomains?: { domain: string; enabled: boolean }[];
+  /** Mirrors `spectra.config.ts`'s `executionConfig.environmentVariables`. */
+  environmentVariables?: Record<string, string>;
+}

package/tsconfig.json

@@ -13,5 +13,5 @@
     "forceConsistentCasingInFileNames": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/**/__tests__/**", "src/runtime/**"]
+  "exclude": ["node_modules", "dist", "src/**/__tests__/**"]
 }

package/src/runtime/assertions.ts

@@ -1,454 +0,0 @@
-/**
- * Fluent assertion matchers for `SingleElementProxy`.
- *
- * Each matcher polls the bound `PlatformDriverBridge` (or the delegated state getters) with
- * `trackStep('assertion')` instrumentation. There is zero `activePlatform` branching here —
- * platform-specific behavior lives entirely in the driver's `isClickable` / `hasClass` /
- * state-inspection methods.
- */
-
-import type { AssertionOptions, ScopedSelector } from '../types.js';
-
-export function createElementAssertions(
-  selector: string | ScopedSelector,
-  index: number | null,
-  state: Record<string, any>,
-): Record<string, any> {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-  const selectorText = typeof selector === 'string' ? selector : selector.selector;
-
-  async function shouldBeVisible(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.visible', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isVisible(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be visible`);
-      },
-    );
-  }
-
-  async function shouldNotBeVisible(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.visible', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isVisible()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be visible`);
-      },
-    );
-  }
-
-  async function shouldExist(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'exist', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isExisting(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to exist in DOM`);
-      },
-    );
-  }
-
-  async function shouldNotExist(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.exist', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isExisting()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to exist in DOM`);
-      },
-    );
-  }
-
-  async function shouldBeEnabled(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.enabled', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isEnabled(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be enabled`);
-      },
-    );
-  }
-
-  async function shouldBeDisabled(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.disabled', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isEnabled()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be disabled`);
-      },
-    );
-  }
-
-  async function shouldBeClickable(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.clickable', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => driver().isClickable(selector, index),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be clickable`);
-      },
-    );
-  }
-
-  async function shouldNotBeClickable(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.clickable', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await driver().isClickable(selector, index)),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be clickable`);
-      },
-    );
-  }
-
-  async function shouldBeChecked(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.checked', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isChecked(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be checked`);
-      },
-    );
-  }
-
-  async function shouldNotBeChecked(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.checked', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isChecked()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be checked`);
-      },
-    );
-  }
-
-  async function shouldBeFocused(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'be.focused', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => state.isFocused(),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to be focused`);
-      },
-    );
-  }
-
-  async function shouldNotBeFocused(options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.be.focused', target: selector, args: [] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await state.isFocused()),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to be focused`);
-      },
-    );
-  }
-
-  async function shouldHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.value', target: selector, args: [value] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getValue();
-          return actual === String(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" to have value "${value}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotHaveValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.value', target: selector, args: [value] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getValue();
-          return actual !== String(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have value "${value}"`);
-      },
-    );
-  }
-
-  async function shouldContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'contain.value', target: selector, args: [value] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getValue();
-          return actual.includes(String(value));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" to contain value "${value}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotContainValue(value: unknown, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.contain.value', target: selector, args: [value] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getValue();
-          return !actual.includes(String(value));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain value "${value}"`);
-      },
-    );
-  }
-
-  async function shouldHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.text', target: selector, args: [expected] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getText();
-          if (expected instanceof RegExp) return expected.test(actual);
-          return actual === String(expected) || actual.trim() === String(expected).trim();
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (expected instanceof RegExp)
-            throw new Error(`Expected element "${selectorText}" text to match ${expected}, but got "${actual}"`);
-          throw new Error(`Expected element "${selectorText}" to have text "${expected}", but got "${actual}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldNotHaveText(expected: string | RegExp, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.text', target: selector, args: [expected] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          if (!(await state.isExisting())) return false;
-          actual = await state.getText();
-          if (expected instanceof RegExp) return !expected.test(actual);
-          return actual !== String(expected) && actual.trim() !== String(expected).trim();
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (expected instanceof RegExp)
-            throw new Error(`Expected element "${selectorText}" text not to match ${expected}`);
-          throw new Error(`Expected element "${selectorText}" not to have text "${expected}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldContainText(substring: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'contain.text', target: selector, args: [substring] },
-      async () => {
-        let actual = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getText();
-          return actual.includes(String(substring));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok)
-          throw new Error(`Expected element "${selectorText}" to contain text "${substring}", but got "${actual}"`);
-      },
-    );
-  }
-
-  async function shouldNotContainText(substring: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.contain.text', target: selector, args: [substring] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getText();
-          return !actual.includes(String(substring));
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to contain text "${substring}"`);
-      },
-    );
-  }
-
-  async function shouldHaveClass(className: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.class', target: selector, args: [className] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          () => driver().hasClass(selector, className, index),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" to have class "${className}"`);
-      },
-    );
-  }
-
-  async function shouldNotHaveClass(className: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.class', target: selector, args: [className] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-          async () => !(await driver().hasClass(selector, className, index)),
-          options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs(),
-        );
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have class "${className}"`);
-      },
-    );
-  }
-
-  async function shouldHaveAttribute(name: string, value?: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.attr', target: selector, args: value !== undefined ? [name, value] : [name] },
-      async () => {
-        let actual: string | null = null;
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          actual = await state.getAttribute(name);
-          if (value !== undefined) return actual === String(value);
-          return actual !== null;
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) {
-          if (value !== undefined)
-            throw new Error(
-              `Expected element "${selectorText}" to have attribute "${name}" = "${value}", but got "${actual}"`,
-            );
-          throw new Error(`Expected element "${selectorText}" to have attribute "${name}"`);
-        }
-      },
-    );
-  }
-
-  async function shouldNotHaveAttribute(name: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.attr', target: selector, args: [name] },
-      async () => {
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const actual = await state.getAttribute(name);
-          return actual === null;
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have attribute "${name}"`);
-      },
-    );
-  }
-
-  async function shouldHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'have.css', target: selector, args: [property, value] },
-      async () => {
-        const norm = (v: any) =>
-          String(v ?? '')
-            .replace(/\s+/g, '')
-            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-            .toLowerCase();
-        let actualCss = '';
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const css = await state.getCSSProperty(property);
-          actualCss = css.value;
-          return norm(actualCss) === norm(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok)
-          throw new Error(
-            `Expected element "${selectorText}" to have CSS "${property}" = "${value}", but got "${actualCss}"`,
-          );
-      },
-    );
-  }
-
-  async function shouldNotHaveCss(property: string, value: string, options?: AssertionOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'assertion',
-      { type: 'assertion', key: 'not.have.css', target: selector, args: [property, value] },
-      async () => {
-        const norm = (v: any) =>
-          String(v ?? '')
-            .replace(/\s+/g, '')
-            .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-            .toLowerCase();
-        const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-          const css = await state.getCSSProperty(property);
-          return norm(css.value) !== norm(value);
-        }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-        if (!ok) throw new Error(`Expected element "${selectorText}" not to have CSS "${property}" = "${value}"`);
-      },
-    );
-  }
-
-  return {
-    shouldBeVisible,
-    shouldNotBeVisible,
-    shouldExist,
-    shouldNotExist,
-    shouldBeEnabled,
-    shouldBeDisabled,
-    shouldBeClickable,
-    shouldNotBeClickable,
-    shouldBeChecked,
-    shouldNotBeChecked,
-    shouldBeFocused,
-    shouldNotBeFocused,
-    shouldHaveValue,
-    shouldNotHaveValue,
-    shouldContainValue,
-    shouldNotContainValue,
-    shouldHaveText,
-    shouldNotHaveText,
-    shouldContainText,
-    shouldNotContainText,
-    shouldHaveClass,
-    shouldNotHaveClass,
-    shouldHaveAttribute,
-    shouldNotHaveAttribute,
-    shouldHaveCss,
-    shouldNotHaveCss,
-  };
-}
-
-globalThis.__TS_RUNTIME__.createElementAssertions = createElementAssertions;