@ripplo/testing 0.0.1

package/dist/actions.js

@@ -0,0 +1,116 @@
+import {
+  toSpecLocator
+} from "./chunk-2VUWFRR5.js";
+import {
+  createStep
+} from "./chunk-MGATMMCZ.js";
+import "./chunk-DCJBLS2U.js";
+
+// src/steps/actions.ts
+function navigate(url) {
+  return createStep({ type: "goto", url: { type: "static", value: url } });
+}
+function click(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "click" });
+}
+function fill(locator, value) {
+  return createStep({
+    locator: toSpecLocator(locator),
+    type: "fill",
+    value: { type: "static", value }
+  });
+}
+function select(locator, value) {
+  return createStep({
+    locator: toSpecLocator(locator),
+    type: "select",
+    value: { type: "static", value }
+  });
+}
+function check(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "check" });
+}
+function uncheck(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "uncheck" });
+}
+function hover(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "hover" });
+}
+function press(key) {
+  return createStep({ key, type: "press" });
+}
+function upload(locator, path) {
+  return createStep({
+    files: [path],
+    locator: toSpecLocator(locator),
+    type: "upload"
+  });
+}
+function dblclick(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "dblclick" });
+}
+function focus(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "focus" });
+}
+function clear(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "clear" });
+}
+function typeText(locator, value) {
+  return createStep({
+    locator: toSpecLocator(locator),
+    type: "type",
+    value: { type: "static", value }
+  });
+}
+function rightClick(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "rightClick" });
+}
+function scrollIntoView(locator) {
+  return createStep({ locator: toSpecLocator(locator), type: "scrollIntoView" });
+}
+function drag(source, target) {
+  return createStep({
+    source: toSpecLocator(source),
+    target: toSpecLocator(target),
+    type: "drag"
+  });
+}
+function handleDialog({ action, promptText }) {
+  return createStep({ action, promptText, type: "handleDialog" });
+}
+function clipboard({ action, value, variable }) {
+  return createStep({
+    action,
+    type: "clipboard",
+    value: value == null ? void 0 : { type: "static", value },
+    variable
+  });
+}
+function setPermission({ permission, state }) {
+  return createStep({ permission, state, type: "setPermission" });
+}
+function setViewport({ height, width }) {
+  return createStep({ height, type: "setViewport", width });
+}
+export {
+  check,
+  clear,
+  click,
+  clipboard,
+  dblclick,
+  drag,
+  fill,
+  focus,
+  handleDialog,
+  hover,
+  navigate,
+  press,
+  rightClick,
+  scrollIntoView,
+  select,
+  setPermission,
+  setViewport,
+  typeText,
+  uncheck,
+  upload
+};

package/dist/assert.d.ts

@@ -0,0 +1,182 @@
+import { U as UnlabeledStep } from './step-DLfkKI3V.js';
+import { CheckLocator, AnyLocator } from './locators.js';
+import '@ripplo/spec';
+
+declare const assert: {
+    not: {
+        checked(locator: CheckLocator): UnlabeledStep<{
+            locator: {
+                by: "testId";
+                value: string;
+            } | {
+                by: "role";
+                role: string;
+                name?: string | undefined;
+            };
+            type: "assertNotChecked";
+        }>;
+        enabled(locator: AnyLocator): UnlabeledStep<{
+            locator: {
+                by: "testId";
+                value: string;
+            } | {
+                by: "role";
+                role: string;
+                name?: string | undefined;
+            };
+            type: "assertDisabled";
+        }>;
+        focused(locator: AnyLocator): UnlabeledStep<{
+            locator: {
+                by: "testId";
+                value: string;
+            } | {
+                by: "role";
+                role: string;
+                name?: string | undefined;
+            };
+            type: "assertNotFocused";
+        }>;
+        visible(locator: AnyLocator): UnlabeledStep<{
+            locator: {
+                by: "testId";
+                value: string;
+            } | {
+                by: "role";
+                role: string;
+                name?: string | undefined;
+            };
+            type: "assertNotVisible";
+        }>;
+    };
+    attribute(locator: AnyLocator, attribute: string, expected: string): UnlabeledStep<{
+        attribute: string;
+        expected: {
+            type: "static";
+            value: string;
+        };
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        operator: "equals";
+        type: "assertAttribute";
+    }>;
+    checked(locator: CheckLocator): UnlabeledStep<{
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        type: "assertChecked";
+    }>;
+    count(locator: AnyLocator, expected: number): UnlabeledStep<{
+        expected: {
+            type: "static";
+            value: number;
+        };
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        operator: "equals";
+        type: "assertCount";
+    }>;
+    disabled(locator: AnyLocator): UnlabeledStep<{
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        type: "assertDisabled";
+    }>;
+    enabled(locator: AnyLocator): UnlabeledStep<{
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        type: "assertEnabled";
+    }>;
+    focused(locator: AnyLocator): UnlabeledStep<{
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        type: "assertFocused";
+    }>;
+    text(locator: AnyLocator, expected: string): UnlabeledStep<{
+        expected: {
+            type: "static";
+            value: string;
+        };
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        operator: "equals";
+        type: "assertText";
+    }>;
+    url(expected: string): UnlabeledStep<{
+        expected: {
+            type: "static";
+            value: string;
+        };
+        operator: "contains";
+        type: "assertUrl";
+    }>;
+    value(locator: AnyLocator, expected: string): UnlabeledStep<{
+        expected: {
+            type: "static";
+            value: string;
+        };
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        operator: "equals";
+        type: "assertValue";
+    }>;
+    visible(locator: AnyLocator): UnlabeledStep<{
+        locator: {
+            by: "testId";
+            value: string;
+        } | {
+            by: "role";
+            role: string;
+            name?: string | undefined;
+        };
+        type: "assertVisible";
+    }>;
+};
+
+export { assert };

