@itmetsam/samurai-framework 0.7.0 → 0.7.1

package/dist/cli/main.js

@@ -145,8 +145,8 @@ export async function main(argv, io) {
             });
             if (!values.json) {
                 io.out(`\nRecorded ${count} ${count === 1 ? "step" : "steps"} into "${result.test}" in ${result.file}\n`);
-                if (result.secrets.length > 0) {
-                    io.out(`Set ${result.secrets.map((name) => `SAMURAI_SECRET_${name}`).join(", ")} (environment variable or .env.<environment>) before running it.\n`);
+                if (result.unsetSecrets.length > 0) {
+                    io.out(`Set ${result.unsetSecrets.map((name) => `SAMURAI_SECRET_${name}`).join(", ")} (environment variable or .env.<environment>) before running it.\n`);
                 }
             }
             return 0;

package/dist/recorder/session.d.ts

@@ -48,6 +48,8 @@ export interface RecordResult {
     events: RecorderEvent[];
     /** Names the recorded steps read with `secrets.<NAME>`: they must be set before the test can run */
     secrets: string[];
+    /** Those of `secrets` that have no value in the recording's environment yet, read when the recording ended */
+    unsetSecrets: string[];
 }
 /** What the toolbar shows of the project: its environment, variables, secrets and the test's screenshots */
 export declare function toolbarOptions(run: Pick<PreparedRun, "settings" | "secrets">, source: string, dir: string, config: Pick<SamuraiTestConfig, "environments">, testIndex: number): Promise<ControllerOptions>;

package/dist/recorder/session.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { Browser } from "../browser/browser.js";
 import { ensureWarm } from "../browser/warm-up.js";
 import { loadConfig, projectDir } from "../config/config.js";
+import { loadSecrets } from "../config/secrets.js";
 import { isGitIgnored } from "../project/index.js";
 import { withProject } from "../runner/project.js";
 import { parseSpec } from "../steps/parse.js";
@@ -165,6 +166,9 @@ export async function recordSpec(options) {
             await browser.close().catch(() => undefined);
         }
         const secrets = resultSecrets(events, addedSecrets);
-        return { file, test: test.name, events, secrets };
+        // Read again: the toolbar may have written new ones to the .env file
+        const set = loadSecrets(settings.environment);
+        const unsetSecrets = secrets.filter((name) => !set.has(name));
+        return { file, test: test.name, events, secrets, unsetSecrets };
     });
 }

package/dist/steps/edit.d.ts

@@ -24,7 +24,8 @@ export type StepEdit = {
     to: number;
 };
 /**
- * Applies one edit and returns the new source. Only the touched statement changes: everything else,
- * formatting and comments included, stays byte for byte.
+ * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters
+ * when the step reads a fixture (`env`, `secrets`) they don't have yet: everything else, formatting and
+ * comments included, stays byte for byte.
  */
 export declare function applyEdit(source: string, edit: StepEdit): string;

package/dist/steps/edit.js

@@ -51,19 +51,43 @@ function removeStep(source, parsed, index) {
     const { anchor, end } = pickStep(parsed, index);
     return splice(source, lineStart(source, anchor), lineEnd(source, end), "");
 }
+/** The fixtures a step's statement reads */
+function fixturesOf(step) {
+    if (step.kind !== "fill" || step.value.kind === "literal")
+        return [];
+    return [step.value.kind === "env" ? "env" : "secrets"];
+}
+/** Adds the fixtures the step reads to the test's parameters, when they aren't there yet */
+function withFixtures(source, parsed, step) {
+    const { fixtures } = parsed;
+    if (!fixtures)
+        return source;
+    const missing = fixturesOf(step).filter((name) => !fixtures.names.includes(name));
+    if (missing.length === 0)
+        return source;
+    const list = missing.join(", ");
+    const text = fixtures.shape === "list"
+        ? `, ${list}`
+        : fixtures.shape === "empty"
+            ? ` ${list} `
+            : `{ ${list} }`;
+    return splice(source, fixtures.at, fixtures.at, text);
+}
 /**
- * Applies one edit and returns the new source. Only the touched statement changes: everything else,
- * formatting and comments included, stays byte for byte.
+ * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters
+ * when the step reads a fixture (`env`, `secrets`) they don't have yet: everything else, formatting and
+ * comments included, stays byte for byte.
  */
 export function applyEdit(source, edit) {
     const parsed = pickTest(source, edit.test);
     switch (edit.op) {
         case "replace": {
             const { start, end } = pickStep(parsed, edit.index);
-            return splice(source, start, end, stepToSource(edit.step));
+            // The parameters come before the body: adding to them leaves the step's offsets valid
+            return withFixtures(splice(source, start, end, stepToSource(edit.step)), parsed, edit.step);
         }
         case "insert":
-            return insertCode(source, parsed, edit.index, stepToSource(edit.step));
+            return withFixtures(insertCode(source, parsed, edit.index, stepToSource(edit.step)), parsed, edit.step);
         case "remove":
             return removeStep(source, parsed, edit.index);
         case "move": {

package/dist/steps/model.d.ts

@@ -117,4 +117,14 @@ export interface ParsedTest {
     /** Offset just after the `{` of the test body, and of its closing `}` */
     bodyStart: number;
     bodyEnd: number;
+    /**
+     * 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`).
+     * Undefined when the parameter can't take one: a plain identifier, or a rest element
+     */
+    fixtures?: {
+        names: string[];
+        at: number;
+        shape: "list" | "empty" | "none";
+    };
 }

package/dist/steps/parse.js

@@ -257,6 +257,28 @@ function parseStatement(source, statement, sourceFile) {
         anchor: comments?.[0]?.pos ?? start,
     };
 }
+function callbackFixtures(callback, sourceFile) {
+    const [first] = callback.parameters;
+    if (!first) {
+        const open = callback
+            .getChildren(sourceFile)
+            .find((child) => child.kind === ts.SyntaxKind.OpenParenToken);
+        return open ? { names: [], at: open.end, shape: "none" } : undefined;
+    }
+    const pattern = first.name;
+    if (!ts.isObjectBindingPattern(pattern))
+        return undefined;
+    if (pattern.elements.some((element) => element.dotDotDotToken))
+        return undefined;
+    const last = pattern.elements[pattern.elements.length - 1];
+    if (!last)
+        return { names: [], at: pattern.getStart(sourceFile) + 1, shape: "empty" };
+    return {
+        names: pattern.elements.map(({ propertyName, name }) => (propertyName ?? name).getText(sourceFile)),
+        at: last.end,
+        shape: "list",
+    };
+}
 function callbackBody(node) {
     return node &&
         (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
@@ -280,6 +302,7 @@ export function parseSpec(source) {
                     steps: body.statements.map((statement) => parseStatement(source, statement, sourceFile)),
                     bodyStart: body.getStart(sourceFile) + 1,
                     bodyEnd: body.end - 1,
+                    fixtures: callbackFixtures(node.arguments[1], sourceFile),
                 });
                 return;
             }

package/package.json

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