@itmetsam/samurai-framework 0.2.3 → 0.4.0

package/dist/runner/groups.js

@@ -0,0 +1,58 @@
+import { matchesGlob, relative, resolve } from "node:path";
+/** The test folder when the config names none */
+export const DEFAULT_SRC_DIR = "./src";
+/** The spec pattern when a group names none */
+export const DEFAULT_TEST_MATCH = "**/*.spec.ts";
+/** Separators of any platform become `/` */
+export const toPosix = (p) => p.replace(/\\/g, "/");
+/** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */
+export const testId = (file, name) => `${toPosix(file)}::${name}`;
+/** Works out which of `tests` (files relative to `srcDir`) belong to the group */
+export function resolveGroup(group, tests, projectDir, srcDir) {
+    const found = tests.map((t) => ({ ...t, id: testId(t.file, t.name) }));
+    // Tests picked by hand override src and testMatch
+    if (group.tests) {
+        const known = new Set(found.map((t) => t.id));
+        const picked = group.tests.map(({ file, title }) => ({
+            file,
+            title,
+            id: testId(file, title),
+        }));
+        return {
+            name: group.name,
+            kind: "picked",
+            testIds: picked.filter((t) => known.has(t.id)).map((t) => t.id),
+            missing: picked
+                .filter((t) => !known.has(t.id))
+                .map(({ file, title }) => ({ file, title })),
+        };
+    }
+    const base = group.src ? resolve(projectDir, group.src) : srcDir;
+    const pattern = group.testMatch ?? DEFAULT_TEST_MATCH;
+    const testIds = found
+        .filter((t) => {
+        const fromBase = toPosix(relative(base, resolve(srcDir, t.file)));
+        return !fromBase.startsWith("..") && matchesGlob(fromBase, pattern);
+    })
+        .map((t) => t.id);
+    return {
+        name: group.name,
+        kind: "pattern",
+        pattern: [group.src, group.testMatch].filter(Boolean).join(" · ") || pattern,
+        testIds,
+        missing: [],
+    };
+}
+/** Resolves every group of the config */
+export function resolveGroups(config, tests, projectDir, srcDir) {
+    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir));
+}
+/** The group called `name`, or an error naming the groups there are */
+export function findGroup(groups, name) {
+    const group = groups.find((g) => g.name === name);
+    if (group)
+        return group;
+    throw new Error(groups.length === 0
+        ? `Unknown group "${name}". No groups are configured.`
+        : `Unknown group "${name}". Groups: ${groups.map((g) => g.name).join(", ")}.`);
+}

package/dist/runner/run.d.ts

@@ -1,5 +1,6 @@
 import type { TestSummary } from "../types/test.js";
 import { type ProjectOptions } from "./project.js";
+import type { ResolvedGroup } from "./groups.js";
 import { type RunnerOptions } from "./test-runner.js";
 export interface RunTestsOptions extends RunnerOptions, ProjectOptions {
 }
@@ -21,7 +22,10 @@ export interface FoundTest {
 }
 /** Imports the project's specs without running anything and lists the tests the options select */
 export declare function listTests(options?: RunTestsOptions): Promise<FoundTest[]>;
