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

test/providers.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import "reflect-metadata";
+import { AlveoFactory, Container, Module } from "../index";
+
+describe("Alveo Providers", () => {
+	test("should support Factory Providers", async () => {
+		const TOKEN = "FACTORY";
+
+		@Module({
+			providers: [
+				{
+					provide: TOKEN,
+					useFactory: () => "dynamic_value",
+				},
+			],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const value = await app.get(TOKEN);
+
+		expect(value).toBe("dynamic_value");
+	});
+
+	test("should support Asynchronous Factory Providers", async () => {
+		const TOKEN = "ASYNC_FACTORY";
+
+		@Module({
+			providers: [
+				{
+					provide: TOKEN,
+					useFactory: async () => {
+						await new Promise((resolve) => setTimeout(resolve, 10));
+						return "async_value";
+					},
+				},
+			],
+		})
+		class RootModule {}
+
+		const app = await AlveoFactory.create(RootModule);
+		const value = await app.get(TOKEN);
+
+		expect(value).toBe("async_value");
+	});
+
+	test("should handle concurrent resolution of the same async provider", async () => {
+		const TOKEN = "CONCURRENT_ASYNC";
+		let callCount = 0;
+
+		@Module({
+			providers: [
+				{
+					provide: TOKEN,
+					useFactory: async () => {
+						callCount++;
+						await new Promise((resolve) => setTimeout(resolve, 20));
+						return { id: Math.random() };
+					},
+				},
+			],
+		})
+		class RootModule {}
+
+		// We use a fresh container to test concurrent resolution
+		// bypassing the sequential resolveAll() of AlveoFactory.create()
+		const container = new Container();
+		await container.registerRootModule(RootModule);
+
+		const [val1, val2] = await Promise.all([
+			container.get(TOKEN),
+			container.get(TOKEN),
+		]);
+
+		expect(val1).toBe(val2);
+		expect(callCount).toBe(1);
+	});
+});