@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/tests/runner.js

@@ -1,150 +1,189 @@
-import "../index.js";
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tests/runner.ts
 import { deepStrictEqual } from "assert";
 
-//#region src/tests/runner.ts
-var TestRunner = class {
-	constructor(config) {
-		this.config = config;
-	}
-	async run(spec) {
-		const scenarios = [];
-		let passed = 0;
-		let failed = 0;
-		for (const scenario of spec.scenarios) {
-			await this.config.beforeEach?.(scenario);
-			const result = await this.runScenario(spec, scenario);
-			scenarios.push(result);
-			if (result.status === "passed") passed += 1;
-			else failed += 1;
-			await this.config.afterEach?.(scenario, result);
-		}
-		return {
-			spec,
-			scenarios,
-			passed,
-			failed
-		};
-	}
-	async runScenario(spec, scenario) {
-		const assertionResults = [];
-		try {
-			const context = await this.createContext();
-			const fixtures = [...spec.fixtures ?? [], ...scenario.given ?? []];
-			const events = [];
-			for (const fixture of fixtures) await this.executeOperation(fixture, context, events);
-			const actionResult = await this.executeOperation(scenario.when, context, events);
-			const assertions = scenario.then ?? [];
-			for (const assertion of assertions) {
-				const assertionResult = this.evaluateAssertion(assertion, actionResult, events);
-				assertionResults.push(assertionResult);
-			}
-			return {
-				scenario,
-				status: assertionResults.some((assertion) => assertion.status === "failed") ? "failed" : "passed",
-				assertionResults
-			};
-		} catch (error) {
-			return {
-				scenario,
-				status: "failed",
-				error,
-				assertionResults
-			};
-		}
-	}
-	async createContext() {
-		return { ...await this.config.createContext?.() ?? {} };
-	}
-	async executeOperation(action, baseCtx, recordedEvents) {
-		const ctx = {
-			...baseCtx,
-			eventPublisher: async (event) => {
-				recordedEvents.push({
-					key: event.key,
-					version: event.version,
-					payload: event.payload
-				});
-				await baseCtx.eventPublisher?.(event);
-			}
-		};
-		try {
-			return {
-				output: await this.config.registry.execute(action.operation.key, action.operation.version, action.input ?? null, ctx),
-				events: recordedEvents
-			};
-		} catch (error) {
-			return {
-				error,
-				events: recordedEvents
-			};
-		}
-	}
-	evaluateAssertion(assertion, result, events) {
-		switch (assertion.type) {
-			case "expectOutput": return this.evaluateOutputAssertion(assertion, result);
-			case "expectError": return this.evaluateErrorAssertion(assertion, result);
-			case "expectEvents": return this.evaluateEventsAssertion(assertion, events);
-			default: return {
-				assertion,
-				status: "failed",
-				message: `Unknown assertion type ${assertion.type}`
-			};
-		}
-	}
-	evaluateOutputAssertion(assertion, result) {
-		if (result.error) return {
-			assertion,
-			status: "failed",
-			message: `Expected output but operation threw error: ${result.error.message}`
-		};
-		try {
-			deepStrictEqual(result.output, assertion.match);
-			return {
-				assertion,
-				status: "passed"
-			};
-		} catch (error) {
-			return {
-				assertion,
-				status: "failed",
-				message: error instanceof Error ? error.message : "Output assertion failed"
-			};
-		}
-	}
-	evaluateErrorAssertion(assertion, result) {
-		if (!result.error) return {
-			assertion,
-			status: "failed",
-			message: "Expected an error but operation completed successfully"
-		};
-		if (assertion.messageIncludes && !result.error.message.includes(assertion.messageIncludes)) return {
-			assertion,
-			status: "failed",
-			message: `Error message "${result.error.message}" did not include expected substring "${assertion.messageIncludes}"`
-		};
-		return {
-			assertion,
-			status: "passed"
-		};
-	}
-	evaluateEventsAssertion(assertion, events) {
-		const failures = [];
-		for (const expected of assertion.events) {
-			const count = events.filter((event) => event.key === expected.key && event.version === expected.version).length;
-			if (typeof expected.min === "number" && count < expected.min || typeof expected.max === "number" && count > expected.max) failures.push(`Event ${expected.key}.v${expected.version} occurred ${count} times (expected ${expected.min ?? 0} - ${expected.max ?? "∞"})`);
-			else if (typeof expected.min === "undefined" && typeof expected.max === "undefined" && count === 0) failures.push(`Event ${expected.key}.v${expected.version} did not occur`);
-		}
-		if (failures.length > 0) return {
-			assertion,
-			status: "failed",
-			message: failures.join("; ")
-		};
-		return {
-			assertion,
-			status: "passed"
-		};
-	}
+class TestRunner {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async run(spec) {
+    const scenarios = [];
+    let passed = 0;
+    let failed = 0;
+    for (const scenario of spec.scenarios) {
+      await this.config.beforeEach?.(scenario);
+      const result = await this.runScenario(spec, scenario);
+      scenarios.push(result);
+      if (result.status === "passed")
+        passed += 1;
+      else
+        failed += 1;
+      await this.config.afterEach?.(scenario, result);
+    }
+    return {
+      spec,
+      scenarios,
+      passed,
+      failed
+    };
+  }
+  async runScenario(spec, scenario) {
+    const assertionResults = [];
+    try {
+      const context = await this.createContext();
+      const fixtures = [...spec.fixtures ?? [], ...scenario.given ?? []];
+      const events = [];
+      for (const fixture of fixtures) {
+        await this.executeOperation(fixture, context, events);
+      }
+      const actionResult = await this.executeOperation(scenario.when, context, events);
+      const assertions = scenario.then ?? [];
+      for (const assertion of assertions) {
+        const assertionResult = this.evaluateAssertion(assertion, actionResult, events);
+        assertionResults.push(assertionResult);
+      }
+      const hasFailure = assertionResults.some((assertion) => assertion.status === "failed");
+      return {
+        scenario,
+        status: hasFailure ? "failed" : "passed",
+        assertionResults
+      };
+    } catch (error) {
+      return {
+        scenario,
+        status: "failed",
+        error,
+        assertionResults
+      };
+    }
+  }
+  async createContext() {
+    const baseCtx = await this.config.createContext?.() ?? {};
+    return { ...baseCtx };
+  }
+  async executeOperation(action, baseCtx, recordedEvents) {
+    const ctx = {
+      ...baseCtx,
+      eventPublisher: async (event) => {
+        recordedEvents.push({
+          key: event.key,
+          version: event.version,
+          payload: event.payload
+        });
+        await baseCtx.eventPublisher?.(event);
+      }
+    };
+    try {
+      const output = await this.config.registry.execute(action.operation.key, action.operation.version, action.input ?? null, ctx);
+      return { output, events: recordedEvents };
+    } catch (error) {
+      return { error, events: recordedEvents };
+    }
+  }
+  evaluateAssertion(assertion, result, events) {
+    switch (assertion.type) {
+      case "expectOutput":
+        return this.evaluateOutputAssertion(assertion, result);
+      case "expectError":
+        return this.evaluateErrorAssertion(assertion, result);
+      case "expectEvents":
+        return this.evaluateEventsAssertion(assertion, events);
+      default:
+        return {
+          assertion,
+          status: "failed",
+          message: `Unknown assertion type ${assertion.type}`
+        };
+    }
+  }
+  evaluateOutputAssertion(assertion, result) {
+    if (result.error) {
+      return {
+        assertion,
+        status: "failed",
+        message: `Expected output but operation threw error: ${result.error.message}`
+      };
+    }
+    try {
+      deepStrictEqual(result.output, assertion.match);
+      return { assertion, status: "passed" };
+    } catch (error) {
+      return {
+        assertion,
+        status: "failed",
+        message: error instanceof Error ? error.message : "Output assertion failed"
+      };
+    }
+  }
+  evaluateErrorAssertion(assertion, result) {
+    if (!result.error) {
+      return {
+        assertion,
+        status: "failed",
+        message: "Expected an error but operation completed successfully"
+      };
+    }
+    if (assertion.messageIncludes && !result.error.message.includes(assertion.messageIncludes)) {
+      return {
+        assertion,
+        status: "failed",
+        message: `Error message "${result.error.message}" did not include expected substring "${assertion.messageIncludes}"`
+      };
+    }
+    return { assertion, status: "passed" };
+  }
+  evaluateEventsAssertion(assertion, events) {
+    const failures = [];
+    for (const expected of assertion.events) {
+      const matches = events.filter((event) => event.key === expected.key && event.version === expected.version);
+      const count = matches.length;
+      if (typeof expected.min === "number" && count < expected.min || typeof expected.max === "number" && count > expected.max) {
+        failures.push(`Event ${expected.key}.v${expected.version} occurred ${count} times (expected ${expected.min ?? 0} - ${expected.max ?? "\u221E"})`);
+      } else if (typeof expected.min === "undefined" && typeof expected.max === "undefined" && count === 0) {
+        failures.push(`Event ${expected.key}.v${expected.version} did not occur`);
+      }
+    }
+    if (failures.length > 0) {
+      return {
+        assertion,
+        status: "failed",
+        message: failures.join("; ")
+      };
+    }
+    return { assertion, status: "passed" };
+  }
+}
+export {
+  TestRunner
 };
-
-//#endregion
-export { TestRunner };

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runner.test.d.ts.map

package/dist/tests/runner.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.test.d.ts","sourceRoot":"","sources":["../../src/tests/runner.test.ts"],"names":[],"mappings":""}

package/dist/tests/spec.d.ts

@@ -1,87 +1,83 @@
-import { OptionalVersionedSpecRef } from "../versioning/refs.js";
-import { OwnerShipMeta } from "../ownership.js";
-
-//#region src/tests/spec.d.ts
-
+import type { OwnerShipMeta } from '../ownership';
+import type { OptionalVersionedSpecRef } from '../versioning';
 /**
  * Reference to an operation to be tested.
  * Version is optional; when omitted, refers to the latest version.
  */
-type OperationTargetRef = OptionalVersionedSpecRef;
+export type OperationTargetRef = OptionalVersionedSpecRef;
 /**
  * Reference to a workflow to be tested.
  * Version is optional; when omitted, refers to the latest version.
  */
-type WorkflowTargetRef = OptionalVersionedSpecRef;
-type TestTarget = {
-  type: 'operation';
-  operation: OperationTargetRef;
+export type WorkflowTargetRef = OptionalVersionedSpecRef;
+export type TestTarget = {
+    type: 'operation';
+    operation: OperationTargetRef;
 } | {
-  type: 'workflow';
-  workflow: WorkflowTargetRef;
+    type: 'workflow';
+    workflow: WorkflowTargetRef;
 };
-interface Fixture {
-  description?: string;
-  operation: OperationTargetRef;
-  input?: unknown;
+export interface Fixture {
+    description?: string;
+    operation: OperationTargetRef;
+    input?: unknown;
 }
-interface Action {
-  operation: OperationTargetRef;
-  input?: unknown;
+export interface Action {
+    operation: OperationTargetRef;
+    input?: unknown;
 }
-interface ExpectOutputAssertion {
-  type: 'expectOutput';
-  match: unknown;
+export interface ExpectOutputAssertion {
+    type: 'expectOutput';
+    match: unknown;
 }
-interface ExpectErrorAssertion {
-  type: 'expectError';
-  messageIncludes?: string;
+export interface ExpectErrorAssertion {
+    type: 'expectError';
+    messageIncludes?: string;
 }
-interface ExpectedEvent {
-  key: string;
-  version: string;
-  min?: number;
-  max?: number;
+export interface ExpectedEvent {
+    key: string;
+    version: string;
+    min?: number;
+    max?: number;
 }
-interface ExpectEventsAssertion {
-  type: 'expectEvents';
-  events: ExpectedEvent[];
+export interface ExpectEventsAssertion {
+    type: 'expectEvents';
+    events: ExpectedEvent[];
 }
-type Assertion = ExpectOutputAssertion | ExpectErrorAssertion | ExpectEventsAssertion;
-interface TestScenario {
-  key: string;
-  description?: string;
-  given?: Fixture[];
-  when: Action;
-  then?: Assertion[];
+export type Assertion = ExpectOutputAssertion | ExpectErrorAssertion | ExpectEventsAssertion;
+export interface TestScenario {
+    key: string;
+    description?: string;
+    given?: Fixture[];
+    when: Action;
+    then?: Assertion[];
 }
-interface CoverageRequirement {
-  statements?: number;
-  branches?: number;
-  functions?: number;
-  lines?: number;
-  mutations?: number;
+export interface CoverageRequirement {
+    statements?: number;
+    branches?: number;
+    functions?: number;
+    lines?: number;
+    mutations?: number;
 }
-type TestSpecMeta = OwnerShipMeta;
-interface TestSpec {
-  meta: TestSpecMeta;
-  target: TestTarget;
-  fixtures?: Fixture[];
-  scenarios: TestScenario[];
-  coverage?: CoverageRequirement;
+export type TestSpecMeta = OwnerShipMeta;
+export interface TestSpec {
+    meta: TestSpecMeta;
+    target: TestTarget;
+    fixtures?: Fixture[];
+    scenarios: TestScenario[];
+    coverage?: CoverageRequirement;
 }
 /**
  * Reference to a test spec.
  * Version is optional; when omitted, refers to the latest version.
  */
-type TestSpecRef = OptionalVersionedSpecRef;
-declare class TestRegistry {
-  private readonly items;
-  register(spec: TestSpec): this;
-  list(): TestSpec[];
-  get(name: string, version?: string): TestSpec | undefined;
+export type TestSpecRef = OptionalVersionedSpecRef;
+export declare class TestRegistry {
+    private readonly items;
+    register(spec: TestSpec): this;
+    list(): TestSpec[];
+    get(name: string, version?: string): TestSpec | undefined;
 }
-declare function makeTestKey(meta: TestSpecMeta): string;
-declare function defineTestSpec(spec: TestSpec): TestSpec;
-//#endregion
-export { Action, Assertion, CoverageRequirement, ExpectErrorAssertion, ExpectEventsAssertion, ExpectOutputAssertion, ExpectedEvent, Fixture, OperationTargetRef, TestRegistry, TestScenario, TestSpec, TestSpecMeta, TestSpecRef, TestTarget, WorkflowTargetRef, defineTestSpec, makeTestKey };
+export declare function makeTestKey(meta: TestSpecMeta): string;
+export declare function defineTestSpec(spec: TestSpec): TestSpec;
+//# sourceMappingURL=spec.d.ts.map

package/dist/tests/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/tests/spec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AAEzD,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,kBAAkB,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAEtD,MAAM,WAAW,OAAO;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,aAAa,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED,MAAM,MAAM,SAAS,GACjB,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC;AAEzC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,wBAAwB,CAAC;AAInD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IAErD,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAS9B,IAAI,IAAI,QAAQ,EAAE;IAIlB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;CAgB1D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,UAE7C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,YAE5C"}

package/dist/tests/spec.js

@@ -1,34 +1,74 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tests/spec.ts
 import { compareVersions } from "compare-versions";
+var testKey = (meta) => `${meta.key}.v${meta.version}`;
 
-//#region src/tests/spec.ts
-const testKey = (meta) => `${meta.key}.v${meta.version}`;
-var TestRegistry = class {
-	items = /* @__PURE__ */ new Map();
-	register(spec) {
-		const key = testKey(spec.meta);
-		if (this.items.has(key)) throw new Error(`Duplicate TestSpec registration for ${key}`);
-		this.items.set(key, spec);
-		return this;
-	}
-	list() {
-		return [...this.items.values()];
-	}
-	get(name, version) {
-		if (version != null) return this.items.get(`${name}.v${version}`);
-		let latest;
-		for (const spec of this.items.values()) {
-			if (spec.meta.key !== name) continue;
-			if (!latest || compareVersions(spec.meta.version, latest.meta.version) > 0) latest = spec;
-		}
-		return latest;
-	}
-};
+class TestRegistry {
+  items = new Map;
+  register(spec) {
+    const key = testKey(spec.meta);
+    if (this.items.has(key)) {
+      throw new Error(`Duplicate TestSpec registration for ${key}`);
+    }
+    this.items.set(key, spec);
+    return this;
+  }
+  list() {
+    return [...this.items.values()];
+  }
+  get(name, version) {
+    if (version != null) {
+      return this.items.get(`${name}.v${version}`);
+    }
+    let latest;
+    for (const spec of this.items.values()) {
+      if (spec.meta.key !== name)
+        continue;
+      if (!latest || compareVersions(spec.meta.version, latest.meta.version) > 0) {
+        latest = spec;
+      }
+    }
+    return latest;
+  }
+}
 function makeTestKey(meta) {
-	return testKey(meta);
+  return testKey(meta);
 }
 function defineTestSpec(spec) {
-	return spec;
+  return spec;
 }
-
-//#endregion
-export { TestRegistry, defineTestSpec, makeTestKey };
+export {
+  makeTestKey,
+  defineTestSpec,
+  TestRegistry
+};

package/dist/tests/spec.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spec.test.d.ts.map

package/dist/tests/spec.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.test.d.ts","sourceRoot":"","sources":["../../src/tests/spec.test.ts"],"names":[],"mappings":""}