@solidxai/core 0.1.15 → 0.1.16-beta.1

package/src/testing/runner/read-scenarios-file.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+
+import type { ScenarioSpec, TestingDataRecord } from "../contracts/testing-metadata.types";
+
+/**
+ * Result of reading a scenario JSON file. `ok:false` means the file was missing,
+ * unreadable, or contained invalid JSON — never a thrown error.
+ */
+export interface ReadScenariosResult {
+  scenarios: ScenarioSpec[];
+  data?: TestingDataRecord[];
+  ok: boolean;
+  error?: string;
+}
+
+/**
+ * Read + parse an application's scenario file `{ testing: { scenarios, data } }` from an
+ * absolute path, on the WORKER tier (which shares the filesystem with the caller in the
+ * default single-process deployment). Tolerant by design — mirrors
+ * ScenarioFileService.resolvePayload in testingHub — so a concurrent editor half-writing
+ * the file, a deleted file (TOCTOU between existsSync and readFileSync), or invalid JSON
+ * returns `{ ok:false }` instead of throwing. The worker fails the run loudly on `ok:false`.
+ *
+ * Lives in core (not testingHub) because the worker is a core component and must not import
+ * testingHub code.
+ */
+export function readScenariosFile(absPath: string): ReadScenariosResult {
+  if (!absPath || !fs.existsSync(absPath)) {
+    return { scenarios: [], ok: false, error: "file_not_found" };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+    const rawScenarios =
+      parsed?.testing?.scenarios ??
+      parsed?.scenarios ??
+      (Array.isArray(parsed) ? parsed : []);
+    const scenarios: ScenarioSpec[] = Array.isArray(rawScenarios) ? rawScenarios : [];
+    const rawData = parsed?.testing?.data ?? parsed?.data;
+    const data: TestingDataRecord[] | undefined = Array.isArray(rawData) ? rawData : undefined;
+    return { scenarios, data, ok: true };
+  } catch (err) {
+    return { scenarios: [], ok: false, error: (err as Error)?.message || "read_error" };
+  }
+}

package/src/testing/runner/run-from-metadata.ts

@@ -1,5 +1,5 @@
 import type { Reporter } from "../reporter/reporter.types";
