@itmetsam/samurai-framework 0.17.0 → 0.18.0

package/dist/capabilities.d.ts

@@ -31,6 +31,8 @@ export declare const CAPABILITIES: {
     readonly recorderStartStatus: true;
     /** `outputDir` on `runTests` and `runFlowInProject`: a folder per run for the report and the screenshots. */
     readonly outputDir: true;
+    /** `runFlowInProject`'s `outputDir` gives each node its own folder, `nodes/<node id>/`. */
+    readonly flowNodeFolders: true;
 };
 /** The shape of {@link CAPABILITIES}. */
 export type Capabilities = typeof CAPABILITIES;

package/dist/capabilities.js

@@ -31,4 +31,6 @@ export const CAPABILITIES = {
     recorderStartStatus: true,
     /** `outputDir` on `runTests` and `runFlowInProject`: a folder per run for the report and the screenshots. */
     outputDir: true,
+    /** `runFlowInProject`'s `outputDir` gives each node its own folder, `nodes/<node id>/`. */
+    flowNodeFolders: true,
 };

package/dist/flows/run/handlers/support.js

@@ -7,7 +7,7 @@ export const fail = (e) => ({
 export async function runNodeTests(node, run, list) {
     let result;
     try {
-        result = await run.runTests(list, (e) => run.onTestEvent(node.id, e), run.nodeBrowsers?.[node.id]);
+        result = await run.runTests(node.id, list, (e) => run.onTestEvent(node.id, e), run.nodeBrowsers?.[node.id]);
     }
     catch (e) {
         return fail(e);

package/dist/flows/run/handlers/types.d.ts

@@ -14,7 +14,7 @@ export interface HandlerRun {
     /** The browsers of the nodes that have their own (a Group node's group); the others use the project's */
     nodeBrowsers?: Record<string, SupportedBrowser[]>;
     signal: AbortSignal;
-    runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void, browsers?: SupportedBrowser[]) => Promise<"passed" | "failed" | "cancelled">;
+    runTests: (nodeId: string, tests: NodeTest[], onEvent: (e: RunEvent) => void, browsers?: SupportedBrowser[]) => Promise<"passed" | "failed" | "cancelled">;
     sleep: (ms: number, signal: AbortSignal) => Promise<void>;
     onTestEvent: (nodeId: string, e: RunEvent) => void;
     /** Definitions of kinds core doesn't have (steps), for expression scopes */

package/dist/flows/run/node-pool.d.ts

@@ -4,6 +4,6 @@ import type { WorkItem } from "../../runner/worker-protocol.js";
 import type { SupportedBrowser } from "../../types/browser.js";
 import type { NodeTest } from "./events.js";
 /** The work items of a node: each test in each browser, the browsers one after the other */
-export declare function itemsOf(tests: NodeTest[], browsers: readonly SupportedBrowser[]): WorkItem[];
+export declare function itemsOf(tests: NodeTest[], browsers: readonly SupportedBrowser[], outputDir?: string): WorkItem[];
 /** Runs the tests of a node on the pool and reports them as a run would */
 export declare function runOnPool(pool: Pick<WorkerPool, "run">, items: WorkItem[], onEvent: (event: RunEvent) => void, signal: AbortSignal): Promise<"passed" | "failed" | "cancelled">;

package/dist/flows/run/node-pool.js

@@ -1,7 +1,12 @@
 /** The work items of a node: each test in each browser, the browsers one after the other */
-export function itemsOf(tests, browsers) {
+export function itemsOf(tests, browsers, outputDir) {
     return browsers
-        .flatMap((browser) => tests.map((t) => ({ file: t.file, testName: t.name, browser })))
+        .flatMap((browser) => tests.map((t) => ({
+        file: t.file,
+        testName: t.name,
+        browser,
+        ...(outputDir !== undefined && { outputDir }),
+    })))
         .map((item, index) => ({ ...item, index }));
 }
 /** Runs the tests of a node on the pool and reports them as a run would */

package/dist/flows/run/project-options.d.ts

@@ -20,7 +20,11 @@ export interface RunFlowInProjectOptions extends ProjectOptions {
     /** `"fail"` (default): a flow with a node that can't run is refused. `"skip"`: those nodes are skipped. */
     unsupported?: "fail" | "skip";
     port?: number;
-    /** The folder the tests' named screenshots go in, instead of `<project>/result` (see `runTests`). Relative to the project folder */
+    /**
+     * The folder for the tests' named screenshots, instead of `<project>/result` (see `runTests`). Each node writes to
+     * `nodes/<node id>/` inside it, so a test that runs in two nodes keeps both sets; screenshot paths in a node's
+     * results are relative to that folder. Relative to the project folder
+     */
     outputDir?: string;
     /**
      * How many worker processes the tests of the whole run share: a number, or a percentage like `"50%"`. Unset

package/dist/flows/run/project.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { cleanName } from "../../browser/evidence.js";
 import { DEFAULT_SRC_DIR } from "../../config/defaults.js";
 import { projectConfig } from "../../config/config.js";
 import { checkFlow, withKeys, } from "../core/index.js";
@@ -176,9 +177,6 @@ async function walkFlowInProject(options) {
                 ...(options.headless !== undefined && {
                     headless: options.headless,
                 }),
-                ...(options.outputDir !== undefined && {
-                    outputDir: options.outputDir,
-                }),
                 files,
                 basePort: options.port ?? DEFAULT_PORT,
                 ...(retries > 0 && { retries }),
@@ -197,9 +195,13 @@ async function walkFlowInProject(options) {
             unsupported,
             handlers: { ...HANDLERS, ...steps.handlers },
             nodes: steps.nodes,
-            runTests: async ({ tests, onEvent, signal, browsers }) => {
+            runTests: async ({ nodeId, tests, onEvent, signal, browsers }) => {
+                // Each node gets a folder of its own: the same test in two nodes would overwrite its screenshots
+                const outputDir = options.outputDir !== undefined
+                    ? path.join(options.outputDir, "nodes", cleanName(nodeId))
+                    : undefined;
                 if (pool)
-                    return runOnPool(pool, itemsOf(tests, browsers ?? browsersFor({ project: config.browsers })), onEvent, signal);
+                    return runOnPool(pool, itemsOf(tests, browsers ?? browsersFor({ project: config.browsers }), outputDir), onEvent, signal);
                 const summary = await run({
                     projectDir,
                     config,
@@ -217,9 +219,7 @@ async function walkFlowInProject(options) {
                     files: [...new Set(tests.map((t) => t.file))],
                     testNames: tests.map((t) => t.name),
                     reportPath: false,
-                    ...(options.outputDir !== undefined && {
-                        outputDir: options.outputDir,
-                    }),
+                    ...(outputDir !== undefined && { outputDir }),
                     signal,
                     onEvent,
                 });

package/dist/flows/run/run.d.ts

@@ -20,6 +20,8 @@ export interface RunFlowOptions {
     signal?: AbortSignal;
     onEvent?: (event: FlowEvent) => void;
     runTests: (input: {
+        /** The node the tests are for: a node runs at most once in a run */
+        nodeId: string;
         tests: NodeTest[];
         onEvent: (e: RunEvent) => void;
         signal: AbortSignal;

package/dist/flows/run/run.js

@@ -34,7 +34,8 @@ export async function runFlow(options) {
         ...(options.nodeBrowsers && { nodeBrowsers: options.nodeBrowsers }),
         signal,
         sleep: options.sleep ?? defaultSleep,
-        runTests: (tests, onTestEvent, browsers) => options.runTests({
+        runTests: (nodeId, tests, onTestEvent, browsers) => options.runTests({
+            nodeId,
             tests,
             onEvent: onTestEvent,
             signal,

package/dist/runner/worker-protocol.d.ts

@@ -11,6 +11,8 @@ export interface WorkItem {
     browser: SupportedBrowser;
     /** Items with the same key never run at the same time */
     serialKey?: string;
+    /** Where this test's screenshots go, instead of the run's `outputDir` (a flow gives each node its own) */
+    outputDir?: string;
 }
 /** What a worker needs to start: the project and the settings that are the same for every test */
 export interface WorkerInit {

package/dist/runner/worker-session.js

@@ -36,7 +36,7 @@ export function openSession(init) {
             });
             resolve({
                 tests: loaded.all,
-                async runTest(test, browser, signal, onEvent) {
+                async runTest(test, browser, signal, onEvent, perTest = {}) {
                     const reporter = new TestReporter({
                         environment: run.settings.environment,
                         browsers: [browser],
@@ -48,8 +48,8 @@ export function openSession(init) {
                         ...(init.reportPath !== undefined && {
                             reportPath: init.reportPath,
                         }),
-                        ...(init.outputDir !== undefined && {
-                            outputDir: init.outputDir,
+                        ...((perTest.outputDir ?? init.outputDir) !== undefined && {
+                            outputDir: perTest.outputDir ?? init.outputDir,
                         }),
                         port,
                         signal,

package/dist/runner/worker.d.ts

@@ -6,7 +6,9 @@ import type { FromWorker, ToWorker, WorkerInit } from "./worker-protocol.js";
 export interface WorkerSession {
     tests: readonly RegisteredTestCase[];
     /** Runs one test; `onEvent` gets the reporter's events for it. Aborting `signal` ends the test as aborted */
-    runTest(test: RegisteredTestCase, browser: SupportedBrowser, signal: AbortSignal, onEvent: (event: RunEvent) => void): Promise<void>;
+    runTest(test: RegisteredTestCase, browser: SupportedBrowser, signal: AbortSignal, onEvent: (event: RunEvent) => void, options?: {
+        outputDir?: string;
+    }): Promise<void>;
     /** Ends the project's session */
     close(): Promise<void>;
 }

package/dist/runner/worker.js

@@ -54,7 +54,7 @@ export function handleMessages(channel, { open, exit }) {
                     id,
                     result: { ...event.result, worker: workerIndex },
                 });
-            });
+            }, item.outputDir !== undefined ? { outputDir: item.outputDir } : {});
         }
         finally {
             current = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Browser test framework over WebDriver BiDi: auto-waiting locators, environments and secrets, a recorder, and a command line.",
   "main": "dist/api.js",
   "exports": {