package/dist/assert.js

@@ -0,0 +1,83 @@
+import {
+  toSpecLocator
+} from "./chunk-2VUWFRR5.js";
+import {
+  createStep
+} from "./chunk-MGATMMCZ.js";
+import "./chunk-DCJBLS2U.js";
+
+// src/steps/assert.ts
+var assert = {
+  not: {
+    checked(locator) {
+      return createStep({ locator: toSpecLocator(locator), type: "assertNotChecked" });
+    },
+    enabled(locator) {
+      return createStep({ locator: toSpecLocator(locator), type: "assertDisabled" });
+    },
+    focused(locator) {
+      return createStep({ locator: toSpecLocator(locator), type: "assertNotFocused" });
+    },
+    visible(locator) {
+      return createStep({ locator: toSpecLocator(locator), type: "assertNotVisible" });
+    }
+  },
+  attribute(locator, attribute, expected) {
+    return createStep({
+      attribute,
+      expected: { type: "static", value: expected },
+      locator: toSpecLocator(locator),
+      operator: "equals",
+      type: "assertAttribute"
+    });
+  },
+  checked(locator) {
+    return createStep({ locator: toSpecLocator(locator), type: "assertChecked" });
+  },
+  count(locator, expected) {
+    return createStep({
+      expected: { type: "static", value: expected },
+      locator: toSpecLocator(locator),
+      operator: "equals",
+      type: "assertCount"
+    });
+  },
+  disabled(locator) {
+    return createStep({ locator: toSpecLocator(locator), type: "assertDisabled" });
+  },
+  enabled(locator) {
+    return createStep({ locator: toSpecLocator(locator), type: "assertEnabled" });
+  },
+  focused(locator) {
+    return createStep({ locator: toSpecLocator(locator), type: "assertFocused" });
+  },
+  text(locator, expected) {
+    return createStep({
+      expected: { type: "static", value: expected },
+      locator: toSpecLocator(locator),
+      operator: "equals",
+      type: "assertText"
+    });
+  },
+  url(expected) {
+    return createStep({
+      expected: { type: "static", value: expected },
+      operator: "contains",
+      type: "assertUrl"
+    });
+  },
+  value(locator, expected) {
+    return createStep({
+      expected: { type: "static", value: expected },
+      locator: toSpecLocator(locator),
+      operator: "equals",
+      type: "assertValue"
+    });
+  },
+  visible(locator) {
+    return createStep({ locator: toSpecLocator(locator), type: "assertVisible" });
+  }
+};
+export {
+  assert
+};

