@ripplo/testing 0.4.7 → 0.4.8

package/README.md

@@ -158,6 +158,7 @@ import {
   navigate,
   scrollIntoView,
   drag,
+  fixture,
   upload,
   handleDialog,
   clipboard,
@@ -171,10 +172,22 @@ fill(role("textbox", "Email"), "test@x.com"); // clear + type
 select(role("combobox", "Role"), "admin");
 check(role("checkbox", "Terms"));
 press("Enter");
-upload(testId("file-input"), "./test.png");
+upload(testId("file-input"), fixture("logo.png"));
 drag(role("row", "Item 1"), role("row", "Item 2"));
 ```
 
+### Upload fixtures
+
+`upload()` requires a `fixture()` reference. Fixture files live in `.ripplo/fixtures/` (committed). Limits: 10 MB per file, 50 MB total.
+
+```ts
+// .ripplo/fixtures/logo.png exists
+upload(testId("logo-input"), fixture("logo.png"));
+
+// Multiple files
+upload(testId("attachments"), [fixture("a.pdf"), fixture("b.pdf")]);
+```
+
 ### Assertions
 
 ```typescript

package/dist/actions.d.ts

@@ -3,6 +3,14 @@ import { U as UnlabeledStep } from './step-De52hTLd.js';
 import { CheckLocator, InputLocator, AnyLocator, SelectLocator } from './locators.js';
 import '@ripplo/spec';
 
+declare class Fixture {
+    readonly kind: "fixture";
+    readonly name: string;
+    constructor(name: string);
+}
+declare function fixture(name: string): Fixture;
+declare function isFixture(value: unknown): value is Fixture;
+
 type StringOrVariable = string | Variable<string>;
 declare function navigate(url: string): UnlabeledStep<{
     type: "goto";
@@ -87,7 +95,7 @@ declare function press(key: string): UnlabeledStep<{
     key: string;
     type: "press";
 }>;
-declare function upload(locator: AnyLocator, path: string, options?: StepOptions): UnlabeledStep<{
+declare function upload(locator: AnyLocator, files: Fixture | ReadonlyArray<Fixture>, options?: StepOptions): UnlabeledStep<{
     files: string[];
     locator: {
         by: "testId";
@@ -247,4 +255,4 @@ declare function setViewport({ height, width }: SetViewportOptions): UnlabeledSt
     width: number;
 }>;
 
-export { check, clear, click, clipboard, dblclick, drag, fill, focus, handleDialog, hover, navigate, press, rightClick, scrollIntoView, select, setPermission, setViewport, typeText, uncheck, upload };
+export { Fixture, check, clear, click, clipboard, dblclick, drag, fill, fixture, focus, handleDialog, hover, isFixture, navigate, press, rightClick, scrollIntoView, select, setPermission, setViewport, typeText, uncheck, upload };

package/dist/actions.js

@@ -9,6 +9,24 @@ import {
 } from "./chunk-MGATMMCZ.js";
 import "./chunk-4MGIQFAJ.js";
 
+// src/steps/fixture.ts
+var Fixture = class {
+  kind = "fixture";
+  name;
+  constructor(name) {
+    if (name.length === 0) {
+      throw new Error("fixture(name) requires a non-empty name");
+    }
+    this.name = name;
+  }
+};
+function fixture(name) {
+  return new Fixture(name);
+}
+function isFixture(value) {
+  return value instanceof Fixture;
+}
+
 // src/steps/actions.ts
 function navigate(url) {
   return createStep({ type: "goto", url: { type: "static", value: url } });
@@ -46,9 +64,10 @@ function hover(locator) {
 function press(key) {
   return createStep({ key, type: "press" });
 }
-function upload(locator, path, options) {
+function upload(locator, files, options) {
+  const list = files instanceof Fixture ? [files] : [...files];
   return createStep({
-    files: [path],
+    files: list.map((f) => f.name),
     locator: toSpecLocator(locator),
     type: "upload",
     uiOnly: options?.uiOnly
@@ -101,6 +120,7 @@ function setViewport({ height, width }) {
   return createStep({ height, type: "setViewport", width });
 }
 export {
+  Fixture,
   check,
   clear,
   click,
@@ -108,9 +128,11 @@ export {
   dblclick,
   drag,
   fill,
+  fixture,
   focus,
   handleDialog,
   hover,
+  isFixture,
   navigate,
   press,
   rightClick,

package/dist/{chunk-DL3HLCD7.js → chunk-YFOTJIVF.js}

@@ -25,7 +25,7 @@ function compile(ripplo) {
     };
   });
   const tests = testDefs.map((def) => compileTest(def, preconditionDefs));
-  return { observers, preconditions, tests };
+  return { fixtures: {}, observers, preconditions, tests };
 }
 function validateUniqueIds(defs) {
   const seen = /* @__PURE__ */ new Map();

package/dist/compiler.d.ts

@@ -3,7 +3,12 @@ import { d as RipploBuilder } from './builder-BMjy83Iy.js';
 import './types-16SB7zjP.js';
 import './step-De52hTLd.js';
 
+interface CompiledFixture {
+    readonly sha256: string;
+    readonly size: number;
+}
 interface CompileResult {
+    readonly fixtures: Record<string, CompiledFixture>;
     readonly observers: Record<string, Observer>;
     readonly preconditions: Record<string, Precondition>;
     readonly tests: ReadonlyArray<CompiledTest>;
@@ -24,4 +29,4 @@ interface CompiledTest {
 }
 declare function compile(ripplo: RipploBuilder): CompileResult;
 
-export { type CompileResult, type CompiledTest, compile };
+export { type CompileResult, type CompiledFixture, type CompiledTest, compile };

package/dist/compiler.js

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-DL3HLCD7.js";
+} from "./chunk-YFOTJIVF.js";
 import "./chunk-MGATMMCZ.js";
 import "./chunk-4MGIQFAJ.js";
 export {

package/dist/index.js

@@ -14,7 +14,7 @@ import {
 } from "./chunk-YQAEOH5W.js";
 import {
   compile
-} from "./chunk-DL3HLCD7.js";
+} from "./chunk-YFOTJIVF.js";
 import "./chunk-MGATMMCZ.js";
 import {
   buildSetCookieHeader,
@@ -780,6 +780,30 @@ function observerParamsReferenceVariables(nodes, test2, report) {
     });
   });
 }
+function uploadFixtureName(nodes, _test, report) {
+  nodes.forEach((node) => {
+    if (node.type !== "upload") {
+      return;
+    }
+    node.files.forEach((name) => {
+      if (name.length === 0) {
+        report({
+          message: `upload "${node.label ?? node.id}" references an empty fixture name`,
+          rule: "upload-fixture-name",
+          step: node.label ?? node.id
+        });
+        return;
+      }
+      if (name.includes("..") || name.startsWith("/")) {
+        report({
+          message: `upload "${node.label ?? node.id}" references "${name}" \u2014 fixture names must be relative paths under .ripplo/fixtures/, no ".." or absolute paths`,
+          rule: "upload-fixture-name",
+          step: node.label ?? node.id
+        });
+      }
+    });
+  });
+}
 function noLiteralTemplateStrings(nodes, test2, report) {
   const declaredKeys = new Set(Object.keys(test2.spec.variables ?? {}));
   const pattern = /\{\{([^{}]+?)\}\}/g;
@@ -818,7 +842,8 @@ var RULES = [
   tautologicalPostClickAssert,
   expectedOutcomeKeywordCoverage,
   mutationWithoutObserverCoverage,
-  observerParamsReferenceVariables
+  observerParamsReferenceVariables,
+  uploadFixtureName
 ];
 
 // src/engine.ts

package/dist/lockfile.d.ts

@@ -6,7 +6,17 @@ import './types-16SB7zjP.js';
 import './step-De52hTLd.js';
 
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
-declare const lockfileBodySchema: z.ZodObject<{
+declare const FIXTURES_RELATIVE_PATH = ".ripplo/fixtures";
+declare const fixtureEntrySchema: z.ZodObject<{
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+type FixtureEntry = z.infer<typeof fixtureEntrySchema>;
+declare const lockfileBodyV2Schema: z.ZodObject<{
+    fixtures: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>>;
     observers: z.ZodRecord<z.ZodString, z.ZodObject<{
         budget: z.ZodEnum<{
             fast: "fast";
@@ -677,7 +687,7 @@ declare const lockfileBodySchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type Lockfile = z.infer<typeof lockfileBodySchema>;
+type Lockfile = z.infer<typeof lockfileBodyV2Schema>;
 declare const lockfileCodec: Codec<Lockfile>;
 declare function compileResultToLockfile(result: CompileResult): Lockfile;
 declare function serializeLockfile(lockfile: Lockfile): string;
@@ -690,6 +700,11 @@ interface WriteLockfileParams {
     readonly result: CompileResult;
 }
 declare function writeLockfile({ cwd, result }: WriteLockfileParams): Promise<void>;
+interface HashFixturesParams {
+    readonly cwd: string;
+    readonly result: CompileResult;
+}
+declare function hashFixturesIntoCompileResult({ cwd, result, }: HashFixturesParams): Promise<CompileResult>;
 type LockfileComparison = "match" | "missing" | "stale";
 interface CompareLockfileParams {
     readonly compiled: CompileResult;
@@ -697,4 +712,4 @@ interface CompareLockfileParams {
 }
 declare function compareCompileToLockfile({ compiled, existing, }: CompareLockfileParams): LockfileComparison;
 
-export { type CompareLockfileParams, LOCKFILE_RELATIVE_PATH, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, lockfileCodec, readLockfile, serializeLockfile, writeLockfile };
+export { type CompareLockfileParams, FIXTURES_RELATIVE_PATH, type FixtureEntry, LOCKFILE_RELATIVE_PATH, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, hashFixturesIntoCompileResult, lockfileCodec, readLockfile, serializeLockfile, writeLockfile };

package/dist/lockfile.js

@@ -1,6 +1,7 @@
 import "./chunk-4MGIQFAJ.js";
 
 // src/lockfile.ts
+import { createHash } from "crypto";
 import fs from "fs/promises";
 import path from "path";
 
@@ -500,6 +501,7 @@ var observerSchema = z9.object({
 // src/lockfile.ts
 import { z as z10 } from "zod";
 var LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
+var FIXTURES_RELATIVE_PATH = ".ripplo/fixtures";
 var MAX_TESTS = 5e3;
 var requiresKeysSchema = z10.record(z10.string().max(200), z10.string().max(200));
 var compiledTestSchema = z10.object({
@@ -512,14 +514,32 @@ var compiledTestSchema = z10.object({
   sourcePath: z10.string().max(500).optional(),
   spec: workflowSpecSchema
 });
-var lockfileBodySchema = z10.object({
+var fixtureEntrySchema = z10.object({
+  sha256: z10.string().regex(/^[0-9a-f]{64}$/u),
+  size: z10.number().int().nonnegative()
+});
+var fixturesMapSchema = z10.record(z10.string().min(1).max(500), fixtureEntrySchema);
+var lockfileBodyV1Schema = z10.object({
+  observers: z10.record(z10.string().max(200), observerSchema),
+  preconditions: z10.record(z10.string().max(200), preconditionSchema),
+  tests: z10.array(compiledTestSchema).max(MAX_TESTS)
+});
+var lockfileBodyV2Schema = z10.object({
+  fixtures: fixturesMapSchema,
   observers: z10.record(z10.string().max(200), observerSchema),
   preconditions: z10.record(z10.string().max(200), preconditionSchema),
   tests: z10.array(compiledTestSchema).max(MAX_TESTS)
 });
-var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodySchema).build();
+var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodyV1Schema).upgrade(
+  lockfileBodyV2Schema,
+  (prev) => ({
+    ...prev,
+    fixtures: {}
+  })
+).build();
 function compileResultToLockfile(result) {
   return {
+    fixtures: { ...result.fixtures },
     observers: result.observers,
     preconditions: result.preconditions,
     tests: result.tests.filter((test) => test.implemented).map((test) => ({
@@ -547,12 +567,76 @@ async function readLockfile({ cwd }) {
   }
   return decodeJson(lockfileCodec, raw);
 }
+var MAX_FIXTURE_BYTES = 10 * 1024 * 1024;
+var MAX_TOTAL_FIXTURE_BYTES = 50 * 1024 * 1024;
 async function writeLockfile({ cwd, result }) {
-  const lockfile = compileResultToLockfile(result);
+  const hydrated = await hashFixturesIntoCompileResult({ cwd, result });
+  const lockfile = compileResultToLockfile(hydrated);
   const lockfilePath = path.join(cwd, LOCKFILE_RELATIVE_PATH);
   await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
   await fs.writeFile(lockfilePath, serializeLockfile(lockfile), "utf8");
 }
+async function hashFixturesIntoCompileResult({
+  cwd,
+  result
+}) {
+  const referenced = collectFixtureReferences(result);
+  if (referenced.size === 0) {
+    return { ...result, fixtures: {} };
+  }
+  const fixturesRoot = path.join(cwd, FIXTURES_RELATIVE_PATH);
+  const sortedNames = [...referenced].toSorted((a, b) => a.localeCompare(b));
+  const hashed = await Promise.all(
+    sortedNames.map(async (name) => {
+      const entry = await hashOneFixture({ fixturesRoot, name });
+      if (entry.size > MAX_FIXTURE_BYTES) {
+        throw new Error(
+          `Fixture "${name}" is ${String(entry.size)} bytes; exceeds per-file limit of ${String(MAX_FIXTURE_BYTES)} bytes`
+        );
+      }
+      return [name, entry];
+    })
+  );
+  const total = hashed.reduce((sum, [, entry]) => sum + entry.size, 0);
+  if (total > MAX_TOTAL_FIXTURE_BYTES) {
+    throw new Error(
+      `Total fixtures size exceeds limit of ${String(MAX_TOTAL_FIXTURE_BYTES)} bytes`
+    );
+  }
+  return { ...result, fixtures: Object.fromEntries(hashed) };
+}
+async function hashOneFixture({ fixturesRoot, name }) {
+  if (name.includes("..") || path.isAbsolute(name)) {
+    throw new Error(`Invalid fixture name "${name}": must be a path under .ripplo/fixtures/`);
+  }
+  const abs = path.join(fixturesRoot, name);
+  const stat = await fs.lstat(abs).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Fixture "${name}" not found at ${abs}`);
+    }
+    throw error;
+  });
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Fixture "${name}" is a symlink; symlinks are not allowed`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Fixture "${name}" is not a regular file`);
+  }
+  const bytes = await fs.readFile(abs);
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  return { sha256, size: bytes.byteLength };
+}
+function collectFixtureReferences(result) {
+  const names = /* @__PURE__ */ new Set();
+  result.tests.forEach((test) => {
+    Object.values(test.spec.nodes).forEach((node) => {
+      if (node.type === "upload") {
+        node.files.forEach((name) => names.add(name));
+      }
+    });
+  });
+  return names;
+}
 function compareCompileToLockfile({
   compiled,
   existing
@@ -589,9 +673,11 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
+  FIXTURES_RELATIVE_PATH,
   LOCKFILE_RELATIVE_PATH,
   compareCompileToLockfile,
   compileResultToLockfile,
+  hashFixturesIntoCompileResult,
   lockfileCodec,
   readLockfile,
   serializeLockfile,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "type": "module",
   "files": [
     "dist"
@@ -99,8 +99,8 @@
     "tsup": "^8.5.1",
     "typescript": "catalog:",
     "vitest": "^4.1.4",
-    "@ripplo/spec": "^0.0.0",
-    "@ripplo/eslint-config": "0.0.0"
+    "@ripplo/eslint-config": "0.0.0",
+    "@ripplo/spec": "^0.0.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",