framework/container/Container.test.ts

import "reflect-metadata";

import Container from "@framework/container/Container";
import crypto from "crypto";
import { afterEach, beforeEach, describe, expect, it } from "vitest";

describe("container bindings", () => {
    let container: Container;

    beforeEach(() => {
        container = Container.getInstance();
    });

    afterEach(() => {
        Container.destroyGlobalContainer();
    });

    it("should bind and resolve a class instance", () => {
        class MyClass {}

        container.bind(MyClass);
        const instance = container.resolveByClass(MyClass);

        expect(instance).toBeInstanceOf(MyClass);
    });

    it("should bind and resolve a singleton class instance", () => {
        class MyClass {}

        container.bind(MyClass, { singleton: true });
        const instance1 = container.resolveByClass(MyClass);
        const instance2 = container.resolveByClass(MyClass);

        expect(instance1).toBeInstanceOf(MyClass);
        expect(instance2).toBe(instance1);
    });

    it("should bind and resolve a class instance with a custom key", () => {
        class MyClass {}

        container.bind(MyClass, { key: "myClass", singleton: true });

        const instance = container.resolve("myClass");
        expect(instance).toBeInstanceOf(MyClass);

        const instance2 = container.resolveByClass(MyClass);
        expect(instance2).toBeInstanceOf(MyClass);

        expect(instance2).toBe(instance);
    });

    it("should implicitly resolve a class instance if not bound", () => {
        class MyClass {}

        const instance = container.resolveByClass(MyClass);
        expect(instance).toBeInstanceOf(MyClass);
    });
});

describe("container bindings with dependencies", () => {
    let container: Container;

    beforeEach(() => {
        container = Container.getInstance();
    });

    afterEach(() => {
        Container.destroyGlobalContainer();
    });

    it("should bind and resolve a class instance with dependencies", () => {
        class MyClass {}

        class MyDependentClass {
            public constructor(public myClass: MyClass) {}
        }

        Reflect.defineMetadata("design:paramtypes", [MyClass], MyDependentClass);

        container.bind(MyClass);
        container.bind(MyDependentClass);

        const instance = container.resolveByClass(MyDependentClass);

        expect(instance).toBeInstanceOf(MyDependentClass);
        expect(instance.myClass).toBeInstanceOf(MyClass);
    });

    it("should bind and resolve a class instance with singleton dependencies", () => {
        class MyClass {}
        class MyClass2 {}

        class MyDependentClass {
            public constructor(
                public myClass: MyClass,
                public myClass2: MyClass2
            ) {}
        }

        Reflect.defineMetadata("design:paramtypes", [MyClass, MyClass2], MyDependentClass);

        container.bind(MyClass, { singleton: true });
        container.bind(MyClass2, { singleton: true });
        container.bind(MyDependentClass, { singleton: true });

        const instance1 = container.resolveByClass(MyDependentClass);
        const instance2 = container.resolveByClass(MyDependentClass);

        expect(instance1).toBeInstanceOf(MyDependentClass);
        expect(instance2).toBe(instance1);
        expect(instance1.myClass).toBeInstanceOf(MyClass);
        expect(instance2.myClass).toBe(instance1.myClass);
        expect(instance1.myClass2).toBeInstanceOf(MyClass2);
        expect(instance2.myClass2).toBe(instance1.myClass2);
    });

    it("should bind and resolve a class instance with deep and circular dependencies", () => {
        class Level0Dep0 {}
        class Level0Dep1 {}

        class Level1Dep0 {
            public constructor(public level0Dep0: Level0Dep0) {}
        }

        Reflect.defineMetadata("design:paramtypes", [Level0Dep0], Level1Dep0);

        class Level1Dep1 {
            public constructor(
                public level0Dep0: Level0Dep0,
                public level0Dep1: Level0Dep1
            ) {}
        }

        Reflect.defineMetadata("design:paramtypes", [Level0Dep0, Level0Dep1], Level1Dep1);

        class Level2Dep0 {
            public constructor(
                public level1Dep0: Level1Dep0,
                public level0Dep1: Level0Dep1
            ) {}
        }

        Reflect.defineMetadata("design:paramtypes", [Level1Dep0, Level0Dep1], Level2Dep0);

        class Level2Dep1 {
            public constructor(
                public level1Dep0: Level1Dep0,
                public level0Dep0: Level0Dep0,
                public level1Dep1: Level1Dep1
            ) {}
        }

        Reflect.defineMetadata(
            "design:paramtypes",
            [Level1Dep0, Level0Dep0, Level1Dep1],
            Level2Dep1
        );

        class Application {
            public constructor(
                public level2Dep1: Level2Dep1,
                public level2Dep0: Level2Dep0
            ) {}
        }

        Reflect.defineMetadata("design:paramtypes", [Level2Dep1, Level2Dep0], Application);

        container.bind(Level0Dep0, { singleton: true });
        container.bind(Level0Dep1, { singleton: true });
        container.bind(Level1Dep0, { singleton: true });
        container.bind(Level1Dep1, { singleton: true });
        container.bind(Level2Dep0, { singleton: true });
        container.bind(Level2Dep1, { singleton: true });
        container.bind(Application);

        const instance = container.resolveByClass(Application);

        expect(instance).toBeInstanceOf(Application);

        expect(instance.level2Dep0).toBeInstanceOf(Level2Dep0);
        expect(instance.level2Dep1).toBeInstanceOf(Level2Dep1);

        expect(instance.level2Dep0.level1Dep0).toBeInstanceOf(Level1Dep0);
        expect(instance.level2Dep0.level0Dep1).toBeInstanceOf(Level0Dep1);

        expect(instance.level2Dep1.level1Dep0).toBeInstanceOf(Level1Dep0);
        expect(instance.level2Dep1.level0Dep0).toBeInstanceOf(Level0Dep0);
        expect(instance.level2Dep1.level1Dep1).toBeInstanceOf(Level1Dep1);

        expect(instance.level2Dep1.level1Dep1.level0Dep0).toBeInstanceOf(Level0Dep0);
        expect(instance.level2Dep1.level1Dep1.level0Dep1).toBeInstanceOf(Level0Dep1);

        expect(instance.level2Dep1.level1Dep1.level0Dep0).toBe(
            instance.level2Dep0.level1Dep0.level0Dep0
        );
        expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);

        expect(instance.level2Dep0.level1Dep0.level0Dep0).toBe(
            instance.level2Dep1.level1Dep0.level0Dep0
        );
        expect(instance.level2Dep0.level0Dep1).toBe(instance.level2Dep1.level1Dep1.level0Dep1);

        expect(instance.level2Dep1.level1Dep0.level0Dep0).toBe(
            instance.level2Dep0.level1Dep0.level0Dep0
        );
        expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);

        expect(instance.level2Dep1.level1Dep0.level0Dep0).toBe(
            instance.level2Dep0.level1Dep0.level0Dep0
        );
        expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);
    });
});

