test: split container.test.ts into modular test files

test/injection.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import "reflect-metadata";
+import {
+	AlveoFactory,
+	Inject,
+	Injectable,
+	Module,
+	ProviderNotFoundError,
+} from "../index";
+
+describe("Alveo Injection", () => {
+	test("should resolve a simple singleton service", async () => {
+		@Injectable()
+		class SimpleService {
+			getValue() {
+				return "hello";
+			}
+		}
+
+		@Module({
+			providers: [SimpleService],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const service = await app.get(SimpleService);
+
+		expect(service).toBeInstanceOf(SimpleService);
+		expect(service.getValue()).toBe("hello");
+	});
+
+	test("should inject dependencies via constructor", async () => {
+		@Injectable()
+		class Dependency {
+			name = "dep";
+		}
+
+		@Injectable()
+		class MainService {
+			constructor(public readonly dep: Dependency) {}
+		}
+
+		@Module({
+			providers: [Dependency, MainService],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const main = await app.get(MainService);
+
+		expect(main.dep).toBeInstanceOf(Dependency);
+		expect(main.dep.name).toBe("dep");
+	});
+
+	test("should support Value Providers", async () => {
+		const TOKEN = Symbol("CONFIG");
+
+		@Injectable()
+		class Service {
+			constructor(
+				@Inject(TOKEN) public readonly config: { apiKey: string },
+			) {}
+		}
+
+		@Module({
+			providers: [
+				Service,
+				{ provide: TOKEN, useValue: { apiKey: "123" } },
+			],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const service = await app.get(Service);
+
+		expect(service.config.apiKey).toBe("123");
+	});
+
+	test("should support existing providers (aliases)", async () => {
+		const ALIAS = "ALIAS_TOKEN";
+
+		@Injectable()
+		class RealService {
+			ok() {
+				return true;
+			}
+		}
+
+		@Module({
+			providers: [
+				RealService,
+				{ provide: ALIAS, useExisting: RealService },
+			],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const real = await app.get(RealService);
+		const aliased = await app.get(ALIAS);
+
+		expect(aliased).toBe(real);
+		expect((aliased as RealService).ok()).toBe(true);
+	});
+
+	test("should throw ProviderNotFoundError when dependency is missing", async () => {
+		@Injectable()
+		class MissingDep {}
+
+		@Injectable()
+		class Target {
+			constructor(_dep: MissingDep) {}
+		}
+
+		@Module({
+			providers: [Target],
+		})
+		class RootModule {}
+
+		expect(AlveoFactory.create(RootModule)).rejects.toThrow(
+			ProviderNotFoundError,
+		);
+	});
+});