test(*): add TestBed for simple di control in tests

Author: MarcScheib

dist/index.js

@@ -1,8 +1,8 @@
 import { vol } from 'memfs';
 import { temporaryDirectory } from 'tempy';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CONFIG, initConfig } from '../config.js';
-import { DefaultInjector, inject, Logger } from '../utils/index.js';
+import { Logger, TestBed } from '../utils/index.js';
 import { TemplatesAccess } from './access/templates-access.js';
 import { RepositoriesRepository } from './repositories.repository.js';
 
@@ -16,14 +16,21 @@ describe('RepositoriesRepository', () => {
   beforeEach(() => {
     const config = initConfig(path, 'acme', null).store;
 
-    DefaultInjector.getInstance([
-      [CONFIG, { factory: () => config }],
-      [Logger, { factory: () => new Logger() }],
-      [TemplatesAccess, { factory: () => new TemplatesAccess() }],
-      [RepositoriesRepository, { factory: () => new RepositoriesRepository() }],
-    ]);
+    TestBed.configureTestingModule({
+      providers: [
+        [CONFIG, () => config],
+        [Logger, () => new Logger()],
+        [TemplatesAccess, () => new TemplatesAccess()],
+        [RepositoriesRepository, () => new RepositoriesRepository()],
+      ],
+    });
+
+    sut = TestBed.inject(RepositoriesRepository);
+  });
 
-    sut = inject(RepositoriesRepository);
+  afterEach(() => {
+    vol.reset();
+    TestBed.resetTestingModule();
   });
 
   it('should load repositories; empty list', async () => {

src/services/repositories.repository.test.ts

@@ -1,15 +1,20 @@
-import { beforeEach, describe, expect, test } from 'vitest';
-import { DefaultInjector, inject } from '../utils/index.js';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { TestBed } from '../utils/index.js';
 import { ScriptExecutor } from './script-executor.js';
 
 describe('ScriptExecutor', () => {
   let sut: ScriptExecutor;
 
   beforeEach(() => {
-    DefaultInjector.getInstance([
-      [ScriptExecutor, { factory: () => new ScriptExecutor() }],
-    ]);
-    sut = inject(ScriptExecutor);
+    TestBed.configureTestingModule({
+      providers: [[ScriptExecutor, () => new ScriptExecutor()]],
+    });
+
+    sut = TestBed.inject(ScriptExecutor);
+  });
+
+  afterEach(() => {
+    TestBed.resetTestingModule();
   });
 
   describe('executeFormula', () => {

src/services/script-executor.test.ts

@@ -1,8 +1,8 @@
 import { vol } from 'memfs';
 import { temporaryDirectory } from 'tempy';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CONFIG, initConfig } from '../config.js';
-import { DefaultInjector, inject, Logger } from '../utils/index.js';
+import { Logger, TestBed } from '../utils/index.js';
 import { TemplatesAccess } from './access/templates-access.js';
 import { ServersRepository } from './servers.repository.js';
 
@@ -16,14 +16,21 @@ describe('ServersRepository', () => {
   beforeEach(() => {
     const config = initConfig(path, 'acme', null).store;
 
-    DefaultInjector.getInstance([
-      [CONFIG, { factory: () => config }],
-      [Logger, { factory: () => new Logger() }],
-      [TemplatesAccess, { factory: () => new TemplatesAccess() }],
-      [ServersRepository, { factory: () => new ServersRepository() }],
-    ]);
+    TestBed.configureTestingModule({
+      providers: [
+        [CONFIG, () => config],
+        [Logger, () => new Logger()],
+        [TemplatesAccess, () => new TemplatesAccess()],
+        [ServersRepository, () => new ServersRepository()],
+      ],
+    });
+
+    sut = TestBed.inject(ServersRepository);
+  });
 
-    sut = inject(ServersRepository);
+  afterEach(() => {
+    vol.reset();
+    TestBed.resetTestingModule();
   });
 
   it('should load servers; empty list', async () => {

src/services/servers.repository.test.ts

@@ -1,8 +1,8 @@
 import { vol } from 'memfs';
 import { temporaryDirectory } from 'tempy';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CONFIG, initConfig } from '../config.js';
-import { DefaultInjector, inject, Logger } from '../utils/index.js';
+import { Logger, TestBed } from '../utils/index.js';
 import { TemplatesAccess } from './access/templates-access.js';
 import { UseCasesRepository } from './use-cases.repository.js';
 
@@ -16,14 +16,21 @@ describe('UseCasesRepository', () => {
   beforeEach(() => {
     const config = initConfig(path, 'acme', null).store;
 
-    DefaultInjector.getInstance([
-      [CONFIG, { factory: () => config }],
-      [Logger, { factory: () => new Logger() }],
-      [TemplatesAccess, { factory: () => new TemplatesAccess() }],
-      [UseCasesRepository, { factory: () => new UseCasesRepository() }],
-    ]);
+    TestBed.configureTestingModule({
+      providers: [
+        [CONFIG, () => config],
+        [Logger, () => new Logger()],
+        [TemplatesAccess, () => new TemplatesAccess()],
+        [UseCasesRepository, () => new UseCasesRepository()],
+      ],
+    });
+
+    sut = TestBed.inject(UseCasesRepository);
+  });
 
-    sut = inject(UseCasesRepository);
+  afterEach(() => {
+    vol.reset();
+    TestBed.resetTestingModule();
   });
 
   it('should load use cases; empty list', async () => {

src/services/use-cases.repository.test.ts

@@ -3,7 +3,7 @@ import { temporaryDirectory } from 'tempy';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CONFIG, initConfig } from '../../config.js';
 import { UseCase } from '../../types/use-case.js';
-import { DefaultInjector, inject, Logger } from '../../utils/index.js';
+import { Logger, TestBed } from '../../utils/index.js';
 import { TemplatesAccess } from '../access/templates-access.js';
 import { RepositoriesRepository } from '../repositories.repository.js';
 import { ScriptExecutor } from '../script-executor.js';
@@ -23,24 +23,27 @@ describe('UseCaseRunner', () => {
   beforeEach(() => {
     const config = initConfig(path, 'acme', null).store;
 
-    DefaultInjector.getInstance([
-      [CONFIG, { factory: () => config }],
-      [Logger, { factory: () => new Logger() }],
-      [ScriptExecutor, { factory: () => new ScriptExecutor() }],
-      [TemplatesAccess, { factory: () => new TemplatesAccess() }],
-      [UseCasesRepository, { factory: () => new UseCasesRepository() }],
-      [ServersRepository, { factory: () => new ServersRepository() }],
-      [RepositoriesRepository, { factory: () => new RepositoriesRepository() }],
-      [ContextCreator, { factory: () => new ContextCreator() }],
-      [UseCaseRunner, { factory: () => new UseCaseRunner() }],
-    ]);
-
-    scriptExecutor = inject(ScriptExecutor);
-    sut = inject(UseCaseRunner);
+    TestBed.configureTestingModule({
+      providers: [
+        [CONFIG, () => config],
+        [Logger, () => new Logger()],
+        [ScriptExecutor, () => new ScriptExecutor()],
+        [TemplatesAccess, () => new TemplatesAccess()],
+        [UseCasesRepository, () => new UseCasesRepository()],
+        [ServersRepository, () => new ServersRepository()],
+        [RepositoriesRepository, () => new RepositoriesRepository()],
+        [ContextCreator, () => new ContextCreator()],
+        [UseCaseRunner, () => new UseCaseRunner()],
+      ],
+    });
+
+    scriptExecutor = TestBed.inject(ScriptExecutor);
+    sut = TestBed.inject(UseCaseRunner);
   });
 
   afterEach(() => {
     vol.reset();
+    TestBed.resetTestingModule();
   });
 
   describe('run', () => {

src/services/use-cases/use-case-runner.test.ts

@@ -1,3 +1,4 @@
 export * from './default-injector.js';
 export * from './inject.js';
 export { InjectionToken, Injector } from './interfaces.js';
+export { TestBed } from './test-bed.js';

src/utils/di/index.ts

@@ -0,0 +1,29 @@
+import { DefaultInjector } from './default-injector.js';
+import { inject } from './index.js';
+import { ProviderToken } from './interfaces.js';
+
+export declare interface TestModuleMetadata {
+  providers?: Array<[ProviderToken<unknown>, factory: () => unknown]>;
+}
+
+export class TestBed {
+  static configureTestingModule(moduleDef: TestModuleMetadata): void {
+    DefaultInjector.getInstance([]);
+
+    if (moduleDef.providers?.length) {
+      moduleDef.providers.forEach(provider => {
+        DefaultInjector.getInstance().register(provider[0], provider[1]);
+      });
+    }
+  }
+
+  static resetTestingModule(): void {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    DefaultInjector.instance = null as unknown as DefaultInjector;
+  }
+
+  static inject<T>(token: ProviderToken<T>) {
+    return inject(token);
+  }
+}