package/dist/builder-DTWMrbuv.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import { S as Step } from './step-DLfkKI3V.js';
+
+declare const dslConfigSchema: z.ZodObject<{
+    appUrl: z.ZodString;
+    preconditionsUrl: z.ZodString;
+    projectId: z.ZodString;
+    webhookSecret: z.ZodString;
+}, z.core.$strip>;
+type DslConfig = z.infer<typeof dslConfigSchema>;
+interface CookieOptions {
+    readonly domain: string | undefined;
+    readonly expires: number | undefined;
+    readonly httpOnly: boolean | undefined;
+    readonly path: string | undefined;
+    readonly sameSite: "lax" | "none" | "strict" | undefined;
+    readonly secure: boolean | undefined;
+}
+interface CookieEntry {
+    readonly name: string;
+    readonly options: CookieOptions | undefined;
+    readonly value: string;
+}
+declare const TEST_VALUE_BRAND: unique symbol;
+interface TestValue {
+    readonly [TEST_VALUE_BRAND]: true;
+}
+interface SetupContext {
+    readonly runId: string;
+    fixed(value: string): TestValue;
+    setCookie(name: string, value: string, options?: CookieOptions): void;
+    uniqueEmail(): TestValue;
+    uniqueId(prefix: string): TestValue;
+}
+interface TeardownContext<TData extends Record<string, string>> {
+    readonly data: TData;
+}
+declare const PRECONDITION_DATA: unique symbol;
+declare const PRECONDITION_DEPS: unique symbol;
+declare const PRECONDITION_NAME: unique symbol;
+interface Precondition<TData extends Record<string, string> = Record<string, string>, TDeps extends Record<string, Record<string, string>> = Record<string, Record<string, string>>> {
+    readonly [PRECONDITION_DATA]: TData;
+    readonly [PRECONDITION_DEPS]: TDeps;
+    readonly [PRECONDITION_NAME]: string;
+}
+type PreconditionData<T extends Precondition> = T[typeof PRECONDITION_DATA];
+type PreconditionDeps<T extends Precondition> = T[typeof PRECONDITION_DEPS];
+interface PreconditionDefinition {
+    readonly dependsOn: ReadonlyArray<string>;
+    readonly depMapping: ReadonlyArray<readonly [string, string]>;
+    readonly description: string;
+    readonly implemented: boolean;
+    readonly name: string;
+    readonly returns: ReadonlyArray<string>;
+    readonly teardown: ((ctx: TeardownContext<Record<string, string>>) => Promise<void>) | undefined;
+    readonly setup: (ctx: SetupContext, deps: Record<string, Record<string, string>>) => Promise<Record<string, TestValue>>;
+}
+type VarsFn<T> = (vars: Record<string, Record<string, string>>) => T;
+interface TestDefinition {
+    readonly description: string;
+    readonly expectedOutcome: string;
+    readonly id: string;
+    readonly implemented: boolean;
+    readonly name: string;
+    readonly requires: ReadonlyArray<string>;
+    readonly requiresKeys: Record<string, string>;
+    readonly startsAtFn: VarsFn<string> | undefined;
+    readonly stepsFn: VarsFn<ReadonlyArray<Step>> | undefined;
+}
+interface UnimplementedItems {
+    readonly preconditions: ReadonlyArray<string>;
+    readonly tests: ReadonlyArray<string>;
+}
+
+type PreconditionRecord = Record<string, Precondition>;
+type ResolveDeps<TDeps extends PreconditionRecord> = {
+    readonly [K in keyof TDeps]: PreconditionData<TDeps[K]>;
+};
+type ResolveData<T extends Record<string, TestValue>> = {
+    readonly [K in keyof T]: string;
+};
+interface PreconditionNeedsSetup {
+    readonly contract: <TData extends Record<string, string>>() => Precondition<TData>;
+    readonly description: (text: string) => PreconditionNeedsSetup;
+    readonly notImplemented: () => Precondition<Record<string, never>>;
+    readonly requires: <TDeps extends PreconditionRecord>(deps: TDeps) => PreconditionNeedsSetupWithDeps<TDeps>;
+    readonly setup: <TData extends Record<string, TestValue>>(fn: (ctx: SetupContext) => Promise<TData>) => PreconditionHasSetup<ResolveData<TData>>;
+}
+interface PreconditionNeedsSetupWithDeps<TDeps extends PreconditionRecord> {
+    readonly contract: <TData extends Record<string, string>>() => Precondition<TData, ResolveDeps<TDeps>>;
+    readonly description: (text: string) => PreconditionNeedsSetupWithDeps<TDeps>;
+    readonly notImplemented: () => Precondition<Record<string, never>>;
+    readonly requires: <TDeps2 extends PreconditionRecord>(deps: TDeps2) => PreconditionNeedsSetupWithDeps<TDeps2>;
+    readonly setup: <TData extends Record<string, TestValue>>(fn: (ctx: SetupContext, deps: ResolveDeps<TDeps>) => Promise<TData>) => PreconditionHasSetup<ResolveData<TData>>;
+}
+interface PreconditionHasSetup<TData extends Record<string, string>> {
+    readonly teardown: (fn: (ctx: TeardownContext<TData>) => Promise<void>) => Precondition<TData>;
+}
+interface TestNeedsName {
+    readonly name: (displayName: string) => TestNeedsRequires;
+}
+interface TestNeedsRequires {
+    readonly description: (text: string) => TestNeedsRequires;
+    readonly requires: <TReqs extends PreconditionRecord>(reqs: TReqs) => TestNeedsOutcome<ResolveDeps<TReqs>>;
+}
+interface TestNeedsOutcome<TVars extends Record<string, Record<string, string>>> {
+    readonly description: (text: string) => TestNeedsOutcome<TVars>;
+    readonly expectedOutcome: (text: string) => TestNeedsStartsAt<TVars>;
+}
+interface TestNeedsStartsAt<TVars extends Record<string, Record<string, string>>> {
+    readonly notImplemented: () => void;
+    readonly startsAt: (fn: (vars: TVars) => string) => TestNeedsSteps<TVars>;
+}
+interface TestNeedsSteps<TVars extends Record<string, Record<string, string>>> {
+    readonly steps: (fn: (vars: TVars) => ReadonlyArray<Step>) => void;
+}
+
+interface PreconditionImpl<TData extends Record<string, string>, TDeps extends Record<string, Record<string, string>>> {
+    readonly setup: (ctx: SetupContext, deps: TDeps) => Promise<Record<string, TestValue>>;
+    readonly teardown: (ctx: TeardownContext<TData>) => Promise<void>;
+}
+interface RipploBuilder {
+    readonly getConfig: () => DslConfig;
+    readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
+    readonly getTests: () => ReadonlyArray<TestDefinition>;
+    readonly getUnimplemented: () => UnimplementedItems;
+    readonly implement: <TData extends Record<string, string>, TDeps extends Record<string, Record<string, string>>>(handle: Precondition<TData, TDeps>, impl: PreconditionImpl<TData, TDeps>) => void;
+    readonly precondition: (name: string) => PreconditionNeedsSetup;
+    readonly test: (id: string) => TestNeedsName;
+}
+declare function createRipplo(rawConfig: DslConfig): RipploBuilder;
+
+export { type CookieEntry as C, type DslConfig as D, type Precondition as P, type RipploBuilder as R, type SetupContext as S, type TeardownContext as T, type CookieOptions as a, type PreconditionDeps as b, type PreconditionImpl as c, type PreconditionRecord as d, type ResolveDeps as e, createRipplo as f };

package/dist/chunk-2VUWFRR5.js

@@ -0,0 +1,20 @@
+import {
+  readLocator
+} from "./chunk-DCJBLS2U.js";
+
+// src/steps/to-spec-locator.ts
+function toSpecLocator(loc) {
+  const spec = readLocator(loc);
+  switch (spec.by) {
+    case "role": {
+      return { by: "role", name: spec.name, role: spec.role };
+    }
+    case "testId": {
+      return { by: "testId", value: spec.value };
+    }
+  }
+}
+
+export {
+  toSpecLocator
+};

package/dist/chunk-DCJBLS2U.js

@@ -0,0 +1,26 @@
+// src/locators.ts
+function readLocator(loc) {
+  return loc.spec;
+}
+function makeLocator(spec) {
+  return { spec };
+}
+function role(ariaRole, name) {
+  return makeLocator({
+    by: "role",
+    name: name ?? void 0,
+    role: ariaRole
+  });
+}
+function testId(id) {
+  return makeLocator({
+    by: "testId",
+    value: id
+  });
+}
+
+export {
+  readLocator,
+  role,
+  testId
+};