describe("container bindings with factories", () => {
    let container: Container;

    beforeEach(() => {
        container = Container.getInstance();
    });

    afterEach(() => {
        Container.destroyGlobalContainer();
    });

    it("should bind and resolve a class instance with a factory", async () => {
        class MyClass {
            public constructor(public value: number) {}
        }

        await container.bind(MyClass, {
            factory: () => new MyClass(crypto.getRandomValues(new Uint32Array(1))[0])
        });

        const instance = container.resolveByClass(MyClass);
        const instance2 = container.resolveByClass(MyClass);

        expect(instance).toBeInstanceOf(MyClass);
        expect(instance2).toBeInstanceOf(MyClass);
        expect(instance2).not.toBe(instance);
        expect(instance.value).not.toBe(instance2.value);
    });

    it("should bind and resolve a singleton class instance with a factory", () => {
        class MyClass {
            public constructor(public value: number) {}
        }

        container.bind(MyClass, {
            factory: () => new MyClass(Math.ceil(Math.random() * 100)),
            singleton: true
        });

        const instance = container.resolveByClass(MyClass);
        const instance2 = container.resolveByClass(MyClass);

        expect(instance).toBeInstanceOf(MyClass);
        expect(instance2).toBeInstanceOf(MyClass);
        expect(instance2).toBe(instance);
        expect(instance.value).toBe(instance2.value);
    });
});

describe("global containers", () => {
    it("should return the same container instance", () => {
        const container1 = Container.getInstance();
        const container2 = Container.getInstance();

        expect(container2).toBe(container1);
    });

    it("should destroy the global container instance", () => {
        const container1 = Container.getInstance();
        Container.destroyGlobalContainer();
        const container2 = Container.getInstance();

        expect(container2).not.toBe(container1);
    });
});

