@itmetsam/samurai-framework 0.15.2 → 0.17.0

package/dist/steps/index.d.ts

@@ -1,6 +1,6 @@
-export { parseSpec } from "./parse.js";
+export { parseSpec, parseSpecFile } from "./parse.js";
 export { applyEdit, type StepEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";
 export { locatorFromSpec } from "./build.js";
-export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, } from "./model.js";
+export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, UnparsedTest, } from "./model.js";

package/dist/steps/index.js

@@ -1,4 +1,4 @@
-export { parseSpec } from "./parse.js";
+export { parseSpec, parseSpecFile } from "./parse.js";
 export { applyEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";

package/dist/steps/model.d.ts

@@ -146,6 +146,15 @@ export interface ParsedTest {
     /** Offset just after the `{` of the test body, and of its closing `}` */
     bodyStart: number;
     bodyEnd: number;
+    /** Where the whole test starts: the full start of its statement, so the comments and blank line above are included */
+    start: number;
+    /** Where the whole test ends: the end of its statement, after the `;` */
+    end: number;
+    /**
+     * False when the test call isn't a statement of its own (a loop or `if` body without braces, an arrow's
+     * expression body), so it can't be removed without breaking the file
+     */
+    removable: boolean;
     /**
      * The fixtures the test's callback destructures, and the offset where another one goes: after the last one
      * (`list`), inside an empty `{}` (`empty`) or inside the empty `()` of a callback without parameters (`none`).
@@ -161,3 +170,11 @@ export interface ParsedTest {
     /** The `{ reason }` written with the `skip` or `fixme` that applies, when it is a string literal */
     reason?: string;
 }
+/** A `test` or `describe` call the codec can't read: its title isn't a plain string, or its function isn't written inline */
+export interface UnparsedTest {
+    kind: "test" | "describe";
+    /** The statement's range, as for `ParsedTest` */
+    start: number;
+    end: number;
+    reason: "dynamic-title" | "not-inline";
+}

package/dist/steps/parse.d.ts

@@ -1,3 +1,8 @@
-import type { ParsedTest } from "./model.js";
+import type { ParsedTest, UnparsedTest } from "./model.js";
+/** The tests in a spec file, with their steps and where each statement sits, and the tests and describes it can't read */
+export declare function parseSpecFile(source: string): {
+    tests: ParsedTest[];
+    unparsed: UnparsedTest[];
+};
 /** The tests in a spec file, with their steps and where each statement sits */
 export declare function parseSpec(source: string): ParsedTest[];

package/dist/steps/parse.js

@@ -85,24 +85,64 @@ function effectiveMark(own, describes) {
         };
     return chain.some((m) => m.modifier === "only") ? { modifier: "only" } : {};
 }
