@navios/di 0.8.0 → 0.9.0

package/lib/testing/index.cjs

@@ -1,348 +1,606 @@
-const require_container = require('../container-DENMeJ87.cjs');
+const require_container = require('../container-CaY2fDuk.cjs');
 
 //#region src/testing/test-container.mts
-function applyDecs2203RFactory() {
-	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
-		return function addInitializer(initializer) {
-			assertNotFinished(decoratorFinishedRef, "addInitializer");
-			assertCallable(initializer, "An initializer");
-			initializers.push(initializer);
-		};
+/**
+* TestContainer extends Container with testing utilities.
+*
+* Provides simple value/class binding for integration/e2e tests,
+* plus assertion helpers and dependency graph inspection.
+*
+* @example
+* ```ts
+* const container = new TestContainer()
+*
+* // Bind mock values
+* container.bind(DatabaseToken).toValue(mockDatabase)
+* container.bind(UserService).toClass(MockUserService)
+*
+* // Use container normally
+* const service = await container.get(MyService)
+*
+* // Assert on container state
+* container.expectResolved(MyService)
+* container.expectSingleton(MyService)
+* ```
+*/ var TestContainer = class extends require_container._Container {
+	testRegistry;
+	methodCalls = /* @__PURE__ */ new Map();
+	lifecycleEvents = /* @__PURE__ */ new Map();
+	instanceCounts = /* @__PURE__ */ new Map();
+	boundTokens = /* @__PURE__ */ new Set();
+	/**
+	* Creates a new TestContainer.
+	*
+	* @param options - Configuration options
+	* @param options.parentRegistry - Parent registry. Defaults to globalRegistry.
+	*   Pass `null` for a completely isolated container.
+	* @param options.logger - Optional logger for debugging.
+	*
+	* @example
+	* ```ts
+	* // Uses globalRegistry as parent (default)
+	* const container = new TestContainer()
+	*
+	* // Isolated container (no access to @Injectable classes)
+	* const isolated = new TestContainer({ parentRegistry: null })
+	*
+	* // Custom parent registry
+	* const custom = new TestContainer({ parentRegistry: myRegistry })
+	* ```
+	*/ constructor(options = {}) {
+		const { parentRegistry = require_container.globalRegistry, logger = null } = options;
+		const testRegistry = parentRegistry ? new require_container.Registry(parentRegistry) : new require_container.Registry();
+		super(testRegistry, logger, require_container.defaultInjectors);
+		this.testRegistry = testRegistry;
 	}
-	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
-		var kindStr;
-		switch (kind) {
-			case 1:
-				kindStr = "accessor";
-				break;
-			case 2:
-				kindStr = "method";
-				break;
-			case 3:
-				kindStr = "getter";
-				break;
-			case 4:
-				kindStr = "setter";
-				break;
-			default: kindStr = "field";
-		}
-		var ctx = {
-			kind: kindStr,
-			name: isPrivate ? "#" + name : name,
-			static: isStatic,
-			private: isPrivate,
-			metadata
-		};
-		var decoratorFinishedRef = { v: false };
-		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
-		var get, set;
-		if (kind === 0) if (isPrivate) {
-			get = desc.get;
-			set = desc.set;
-		} else {
-			get = function() {
-				return this[name];
-			};
-			set = function(v) {
-				this[name] = v;
-			};
-		}
-		else if (kind === 2) get = function() {
-			return desc.value;
+	/**
+	* Creates a binding builder for the given token.
+	*
+	* @example
+	* ```ts
+	* container.bind(UserService).toValue(mockUserService)
+	* container.bind(DatabaseToken).toClass(MockDatabase)
+	* container.bind(ConfigToken).toFactory(() => ({ apiKey: 'test' }))
+	* ```
+	*/ bind(token) {
+		const realToken = this.resolveToken(token);
+		const tokenId = realToken.id;
+		return {
+			toValue: (value) => {
+				this.boundTokens.add(tokenId);
+				this.registerValueBinding(realToken, value);
+			},
+			toClass: (cls) => {
+				this.boundTokens.add(tokenId);
+				this.registerClassBinding(realToken, cls);
+			},
+			toFactory: (factory) => {
+				this.boundTokens.add(tokenId);
+				this.registerFactoryBinding(realToken, factory);
+			}
 		};
-		else {
-			if (kind === 1 || kind === 3) get = function() {
-				return desc.get.call(this);
-			};
-			if (kind === 1 || kind === 4) set = function(v) {
-				desc.set.call(this, v);
-			};
+	}
+	/**
+	* Clears all bindings and resets container state.
+	*/ async clear() {
+		await this.dispose();
+		this.methodCalls.clear();
+		this.lifecycleEvents.clear();
+		this.instanceCounts.clear();
+		this.boundTokens.clear();
+	}
+	/**
+	* Asserts that a service has been resolved at least once.
+	*/ expectResolved(token) {
+		const realToken = this.resolveToken(token);
+		if (!this.getStorage().getAllNames().some((name) => name.includes(realToken.id))) throw new Error(`Expected ${realToken.toString()} to be resolved, but it was not`);
+	}
+	/**
+	* Asserts that a service has NOT been resolved.
+	*/ expectNotResolved(token) {
+		const realToken = this.resolveToken(token);
+		if (this.getStorage().getAllNames().some((name) => name.includes(realToken.id))) throw new Error(`Expected ${realToken.toString()} to NOT be resolved, but it was`);
+	}
+	/**
+	* Asserts that a service is registered as singleton scope.
+	*/ expectSingleton(token) {
+		const realToken = this.resolveToken(token);
+		const registry = this.getRegistry();
+		if (!registry.has(realToken)) throw new Error(`Expected ${realToken.toString()} to be registered, but it was not`);
+		const record = registry.get(realToken);
+		if (record.scope !== require_container.InjectableScope.Singleton) throw new Error(`Expected ${realToken.toString()} to be Singleton scope, but it was ${record.scope}`);
+	}
+	/**
+	* Asserts that a service is registered as transient scope.
+	*/ expectTransient(token) {
+		const realToken = this.resolveToken(token);
+		const registry = this.getRegistry();
+		if (!registry.has(realToken)) throw new Error(`Expected ${realToken.toString()} to be registered, but it was not`);
+		const record = registry.get(realToken);
+		if (record.scope !== require_container.InjectableScope.Transient) throw new Error(`Expected ${realToken.toString()} to be Transient scope, but it was ${record.scope}`);
+	}
+	/**
+	* Asserts that a service is registered as request scope.
+	*/ expectRequestScoped(token) {
+		const realToken = this.resolveToken(token);
+		const registry = this.getRegistry();
+		if (!registry.has(realToken)) throw new Error(`Expected ${realToken.toString()} to be registered, but it was not`);
+		const record = registry.get(realToken);
+		if (record.scope !== require_container.InjectableScope.Request) throw new Error(`Expected ${realToken.toString()} to be Request scope, but it was ${record.scope}`);
+	}
+	/**
+	* Asserts that two service resolutions return the same instance.
+	*/ async expectSameInstance(token) {
+		if (await this.get(token) !== await this.get(token)) {
+			const realToken = this.resolveToken(token);
+			throw new Error(`Expected ${realToken.toString()} to return same instance, but got different instances`);
 		}
-		ctx.access = get && set ? {
-			get,
-			set
-		} : get ? { get } : { set };
-		try {
-			return dec(value, ctx);
-		} finally {
-			decoratorFinishedRef.v = true;
+	}
+	/**
+	* Asserts that two service resolutions return different instances.
+	*/ async expectDifferentInstances(token) {
+		if (await this.get(token) === await this.get(token)) {
+			const realToken = this.resolveToken(token);
+			throw new Error(`Expected ${realToken.toString()} to return different instances, but got same instance`);
 		}
 	}
-	function assertNotFinished(decoratorFinishedRef, fnName) {
-		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
-	}
-	function assertCallable(fn, hint) {
-		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
-	}
-	function assertValidReturnValue(kind, value) {
-		var type = typeof value;
-		if (kind === 1) {
-			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
-			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
-			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
-			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
-		} else if (type !== "function") {
-			var hint;
-			if (kind === 0) hint = "field";
-			else if (kind === 10) hint = "class";
-			else hint = "method";
-			throw new TypeError(hint + " decorators must return a function or void 0");
+	/**
+	* Asserts that a service's onServiceInit was called.
+	*/ expectInitialized(token) {
+		const realToken = this.resolveToken(token);
+		if (!(this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "initialized")) throw new Error(`Expected ${realToken.toString()} to be initialized, but onServiceInit was not called`);
+	}
+	/**
+	* Asserts that a service's onServiceDestroy was called.
+	*/ expectDestroyed(token) {
+		const realToken = this.resolveToken(token);
+		if (!(this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "destroyed")) throw new Error(`Expected ${realToken.toString()} to be destroyed, but onServiceDestroy was not called`);
+	}
+	/**
+	* Asserts that a service has NOT been destroyed.
+	*/ expectNotDestroyed(token) {
+		const realToken = this.resolveToken(token);
+		if ((this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "destroyed")) throw new Error(`Expected ${realToken.toString()} to NOT be destroyed, but onServiceDestroy was called`);
+	}
+	/**
+	* Records a method call for tracking.
+	* Call this from your mock implementations.
+	*/ recordMethodCall(token, method, args, result, error) {
+		const realToken = this.resolveToken(token);
+		const calls = this.methodCalls.get(realToken.id) || [];
+		calls.push({
+			method,
+			args,
+			timestamp: Date.now(),
+			result,
+			error
+		});
+		this.methodCalls.set(realToken.id, calls);
+	}
+	/**
+	* Records a lifecycle event for tracking.
+	*/ recordLifecycleEvent(token, event, instanceName) {
+		const realToken = this.resolveToken(token);
+		const events = this.lifecycleEvents.get(realToken.id) || [];
+		events.push({
+			event,
+			timestamp: Date.now(),
+			instanceName
+		});
+		this.lifecycleEvents.set(realToken.id, events);
+		if (event === "created") {
+			const count = this.instanceCounts.get(realToken.id) || 0;
+			this.instanceCounts.set(realToken.id, count + 1);
 		}
 	}
-	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
-		var decs = decInfo[0];
-		var desc, init, value;
-		if (isPrivate) if (kind === 0 || kind === 1) desc = {
-			get: decInfo[3],
-			set: decInfo[4]
-		};
-		else if (kind === 3) desc = { get: decInfo[3] };
-		else if (kind === 4) desc = { set: decInfo[3] };
-		else desc = { value: decInfo[3] };
-		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
-		if (kind === 1) value = {
-			get: desc.get,
-			set: desc.set
+	/**
+	* Asserts that a method was called on a service.
+	*/ expectCalled(token, method) {
+		const realToken = this.resolveToken(token);
+		if (!(this.methodCalls.get(realToken.id) || []).some((c) => c.method === method)) throw new Error(`Expected ${realToken.toString()}.${method}() to be called, but it was not`);
+	}
+	/**
+	* Asserts that a method was called with specific arguments.
+	*/ expectCalledWith(token, method, expectedArgs) {
+		const realToken = this.resolveToken(token);
+		if (!(this.methodCalls.get(realToken.id) || []).some((c) => c.method === method && this.argsMatch(c.args, expectedArgs))) throw new Error(`Expected ${realToken.toString()}.${method}() to be called with ${JSON.stringify(expectedArgs)}, but it was not`);
+	}
+	/**
+	* Asserts that a method was called a specific number of times.
+	*/ expectCallCount(token, method, count) {
+		const realToken = this.resolveToken(token);
+		const actualCount = (this.methodCalls.get(realToken.id) || []).filter((c) => c.method === method).length;
+		if (actualCount !== count) throw new Error(`Expected ${realToken.toString()}.${method}() to be called ${count} times, but was called ${actualCount} times`);
+	}
+	/**
+	* Gets all recorded method calls for a service.
+	*/ getMethodCalls(token) {
+		const realToken = this.resolveToken(token);
+		return this.methodCalls.get(realToken.id) || [];
+	}
+	/**
+	* Gets statistics about a mocked service.
+	*/ getServiceStats(token) {
+		const realToken = this.resolveToken(token);
+		return {
+			instanceCount: this.instanceCounts.get(realToken.id) || 0,
+			methodCalls: this.methodCalls.get(realToken.id) || [],
+			lifecycleEvents: this.lifecycleEvents.get(realToken.id) || []
 		};
-		else if (kind === 2) value = desc.value;
-		else if (kind === 3) value = desc.get;
-		else if (kind === 4) value = desc.set;
-		var newValue, get, set;
-		if (typeof decs === "function") {
-			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-			if (newValue !== void 0) {
-				assertValidReturnValue(kind, newValue);
-				if (kind === 0) init = newValue;
-				else if (kind === 1) {
-					init = newValue.init;
-					get = newValue.get || value.get;
-					set = newValue.set || value.set;
-					value = {
-						get,
-						set
-					};
-				} else value = newValue;
-			}
-		} else for (var i = decs.length - 1; i >= 0; i--) {
-			var dec = decs[i];
-			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-			if (newValue !== void 0) {
-				assertValidReturnValue(kind, newValue);
-				var newInit;
-				if (kind === 0) newInit = newValue;
-				else if (kind === 1) {
-					newInit = newValue.init;
-					get = newValue.get || value.get;
-					set = newValue.set || value.set;
-					value = {
-						get,
-						set
-					};
-				} else value = newValue;
-				if (newInit !== void 0) if (init === void 0) init = newInit;
-				else if (typeof init === "function") init = [init, newInit];
-				else init.push(newInit);
-			}
-		}
-		if (kind === 0 || kind === 1) {
-			if (init === void 0) init = function(instance, init$1) {
-				return init$1;
+	}
+	/**
+	* Clears all recorded method calls.
+	*/ clearMethodCalls() {
+		this.methodCalls.clear();
+	}
+	/**
+	* Gets the dependency graph for snapshot testing.
+	* Returns a serializable structure that can be used with vitest snapshots.
+	*/ getDependencyGraph() {
+		const storage = this.getStorage();
+		const nodes = {};
+		const rootTokens = [];
+		storage.forEach((name, holder) => {
+			const tokenMatch = name.match(/^([^:]+)/);
+			nodes[name] = {
+				token: tokenMatch ? tokenMatch[1] : name,
+				instanceName: name,
+				scope: holder.scope,
+				dependencies: Array.from(holder.deps),
+				dependents: storage.findDependents(name)
 			};
-			else if (typeof init !== "function") {
-				var ownInitializers = init;
-				init = function(instance, init$1) {
-					var value$1 = init$1;
-					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
-					return value$1;
-				};
-			} else {
-				var originalInitializer = init;
-				init = function(instance, init$1) {
-					return originalInitializer.call(instance, init$1);
-				};
-			}
-			ret.push(init);
-		}
-		if (kind !== 0) {
-			if (kind === 1) {
-				desc.get = value.get;
-				desc.set = value.set;
-			} else if (kind === 2) desc.value = value;
-			else if (kind === 3) desc.get = value;
-			else if (kind === 4) desc.set = value;
-			if (isPrivate) if (kind === 1) {
-				ret.push(function(instance, args) {
-					return value.get.call(instance, args);
-				});
-				ret.push(function(instance, args) {
-					return value.set.call(instance, args);
-				});
-			} else if (kind === 2) ret.push(value);
-			else ret.push(function(instance, args) {
-				return value.call(instance, args);
-			});
-			else Object.defineProperty(base, name, desc);
-		}
+			if (storage.findDependents(name).length === 0) rootTokens.push(name);
+		});
+		return {
+			nodes,
+			rootTokens
+		};
 	}
-	function applyMemberDecs(Class, decInfos, metadata) {
-		var ret = [];
-		var protoInitializers;
-		var staticInitializers;
-		var existingProtoNonFields = /* @__PURE__ */ new Map();
-		var existingStaticNonFields = /* @__PURE__ */ new Map();
-		for (var i = 0; i < decInfos.length; i++) {
-			var decInfo = decInfos[i];
-			if (!Array.isArray(decInfo)) continue;
-			var kind = decInfo[1];
-			var name = decInfo[2];
-			var isPrivate = decInfo.length > 3;
-			var isStatic = kind >= 5;
-			var base;
-			var initializers;
-			if (isStatic) {
-				base = Class;
-				kind = kind - 5;
-				staticInitializers = staticInitializers || [];
-				initializers = staticInitializers;
-			} else {
-				base = Class.prototype;
-				protoInitializers = protoInitializers || [];
-				initializers = protoInitializers;
-			}
-			if (kind !== 0 && !isPrivate) {
-				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
-				var existingKind = existingNonFields.get(name) || 0;
-				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
-				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
-				else existingNonFields.set(name, true);
+	/**
+	* Gets a simplified dependency graph showing only token relationships.
+	* Useful for cleaner snapshot comparisons.
+	*/ getSimplifiedDependencyGraph() {
+		const storage = this.getStorage();
+		const graph = {};
+		storage.forEach((name, holder) => {
+			const tokenMatch = name.match(/^([^:]+)/);
+			const tokenId = tokenMatch ? tokenMatch[1] : name;
+			if (!graph[tokenId]) graph[tokenId] = [];
+			for (const dep of holder.deps) {
+				const depTokenMatch = dep.match(/^([^:]+)/);
+				const depTokenId = depTokenMatch ? depTokenMatch[1] : dep;
+				if (!graph[tokenId].includes(depTokenId)) graph[tokenId].push(depTokenId);
 			}
-			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
-		}
-		pushInitializers(ret, protoInitializers);
-		pushInitializers(ret, staticInitializers);
-		return ret;
-	}
-	function pushInitializers(ret, initializers) {
-		if (initializers) ret.push(function(instance) {
-			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
-			return instance;
 		});
+		for (const key of Object.keys(graph)) graph[key].sort();
+		return graph;
+	}
+	resolveToken(token) {
+		if (typeof token === "function") return require_container.getInjectableToken(token);
+		return token;
+	}
+	registerValueBinding(token, value) {
+		const ValueHolder = class {
+			static instance = value;
+		};
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, ValueHolder, require_container.InjectableType.Class);
+		const instanceName = this.getNameResolver().generateInstanceName(token, void 0, void 0, require_container.InjectableScope.Singleton);
+		this.getStorage().storeInstance(instanceName, value);
+		this.recordLifecycleEvent(token, "created", instanceName);
+	}
+	registerClassBinding(token, cls) {
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, cls, require_container.InjectableType.Class);
 	}
-	function applyClassDecs(targetClass, classDecs, metadata) {
-		if (classDecs.length > 0) {
-			var initializers = [];
-			var newClass = targetClass;
-			var name = targetClass.name;
-			for (var i = classDecs.length - 1; i >= 0; i--) {
-				var decoratorFinishedRef = { v: false };
-				try {
-					var nextNewClass = classDecs[i](newClass, {
-						kind: "class",
-						name,
-						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
-						metadata
-					});
-				} finally {
-					decoratorFinishedRef.v = true;
-				}
-				if (nextNewClass !== void 0) {
-					assertValidReturnValue(10, nextNewClass);
-					newClass = nextNewClass;
-				}
+	registerFactoryBinding(token, factory) {
+		const FactoryWrapper = class {
+			static factory = factory;
+			async create() {
+				return await factory();
 			}
-			return [defineMetadata(newClass, metadata), function() {
-				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
-			}];
-		}
+		};
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, FactoryWrapper, require_container.InjectableType.Factory);
 	}
-	function defineMetadata(Class, metadata) {
-		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
-			configurable: true,
-			enumerable: true,
-			value: metadata
+	argsMatch(actual, expected) {
+		if (actual.length !== expected.length) return false;
+		return actual.every((arg, index) => {
+			const exp = expected[index];
+			if (typeof exp === "object" && exp !== null) return JSON.stringify(arg) === JSON.stringify(exp);
+			return arg === exp;
 		});
 	}
-	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
-		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
-		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
-		var e = applyMemberDecs(targetClass, memberDecs, metadata);
-		if (!classDecs.length) defineMetadata(targetClass, metadata);
-		return {
-			e,
-			get c() {
-				return applyClassDecs(targetClass, classDecs, metadata);
+};
+
+//#endregion
+//#region src/testing/unit-test-container.mts
+/**
+* Creates a tracking proxy that records method calls.
+*/ function createTrackingProxy(target, tokenId, methodCalls) {
+	return new Proxy(target, { get(obj, prop) {
+		const value = Reflect.get(obj, prop);
+		if (typeof value === "function" && typeof prop === "string") return function(...args) {
+			const calls = methodCalls.get(tokenId) || [];
+			const record = {
+				method: prop,
+				args,
+				timestamp: Date.now()
+			};
+			try {
+				const result = value.apply(this === void 0 ? obj : this, args);
+				if (result instanceof Promise) return result.then((res) => {
+					record.result = res;
+					calls.push(record);
+					methodCalls.set(tokenId, calls);
+					return res;
+				}).catch((err) => {
+					record.error = err;
+					calls.push(record);
+					methodCalls.set(tokenId, calls);
+					throw err;
+				});
+				record.result = result;
+				calls.push(record);
+				methodCalls.set(tokenId, calls);
+				return result;
+			} catch (err) {
+				record.error = err;
+				calls.push(record);
+				methodCalls.set(tokenId, calls);
+				throw err;
 			}
 		};
-	};
+		return value;
+	} });
 }
-function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+/**
+* Creates an auto-mock proxy that throws on method access.
+*/ function createAutoMockProxy(tokenId) {
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "then" || prop === "catch" || prop === "finally") return;
+		if (typeof prop === "symbol") return;
+		throw new Error(`[UnitTestContainer] Attempted to access '${prop}' on auto-mocked service '${tokenId}'. This service was not provided in the providers list. Add it to providers or use allowUnregistered: false to catch this earlier.`);
+	} });
 }
-var _dec, _initClass, _Container;
 /**
-* A binding builder for the TestContainer that allows chaining binding operations.
-*/ var TestBindingBuilder = class {
-	container;
-	token;
-	constructor(container, token) {
-		this.container = container;
-		this.token = token;
-	}
-	/**
-	* Binds the token to a specific value.
-	* This is useful for testing with mock values or constants.
-	* @param value The value to bind to the token
-	*/ toValue(value) {
-		const instanceName = this.container.getServiceLocator().getInstanceIdentifier(this.token);
-		this.container.getServiceLocator().getManager().storeCreatedHolder(instanceName, value, require_container.InjectableType.Class, require_container.InjectableScope.Singleton);
-		return this.container;
-	}
-	/**
-	* Binds the token to a class constructor.
-	* @param target The class constructor to bind to
-	*/ toClass(target) {
-		this.container["registry"].set(this.token, require_container.InjectableScope.Singleton, target, require_container.InjectableType.Class);
-		return this.container;
+* UnitTestContainer for isolated unit testing.
+*
+* Only services explicitly listed in `providers` can be resolved.
+* All method calls are automatically tracked via proxies.
+* Unregistered dependencies throw by default, or can be auto-mocked.
+*
+* @example
+* ```ts
+* const container = new UnitTestContainer({
+*   providers: [
+*     { token: UserService, useClass: MockUserService },
+*     { token: ConfigToken, useValue: { apiUrl: 'test' } },
+*   ],
+* })
+*
+* const service = await container.get(UserService)
+*
+* // All method calls are automatically tracked
+* await service.findUser('123')
+*
+* container.expectCalled(UserService, 'findUser')
+* container.expectCalledWith(UserService, 'findUser', ['123'])
+* ```
+*/ var UnitTestContainer = class extends require_container._Container {
+	testRegistry;
+	methodCalls = /* @__PURE__ */ new Map();
+	lifecycleEvents = /* @__PURE__ */ new Map();
+	instanceCounts = /* @__PURE__ */ new Map();
+	registeredTokenIds = /* @__PURE__ */ new Set();
+	autoMockedTokenIds = /* @__PURE__ */ new Set();
+	allowUnregistered;
+	constructor(options) {
+		const testRegistry = new require_container.Registry();
+		super(testRegistry, options.logger ?? null, require_container.defaultInjectors);
+		this.testRegistry = testRegistry;
+		this.allowUnregistered = options.allowUnregistered ?? false;
+		for (const provider of options.providers) this.registerProvider(provider);
 	}
-};
-let _TestContainer;
-_dec = require_container.Injectable();
-var TestContainer = class extends (_Container = require_container._Container) {
-	static {
-		({c: [_TestContainer, _initClass]} = _apply_decs_2203_r(this, [], [_dec], _Container));
+	/**
+	* Enables auto-mocking for unregistered dependencies.
+	* Call this to switch from strict mode to auto-mock mode.
+	*/ enableAutoMocking() {
+		this.allowUnregistered = true;
+		return this;
 	}
-	constructor(registry = require_container.globalRegistry, logger = null, injectors = void 0) {
-		super(registry, logger, injectors);
+	/**
+	* Disables auto-mocking (strict mode).
+	* Unregistered dependencies will throw.
+	*/ disableAutoMocking() {
+		this.allowUnregistered = false;
+		return this;
 	}
-	bind(token) {
-		let realToken = token;
-		if (typeof token === "function") realToken = require_container.getInjectableToken(token);
-		return new TestBindingBuilder(this, realToken);
+	/**
+	* Override get to wrap instances in tracking proxies.
+	*/ async get(token, args) {
+		const realToken = this.resolveToken(token);
+		if (!this.registeredTokenIds.has(realToken.id)) {
+			if (!this.allowUnregistered) throw require_container.DIError.factoryNotFound(`${realToken.toString()} is not in the providers list. Add it to providers or enable allowUnregistered.`);
+			if (!this.autoMockedTokenIds.has(realToken.id)) this.autoMockedTokenIds.add(realToken.id);
+			return createAutoMockProxy(realToken.id);
+		}
+		const instance = await super.get(token, args);
+		if (instance && typeof instance === "object") return createTrackingProxy(instance, realToken.id, this.methodCalls);
+		return instance;
 	}
-	bindValue(token, value) {
-		return this.bind(token).toValue(value);
+	/**
+	* Clears all state and disposes the container.
+	*/ async clear() {
+		await this.dispose();
+		this.methodCalls.clear();
+		this.lifecycleEvents.clear();
+		this.instanceCounts.clear();
+		this.autoMockedTokenIds.clear();
 	}
-	bindClass(token, target) {
-		return this.bind(token).toClass(target);
+	/**
+	* Asserts that a service has been resolved at least once.
+	*/ expectResolved(token) {
+		const realToken = this.resolveToken(token);
+		if (!this.getStorage().getAllNames().some((name) => name.includes(realToken.id))) throw new Error(`Expected ${realToken.toString()} to be resolved, but it was not`);
+	}
+	/**
+	* Asserts that a service has NOT been resolved.
+	*/ expectNotResolved(token) {
+		const realToken = this.resolveToken(token);
+		if (this.getStorage().getAllNames().some((name) => name.includes(realToken.id))) throw new Error(`Expected ${realToken.toString()} to NOT be resolved, but it was`);
+	}
+	/**
+	* Asserts that a service was auto-mocked (not in providers list).
+	*/ expectAutoMocked(token) {
+		const realToken = this.resolveToken(token);
+		if (!this.autoMockedTokenIds.has(realToken.id)) throw new Error(`Expected ${realToken.toString()} to be auto-mocked, but it was not. Either it's in the providers list or hasn't been resolved.`);
+	}
+	/**
+	* Asserts that a service was NOT auto-mocked (is in providers list).
+	*/ expectNotAutoMocked(token) {
+		const realToken = this.resolveToken(token);
+		if (this.autoMockedTokenIds.has(realToken.id)) throw new Error(`Expected ${realToken.toString()} to NOT be auto-mocked, but it was.`);
+	}
+	/**
+	* Records a lifecycle event for tracking.
+	*/ recordLifecycleEvent(token, event, instanceName) {
+		const realToken = this.resolveToken(token);
+		const events = this.lifecycleEvents.get(realToken.id) || [];
+		events.push({
+			event,
+			timestamp: Date.now(),
+			instanceName
+		});
+		this.lifecycleEvents.set(realToken.id, events);
+		if (event === "created") {
+			const count = this.instanceCounts.get(realToken.id) || 0;
+			this.instanceCounts.set(realToken.id, count + 1);
+		}
+	}
+	/**
+	* Asserts that a service's onServiceInit was called.
+	*/ expectInitialized(token) {
+		const realToken = this.resolveToken(token);
+		if (!(this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "initialized")) throw new Error(`Expected ${realToken.toString()} to be initialized, but onServiceInit was not called`);
 	}
 	/**
-	* Creates a new TestContainer instance with the same configuration.
-	* This is useful for creating isolated test containers.
-	* @returns A new TestContainer instance
-	*/ createChild() {
-		return new _TestContainer(this.registry, this.logger, this.injectors);
+	* Asserts that a service's onServiceDestroy was called.
+	*/ expectDestroyed(token) {
+		const realToken = this.resolveToken(token);
+		if (!(this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "destroyed")) throw new Error(`Expected ${realToken.toString()} to be destroyed, but onServiceDestroy was not called`);
 	}
-	static {
-		_initClass();
+	/**
+	* Asserts that a service has NOT been destroyed.
+	*/ expectNotDestroyed(token) {
+		const realToken = this.resolveToken(token);
+		if ((this.lifecycleEvents.get(realToken.id) || []).some((e) => e.event === "destroyed")) throw new Error(`Expected ${realToken.toString()} to NOT be destroyed, but onServiceDestroy was called`);
+	}
+	/**
+	* Asserts that a method was called on a service.
+	*/ expectCalled(token, method) {
+		const realToken = this.resolveToken(token);
+		if (!(this.methodCalls.get(realToken.id) || []).some((c) => c.method === method)) throw new Error(`Expected ${realToken.toString()}.${method}() to be called, but it was not`);
+	}
+	/**
+	* Asserts that a method was NOT called on a service.
+	*/ expectNotCalled(token, method) {
+		const realToken = this.resolveToken(token);
+		if ((this.methodCalls.get(realToken.id) || []).some((c) => c.method === method)) throw new Error(`Expected ${realToken.toString()}.${method}() to NOT be called, but it was`);
+	}
+	/**
+	* Asserts that a method was called with specific arguments.
+	*/ expectCalledWith(token, method, expectedArgs) {
+		const realToken = this.resolveToken(token);
+		const calls = this.methodCalls.get(realToken.id) || [];
+		if (!calls.some((c) => c.method === method && this.argsMatch(c.args, expectedArgs))) {
+			const actualArgs = calls.filter((c) => c.method === method).map((c) => JSON.stringify(c.args)).join(", ");
+			throw new Error(`Expected ${realToken.toString()}.${method}() to be called with ${JSON.stringify(expectedArgs)}. Actual calls: [${actualArgs}]`);
+		}
+	}
+	/**
+	* Asserts that a method was called a specific number of times.
+	*/ expectCallCount(token, method, count) {
+		const realToken = this.resolveToken(token);
+		const actualCount = (this.methodCalls.get(realToken.id) || []).filter((c) => c.method === method).length;
+		if (actualCount !== count) throw new Error(`Expected ${realToken.toString()}.${method}() to be called ${count} times, but was called ${actualCount} times`);
+	}
+	/**
+	* Gets all recorded method calls for a service.
+	*/ getMethodCalls(token) {
+		const realToken = this.resolveToken(token);
+		return this.methodCalls.get(realToken.id) || [];
+	}
+	/**
+	* Gets statistics about a service.
+	*/ getServiceStats(token) {
+		const realToken = this.resolveToken(token);
+		return {
+			instanceCount: this.instanceCounts.get(realToken.id) || 0,
+			methodCalls: this.methodCalls.get(realToken.id) || [],
+			lifecycleEvents: this.lifecycleEvents.get(realToken.id) || []
+		};
+	}
+	/**
+	* Clears all recorded method calls.
+	*/ clearMethodCalls() {
+		this.methodCalls.clear();
+	}
+	/**
+	* Gets list of all registered provider token IDs.
+	*/ getRegisteredTokenIds() {
+		return this.registeredTokenIds;
+	}
+	/**
+	* Gets list of all auto-mocked token IDs.
+	*/ getAutoMockedTokenIds() {
+		return this.autoMockedTokenIds;
+	}
+	resolveToken(token) {
+		if (typeof token === "function") try {
+			return require_container.getInjectableToken(token);
+		} catch {
+			return require_container.InjectionToken.create(token);
+		}
+		return token;
+	}
+	registerProvider(provider) {
+		const realToken = this.resolveToken(provider.token);
+		this.registeredTokenIds.add(realToken.id);
+		if (provider.useValue !== void 0) this.registerValueBinding(realToken, provider.useValue);
+		else if (provider.useClass) this.registerClassBinding(realToken, provider.useClass);
+		else if (provider.useFactory) this.registerFactoryBinding(realToken, provider.useFactory);
+		else if (typeof provider.token === "function") this.testRegistry.set(realToken, require_container.InjectableScope.Singleton, provider.token, require_container.InjectableType.Class);
+	}
+	registerValueBinding(token, value) {
+		const ValueHolder = class {
+			static instance = value;
+		};
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, ValueHolder, require_container.InjectableType.Class);
+		const instanceName = this.getNameResolver().generateInstanceName(token, void 0, void 0, require_container.InjectableScope.Singleton);
+		this.getStorage().storeInstance(instanceName, value);
+		this.recordLifecycleEvent(token, "created", instanceName);
+	}
+	registerClassBinding(token, cls) {
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, cls, require_container.InjectableType.Class);
+	}
+	registerFactoryBinding(token, factory) {
+		const FactoryWrapper = class {
+			static factory = factory;
+			async create() {
+				return await factory();
+			}
+		};
+		this.testRegistry.set(token, require_container.InjectableScope.Singleton, FactoryWrapper, require_container.InjectableType.Factory);
+	}
+	argsMatch(actual, expected) {
+		if (actual.length !== expected.length) return false;
+		return actual.every((arg, index) => {
+			const exp = expected[index];
+			if (typeof exp === "object" && exp !== null) return JSON.stringify(arg) === JSON.stringify(exp);
+			return arg === exp;
+		});
 	}
 };
 
 //#endregion
-exports.TestBindingBuilder = TestBindingBuilder;
-Object.defineProperty(exports, 'TestContainer', {
-  enumerable: true,
-  get: function () {
-    return _TestContainer;
-  }
-});
+exports.TestContainer = TestContainer;
+exports.UnitTestContainer = UnitTestContainer;
 //# sourceMappingURL=index.cjs.map