describe("container property injection", () => {
    let container: Container;

    beforeEach(() => {
        container = Container.getInstance();
    });

    afterEach(() => {
        Container.destroyGlobalContainer();
    });

    it("should inject a class instance with properties", () => {
        class MyClass {
            public value = 42;
        }

        class MyDependentClass {
            @Container.Inject()
            public myClass!: MyClass;
        }

        Reflect.defineMetadata("design:type", MyClass, MyDependentClass.prototype, "myClass");

        container.bind(MyClass, { singleton: true });
        container.bind(MyDependentClass, { singleton: true });

        const instance = container.resolveByClass(MyDependentClass);

        expect(instance).toBeInstanceOf(MyDependentClass);
        expect(instance.myClass).toBeInstanceOf(MyClass);
        expect(instance.myClass.value).toBe(42);

        const instance2 = container.resolveByClass(MyDependentClass);

        expect(instance2).toBe(instance);
        expect(instance2.myClass).toBe(instance.myClass);
        expect(instance2.myClass.value).toBe(instance.myClass.value);

        instance.myClass.value = 100;

        expect(instance2.myClass.value).toBe(100);
    });

    it("should inject a class instance with properties and singleton dependencies", () => {
        class MyClass {
            public value = 42;
        }

        class MyDependentClass {
            @Container.Inject()
            public myClass!: MyClass;
        }

        Reflect.defineMetadata("design:type", MyClass, MyDependentClass.prototype, "myClass");

        container.bind(MyClass, { singleton: true });
        container.bind(MyDependentClass, { singleton: true });

        const instance = container.resolveByClass(MyDependentClass);

        expect(instance).toBeInstanceOf(MyDependentClass);
        expect(instance.myClass).toBeInstanceOf(MyClass);
        expect(instance.myClass.value).toBe(42);

        const instance2 = container.resolveByClass(MyDependentClass);

        expect(instance2).toBe(instance);
        expect(instance2.myClass).toBe(instance.myClass);
        expect(instance2.myClass.value).toBe(instance.myClass.value);

        instance.myClass.value = 100;

        expect(instance2.myClass.value).toBe(100);
    });
});
1	rakinar2	575	import "reflect-metadata";
2
3			import Container from "@framework/container/Container";
4			import crypto from "crypto";
5			import { afterEach, beforeEach, describe, expect, it } from "vitest";
6
7			describe("container bindings", () => {
8			let container: Container;
9
10			beforeEach(() => {
11			container = Container.getInstance();
12			});
13
14			afterEach(() => {
15			Container.destroyGlobalContainer();
16			});
17
18			it("should bind and resolve a class instance", () => {
19			class MyClass {}
20
21			container.bind(MyClass);
22			const instance = container.resolveByClass(MyClass);
23
24			expect(instance).toBeInstanceOf(MyClass);
25			});
26
27			it("should bind and resolve a singleton class instance", () => {
28			class MyClass {}
29
30			container.bind(MyClass, { singleton: true });
31			const instance1 = container.resolveByClass(MyClass);
32			const instance2 = container.resolveByClass(MyClass);
33
34			expect(instance1).toBeInstanceOf(MyClass);
35			expect(instance2).toBe(instance1);
36			});
37
38			it("should bind and resolve a class instance with a custom key", () => {
39			class MyClass {}
40
41			container.bind(MyClass, { key: "myClass", singleton: true });
42
43			const instance = container.resolve("myClass");
44			expect(instance).toBeInstanceOf(MyClass);
45
46			const instance2 = container.resolveByClass(MyClass);
47			expect(instance2).toBeInstanceOf(MyClass);
48
49			expect(instance2).toBe(instance);
50			});
51
52			it("should implicitly resolve a class instance if not bound", () => {
53			class MyClass {}
54
55			const instance = container.resolveByClass(MyClass);
56			expect(instance).toBeInstanceOf(MyClass);
57			});
58			});
59
60			describe("container bindings with dependencies", () => {
61			let container: Container;
62
63			beforeEach(() => {
64			container = Container.getInstance();
65			});
66
67			afterEach(() => {
68			Container.destroyGlobalContainer();
69			});
70
71			it("should bind and resolve a class instance with dependencies", () => {
72			class MyClass {}
73
74			class MyDependentClass {
75			public constructor(public myClass: MyClass) {}
76			}
77
78			Reflect.defineMetadata("design:paramtypes", [MyClass], MyDependentClass);
79
80			container.bind(MyClass);
81			container.bind(MyDependentClass);
82
83			const instance = container.resolveByClass(MyDependentClass);
84
85			expect(instance).toBeInstanceOf(MyDependentClass);
86			expect(instance.myClass).toBeInstanceOf(MyClass);
87			});
88
89			it("should bind and resolve a class instance with singleton dependencies", () => {
90			class MyClass {}
91			class MyClass2 {}
92
93			class MyDependentClass {
94			public constructor(
95			public myClass: MyClass,
96			public myClass2: MyClass2
97			) {}
98			}
99
100			Reflect.defineMetadata("design:paramtypes", [MyClass, MyClass2], MyDependentClass);
101
102			container.bind(MyClass, { singleton: true });
103			container.bind(MyClass2, { singleton: true });
104			container.bind(MyDependentClass, { singleton: true });
105
106			const instance1 = container.resolveByClass(MyDependentClass);
107			const instance2 = container.resolveByClass(MyDependentClass);
108
109			expect(instance1).toBeInstanceOf(MyDependentClass);
110			expect(instance2).toBe(instance1);
111			expect(instance1.myClass).toBeInstanceOf(MyClass);
112			expect(instance2.myClass).toBe(instance1.myClass);
113			expect(instance1.myClass2).toBeInstanceOf(MyClass2);
114			expect(instance2.myClass2).toBe(instance1.myClass2);
115			});
116
117			it("should bind and resolve a class instance with deep and circular dependencies", () => {
118			class Level0Dep0 {}
119			class Level0Dep1 {}
120
121			class Level1Dep0 {
122			public constructor(public level0Dep0: Level0Dep0) {}
123			}
124
125			Reflect.defineMetadata("design:paramtypes", [Level0Dep0], Level1Dep0);
126
127			class Level1Dep1 {
128			public constructor(
129			public level0Dep0: Level0Dep0,
130			public level0Dep1: Level0Dep1
131			) {}
132			}
133
134			Reflect.defineMetadata("design:paramtypes", [Level0Dep0, Level0Dep1], Level1Dep1);
135
136			class Level2Dep0 {
137			public constructor(
138			public level1Dep0: Level1Dep0,
139			public level0Dep1: Level0Dep1
140			) {}
141			}
142
143			Reflect.defineMetadata("design:paramtypes", [Level1Dep0, Level0Dep1], Level2Dep0);
144
145			class Level2Dep1 {
146			public constructor(
147			public level1Dep0: Level1Dep0,
148			public level0Dep0: Level0Dep0,
149			public level1Dep1: Level1Dep1
150			) {}
151			}
152
153			Reflect.defineMetadata(
154			"design:paramtypes",
155			[Level1Dep0, Level0Dep0, Level1Dep1],
156			Level2Dep1
157			);
158
159			class Application {
160			public constructor(
161			public level2Dep1: Level2Dep1,
162			public level2Dep0: Level2Dep0
163			) {}
164			}
165
166			Reflect.defineMetadata("design:paramtypes", [Level2Dep1, Level2Dep0], Application);
167
168			container.bind(Level0Dep0, { singleton: true });
169			container.bind(Level0Dep1, { singleton: true });
170			container.bind(Level1Dep0, { singleton: true });
171			container.bind(Level1Dep1, { singleton: true });
172			container.bind(Level2Dep0, { singleton: true });
173			container.bind(Level2Dep1, { singleton: true });
174			container.bind(Application);
175
176			const instance = container.resolveByClass(Application);
177
178			expect(instance).toBeInstanceOf(Application);
179
180			expect(instance.level2Dep0).toBeInstanceOf(Level2Dep0);
181			expect(instance.level2Dep1).toBeInstanceOf(Level2Dep1);
182
183			expect(instance.level2Dep0.level1Dep0).toBeInstanceOf(Level1Dep0);
184			expect(instance.level2Dep0.level0Dep1).toBeInstanceOf(Level0Dep1);
185
186			expect(instance.level2Dep1.level1Dep0).toBeInstanceOf(Level1Dep0);
187			expect(instance.level2Dep1.level0Dep0).toBeInstanceOf(Level0Dep0);
188			expect(instance.level2Dep1.level1Dep1).toBeInstanceOf(Level1Dep1);
189
190			expect(instance.level2Dep1.level1Dep1.level0Dep0).toBeInstanceOf(Level0Dep0);
191			expect(instance.level2Dep1.level1Dep1.level0Dep1).toBeInstanceOf(Level0Dep1);
192
193			expect(instance.level2Dep1.level1Dep1.level0Dep0).toBe(
194			instance.level2Dep0.level1Dep0.level0Dep0
195			);
196			expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);
197
198			expect(instance.level2Dep0.level1Dep0.level0Dep0).toBe(
199			instance.level2Dep1.level1Dep0.level0Dep0
200			);
201			expect(instance.level2Dep0.level0Dep1).toBe(instance.level2Dep1.level1Dep1.level0Dep1);
202
203			expect(instance.level2Dep1.level1Dep0.level0Dep0).toBe(
204			instance.level2Dep0.level1Dep0.level0Dep0
205			);
206			expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);
207
208			expect(instance.level2Dep1.level1Dep0.level0Dep0).toBe(
209			instance.level2Dep0.level1Dep0.level0Dep0
210			);
211			expect(instance.level2Dep1.level1Dep1.level0Dep1).toBe(instance.level2Dep0.level0Dep1);
212			});
213			});
214
215			describe("container bindings with factories", () => {
216			let container: Container;
217
218			beforeEach(() => {
219			container = Container.getInstance();
220			});
221
222			afterEach(() => {
223			Container.destroyGlobalContainer();
224			});
225
226			it("should bind and resolve a class instance with a factory", async () => {
227			class MyClass {
228			public constructor(public value: number) {}
229			}
230
231			await container.bind(MyClass, {
232			factory: () => new MyClass(crypto.getRandomValues(new Uint32Array(1))[0])
233			});
234
235			const instance = container.resolveByClass(MyClass);
236			const instance2 = container.resolveByClass(MyClass);
237
238			expect(instance).toBeInstanceOf(MyClass);
239			expect(instance2).toBeInstanceOf(MyClass);
240			expect(instance2).not.toBe(instance);
241			expect(instance.value).not.toBe(instance2.value);
242			});
243
244			it("should bind and resolve a singleton class instance with a factory", () => {
245			class MyClass {
246			public constructor(public value: number) {}
247			}
248
249			container.bind(MyClass, {
250			factory: () => new MyClass(Math.ceil(Math.random() * 100)),
251			singleton: true
252			});
253
254			const instance = container.resolveByClass(MyClass);
255			const instance2 = container.resolveByClass(MyClass);
256
257			expect(instance).toBeInstanceOf(MyClass);
258			expect(instance2).toBeInstanceOf(MyClass);
259			expect(instance2).toBe(instance);
260			expect(instance.value).toBe(instance2.value);
261			});
262			});
263
264			describe("global containers", () => {
265			it("should return the same container instance", () => {
266			const container1 = Container.getInstance();
267			const container2 = Container.getInstance();
268
269			expect(container2).toBe(container1);
270			});
271
272			it("should destroy the global container instance", () => {
273			const container1 = Container.getInstance();
274			Container.destroyGlobalContainer();
275			const container2 = Container.getInstance();
276
277			expect(container2).not.toBe(container1);
278			});
279			});
280
281			describe("container property injection", () => {
282			let container: Container;
283
284			beforeEach(() => {
285			container = Container.getInstance();
286			});
287
288			afterEach(() => {
289			Container.destroyGlobalContainer();
290			});
291
292			it("should inject a class instance with properties", () => {
293			class MyClass {
294			public value = 42;
295			}
296
297			class MyDependentClass {
298			@Container.Inject()
299			public myClass!: MyClass;
300			}
301
302			Reflect.defineMetadata("design:type", MyClass, MyDependentClass.prototype, "myClass");
303
304			container.bind(MyClass, { singleton: true });
305			container.bind(MyDependentClass, { singleton: true });
306
307			const instance = container.resolveByClass(MyDependentClass);
308
309			expect(instance).toBeInstanceOf(MyDependentClass);
310			expect(instance.myClass).toBeInstanceOf(MyClass);
311			expect(instance.myClass.value).toBe(42);
312
313			const instance2 = container.resolveByClass(MyDependentClass);
314
315			expect(instance2).toBe(instance);
316			expect(instance2.myClass).toBe(instance.myClass);
317			expect(instance2.myClass.value).toBe(instance.myClass.value);
318
319			instance.myClass.value = 100;
320
321			expect(instance2.myClass.value).toBe(100);
322			});
323
324			it("should inject a class instance with properties and singleton dependencies", () => {
325			class MyClass {
326			public value = 42;
327			}
328
329			class MyDependentClass {
330			@Container.Inject()
331			public myClass!: MyClass;
332			}
333
334			Reflect.defineMetadata("design:type", MyClass, MyDependentClass.prototype, "myClass");
335
336			container.bind(MyClass, { singleton: true });
337			container.bind(MyDependentClass, { singleton: true });
338
339			const instance = container.resolveByClass(MyDependentClass);
340
341			expect(instance).toBeInstanceOf(MyDependentClass);
342			expect(instance.myClass).toBeInstanceOf(MyClass);
343			expect(instance.myClass.value).toBe(42);
344
345			const instance2 = container.resolveByClass(MyDependentClass);
346
347			expect(instance2).toBe(instance);
348			expect(instance2.myClass).toBe(instance.myClass);
349			expect(instance2.myClass.value).toBe(instance.myClass.value);
350
351			instance.myClass.value = 100;
352
353			expect(instance2.myClass.value).toBe(100);
354			});
355			});