-/** The tests in a spec file, with their steps and where each statement sits */
-export function parseSpec(source) {
+/** The range of a whole test: its statement with the comments above it, or the call alone when it isn't a statement */
+function wholeRange(call) {
+    const statement = ts.isExpressionStatement(call.parent) ? call.parent : call;
+    return { start: statement.getFullStart(), end: statement.end };
+}
+/** Whether the call is a statement directly inside a block, a module block or the file, so removing its range leaves valid code */
+function isRemovable(call) {
+    const statement = call.parent;
+    if (!ts.isExpressionStatement(statement))
+        return false;
+    const container = statement.parent;
+    return (ts.isBlock(container) ||
+        ts.isSourceFile(container) ||
+        ts.isModuleBlock(container));
+}
+/** A test or describe the codec can't read, with where its statement sits */
+function unreadable(node, kind, reason) {
+    return { kind, reason, ...wholeRange(node) };
+}
+/** `test.skip(condition, reason)` inside a body: it takes a condition where a test takes a title, so it is neither a test nor unparsed */
+function isConditionForm(node, callee) {
+    const [first] = node.arguments;
+    return ((callee.modifier === "skip" || callee.modifier === "fixme") &&
+        !(first &&
+            (ts.isStringLiteral(first) ||
+                ts.isNoSubstitutionTemplateLiteral(first) ||
+                ts.isTemplateExpression(first))));
+}
+/** The tests in a spec file, with their steps and where each statement sits, and the tests and describes it can't read */
+export function parseSpecFile(source) {
     const sourceFile = ts.createSourceFile("spec.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const tests = [];
+    const unparsed = [];
     const visit = (node, titles, describes) => {
         const callee = ts.isCallExpression(node)
             ? calleeOf(node.expression)
             : undefined;
-        if (ts.isCallExpression(node) && callee) {
+        if (ts.isCallExpression(node) &&
+            callee &&
+            (callee.name === "test" || callee.name === "describe") &&
+            !(callee.name === "test" && isConditionForm(node, callee))) {
+            const kind = callee.name;
             const title = stringOf(node.arguments[0]);
             const { callback, reason } = callbackOf(node, callee.modifier);
             const body = callbackBody(callback);
+            if (title === undefined) {
+                unparsed.push(unreadable(node, kind, "dynamic-title"));
+                return;
+            }
+            if (!body) {
+                unparsed.push(unreadable(node, kind, "not-inline"));
+                return;
+            }
             const mark = {
                 ...(callee.modifier && { modifier: callee.modifier }),
                 ...(reason !== undefined && { reason }),
             };
-            if (title !== undefined && body && callee.name === "test") {
-                // `test.skip(condition, reason)` has no title and no body, so it stays a step of the test it is in
+            if (kind === "test") {
                 const titlePath = [...titles, title];
                 tests.push({
                     titlePath,
@@ -110,18 +150,22 @@ export function parseSpec(source) {
                     steps: body.statements.map((statement) => parseStatement(source, statement, sourceFile)),
                     bodyStart: body.getStart(sourceFile) + 1,
                     bodyEnd: body.end - 1,
+                    ...wholeRange(node),
+                    removable: isRemovable(node),
                     fixtures: callbackFixtures(callback, sourceFile),
                     ...effectiveMark(mark, describes),
                 });
                 return;
             }
-            if (title !== undefined && body && callee.name === "describe") {
-                ts.forEachChild(body, (child) => visit(child, [...titles, title], [...describes, mark]));
-                return;
-            }
+            ts.forEachChild(body, (child) => visit(child, [...titles, title], [...describes, mark]));
+            return;
         }
         ts.forEachChild(node, (child) => visit(child, titles, describes));
     };
     visit(sourceFile, [], []);
-    return tests;
+    return { tests, unparsed };
+}
+/** The tests in a spec file, with their steps and where each statement sits */
+export function parseSpec(source) {
+    return parseSpecFile(source).tests;
 }

package/dist/transport/bidi-connection.d.ts

@@ -1,7 +1,5 @@
 import type { BiDiCommands, BiDiEvents } from "../types/bidi.js";
 import { type EventName, type Subscription, type SubscribeOptions } from "./subscriptions.js";
-/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-export declare const DEFAULT_COMMAND_TIMEOUT = 30000;
 export interface ConnectorOptions {
     /** @default DEFAULT_COMMAND_TIMEOUT */
     commandTimeout?: number;

package/dist/transport/bidi-connection.js

@@ -1,11 +1,10 @@
 import EventEmitter from "node:events";
+import { DEFAULT_COMMAND_TIMEOUT } from "../config/defaults.js";
 import logger from "../logger/index.js";
 import { WaitTimeoutError } from "../wait/wait-until.js";
 import { BiDiError } from "./bidi-error.js";
 import { forLog } from "./log-redaction.js";
 import { SubscriptionManager, } from "./subscriptions.js";
-/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-export const DEFAULT_COMMAND_TIMEOUT = 30000;
 /**
  * The connection to the browser is gone (the browser exited or was closed, or the socket dropped). Commands that
  * were waiting fail with it, and so does every command sent afterwards: a closed socket would swallow them silently.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.15.2",
+  "version": "0.17.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": {
@@ -48,6 +48,10 @@
       "types": "./dist/project/index.d.ts",
       "default": "./dist/project/index.js"
     },
+    "./capabilities": {
+      "types": "./dist/capabilities.d.ts",
+      "default": "./dist/capabilities.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -55,7 +59,7 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/copy-types.mjs",
     "prepack": "npm run build",
     "test": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-timeout=10000 \"src/**/*.test.ts\"",
-    "test:browser": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 --test-timeout=60000 \"src/**/*.browser-test.ts\"",
+    "test:browser": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 --test-timeout=60000 ${SAMURAI_TEST_SHARD:+--test-shard=$SAMURAI_TEST_SHARD} \"src/**/*.browser-test.ts\"",
     "test:browser:chrome": "SAMURAI_TEST_BROWSER=chrome npm run test:browser",
     "test:cli": "tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 \"src/**/*.cli-test.ts\""
   },