-import type { TestingMetadata, TestingDataRecord } from "../contracts/testing-metadata.types";
+import type { TestingMetadata, TestingDataRecord, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { ApiAdapterOptions } from "../adapters/api/api.types";
 import type { PlaywrightAdapterOptions } from "../adapters/ui/ui.types";
 import { ApiAdapter } from "../adapters/api/api-adapter";
@@ -13,7 +13,9 @@ import { StepRegistry } from "../core/step-registry";
 import { SpecRegistry } from "../core/spec-registry";
 import { TestingEngine } from "../core/testing-engine";
 import { filterScenarios } from "./scenario-filter";
+import { collectSecretKeys } from "../core/interpolation";
 import { ensureUiStarted, scenarioNeedsUi } from "./lifecycle";
+import { ensureChromiumInstalled } from "../adapters/ui/browser-provisioner";
 import { ConsoleReporter } from "../reporter/console-reporter";
 
 
@@ -31,7 +33,11 @@ function buildTestDataIndex(data?: TestingDataRecord[]): Record<string, Record<s
 }
 
 export type RunnerOptions = {
-  metadata: TestingMetadata;
+  metadata?: TestingMetadata;
+  scenarios?: ScenarioSpec[];
+  data?: TestingDataRecord[];
+  externalRunId?: string;
+  env?: Record<string, string>;
   scenarioIds?: string[];
   includeTags?: string[];
   skipScenarioIds?: string[];
@@ -41,8 +47,59 @@ export type RunnerOptions = {
   defaults?: { timeoutMs?: number; retries?: number };
   options?: { printApiLogs?: boolean };
   specs?: (registry: SpecRegistry) => void;
+  /**
+   * Resolves `${secret:...}` references against the secret store. Injected by the
+   * caller so this runner stays free of database and DI coupling. Required only if a
+   * scenario actually references a secret.
+   */
+  resolveSecrets?: (keys: string[]) => Promise<Record<string, any>>;
 };
 
+/**
+ * Resolves every secret referenced by the scenarios about to run, in one call, and
+ * returns a per-scenario view of the result.
+ *
+ * Partitioned deliberately: ctxBase is shared across scenarios, so handing every
+ * scenario the whole map would let each read secrets belonging to the others.
+ */
+async function resolveSecretsByScenario(
+  scenarios: ScenarioSpec[],
+  resolveSecrets?: RunnerOptions["resolveSecrets"],
+): Promise<Map<string, Record<string, any>>> {
+  const keysByScenario = new Map<string, string[]>();
+  const allKeys = new Set<string>();
+
+  for (const scenario of scenarios) {
+    const keys = collectSecretKeys(scenario);
+    if (keys.length === 0) continue;
+    keysByScenario.set(scenario.id, keys);
+    keys.forEach((key) => allKeys.add(key));
+  }
+
+  if (allKeys.size === 0) return new Map();
+
+  if (!resolveSecrets) {
+    throw new Error(
+      `Scenarios reference secrets (${[...allKeys].join(", ")}) but no secret resolver was provided to the runner.`,
+    );
+  }
+
+  // Resolved up front so a missing secret fails the run before any scenario executes.
+  const resolved = await resolveSecrets([...allKeys]);
+
+  const byScenario = new Map<string, Record<string, any>>();
+  for (const [scenarioId, keys] of keysByScenario) {
+    byScenario.set(
+      scenarioId,
+      keys.reduce((acc, key) => {
+        acc[key] = resolved[key];
+        return acc;
+      }, {} as Record<string, any>),
+    );
+  }
+  return byScenario;
+}
+
 export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
   const startedAt = Date.now();
   const registry = new StepRegistry();
@@ -53,37 +110,58 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
   registerTestSteps(registry);
 
   const engine = new TestingEngine(registry, opts.defaults);
-  const scenarios = filterScenarios(opts.metadata.testing.scenarios, {
+  const allScenarios = opts.scenarios ?? opts.metadata?.testing?.scenarios ?? [];
+  const scenarios = filterScenarios(allScenarios, {
     scenarioIds: opts.scenarioIds,
     includeTags: opts.includeTags,
     skipScenarioIds: opts.skipScenarioIds,
   });
 
   const specRegistry = new SpecRegistry();
-  const testData = buildTestDataIndex(opts.metadata.testing?.data);
+  const testData = buildTestDataIndex(opts.data ?? opts.metadata?.testing?.data);
   if (opts.specs) {
     opts.specs(specRegistry);
   }
 
+  // Fetch the browser before the reporter starts drawing its footer, so the download
+  // gets a clean terminal and a missing browser fails before any scenario runs.
+  if (scenarios.some(scenarioNeedsUi)) {
+    await ensureChromiumInstalled();
+  }
+
   const resources = new SimpleResourceStore();
-  const reporter = opts.reporter ?? new ConsoleReporter();
-  reporter.onRunStart?.({ total: scenarios.length });
+  const reporter: Reporter = opts.reporter ?? new ConsoleReporter();
   const api = new ApiAdapter(opts.api);
   const { PlaywrightAdapter } = await import("../adapters/ui/playwright-adapter");
   const ui = new PlaywrightAdapter(opts.ui);
-  const ctxBase = { resources, reporter, api, ui, specRegistry, testData, options: opts.options };
+  const ctxBase = { resources, reporter, api, ui, specRegistry, testData, env: opts.env, options: opts.options };
   const uiStarted = { value: false };
   let passed = 0;
   let failed = 0;
   let runError: unknown;
 
+  reporter.onRunStart?.({
+    total: scenarios.length,
+    startedAt: new Date(startedAt).toISOString(),
+    scenarioIds: scenarios.map((s) => s.id),
+    scenarios: scenarios.map((s) => ({ id: s.id, name: s.name, type: s.type })),
+  });
+
   try {
+    // One query for the whole run, after onRunStart so a failure here still reports
+    // run.end. Keys that do not resolve are not fatal — they surface at the step that
+    // references them, where the reporter can name the token and locate the failure.
+    const secretsByScenario = await resolveSecretsByScenario(scenarios, opts.resolveSecrets);
+
     for (const scenario of scenarios) {
       if (scenarioNeedsUi(scenario)) {
         await ensureUiStarted(ctxBase, uiStarted);
       }
       try {
-        await engine.runScenario(scenario, ctxBase);
+        await engine.runScenario(scenario, {
+          ...ctxBase,
+          secrets: secretsByScenario.get(scenario.id),
+        });
         passed += 1;
       } catch (error) {
         failed += 1;
@@ -91,6 +169,11 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
         throw error;
       }
     }
+  } catch (error) {
+    // Also catches a setup failure before the loop (unreachable database, absent
+    // encryption key), which would otherwise leave runError unset and report ok: true.
+    runError = error;
+    throw error;
   } finally {
     reporter.onRunEnd?.({
       ok: !runError,
@@ -100,7 +183,17 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
       durationMs: Date.now() - startedAt,
     });
     if (uiStarted.value) {
-      await ui.stop();
+      // Only KEEP the whole-run video when the run FAILED — passing runs discard it unread.
+      const keepVideo = !!runError;
+      await ui.stop({ keepVideo });
+      // Video bytes are only finalized after ui.stop(); attach it as a run-level artifact so
+      // the reporter uploads it and references it on run.end (queued before flushPending runs).
+      if (keepVideo) {
+        const video = ui.getRunVideo?.();
+        if (video && reporter.attachRunArtifact) {
+          reporter.attachRunArtifact({ name: video.name, contentType: video.contentType, data: video.data });
+        }
+      }
     }
   }
 }

package/src/testing/steps/ui/navigation.step.ts

@@ -3,7 +3,7 @@ import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
 type GotoInput = { url: string; timeoutMs?: number };
-type ExpectUrlInput = { equals?: string; contains?: string };
+type ExpectUrlInput = { equals?: string; contains?: string; timeoutMs?: number };
 
 function requirePage(ctx: TestContext, op: string) {
   if (!ctx.ui || !ctx.ui.page) {
@@ -28,28 +28,32 @@ export function registerNavigationSteps(registry: StepRegistry): void {
   registry.register("ui.expectUrl", async (ctx: TestContext, step: OpStep) => {
     const page = requirePage(ctx, "ui.expectUrl");
     const input = (step.with ?? {}) as ExpectUrlInput;
-    const current = page.url();
 
-    if (input.equals !== undefined) {
-      if (current !== input.equals) {
-        throw new Error(
-          `Expected URL to equal "${input.equals}" but got "${current}"`,
-        );
-      }
-      return;
+    if (input.equals === undefined && input.contains === undefined) {
+      throw new Error(
+        'Missing "equals" or "contains" in step.with for op "ui.expectUrl"',
+      );
     }
 
-    if (input.contains !== undefined) {
-      if (!current.includes(input.contains)) {
-        throw new Error(
-          `Expected URL to contain "${input.contains}" but got "${current}"`,
-        );
-      }
-      return;
-    }
+    const expectation =
+      input.equals !== undefined
+        ? `equal "${input.equals}"`
+        : `contain "${input.contains}"`;
 
-    throw new Error(
-      'Missing "equals" or "contains" in step.with for op "ui.expectUrl"',
-    );
+    // Waits for the URL rather than sampling it, so an assertion placed straight
+    // after a click does not race the navigation.
+    try {
+      await page.waitForURL(
+        (url) =>
+          input.equals !== undefined
+            ? url.toString() === input.equals
+            : url.toString().includes(String(input.contains)),
+        { timeout: ctx.ui?.resolveNavigationTimeout(input.timeoutMs) },
+      );
+    } catch {
+      throw new Error(
+        `Expected URL to ${expectation} but got "${page.url()}"`,
+      );
+    }
   });
 }

package/dist/services/access-token-storage.service.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=access-token-storage.service.d.ts.map

package/dist/services/access-token-storage.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"access-token-storage.service.d.ts","sourceRoot":"","sources":["../../src/services/access-token-storage.service.ts"],"names":[],"mappings":""}

package/dist/services/access-token-storage.service.js

@@ -1 +0,0 @@
-//# sourceMappingURL=access-token-storage.service.js.map

package/dist/services/access-token-storage.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"access-token-storage.service.js","sourceRoot":"","sources":["../../src/services/access-token-storage.service.ts"],"names":[],"mappings":"","sourcesContent":[""]}