provider is key

dependency-manager.test.ts

@@ -1,77 +1,91 @@
 import {
-  assertEquals,
-  assertRejects,
-  assertThrows,
-} from "https://deno.land/std@0.224.0/assert/mod.ts";
-import { DependencyManager } from "./dependency-manager.ts";
+	assertEquals,
+	assertThrows,
+} from 'https://deno.land/std@0.224.0/assert/mod.ts';
 
-// Test case for registering a module
-Deno.test("DependencyManager: register a module", () => {
-  const manager = new DependencyManager();
-  const provider = () => "dependency";
-  manager.register("identifier", provider);
-  assertEquals(
-    manager.resolve("identifier"),
-    Promise.resolve("dependency"),
-  );
+import { DependencyManager, Provider } from './dependency-manager.ts';
+
+Deno.test('should register and resolve a simple dependency', () => {
+	const manager = new DependencyManager();
+
+	const dependency = () => 'test';
+	manager.register(dependency);
+
+	const resolved = manager.resolve(dependency);
+	assertEquals(resolved, 'test');
 });
 
-// Test case for resolving a module
-Deno.test("DependencyManager: resolve a module", async () => {
-  const manager = new DependencyManager();
-  const provider = () => "dependency";
-  manager.register("identifier", provider);
-  const result = await manager.resolve("identifier");
-  assertEquals(result, "dependency");
+Deno.test('should register and resolve a module with multiple dependencies', () => {
+	const manager = new DependencyManager();
+
+	const module = {
+		a: () => 'test1',
+		b: () => 42,
+	};
+
+	manager.register(module);
+
+	const a = manager.resolve(module.a);
+	const b = manager.resolve(module.b);
+
+	assertEquals(a, 'test1');
+	assertEquals(b, 42);
 });
 
-// Test case for resolving an async module
-Deno.test("DependencyManager: resolve an async module", async () => {
-  const manager = new DependencyManager();
-  const provider = () => {
-    return new Promise((resolve) =>
-      setTimeout(() => resolve("dependency"), 100)
-    );
-  };
-  manager.register("identifier", provider);
-  const result = await manager.resolve("identifier");
-  assertEquals(result, "dependency");
+Deno.test('should throw error when registering the same dependency twice', () => {
+	const manager = new DependencyManager();
+
+	const dependency = () => 'test';
+	manager.register(dependency);
+
+	assertThrows(
+		() => manager.register(dependency),
+		Error,
+		'This dependency or module has already been registered',
+	);
 });
 
-// Test case for handling circular dependencies
-Deno.test("DependencyManager: circular dependency detection", async () => {
-  const manager = new DependencyManager();
-  const providerA = async () => await manager.resolve("B");
-  const providerB = async () => await manager.resolve("A");
+Deno.test('should throw error when resolving a non-registered dependency', () => {
+	const manager = new DependencyManager();
 
-  manager.register("A", providerA);
-  manager.register("B", providerB);
+	const dependency = () => 'test';
 
-  await assertRejects(
-    () => manager.resolve("A"),
-    Error,
-    "Circular dependency detected for module A.",
-  );
+	assertThrows(
+		() => manager.resolve(dependency),
+		Error,
+		'This key has not (yet ?) been used to register something',
+	);
 });
 
-// Test case for handling duplicate module registration
-Deno.test("DependencyManager: duplicate module registration", () => {
-  const manager = new DependencyManager();
-  const provider = () => "dependency";
-  manager.register("identifier", provider);
-  assertThrows(
-    () => manager.register("identifier", provider),
-    Error,
-    "Module identifier is already registered.",
-  );
+Deno.test('should resolve dependency recursively (when not circular)', () => {
+	const manager = new DependencyManager();
+
+	const dependencyA = () => 'A';
+	const dependencyB = (manager: DependencyManager) =>
+		manager.resolve(dependencyA);
+
+	manager.register(dependencyA);
+	manager.register(dependencyB);
+
+	const b = manager.resolve(dependencyB);
+
+	assertEquals(b, 'A');
 });
 
-// Test case for handling unresolved modules
-Deno.test("DependencyManager: resolve an unregistered module", async () => {
-  const manager = new DependencyManager();
-  await assertRejects(
-    () => manager.resolve("unregistered-identifier"),
-    Error,
-    "Module unregistered-identifier is not registered.",
-  );
+Deno.test('should throw error when detecting a circular dependency', () => {
+	const manager = new DependencyManager();
+
+	const dependencyA: Provider<string> = (manager) =>
+		manager.resolve(dependencyB);
+	const dependencyB: Provider<string> = (manager) =>
+		manager.resolve(dependencyA);
+
+	manager.register(dependencyA);
+	manager.register(dependencyB);
+
+	assertThrows(
+		() => manager.resolve(dependencyA),
+		Error,
+		'Circular dependency detected',
+	);
 });