@voidhash/mimic-effect 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/testing/assertions.cjs

@@ -0,0 +1,117 @@
+const require_types = require('./types.cjs');
+let effect = require("effect");
+
+//#region src/testing/assertions.ts
+/**
+* @voidhash/mimic-effect/testing - Assertion Helpers
+*
+* Internal assertion helpers used by the test suites.
+*/
+/**
+* Deep equality check that handles objects, arrays, and primitives.
+* Skips function properties since reconstructed objects (like OperationPath)
+* will have new function instances even when the underlying data is identical.
+*/
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	if (a === null || b === null) return a === b;
+	if (a === void 0 || b === void 0) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "function" && typeof b === "function") return true;
+	if (typeof a === "number" && typeof b === "number") {
+		if (Number.isNaN(a) && Number.isNaN(b)) return true;
+		return a === b;
+	}
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!isDeepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const aObj = a;
+		const bObj = b;
+		const aKeys = Object.keys(aObj).filter((k) => typeof aObj[k] !== "function");
+		const bKeys = Object.keys(bObj).filter((k) => typeof bObj[k] !== "function");
+		if (aKeys.length !== bKeys.length) return false;
+		for (const key of aKeys) {
+			if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+			if (!isDeepEqual(aObj[key], bObj[key])) return false;
+		}
+		return true;
+	}
+	return false;
+};
+/**
+* Assert that two values are deeply equal.
+*/
+const assertEqual = (actual, expected, message) => effect.Effect.gen(function* () {
+	if (!isDeepEqual(actual, expected)) yield* effect.Effect.fail(new require_types.TestError({
+		message,
+		expected,
+		actual
+	}));
+});
+/**
+* Assert that a condition is true.
+*/
+const assertTrue = (condition, message) => effect.Effect.gen(function* () {
+	if (!condition) yield* effect.Effect.fail(new require_types.TestError({ message }));
+});
+/**
+* Assert that a value is undefined.
+*/
+const assertUndefined = (value, message) => effect.Effect.gen(function* () {
+	if (value !== void 0) yield* effect.Effect.fail(new require_types.TestError({
+		message,
+		expected: void 0,
+		actual: value
+	}));
+});
+/**
+* Assert that a value is defined (not undefined).
+*/
+const assertDefined = (value, message) => effect.Effect.gen(function* () {
+	if (value === void 0) yield* effect.Effect.fail(new require_types.TestError({
+		message,
+		expected: "defined value",
+		actual: void 0
+	}));
+	return value;
+});
+/**
+* Assert that an array has the expected length.
+*/
+const assertLength = (array, expectedLength, message) => effect.Effect.gen(function* () {
+	if (array.length !== expectedLength) yield* effect.Effect.fail(new require_types.TestError({
+		message,
+		expected: expectedLength,
+		actual: array.length
+	}));
+});
+/**
+* Assert that an array is empty.
+*/
+const assertEmpty = (array, message) => assertLength(array, 0, message);
+/**
+* Assert that an array is sorted by a key.
+*/
+const assertSortedBy = (array, key, message) => effect.Effect.gen(function* () {
+	for (let i = 1; i < array.length; i++) {
+		const prev = array[i - 1][key];
+		const curr = array[i][key];
+		if (prev > curr) yield* effect.Effect.fail(new require_types.TestError({
+			message,
+			expected: `array sorted by ${String(key)}`,
+			actual: `element at index ${i - 1} (${prev}) > element at index ${i} (${curr})`
+		}));
+	}
+});
+
+//#endregion
+exports.assertDefined = assertDefined;
+exports.assertEmpty = assertEmpty;
+exports.assertEqual = assertEqual;
+exports.assertLength = assertLength;
+exports.assertSortedBy = assertSortedBy;
+exports.assertTrue = assertTrue;
+exports.assertUndefined = assertUndefined;

package/dist/testing/assertions.mjs

@@ -0,0 +1,112 @@
+import { TestError } from "./types.mjs";
+import { Effect } from "effect";
+
+//#region src/testing/assertions.ts
+/**
+* @voidhash/mimic-effect/testing - Assertion Helpers
+*
+* Internal assertion helpers used by the test suites.
+*/
+/**
+* Deep equality check that handles objects, arrays, and primitives.
+* Skips function properties since reconstructed objects (like OperationPath)
+* will have new function instances even when the underlying data is identical.
+*/
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	if (a === null || b === null) return a === b;
+	if (a === void 0 || b === void 0) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "function" && typeof b === "function") return true;
+	if (typeof a === "number" && typeof b === "number") {
+		if (Number.isNaN(a) && Number.isNaN(b)) return true;
+		return a === b;
+	}
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!isDeepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const aObj = a;
+		const bObj = b;
+		const aKeys = Object.keys(aObj).filter((k) => typeof aObj[k] !== "function");
+		const bKeys = Object.keys(bObj).filter((k) => typeof bObj[k] !== "function");
+		if (aKeys.length !== bKeys.length) return false;
+		for (const key of aKeys) {
+			if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+			if (!isDeepEqual(aObj[key], bObj[key])) return false;
+		}
+		return true;
+	}
+	return false;
+};
+/**
+* Assert that two values are deeply equal.
+*/
+const assertEqual = (actual, expected, message) => Effect.gen(function* () {
+	if (!isDeepEqual(actual, expected)) yield* Effect.fail(new TestError({
+		message,
+		expected,
+		actual
+	}));
+});
+/**
+* Assert that a condition is true.
+*/
+const assertTrue = (condition, message) => Effect.gen(function* () {
+	if (!condition) yield* Effect.fail(new TestError({ message }));
+});
+/**
+* Assert that a value is undefined.
+*/
+const assertUndefined = (value, message) => Effect.gen(function* () {
+	if (value !== void 0) yield* Effect.fail(new TestError({
+		message,
+		expected: void 0,
+		actual: value
+	}));
+});
+/**
+* Assert that a value is defined (not undefined).
+*/
+const assertDefined = (value, message) => Effect.gen(function* () {
+	if (value === void 0) yield* Effect.fail(new TestError({
+		message,
+		expected: "defined value",
+		actual: void 0
+	}));
+	return value;
+});
+/**
+* Assert that an array has the expected length.
+*/
+const assertLength = (array, expectedLength, message) => Effect.gen(function* () {
+	if (array.length !== expectedLength) yield* Effect.fail(new TestError({
+		message,
+		expected: expectedLength,
+		actual: array.length
+	}));
+});
+/**
+* Assert that an array is empty.
+*/
+const assertEmpty = (array, message) => assertLength(array, 0, message);
+/**
+* Assert that an array is sorted by a key.
+*/
+const assertSortedBy = (array, key, message) => Effect.gen(function* () {
+	for (let i = 1; i < array.length; i++) {
+		const prev = array[i - 1][key];
+		const curr = array[i][key];
+		if (prev > curr) yield* Effect.fail(new TestError({
+			message,
+			expected: `array sorted by ${String(key)}`,
+			actual: `element at index ${i - 1} (${prev}) > element at index ${i} (${curr})`
+		}));
+	}
+});
+
+//#endregion
+export { assertDefined, assertEmpty, assertEqual, assertLength, assertSortedBy, assertTrue, assertUndefined };
+//# sourceMappingURL=assertions.mjs.map

package/dist/testing/assertions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.mjs","names":[],"sources":["../../src/testing/assertions.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect/testing - Assertion Helpers\n *\n * Internal assertion helpers used by the test suites.\n */\nimport { Effect } from \"effect\";\nimport { TestError } from \"./types\";\n\n// =============================================================================\n// Deep Equality\n// =============================================================================\n\n/**\n * Deep equality check that handles objects, arrays, and primitives.\n * Skips function properties since reconstructed objects (like OperationPath)\n * will have new function instances even when the underlying data is identical.\n */\nexport const isDeepEqual = (a: unknown, b: unknown): boolean => {\n  if (a === b) return true;\n\n  if (a === null || b === null) return a === b;\n  if (a === undefined || b === undefined) return a === b;\n\n  if (typeof a !== typeof b) return false;\n\n  // Skip function comparison - functions with same behavior but different references should be considered equal\n  if (typeof a === \"function\" && typeof b === \"function\") return true;\n\n  if (typeof a === \"number\" && typeof b === \"number\") {\n    if (Number.isNaN(a) && Number.isNaN(b)) return true;\n    return a === b;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!isDeepEqual(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  if (typeof a === \"object\" && typeof b === \"object\") {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n\n    // Filter out function properties for comparison\n    const aKeys = Object.keys(aObj).filter(k => typeof aObj[k] !== \"function\");\n    const bKeys = Object.keys(bObj).filter(k => typeof bObj[k] !== \"function\");\n\n    if (aKeys.length !== bKeys.length) return false;\n\n    for (const key of aKeys) {\n      if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;\n      if (!isDeepEqual(aObj[key], bObj[key])) return false;\n    }\n\n    return true;\n  }\n\n  return false;\n};\n\n// =============================================================================\n// Assertion Helpers\n// =============================================================================\n\n/**\n * Assert that two values are deeply equal.\n */\nexport const assertEqual = <T>(\n  actual: T,\n  expected: T,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    if (!isDeepEqual(actual, expected)) {\n      yield* Effect.fail(new TestError({ message, expected, actual }));\n    }\n  });\n\n/**\n * Assert that a condition is true.\n */\nexport const assertTrue = (\n  condition: boolean,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    if (!condition) {\n      yield* Effect.fail(new TestError({ message }));\n    }\n  });\n\n/**\n * Assert that a condition is false.\n */\nexport const assertFalse = (\n  condition: boolean,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    if (condition) {\n      yield* Effect.fail(new TestError({ message }));\n    }\n  });\n\n/**\n * Assert that a value is undefined.\n */\nexport const assertUndefined = (\n  value: unknown,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    if (value !== undefined) {\n      yield* Effect.fail(\n        new TestError({ message, expected: undefined, actual: value })\n      );\n    }\n  });\n\n/**\n * Assert that a value is defined (not undefined).\n */\nexport const assertDefined = <T>(\n  value: T | undefined,\n  message: string\n): Effect.Effect<T, TestError> =>\n  Effect.gen(function* () {\n    if (value === undefined) {\n      yield* Effect.fail(\n        new TestError({ message, expected: \"defined value\", actual: undefined })\n      );\n    }\n    return value as T;\n  });\n\n/**\n * Assert that an array has the expected length.\n */\nexport const assertLength = <T>(\n  array: T[],\n  expectedLength: number,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    if (array.length !== expectedLength) {\n      yield* Effect.fail(\n        new TestError({\n          message,\n          expected: expectedLength,\n          actual: array.length,\n        })\n      );\n    }\n  });\n\n/**\n * Assert that an array is empty.\n */\nexport const assertEmpty = <T>(\n  array: T[],\n  message: string\n): Effect.Effect<void, TestError> => assertLength(array, 0, message);\n\n/**\n * Assert that an array is sorted by a key.\n */\nexport const assertSortedBy = <T>(\n  array: T[],\n  key: keyof T,\n  message: string\n): Effect.Effect<void, TestError> =>\n  Effect.gen(function* () {\n    for (let i = 1; i < array.length; i++) {\n      const prev = array[i - 1]![key];\n      const curr = array[i]![key];\n      if (prev > curr) {\n        yield* Effect.fail(\n          new TestError({\n            message,\n            expected: `array sorted by ${String(key)}`,\n            actual: `element at index ${i - 1} (${prev}) > element at index ${i} (${curr})`,\n          })\n        );\n      }\n    }\n  });\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,eAAe,GAAY,MAAwB;AAC9D,KAAI,MAAM,EAAG,QAAO;AAEpB,KAAI,MAAM,QAAQ,MAAM,KAAM,QAAO,MAAM;AAC3C,KAAI,MAAM,UAAa,MAAM,OAAW,QAAO,MAAM;AAErD,KAAI,OAAO,MAAM,OAAO,EAAG,QAAO;AAGlC,KAAI,OAAO,MAAM,cAAc,OAAO,MAAM,WAAY,QAAO;AAE/D,KAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAClD,MAAI,OAAO,MAAM,EAAE,IAAI,OAAO,MAAM,EAAE,CAAE,QAAO;AAC/C,SAAO,MAAM;;AAGf,KAAI,MAAM,QAAQ,EAAE,IAAI,MAAM,QAAQ,EAAE,EAAE;AACxC,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,OAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,KAAI,CAAC,YAAY,EAAE,IAAI,EAAE,GAAG,CAAE,QAAO;AAEvC,SAAO;;AAGT,KAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;EAClD,MAAM,OAAO;EACb,MAAM,OAAO;EAGb,MAAM,QAAQ,OAAO,KAAK,KAAK,CAAC,QAAO,MAAK,OAAO,KAAK,OAAO,WAAW;EAC1E,MAAM,QAAQ,OAAO,KAAK,KAAK,CAAC,QAAO,MAAK,OAAO,KAAK,OAAO,WAAW;AAE1E,MAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;AAE1C,OAAK,MAAM,OAAO,OAAO;AACvB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,IAAI,CAAE,QAAO;AAC7D,OAAI,CAAC,YAAY,KAAK,MAAM,KAAK,KAAK,CAAE,QAAO;;AAGjD,SAAO;;AAGT,QAAO;;;;;AAUT,MAAa,eACX,QACA,UACA,YAEA,OAAO,IAAI,aAAa;AACtB,KAAI,CAAC,YAAY,QAAQ,SAAS,CAChC,QAAO,OAAO,KAAK,IAAI,UAAU;EAAE;EAAS;EAAU;EAAQ,CAAC,CAAC;EAElE;;;;AAKJ,MAAa,cACX,WACA,YAEA,OAAO,IAAI,aAAa;AACtB,KAAI,CAAC,UACH,QAAO,OAAO,KAAK,IAAI,UAAU,EAAE,SAAS,CAAC,CAAC;EAEhD;;;;AAkBJ,MAAa,mBACX,OACA,YAEA,OAAO,IAAI,aAAa;AACtB,KAAI,UAAU,OACZ,QAAO,OAAO,KACZ,IAAI,UAAU;EAAE;EAAS,UAAU;EAAW,QAAQ;EAAO,CAAC,CAC/D;EAEH;;;;AAKJ,MAAa,iBACX,OACA,YAEA,OAAO,IAAI,aAAa;AACtB,KAAI,UAAU,OACZ,QAAO,OAAO,KACZ,IAAI,UAAU;EAAE;EAAS,UAAU;EAAiB,QAAQ;EAAW,CAAC,CACzE;AAEH,QAAO;EACP;;;;AAKJ,MAAa,gBACX,OACA,gBACA,YAEA,OAAO,IAAI,aAAa;AACtB,KAAI,MAAM,WAAW,eACnB,QAAO,OAAO,KACZ,IAAI,UAAU;EACZ;EACA,UAAU;EACV,QAAQ,MAAM;EACf,CAAC,CACH;EAEH;;;;AAKJ,MAAa,eACX,OACA,YACmC,aAAa,OAAO,GAAG,QAAQ;;;;AAKpE,MAAa,kBACX,OACA,KACA,YAEA,OAAO,IAAI,aAAa;AACtB,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM,IAAI,GAAI;EAC3B,MAAM,OAAO,MAAM,GAAI;AACvB,MAAI,OAAO,KACT,QAAO,OAAO,KACZ,IAAI,UAAU;GACZ;GACA,UAAU,mBAAmB,OAAO,IAAI;GACxC,QAAQ,oBAAoB,IAAI,EAAE,IAAI,KAAK,uBAAuB,EAAE,IAAI,KAAK;GAC9E,CAAC,CACH;;EAGL"}

package/dist/testing/index.cjs

@@ -0,0 +1,14 @@
+const require_types = require('./types.cjs');
+const require_ColdStorageTestSuite = require('./ColdStorageTestSuite.cjs');
+const require_HotStorageTestSuite = require('./HotStorageTestSuite.cjs');
+const require_StorageIntegrationTestSuite = require('./StorageIntegrationTestSuite.cjs');
+const require_FailingStorage = require('./FailingStorage.cjs');
+
+exports.ColdStorageCategories = require_ColdStorageTestSuite.Categories;
+exports.ColdStorageTestSuite = require_ColdStorageTestSuite.ColdStorageTestSuite;
+exports.FailingStorage = require_FailingStorage.FailingStorage;
+exports.HotStorageCategories = require_HotStorageTestSuite.Categories;
+exports.HotStorageTestSuite = require_HotStorageTestSuite.HotStorageTestSuite;
+exports.IntegrationCategories = require_StorageIntegrationTestSuite.Categories;
+exports.StorageIntegrationTestSuite = require_StorageIntegrationTestSuite.StorageIntegrationTestSuite;
+exports.TestError = require_types.TestError;

package/dist/testing/index.d.cts

@@ -0,0 +1,6 @@
+import { FailedTest, StorageTestCase, TestError, TestResults } from "./types.cjs";
+import { Categories, ColdStorageTestError, ColdStorageTestSuite } from "./ColdStorageTestSuite.cjs";
+import { Categories as Categories$1, HotStorageTestError, HotStorageTestSuite } from "./HotStorageTestSuite.cjs";
+import { Categories as Categories$2, StorageIntegrationTestSuite } from "./StorageIntegrationTestSuite.cjs";
+import { FailingColdStorageConfig, FailingHotStorageConfig, FailingStorage } from "./FailingStorage.cjs";
+export { Categories as ColdStorageCategories, type ColdStorageTestError, ColdStorageTestSuite, type FailedTest, type FailingColdStorageConfig, type FailingHotStorageConfig, FailingStorage, Categories$1 as HotStorageCategories, type HotStorageTestError, HotStorageTestSuite, Categories$2 as IntegrationCategories, StorageIntegrationTestSuite, type StorageTestCase, TestError, type TestResults };

package/dist/testing/index.d.mts

@@ -0,0 +1,6 @@
+import { FailedTest, StorageTestCase, TestError, TestResults } from "./types.mjs";
+import { Categories, ColdStorageTestError, ColdStorageTestSuite } from "./ColdStorageTestSuite.mjs";
+import { Categories as Categories$1, HotStorageTestError, HotStorageTestSuite } from "./HotStorageTestSuite.mjs";
+import { Categories as Categories$2, StorageIntegrationTestSuite } from "./StorageIntegrationTestSuite.mjs";
+import { FailingColdStorageConfig, FailingHotStorageConfig, FailingStorage } from "./FailingStorage.mjs";
+export { Categories as ColdStorageCategories, type ColdStorageTestError, ColdStorageTestSuite, type FailedTest, type FailingColdStorageConfig, type FailingHotStorageConfig, FailingStorage, Categories$1 as HotStorageCategories, type HotStorageTestError, HotStorageTestSuite, Categories$2 as IntegrationCategories, StorageIntegrationTestSuite, type StorageTestCase, TestError, type TestResults };

package/dist/testing/index.mjs

@@ -0,0 +1,7 @@
+import { TestError } from "./types.mjs";
+import { Categories, ColdStorageTestSuite } from "./ColdStorageTestSuite.mjs";
+import { Categories as Categories$1, HotStorageTestSuite } from "./HotStorageTestSuite.mjs";
+import { Categories as Categories$2, StorageIntegrationTestSuite } from "./StorageIntegrationTestSuite.mjs";
+import { FailingStorage } from "./FailingStorage.mjs";
+
+export { Categories as ColdStorageCategories, ColdStorageTestSuite, FailingStorage, Categories$1 as HotStorageCategories, HotStorageTestSuite, Categories$2 as IntegrationCategories, StorageIntegrationTestSuite, TestError };

package/dist/testing/types.cjs

@@ -0,0 +1,15 @@
+let effect = require("effect");
+
+//#region src/testing/types.ts
+/**
+* @voidhash/mimic-effect/testing - Core Types
+*
+* Types used by the storage adapter test utilities.
+*/
+/**
+* Error thrown when a test assertion fails.
+*/
+var TestError = class extends effect.Data.TaggedError("TestError") {};
+
+//#endregion
+exports.TestError = TestError;

package/dist/testing/types.d.cts

@@ -0,0 +1,90 @@
+import { Effect } from "effect";
+import * as effect_Types7 from "effect/Types";
+import * as effect_Cause7 from "effect/Cause";
+
+//#region src/testing/types.d.ts
+
+declare const TestError_base: new <A extends Record<string, any> = {}>(args: effect_Types7.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause7.YieldableError & {
+  readonly _tag: "TestError";
+} & Readonly<A>;
+/**
+ * Error thrown when a test assertion fails.
+ */
+declare class TestError extends TestError_base<{
+  /** Description of what failed */
+  readonly message: string;
+  /** Expected value (if applicable) */
+  readonly expected?: unknown;
+  /** Actual value received (if applicable) */
+  readonly actual?: unknown;
+}> {}
+/**
+ * A single storage adapter test case.
+ *
+ * Test cases are framework-agnostic Effects that can be run with any test runner.
+ *
+ * @template E - The error type for this test case
+ * @template R - The Effect requirements (e.g., ColdStorageTag or HotStorageTag)
+ *
+ * @example
+ * ```typescript
+ * // Using with vitest
+ * const tests = ColdStorageTestSuite.makeTests();
+ *
+ * describe("MyAdapter", () => {
+ *   for (const test of tests) {
+ *     it(test.name, () =>
+ *       Effect.runPromise(test.run.pipe(Effect.provide(myAdapterLayer)))
+ *     );
+ *   }
+ * });
+ * ```
+ */
+interface StorageTestCase<E, R> {
+  /** Human-readable test name */
+  readonly name: string;
+  /** Category for grouping (e.g., "Basic Operations", "Data Integrity") */
+  readonly category: string;
+  /** The test as an Effect - succeeds if test passes, fails with error if not */
+  readonly run: Effect.Effect<void, E, R>;
+}
+/**
+ * Result of a failed test.
+ */
+interface FailedTest<E, R> {
+  /** The test case that failed */
+  readonly test: StorageTestCase<E, R>;
+  /** The error that caused the failure */
+  readonly error: E;
+}
+/**
+ * Results from running all tests in a suite.
+ *
+ * @example
+ * ```typescript
+ * const results = await Effect.runPromise(
+ *   ColdStorageTestSuite.runAll().pipe(Effect.provide(myAdapterLayer))
+ * );
+ *
+ * console.log(`Passed: ${results.passCount}/${results.total}`);
+ *
+ * for (const { test, error } of results.failed) {
+ *   console.error(`FAIL: ${test.name} - ${error._tag}`);
+ * }
+ * ```
+ */
+interface TestResults<E, R> {
+  /** Tests that passed */
+  readonly passed: StorageTestCase<E, R>[];
+  /** Tests that failed with their errors */
+  readonly failed: FailedTest<E, R>[];
+  /** Total number of tests run */
+  readonly total: number;
+  /** Number of tests that passed */
+  readonly passCount: number;
+  /** Number of tests that failed */
+  readonly failCount: number;
+}
+//#endregion
+export { FailedTest, StorageTestCase, TestError, TestResults };
+//# sourceMappingURL=types.d.cts.map

package/dist/testing/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/testing/types.ts"],"sourcesContent":[],"mappings":";;;;;;cAKsC;;;;;;cASzB,SAAA,SAAkB;;;;;;EAAlB,SAAA,MAAU,CAAA,EAAA,OAAQ;AAmC/B,CAAA,CAAA,CAAA;;;;AAgBA;;;;;;AAuBA;;;;;;;;;;;;;UAvCiB;;;;;;gBAMD,MAAA,CAAO,aAAa,GAAG;;;;;UAUtB;;iBAEA,gBAAgB,GAAG;;kBAElB;;;;;;;;;;;;;;;;;;UAmBD;;mBAEE,gBAAgB,GAAG;;mBAEnB,WAAW,GAAG"}

package/dist/testing/types.d.mts

@@ -0,0 +1,90 @@
+import { Effect } from "effect";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/testing/types.d.ts
+
+declare const TestError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "TestError";
+} & Readonly<A>;
+/**
+ * Error thrown when a test assertion fails.
+ */
+declare class TestError extends TestError_base<{
+  /** Description of what failed */
+  readonly message: string;
+  /** Expected value (if applicable) */
+  readonly expected?: unknown;
+  /** Actual value received (if applicable) */
+  readonly actual?: unknown;
+}> {}
+/**
+ * A single storage adapter test case.
+ *
+ * Test cases are framework-agnostic Effects that can be run with any test runner.
+ *
+ * @template E - The error type for this test case
+ * @template R - The Effect requirements (e.g., ColdStorageTag or HotStorageTag)
+ *
+ * @example
+ * ```typescript
+ * // Using with vitest
+ * const tests = ColdStorageTestSuite.makeTests();
+ *
+ * describe("MyAdapter", () => {
+ *   for (const test of tests) {
+ *     it(test.name, () =>
+ *       Effect.runPromise(test.run.pipe(Effect.provide(myAdapterLayer)))
+ *     );
+ *   }
+ * });
+ * ```
+ */
+interface StorageTestCase<E, R> {
+  /** Human-readable test name */
+  readonly name: string;
+  /** Category for grouping (e.g., "Basic Operations", "Data Integrity") */
+  readonly category: string;
+  /** The test as an Effect - succeeds if test passes, fails with error if not */
+  readonly run: Effect.Effect<void, E, R>;
+}
+/**
+ * Result of a failed test.
+ */
+interface FailedTest<E, R> {
+  /** The test case that failed */
+  readonly test: StorageTestCase<E, R>;
+  /** The error that caused the failure */
+  readonly error: E;
+}
+/**
+ * Results from running all tests in a suite.
+ *
+ * @example
+ * ```typescript
+ * const results = await Effect.runPromise(
+ *   ColdStorageTestSuite.runAll().pipe(Effect.provide(myAdapterLayer))
+ * );
+ *
+ * console.log(`Passed: ${results.passCount}/${results.total}`);
+ *
+ * for (const { test, error } of results.failed) {
+ *   console.error(`FAIL: ${test.name} - ${error._tag}`);
+ * }
+ * ```
+ */
+interface TestResults<E, R> {
+  /** Tests that passed */
+  readonly passed: StorageTestCase<E, R>[];
+  /** Tests that failed with their errors */
+  readonly failed: FailedTest<E, R>[];
+  /** Total number of tests run */
+  readonly total: number;
+  /** Number of tests that passed */
+  readonly passCount: number;
+  /** Number of tests that failed */
+  readonly failCount: number;
+}
+//#endregion
+export { FailedTest, StorageTestCase, TestError, TestResults };
+//# sourceMappingURL=types.d.mts.map

package/dist/testing/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/testing/types.ts"],"sourcesContent":[],"mappings":";;;;;;cAKsC;;;;;;cASzB,SAAA,SAAkB;;;;;;EAAlB,SAAA,MAAU,CAAA,EAAA,OAAQ;AAmC/B,CAAA,CAAA,CAAA;;;;AAgBA;;;;;;AAuBA;;;;;;;;;;;;;UAvCiB;;;;;;gBAMD,MAAA,CAAO,aAAa,GAAG;;;;;UAUtB;;iBAEA,gBAAgB,GAAG;;kBAElB;;;;;;;;;;;;;;;;;;UAmBD;;mBAEE,gBAAgB,GAAG;;mBAEnB,WAAW,GAAG"}

package/dist/testing/types.mjs

@@ -0,0 +1,16 @@
+import { Data } from "effect";
+
+//#region src/testing/types.ts
+/**
+* @voidhash/mimic-effect/testing - Core Types
+*
+* Types used by the storage adapter test utilities.
+*/
+/**
+* Error thrown when a test assertion fails.
+*/
+var TestError = class extends Data.TaggedError("TestError") {};
+
+//#endregion
+export { TestError };
+//# sourceMappingURL=types.mjs.map

package/dist/testing/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/testing/types.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect/testing - Core Types\n *\n * Types used by the storage adapter test utilities.\n */\nimport { Data, Effect } from \"effect\";\n\n// =============================================================================\n// Error Types\n// =============================================================================\n\n/**\n * Error thrown when a test assertion fails.\n */\nexport class TestError extends Data.TaggedError(\"TestError\")<{\n  /** Description of what failed */\n  readonly message: string;\n  /** Expected value (if applicable) */\n  readonly expected?: unknown;\n  /** Actual value received (if applicable) */\n  readonly actual?: unknown;\n}> {}\n\n// =============================================================================\n// Test Case Types\n// =============================================================================\n\n/**\n * A single storage adapter test case.\n *\n * Test cases are framework-agnostic Effects that can be run with any test runner.\n *\n * @template E - The error type for this test case\n * @template R - The Effect requirements (e.g., ColdStorageTag or HotStorageTag)\n *\n * @example\n * ```typescript\n * // Using with vitest\n * const tests = ColdStorageTestSuite.makeTests();\n *\n * describe(\"MyAdapter\", () => {\n *   for (const test of tests) {\n *     it(test.name, () =>\n *       Effect.runPromise(test.run.pipe(Effect.provide(myAdapterLayer)))\n *     );\n *   }\n * });\n * ```\n */\nexport interface StorageTestCase<E, R> {\n  /** Human-readable test name */\n  readonly name: string;\n  /** Category for grouping (e.g., \"Basic Operations\", \"Data Integrity\") */\n  readonly category: string;\n  /** The test as an Effect - succeeds if test passes, fails with error if not */\n  readonly run: Effect.Effect<void, E, R>;\n}\n\n// =============================================================================\n// Test Results Types\n// =============================================================================\n\n/**\n * Result of a failed test.\n */\nexport interface FailedTest<E, R> {\n  /** The test case that failed */\n  readonly test: StorageTestCase<E, R>;\n  /** The error that caused the failure */\n  readonly error: E;\n}\n\n/**\n * Results from running all tests in a suite.\n *\n * @example\n * ```typescript\n * const results = await Effect.runPromise(\n *   ColdStorageTestSuite.runAll().pipe(Effect.provide(myAdapterLayer))\n * );\n *\n * console.log(`Passed: ${results.passCount}/${results.total}`);\n *\n * for (const { test, error } of results.failed) {\n *   console.error(`FAIL: ${test.name} - ${error._tag}`);\n * }\n * ```\n */\nexport interface TestResults<E, R> {\n  /** Tests that passed */\n  readonly passed: StorageTestCase<E, R>[];\n  /** Tests that failed with their errors */\n  readonly failed: FailedTest<E, R>[];\n  /** Total number of tests run */\n  readonly total: number;\n  /** Number of tests that passed */\n  readonly passCount: number;\n  /** Number of tests that failed */\n  readonly failCount: number;\n}\n"],"mappings":";;;;;;;;;;;AAcA,IAAa,YAAb,cAA+B,KAAK,YAAY,YAAY,CAOzD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic-effect",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.10",
   "type": "module",
   "repository": {
     "type": "git",
@@ -13,6 +13,11 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.mts",
+      "import": "./dist/testing/index.mjs",
+      "require": "./dist/testing/index.cjs"
     }
   },
   "devDependencies": {
@@ -21,14 +26,14 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "1.0.0-beta.1"
+    "@voidhash/tsconfig": "1.0.0-beta.10"
   },
   "peerDependencies": {
     "@effect/platform": "^0.93.8",
     "@effect/cluster": "^0.55.0",
     "@effect/rpc": "^0.72.2",
     "effect": "^3.19.12",
-    "@voidhash/mimic": "1.0.0-beta.1"
+    "@voidhash/mimic": "1.0.0-beta.10"
   },
   "peerDependenciesMeta": {
     "@effect/cluster": {

package/src/ColdStorage.ts

@@ -104,24 +104,33 @@ export namespace InMemory {
   export const make = (): Layer.Layer<ColdStorageTag> =>
     Layer.effect(
       ColdStorageTag,
-      Effect.gen(function* () {
+      Effect.fn("cold-storage.in-memory.create")(function* () {
         const store = yield* Ref.make(HashMap.empty<string, StoredDocument>());
 
         return {
-          load: (documentId) =>
-            Effect.gen(function* () {
-              const current = yield* Ref.get(store);
-              const result = HashMap.get(current, documentId);
-              return result._tag === "Some" ? result.value : undefined;
-            }),
+          load: Effect.fn("cold-storage.load")(function* (documentId: string) {
+            const current = yield* Ref.get(store);
+            const result = HashMap.get(current, documentId);
+            return result._tag === "Some" ? result.value : undefined;
+          }),
 
-          save: (documentId, document) =>
-            Ref.update(store, (map) => HashMap.set(map, documentId, document)),
+          save: Effect.fn("cold-storage.save")(
+            function* (documentId: string, document: StoredDocument) {
+              yield* Ref.update(store, (map) =>
+                HashMap.set(map, documentId, document)
+              );
+            }
+          ),
 
-          delete: (documentId) =>
-            Ref.update(store, (map) => HashMap.remove(map, documentId)),
+          delete: Effect.fn("cold-storage.delete")(
+            function* (documentId: string) {
+              yield* Ref.update(store, (map) =>
+                HashMap.remove(map, documentId)
+              );
+            }
+          ),
         };
-      })
+      })()
     );
 }