+/** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
+export declare function listGroups(options?: RunTestsOptions): Promise<ResolvedGroup[]>;
 export type { RunEvent } from "./reporter.js";
 export type { TestError, TestResult, TestSummary } from "../types/test.js";
+export type { ResolvedGroup } from "./groups.js";
 export type { RunnerOptions } from "./test-runner.js";
 export type { ProjectOptions } from "./project.js";

package/dist/runner/run.js

@@ -32,3 +32,15 @@ export async function listTests(options = {}) {
         expectTimeout,
     }, async (run) => (await (await TestRunner.init(run, undefined, runner)).register()).map(({ name, file }) => ({ name, file })));
 }
+/** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
+export async function listGroups(options = {}) {
+    const { projectDir, config, dataDir, environment, timeout, expectTimeout, ...runner } = options;
+    return withProject({
+        projectDir,
+        config,
+        dataDir,
+        environment,
+        timeout,
+        expectTimeout,
+    }, async (run) => (await TestRunner.init(run, undefined, runner)).groups());
+}

package/dist/runner/test-runner.d.ts

@@ -2,6 +2,7 @@ import type { RegisteredTestCase } from "../types/test.js";
 import type { PreparedRun } from "./prepare-run.js";
 import { type RunEvent } from "./reporter.js";
 import type { SamuraiGroup } from "../types/config.js";
+import type { ResolvedGroup } from "./groups.js";
 /** What decides which tests of the found files run, and how the browser starts */
 export interface RunnerOptions {
     /** Spec files to run, absolute or relative to the project folder. Default: every `*.spec.ts` under `srcDir` */
@@ -10,6 +11,8 @@ export interface RunnerOptions {
     grep?: string | RegExp;
     /** Only tests with exactly one of these full names (`describe` titles joined with " > ") */
     testNames?: string[];
+    /** Only the tests of this group of the config's `groups` (unknown name: an error). Combines with the other filters */
+    group?: string;
     /** Run the browser without a window. @default false */
     headless?: boolean;
     /** Remote debugging port of the browser. @default 9223 */
@@ -30,12 +33,19 @@ export default class TestRunner {
     private options;
     constructor(testFiles: string[], run: PreparedRun, group?: SamuraiGroup, options?: RunnerOptions);
     static init(run: PreparedRun, group?: SamuraiGroup, options?: RunnerOptions): Promise<TestRunner>;
-    /** Runs the selected tests and returns the summary that was also written to the report */
     /**
-     * Imports the spec files and returns the tests the options select. A fresh registry and a fresh import of each
+     * Imports the spec files and returns every test they register. A fresh registry and a fresh import of each
      * file, so a second run in this process registers its tests again (and sees edited specs, for files loaded as
      * ES modules; CommonJS files stay cached until the process ends)
      */
+    private registerAll;
+    /** Id of a registered test: its spec file relative to `srcDir`, then its name */
+    private idOf;
+    /** The config's groups, resolved against the tests the specs register */
+    private resolveAll;
+    /** The groups of the config with the tests each holds; see `listGroups` */
+    groups(): Promise<ResolvedGroup[]>;
+    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
     register(): Promise<RegisteredTestCase[]>;
     /** Runs the selected tests and returns the summary that was also written to the report */
     start(): Promise<import("../types/test.js").TestSummary>;

package/dist/runner/test-runner.js

@@ -3,7 +3,7 @@ import { glob } from "node:fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 import { Browser } from "../browser/browser.js";
-import { projectDir, readConfig } from "../config/config.js";
+import { loadConfig, projectDir, readConfig } from "../config/config.js";
 import logger from "../logger/index.js";
 import { assertModuleProject } from "./module-type.js";
 import { clearRegistry, registeredTests } from "./registry.js";
@@ -14,6 +14,7 @@ import Page from "../browser/page.js";
 import { takePendingAssertions } from "../assert/expect.js";
 import { toTestError } from "./test-error.js";
 import { ConnectionClosedError } from "../transport/bidi-connection.js";
+import { DEFAULT_SRC_DIR, findGroup, resolveGroups, testId, toPosix, } from "./groups.js";
 import { judgePageLogs } from "./page-logs-report.js";
 /** Whether a test with this full name is selected by the options */
 export function isSelected(name, { grep, testNames }) {
@@ -57,13 +58,12 @@ export default class TestRunner {
         logger.debug("Found %d tests in srcDir", testFiles.length);
         return new TestRunner(testFiles.map((file) => path.join(cwd, file)), run, group, options);
     }
-    /** Runs the selected tests and returns the summary that was also written to the report */
     /**
-     * Imports the spec files and returns the tests the options select. A fresh registry and a fresh import of each
+     * Imports the spec files and returns every test they register. A fresh registry and a fresh import of each
      * file, so a second run in this process registers its tests again (and sees edited specs, for files loaded as
      * ES modules; CommonJS files stay cached until the process ends)
      */
-    async register() {
+    async registerAll() {
         clearRegistry();
         const stamp = `?run=${Date.now().toString(36)}`;
         for (const file of this.testFiles)
@@ -72,8 +72,38 @@ export default class TestRunner {
             logger.verbose("Trying to register file: %s", file);
             await import(pathToFileURL(file).href + stamp);
         }
-        // TODO: Implement test grouping
-        return registeredTests().filter((test) => isSelected(test.name, this.options));
+        return [...registeredTests()];
+    }
+    /** Id of a registered test: its spec file relative to `srcDir`, then its name */
+    idOf(test, srcDir) {
+        return testId(toPosix(path.relative(srcDir, test.file)), test.name);
+    }
+    /** The config's groups, resolved against the tests the specs register */
+    async resolveAll(tests) {
+        const config = await loadConfig();
+        const dir = projectDir();
+        const srcDir = path.resolve(dir, config.srcDir ?? DEFAULT_SRC_DIR);
+        const groups = resolveGroups(config, tests.map(({ file, name }) => ({
+            file: toPosix(path.relative(srcDir, file)),
+            name,
+        })), dir, srcDir);
+        return { groups, srcDir };
+    }
+    /** The groups of the config with the tests each holds; see `listGroups` */
+    async groups() {
+        return (await this.resolveAll(await this.registerAll())).groups;
+    }
+    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
+    async register() {
+        const all = await this.registerAll();
+        const { group } = this.options;
+        let inGroup = () => true;
+        if (group !== undefined) {
+            const { groups, srcDir } = await this.resolveAll(all);
+            const members = new Set(findGroup(groups, group).testIds);
+            inGroup = (test) => members.has(this.idOf(test, srcDir));
+        }
+        return all.filter((test) => inGroup(test) && isSelected(test.name, this.options));
     }
     /** Runs the selected tests and returns the summary that was also written to the report */
     async start() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.2.3",
+  "version": "0.4.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": {
@@ -28,6 +28,18 @@
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"
     },
+    "./flows": {
+      "types": "./dist/flows/core/index.d.ts",
+      "default": "./dist/flows/core/index.js"
+    },
+    "./flows/run": {
+      "types": "./dist/flows/run/index.d.ts",
+      "default": "./dist/flows/run/index.js"
+    },
+    "./flows/steps": {
+      "types": "./dist/flows/steps/index.d.ts",
+      "default": "./dist/flows/steps/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {