@codefast/di-testing 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CodeFast Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# @codefast/di-testing
+
+Solitary and sociable auto-mocking test beds for
+[`@codefast/di`](https://github.com/codefastlabs/codefast/tree/main/packages/di) — write an isolated unit test for an
+`@injectable` class in two lines, with every collaborator mocked for you, or keep chosen collaborators real.
+
+[![npm version](https://img.shields.io/npm/v/@codefast/di-testing)](https://www.npmjs.com/package/@codefast/di-testing)
+[![license](https://img.shields.io/npm/l/@codefast/di-testing)](https://github.com/codefastlabs/codefast/blob/main/LICENSE)
+
+- **Auto-mocking.** `TestBed.solitary(Class)` reads the class's declared dependencies through di's own `MetadataReader`
+  and builds a mock for each — no per-collaborator `bind(...).toConstantValue(...)`.
+- **Real instance, real wiring.** The unit is constructed through a container, so `@postConstruct`, accessor injection,
+  and `@preDestroy` run exactly as in production.
+- **Zero test-framework dependency.** The default mock is a small built-in spy. Pass `() => vi.fn()` (or `jest.fn`,
+  `() => sinon.stub()`) to build the mocks from that backend and use its matchers instead.
+- **Backend-typed lookups.** The factory's return type flows through the whole bed: with `() => vi.fn()`,
+  `mocks.get(EmailToken).send` carries Vitest's own mock surface (`mockReturnValueOnce`, `mockClear`, …) — no adapter
+  package, no module augmentation, no postinstall scripts.
+
+## Requirements
+
+- **Node.js 24 or later**, matching `@codefast/di`.
+- A peer install of `@codefast/di` with `@injectable` / `inject` classes to test.
+- Types for `AsyncDisposable` (`await using`): `@types/node` provides them; without it, add `"ESNext.Disposable"` to
+  your tsconfig `lib`.
+
+## Installation
+
+```bash
+pnpm add -D @codefast/di-testing
+```
+
+## Quick start
+
+```typescript
+import { inject, injectable, token } from "@codefast/di";
+import { TestBed } from "@codefast/di-testing";
+import { expect, it, vi } from "vitest";
+
+const UserServiceToken = token<UserService>("UserService");
+const PaymentGatewayToken = token<PaymentGateway>("PaymentGateway");
+const EmailServiceToken = token<EmailService>("EmailService");
+
+@injectable([inject(UserServiceToken), inject(PaymentGatewayToken), inject(EmailServiceToken)])
+class OrderProcessor {
+  constructor(
+    private readonly users: UserService,
+    private readonly payments: PaymentGateway,
+    private readonly email: EmailService,
+  ) {}
+
+  placeOrder(userId: string, amount: number): string {
+    const user = this.users.findUser(userId);
+    this.payments.charge(userId, amount);
+    this.email.send(user.email, `Order confirmed — ${amount}`);
+    return `ord-${userId}`;
+  }
+}
+
+it("charges then emails a confirmation", () => {
+  const { unit, mocks } = TestBed.solitary(OrderProcessor, { mockFactory: () => vi.fn() })
+    .mock(UserServiceToken)
+    .stub((fn) => ({ findUser: fn().mockReturnValue({ id: "u1", email: "alice@example.com" }) }))
+    .compile();
+
+  unit.placeOrder("u1", 42);
+
+  expect(mocks.get(PaymentGatewayToken).charge).toHaveBeenCalledWith("u1", 42);
+  expect(mocks.get(EmailServiceToken).send).toHaveBeenCalledWith("alice@example.com", "Order confirmed — 42");
+});
+```
+
+The zero-dependency default reads the same, minus the `mockFactory` — assert against the built-in spy's `.mock.calls`
+and stub with `.mockReturnValue()`:
+
+```typescript
+import { TestBed } from "@codefast/di-testing";
+import assert from "node:assert/strict";
+
+const { unit, mocks } = TestBed.solitary(OrderProcessor).compile();
+unit.placeOrder("u1", 42);
+assert.deepEqual(mocks.get(PaymentGatewayToken).charge.mock.calls[0], ["u1", 42]);
+```
+
+## API
+
+### `TestBed.solitary(target, options?)`
+
+Begins a solitary test bed for `target`, auto-mocking every dependency it declares. `options`:
+
+- `mockFactory?: () => spy` — the spy backend for each auto-mock. Defaults to the built-in zero-dependency spy.
+- `metadataReader?: MetadataReader` — the reader dependencies are discovered through. Defaults to di's reader.
+
+### Builder
+
+- `.mock(token).stub((fn) => stub)` — bind a partial stub built from the active spy factory; unlisted members stay
+  auto-mocked. `fn()` is typed as whatever the backend produces, so `fn().mockReturnValue(...)` (jest-shaped) or
+  `fn().returns(...)` (Sinon) both type-check against the factory you chose.
+- `.mock(token).using(value)` — bind a fixed value. The value is **sealed**: it has no mock surface, so `mocks.get`
+  refuses it rather than hand it back mistyped — the test already holds the reference it passed in.
+- `.mock(token).absent()` — leave the dependency unbound: an `optional()` slot resolves `undefined`, an `injectAll()`
+  slot `[]`. Anything else is an `OverrideMismatchError`.
+- `.mock(token).usingAll([a, b])` — supply the elements of an unconstrained `injectAll()` slot, in order. Sealed like
+  `.using`.
+- `.mock(token, { name })` / `.mock(token, { tag })` — target one slot of a token that is injected several ways; the
+  slotless form covers every slot without a more specific override.
+- `.compile()` — instantiate the unit synchronously (the primary path).
+- `.compileAsync()` — for a unit whose `@postConstruct` is asynchronous.
+
+### `TestBed.sociable(target, options?)`
+
+A sociable bed keeps chosen collaborators real while everything else stays mocked — a unit test over a small real
+subtree, not an integration test. It returns only `.expose()`, steering the first call:
+
+```typescript
+const bed = TestBed.sociable(CheckoutService, { mockFactory: () => vi.fn() })
+  .expose(PricingService) // real instance, wired through the container
+  .mock(TaxPolicyToken)
+  .stub((fn) => ({ rateFor: fn().mockReturnValue(0.1) }))
+  .compile();
+
+bed.unit.checkout(100, "USD"); // real PricingService math over the mocked tax boundary
+bed.exposed(PricingService); // the real instance the unit was built with
+```
+
+- **Exposure follows class identity.** A class-keyed dependency — of the unit or of another exposed class — stays real
+  when exposed, and its own dependencies follow the same rules recursively.
+- **Tokens are the boundary.** A `Token`-keyed dependency is always mocked, in both modes: tokens mark where the logic
+  under test meets the outside world.
+- Exposed collaborators are real singletons resolved through the container, so their `@postConstruct` runs at compile
+  and `@preDestroy` on dispose. `bed.exposed(Class)` retrieves them; `mocks.get(Class)` refuses them
+  (`SealedDependencyError`) because they carry no mock surface.
+- Exposing a class the unit never reaches, or exposing and mocking the same class, is an error at compile.
+
+### Behavior notes
+
+- An `optional()` dependency is auto-mocked like any other — it resolves to the mock, not `undefined` as an unbound
+  optional would in production. Use `.mock(token).absent()` to exercise the absent branch.
+- An `injectAll()` dependency receives a one-element array holding the token's mock; use `.mock(token).usingAll([...])`
+  to supply several elements. When the same token also has a named or tagged slot, that slot's binding is collected by
+  the unconstrained `injectAll` too — di's `resolveAll` takes every binding of the token.
+- Named or tagged parameters of one token share the token's mock unless a slot-targeted `.mock(token, { name })` gives
+  that slot its own; either way `mocks.get(token, { name })` addresses the slot directly.
+
+### Result — `UnitTestBed`
+
+- `unit` — the real class under test.
+- `mocks.get(token, options?)` — the `Mocked<T>` bound for a dependency (or one slot of it). Only auto-mocks and `.stub`
+  stubs come back; sealed values throw `SealedDependencyError`.
+- `resetMocks()` — clear the call history and configured behaviour of every auto-mock the bed created.
+- `dispose()` — run the unit's `@preDestroy` hooks and dispose the container. Also runs via `await using`.
+
+## Errors
+
+- `NotInjectableError` — the class under test takes constructor parameters but is not `@injectable`.
+- `UndeclaredDependencyError` — a `.mock(...)` or `mocks.get(...)` named a token or slot the class does not use.
+- `SealedDependencyError` — `mocks.get(...)` asked for a `.using()`/`.absent()`/`.all()` value.
+- `OverrideMismatchError` — `.absent()` on a required dependency, or `.all()` on a non-`injectAll` slot.
+
+## License
+
+MIT

package/dist/discovery/dependency-scanner.d.ts

@@ -0,0 +1,29 @@
+/** Reads the dependencies a class declares, the input every auto-mock is built from. */
+import type { Constructor, DependencySlot, MetadataReader } from "@codefast/di";
+/**
+ * Reads every dependency a class declares — constructor parameters first, then accessor injections.
+ *
+ * @remarks Mirrors di's own fallback: a class with no constructor metadata is fine as long as its
+ * constructor takes no parameters, which keeps zero-arg and accessor-only classes testable without
+ * `@injectable`. A parameterful constructor with no metadata is a {@link NotInjectableError}.
+ */
+export declare function scanDependencies(target: Constructor, reader: MetadataReader): ReadonlyArray<DependencySlot>;
+/**
+ * What a sociable scan finds: the slots to mock, the exposed classes the unit actually reaches, and
+ * the constrained slots those classes are injected through.
+ */
+export interface SociableScan {
+    readonly mockSlots: ReadonlyArray<DependencySlot>;
+    readonly realClasses: ReadonlySet<Constructor>;
+    /** The name/tag-constrained slots each exposed class is requested through, for alias replay. */
+    readonly realSlots: ReadonlyArray<DependencySlot>;
+}
+/**
+ * Walks the unit's dependency graph across the exposed set: an exposed class dependency stays real
+ * and is scanned in turn, everything else becomes a mock slot.
+ *
+ * @remarks Class identity is what exposure follows — a `Token`-keyed dependency is always mocked,
+ * treating tokens as the declared boundary between the logic under test and the outside world.
+ */
+export declare function scanSociableDependencies(target: Constructor, exposed: ReadonlySet<Constructor>, reader: MetadataReader): SociableScan;
+//# sourceMappingURL=dependency-scanner.d.ts.map

package/dist/discovery/dependency-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-scanner.d.ts","sourceRoot":"","sources":["../../src/discovery/dependency-scanner.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAExF,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAIhF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,GAAG,aAAa,CAAC,cAAc,CAAC,CAS3G;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAC/C,gGAAgG;IAChG,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACnD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,EACjC,MAAM,EAAE,cAAc,GACrB,YAAY,CA2Bd"}

package/dist/discovery/dependency-scanner.js

@@ -0,0 +1,51 @@
+/** Reads the dependencies a class declares, the input every auto-mock is built from. */
+import { NotInjectableError } from "#/errors/errors";
+/**
+ * Reads every dependency a class declares — constructor parameters first, then accessor injections.
+ *
+ * @remarks Mirrors di's own fallback: a class with no constructor metadata is fine as long as its
+ * constructor takes no parameters, which keeps zero-arg and accessor-only classes testable without
+ * `@injectable`. A parameterful constructor with no metadata is a {@link NotInjectableError}.
+ */
+export function scanDependencies(target, reader) {
+    const constructorMetadata = reader.getConstructorMetadata(target);
+    if (constructorMetadata === undefined && target.length > 0) {
+        throw new NotInjectableError(target.name);
+    }
+    const accessors = reader.getAccessorMetadata?.(target) ?? [];
+    return [...(constructorMetadata?.params ?? []), ...accessors.map((accessor) => accessor.descriptor)];
+}
+/**
+ * Walks the unit's dependency graph across the exposed set: an exposed class dependency stays real
+ * and is scanned in turn, everything else becomes a mock slot.
+ *
+ * @remarks Class identity is what exposure follows — a `Token`-keyed dependency is always mocked,
+ * treating tokens as the declared boundary between the logic under test and the outside world.
+ */
+export function scanSociableDependencies(target, exposed, reader) {
+    const mockSlots = [];
+    const realClasses = new Set();
+    const realSlots = [];
+    const visited = new Set([target]);
+    const queue = [target];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const slot of scanDependencies(current, reader)) {
+            const token = slot.token;
+            if (typeof token === "function" && exposed.has(token)) {
+                if (slot.name !== undefined || (slot.tags?.length ?? 0) > 0) {
+                    realSlots.push(slot);
+                }
+                if (!visited.has(token)) {
+                    visited.add(token);
+                    realClasses.add(token);
+                    queue.push(token);
+                }
+                continue;
+            }
+            mockSlots.push(slot);
+        }
+    }
+    return { mockSlots, realClasses, realSlots };
+}
+//# sourceMappingURL=dependency-scanner.js.map

package/dist/discovery/dependency-scanner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-scanner.js","sourceRoot":"","sources":["../../src/discovery/dependency-scanner.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAIxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAmB,EAAE,MAAsB;IAC1E,MAAM,mBAAmB,GAAG,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAClE,IAAI,mBAAmB,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3D,MAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IAE7D,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AACvG,CAAC;AAaD;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAAmB,EACnB,OAAiC,EACjC,MAAsB;IAEtB,MAAM,SAAS,GAA0B,EAAE,CAAC;IAC5C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAe,CAAC;IAC3C,MAAM,SAAS,GAA0B,EAAE,CAAC;IAC5C,MAAM,OAAO,GAAG,IAAI,GAAG,CAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAuB,CAAC,MAAM,CAAC,CAAC;IAE3C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;QAC/B,KAAK,MAAM,IAAI,IAAI,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;YACrD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACzB,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC5D,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvB,CAAC;gBACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;oBACxB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBACnB,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBACvB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACpB,CAAC;gBACD,SAAS;YACX,CAAC;YACD,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AAC/C,CAAC"}

package/dist/discovery/mock-binder.d.ts

@@ -0,0 +1,71 @@
+/** Binds a unit's discovered dependencies onto a container as mocks — the sole container coupling. */
+import type { BindingTag, Constructor, Container, DependencyKey, DependencySlot, InjectOptions } from "@codefast/di";
+import type { MockFactory } from "#/mocking/mock-factory";
+/**
+ * How one dependency is supplied instead of a plain auto-mock.
+ *
+ * @remarks A stub's `setup` runs once per compile, so two beds built from one builder never share
+ * seeded spies.
+ */
+export type MockOverride = {
+    readonly kind: "stub";
+    readonly setup: (mock: MockFactory) => unknown;
+} | {
+    readonly kind: "value";
+    readonly value: unknown;
+} | {
+    readonly kind: "absent";
+} | {
+    readonly kind: "all";
+    readonly values: ReadonlyArray<unknown>;
+};
+/**
+ * Normalized slot criteria an override or a `mocks.get` lookup addresses one binding slot with.
+ */
+export interface SlotCriteria {
+    readonly name: string | undefined;
+    readonly tags: ReadonlyArray<BindingTag>;
+}
+/**
+ * One override registration: how a dependency is supplied, and which slot it targets (none = every
+ * slot of the token that has no more specific override).
+ */
+export interface SlottedOverride {
+    readonly criteria: SlotCriteria | undefined;
+    readonly override: MockOverride;
+}
+/**
+ * What one bound entry was supplied with — only `auto` and `stub` entries carry a mock surface.
+ */
+export type BoundMockKind = "auto" | "stub" | "value" | "absent" | "all" | "exposed";
+/**
+ * One bound value `mocks` can look up: its slot criteria, the value, and how it was supplied.
+ */
+export interface BoundMock {
+    readonly criteria: SlotCriteria | undefined;
+    readonly value: unknown;
+    readonly kind: BoundMockKind;
+}
+/**
+ * Folds an `InjectOptions` into slot criteria, or `undefined` when it names no criterion.
+ *
+ * @remarks Tags are copied and deduplicated by identity — di interns each `(key, value)` pair, so a
+ * repeated pair is the same object.
+ */
+export declare function normalizeCriteria(options: InjectOptions | undefined): SlotCriteria | undefined;
+/**
+ * Returns whether two criteria address the same slot — equal name and the same tag set.
+ */
+export declare function criteriaEquals(left: SlotCriteria, right: SlotCriteria): boolean;
+/**
+ * Binds a mock for every discovered dependency and returns the entries `mocks` reads.
+ *
+ * @remarks One shared mock per token for slots without a specific override — duplicate tokens across
+ * parameters share it — while an override carrying slot criteria supplies just its own slot; every
+ * constrained slot is also recorded under its own criteria so `mocks.get(token, options)` resolves.
+ * An override that matches nothing is an {@link UndeclaredDependencyError}; `.absent()` on a
+ * required slot or `.usingAll()` with no unconstrained `injectAll()` slot is an
+ * {@link OverrideMismatchError}.
+ */
+export declare function bindMocks(container: Container, dependencies: ReadonlyArray<DependencySlot>, overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>>, mockFactory: MockFactory, exposed?: ReadonlySet<Constructor>): ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>;
+//# sourceMappingURL=mock-binder.d.ts.map

package/dist/discovery/mock-binder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-binder.d.ts","sourceRoot":"","sources":["../../src/discovery/mock-binder.ts"],"names":[],"mappings":"AAAA,sGAAsG;AAEtG,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAMrH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAA;CAAE,GACzE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAU9F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAE/E;AAgDD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,EAC3C,SAAS,EAAE,WAAW,CAAC,aAAa,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,EACrE,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,GACjC,WAAW,CAAC,aAAa,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC,CA4ItD"}

package/dist/discovery/mock-binder.js

@@ -0,0 +1,206 @@
+/** Binds a unit's discovered dependencies onto a container as mocks — the sole container coupling. */
+import { tokenName } from "@codefast/di";
+import { OverrideMismatchError, UndeclaredDependencyError } from "#/errors/errors";
+import { createAutoMock } from "#/mocking/auto-mock";
+/** The name prefix `usingAll` elements are bound under, so identical constants keep distinct slots. */
+const ALL_ELEMENT_SLOT_PREFIX = "di-testing:all:";
+/**
+ * Folds an `InjectOptions` into slot criteria, or `undefined` when it names no criterion.
+ *
+ * @remarks Tags are copied and deduplicated by identity — di interns each `(key, value)` pair, so a
+ * repeated pair is the same object.
+ */
+export function normalizeCriteria(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    const folded = options.tag === undefined ? (options.tags ?? []) : [options.tag, ...(options.tags ?? [])];
+    const tags = [...new Set(folded)];
+    if (options.name === undefined && tags.length === 0) {
+        return undefined;
+    }
+    return { name: options.name, tags };
+}
+/**
+ * Returns whether two criteria address the same slot — equal name and the same tag set.
+ */
+export function criteriaEquals(left, right) {
+    return left.name === right.name && tagSetEquals(left.tags, right.tags);
+}
+/** Tag pairs are interned by di, so tag lists compare as identity sets, duplicates collapsed. */
+function tagSetEquals(left, right) {
+    const leftSet = new Set(left);
+    const rightSet = new Set(right);
+    if (leftSet.size !== rightSet.size) {
+        return false;
+    }
+    for (const tag of leftSet) {
+        if (!rightSet.has(tag)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Returns the slot's own criteria, or `undefined` for an unconstrained slot. */
+function criteriaOfSlot(slot) {
+    const tags = slot.tags ?? [];
+    if (slot.name === undefined && tags.length === 0) {
+        return undefined;
+    }
+    return { name: slot.name, tags };
+}
+/** Returns whether an override's criteria address exactly this slot. */
+function matchesSlot(criteria, slot) {
+    return criteria.name === slot.name && tagSetEquals(criteria.tags, slot.tags ?? []);
+}
+/** A readable rendering of criteria for error messages. */
+function describeCriteria(criteria) {
+    const parts = [];
+    if (criteria.name !== undefined) {
+        parts.push(`name "${criteria.name}"`);
+    }
+    if (criteria.tags.length > 0) {
+        parts.push(`${String(criteria.tags.length)} tag(s)`);
+    }
+    return `slot with ${parts.join(" and ")}`;
+}
+/** Whether a slot can take a `usingAll` override — an unconstrained `injectAll` collects in order. */
+function acceptsAll(slot) {
+    return slot.multi && slot.name === undefined && (slot.tags?.length ?? 0) === 0;
+}
+/**
+ * Binds a mock for every discovered dependency and returns the entries `mocks` reads.
+ *
+ * @remarks One shared mock per token for slots without a specific override — duplicate tokens across
+ * parameters share it — while an override carrying slot criteria supplies just its own slot; every
+ * constrained slot is also recorded under its own criteria so `mocks.get(token, options)` resolves.
+ * An override that matches nothing is an {@link UndeclaredDependencyError}; `.absent()` on a
+ * required slot or `.usingAll()` with no unconstrained `injectAll()` slot is an
+ * {@link OverrideMismatchError}.
+ */
+export function bindMocks(container, dependencies, overrides, mockFactory, exposed) {
+    if (exposed !== undefined) {
+        for (const key of overrides.keys()) {
+            if (typeof key === "function" && exposed.has(key)) {
+                throw new OverrideMismatchError(tokenName(key), "the class is exposed as a real collaborator, so it cannot also be mocked.");
+            }
+        }
+    }
+    const bound = new Map();
+    const consumed = new Set();
+    // One value per token-level lane and per slotted override, shared across duplicate slots.
+    const sharedValues = new Map();
+    const overrideValues = new Map();
+    const record = (token, entry) => {
+        let entries = bound.get(token);
+        if (entries === undefined) {
+            entries = [];
+            bound.set(token, entries);
+        }
+        // One entry per distinct slot criteria; duplicate slots share the first recording.
+        const duplicate = entries.some((candidate) => candidate.criteria === undefined || entry.criteria === undefined
+            ? candidate.criteria === entry.criteria
+            : criteriaEquals(candidate.criteria, entry.criteria));
+        if (!duplicate) {
+            entries.push(entry);
+        }
+    };
+    const bindConstant = (slot, value) => {
+        const builder = container.bind(slot.token).toConstantValue(value);
+        if (slot.name !== undefined) {
+            builder.whenNamed(slot.name);
+        }
+        if (slot.tags !== undefined) {
+            for (const tag of slot.tags) {
+                builder.whenTagged(tag);
+            }
+        }
+    };
+    for (const slot of dependencies) {
+        const list = overrides.get(slot.token) ?? [];
+        // A slotless `usingAll` applies only to the slots that can take it; other slots fall through.
+        const override = list.find((candidate) => candidate.criteria !== undefined && matchesSlot(candidate.criteria, slot)) ??
+            list.find((candidate) => candidate.criteria === undefined && (candidate.override.kind !== "all" || acceptsAll(slot)));
+        if (override !== undefined) {
+            consumed.add(override);
+            if (override.override.kind === "absent") {
+                if (!slot.optional && !slot.multi) {
+                    throw new OverrideMismatchError(tokenName(slot.token), ".absent() targets a required dependency — only optional() or injectAll() slots can be absent.");
+                }
+                if (!overrideValues.has(override)) {
+                    overrideValues.set(override, undefined);
+                }
+                record(slot.token, { criteria: override.criteria, value: undefined, kind: "absent" });
+                continue;
+            }
+            if (override.override.kind === "all") {
+                if (!acceptsAll(slot)) {
+                    throw new OverrideMismatchError(tokenName(slot.token), ".usingAll() supplies the elements of an unconstrained injectAll() slot — this slot is not one.");
+                }
+                if (!overrideValues.has(override)) {
+                    const values = override.override.values;
+                    overrideValues.set(override, values);
+                    // Every element gets its own named slot: identical slots displace each other, and even a
+                    // default-slot first element would be displaced-then-restored out of order by the second.
+                    // An unconstrained resolveAll ignores slots and collects every binding in order.
+                    for (const [index, value] of values.entries()) {
+                        container
+                            .bind(slot.token)
+                            .toConstantValue(value)
+                            .whenNamed(`${ALL_ELEMENT_SLOT_PREFIX}${String(index)}`);
+                    }
+                    record(slot.token, { criteria: override.criteria, value: values, kind: "all" });
+                }
+                continue;
+            }
+        }
+        // A slotted override owns its own value; the token-level lane is shared across plain slots.
+        const lane = override?.override;
+        const kind = lane === undefined ? "auto" : lane.kind;
+        let value;
+        if (override !== undefined && override.criteria !== undefined) {
+            if (!overrideValues.has(override)) {
+                overrideValues.set(override, buildMock(lane, mockFactory));
+            }
+            value = overrideValues.get(override);
+            record(slot.token, { criteria: override.criteria, value, kind });
+        }
+        else {
+            if (!sharedValues.has(slot.token)) {
+                sharedValues.set(slot.token, buildMock(lane, mockFactory));
+                record(slot.token, { criteria: undefined, value: sharedValues.get(slot.token), kind });
+            }
+            value = sharedValues.get(slot.token);
+            // A constrained slot on the shared lane is also addressable by its own criteria.
+            const slotCriteria = criteriaOfSlot(slot);
+            if (slotCriteria !== undefined) {
+                record(slot.token, { criteria: slotCriteria, value, kind });
+            }
+        }
+        bindConstant(slot, value);
+    }
+    for (const [token, list] of overrides) {
+        for (const override of list) {
+            if (!consumed.has(override)) {
+                throw new UndeclaredDependencyError(tokenName(token), override.criteria === undefined
+                    ? override.override.kind === "all"
+                        ? "no unconstrained injectAll() slot"
+                        : undefined
+                    : describeCriteria(override.criteria));
+            }
+        }
+    }
+    return bound;
+}
+/** Returns the value bound for one lane: an override's value, a seeded auto-mock, or a plain auto-mock. */
+function buildMock(override, mockFactory) {
+    if (override === undefined) {
+        return createAutoMock(mockFactory);
+    }
+    if (override.kind === "value") {
+        return override.value;
+    }
+    // The stub's seed is built here, once per compile, so beds never share seeded spies.
+    return createAutoMock(mockFactory, override.setup(mockFactory));
+}
+//# sourceMappingURL=mock-binder.js.map

package/dist/discovery/mock-binder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-binder.js","sourceRoot":"","sources":["../../src/discovery/mock-binder.ts"],"names":[],"mappings":"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"}

package/dist/errors/errors.d.ts

@@ -0,0 +1,62 @@
+/** The error taxonomy `@codefast/di-testing` raises, each carrying a machine-readable `code`. */
+/**
+ * Base class for every error the testing library throws, each carrying a machine-readable `code`.
+ *
+ * @remarks Mirrors `@codefast/di`'s own `DiError` shape rather than extending it, so a caller can
+ * catch testing-setup failures separately from resolution failures.
+ */
+export declare abstract class TestingError extends Error {
+    abstract readonly code: string;
+    constructor(message: string);
+}
+/**
+ * A scanned class takes constructor parameters but carries no `@injectable` metadata.
+ */
+export declare class NotInjectableError extends TestingError {
+    readonly code = "NOT_INJECTABLE";
+    readonly targetName: string;
+    constructor(targetName: string);
+}
+/**
+ * A `.mock(...)` override or a `mocks.get(...)` lookup named a token or slot the unit does not use.
+ *
+ * @remarks Almost always a typo or a stale token reference; failing loudly beats silently binding an
+ * unused constant or returning `undefined`.
+ */
+export declare class UndeclaredDependencyError extends TestingError {
+    readonly code = "UNDECLARED_DEPENDENCY";
+    readonly tokenName: string;
+    constructor(tokenName: string, detail?: string);
+}
+/** What a sealed entry was supplied with, naming the one cause a lookup error should report. */
+export type SealedCause = "value" | "absent" | "all" | "exposed";
+/**
+ * A `mocks.get(...)` lookup asked for a dependency that is not a retrievable mock.
+ *
+ * @remarks `.using()`, `.absent()`, and `.usingAll()` seal the value, and an exposed class is real —
+ * none of them carries a mock surface, so handing them back typed as `Mocked` would lie.
+ */
+export declare class SealedDependencyError extends TestingError {
+    readonly code = "SEALED_DEPENDENCY";
+    readonly tokenName: string;
+    constructor(tokenName: string, cause: SealedCause);
+}
+/**
+ * An override whose shape does not fit the slot it targets — `.absent()` on a required dependency,
+ * or `.usingAll()` where no unconstrained `injectAll()` slot exists.
+ */
+export declare class OverrideMismatchError extends TestingError {
+    readonly code = "OVERRIDE_MISMATCH";
+    readonly tokenName: string;
+    constructor(tokenName: string, detail: string);
+}
+/**
+ * A sociable bed's exposure could not be honoured — the class is unreachable, already the unit, or
+ * was asked for without having been exposed.
+ */
+export declare class ExposureError extends TestingError {
+    readonly code = "EXPOSURE";
+    readonly targetName: string;
+    constructor(targetName: string, detail: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors/errors.ts"],"names":[],"mappings":"AAAA,iGAAiG;AAEjG;;;;;GAKG;AACH,8BAAsB,YAAa,SAAQ,KAAK;IAC9C,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAE/B,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,QAAQ,CAAC,IAAI,oBAAoB;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,YAAY,UAAU,EAAE,MAAM,EAK7B;CACF;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,YAAY;IACzD,QAAQ,CAAC,IAAI,2BAA2B;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,YAAY,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAK7C;CACF;AAED,gGAAgG;AAChG,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AASjE;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;IACrD,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,YAAY,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAGhD;CACF;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;IACrD,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,YAAY,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAG5C;CACF;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,YAAY;IAC7C,QAAQ,CAAC,IAAI,cAAc;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,YAAY,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAG7C;CACF"}