@navios/di 0.4.1 → 0.4.2

package/src/testing/__tests__/test-container.spec.mts

@@ -0,0 +1,173 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { Injectable } from '../../decorators/injectable.decorator.mjs'
+import { InjectionToken } from '../../injection-token.mjs'
+import { inject } from '../../injector.mjs'
+import { TestContainer } from '../test-container.mjs'
+
+describe('TestContainer', () => {
+  let container: TestContainer
+
+  beforeEach(() => {
+    container = new TestContainer()
+  })
+
+  describe('clear method', () => {
+    it('should clear all instances from the container', () => {
+      // This test verifies that the clear method exists and can be called
+      expect(() => container.clear()).not.toThrow()
+    })
+  })
+
+  describe('bind method', () => {
+    it('should create a TestBindingBuilder', () => {
+      const token = InjectionToken.create<string>('test-token')
+      const builder = container.bind(token)
+      expect(builder).toBeDefined()
+      expect(builder).toHaveProperty('toValue')
+      expect(builder).toHaveProperty('toClass')
+    })
+
+    it('should allow chaining bind operations', () => {
+      const token = InjectionToken.create<string>('test-token')
+      const result = container.bind(token).toValue('test-value')
+      expect(result).toBe(container)
+    })
+
+    it('should bind value and retrieve it correctly', async () => {
+      const token = InjectionToken.create<string>('test-token')
+      const testValue = 'test-value'
+
+      container.bind(token).toValue(testValue)
+
+      const retrievedValue = await container.get(token)
+      expect(retrievedValue).toBe(testValue)
+    })
+
+    it('should bind class and retrieve instance correctly', async () => {
+      @Injectable()
+      class TestService {
+        getValue() {
+          return 'test-service-value'
+        }
+      }
+
+      const token = InjectionToken.create<TestService>('test-service')
+
+      container.bind(token).toClass(TestService)
+
+      const instance = await container.get(token)
+      expect(instance).toBeInstanceOf(TestService)
+      expect(instance.getValue()).toBe('test-service-value')
+    })
+  })
+
+  describe('bindValue method', () => {
+    it('should bind a value to a token', () => {
+      const token = InjectionToken.create<string>('test-token')
+      const result = container.bindValue(token, 'test-value')
+      expect(result).toBe(container)
+    })
+
+    it('should bind value and retrieve it correctly', async () => {
+      const token = InjectionToken.create<number>('number-token')
+      const testValue = 42
+
+      container.bindValue(token, testValue)
+
+      const retrievedValue = await container.get(token)
+      expect(retrievedValue).toBe(testValue)
+    })
+
+    it('should bind object value and retrieve it correctly', async () => {
+      interface TestConfig {
+        apiUrl: string
+        timeout: number
+      }
+
+      const token = InjectionToken.create<TestConfig>('config-token')
+      const testConfig: TestConfig = {
+        apiUrl: 'https://api.example.com',
+        timeout: 5000,
+      }
+
+      container.bindValue(token, testConfig)
+
+      const retrievedConfig = await container.get(token)
+      expect(retrievedConfig).toEqual(testConfig)
+      expect(retrievedConfig.apiUrl).toBe('https://api.example.com')
+      expect(retrievedConfig.timeout).toBe(5000)
+    })
+  })
+
+  describe('bindClass method', () => {
+    it('should bind a class to a token', () => {
+      class TestClass {}
+      const token = InjectionToken.create<TestClass>('test-token')
+      const result = container.bindClass(token, TestClass)
+      expect(result).toBe(container)
+    })
+
+    it('should bind class and retrieve instance correctly', async () => {
+      @Injectable()
+      class UserService {
+        private users: string[] = ['alice', 'bob']
+
+        getUsers() {
+          return this.users
+        }
+
+        addUser(user: string) {
+          this.users.push(user)
+        }
+      }
+
+      const token = InjectionToken.create<UserService>('user-service')
+
+      container.bindClass(token, UserService)
+
+      const instance = await container.get(token)
+      expect(instance).toBeInstanceOf(UserService)
+      expect(instance.getUsers()).toEqual(['alice', 'bob'])
+
+      instance.addUser('charlie')
+      expect(instance.getUsers()).toEqual(['alice', 'bob', 'charlie'])
+    })
+
+    it('should bind class with dependencies and retrieve instance correctly', async () => {
+      @Injectable()
+      class DatabaseService {
+        connect() {
+          return 'connected'
+        }
+      }
+
+      @Injectable()
+      class UserRepository {
+        db = inject(DatabaseService)
+
+        findUser(id: string) {
+          return `User ${id} from ${this.db.connect()}`
+        }
+      }
+
+      const dbToken = InjectionToken.create<DatabaseService>('db-service')
+      const userRepoToken = InjectionToken.create<UserRepository>('user-repo')
+
+      container.bindClass(dbToken, DatabaseService)
+      container.bindClass(userRepoToken, UserRepository)
+
+      const userRepo = await container.get(userRepoToken)
+      expect(userRepo).toBeInstanceOf(UserRepository)
+      expect(userRepo.findUser('123')).toBe('User 123 from connected')
+    })
+  })
+
+  describe('createChild method', () => {
+    it('should create a new TestContainer instance', () => {
+      const child = container.createChild()
+      expect(child).toBeInstanceOf(TestContainer)
+      expect(child).not.toBe(container)
+    })
+  })
+})

package/src/testing/index.mts

@@ -0,0 +1 @@
+export * from './test-container.mjs'

package/src/testing/test-container.mts

@@ -0,0 +1,120 @@
+import type { ClassType, InjectionToken } from '../injection-token.mjs'
+import type { Registry } from '../registry.mjs'
+import type { Injectors } from '../utils/index.mjs'
+
+import { Container } from '../container.mjs'
+import { Injectable } from '../decorators/injectable.decorator.mjs'
+import { InjectableScope, InjectableType } from '../enums/index.mjs'
+import { globalRegistry } from '../registry.mjs'
+import { getInjectableToken } from '../utils/index.mjs'
+
+/**
+ * A binding builder for the TestContainer that allows chaining binding operations.
+ */
+export class TestBindingBuilder<T> {
+  constructor(
+    private readonly container: TestContainer,
+    private readonly token: InjectionToken<T, any>,
+  ) {}
+
+  /**
+   * Binds the token to a specific value.
+   * This is useful for testing with mock values or constants.
+   * @param value The value to bind to the token
+   */
+  toValue(value: T): TestContainer {
+    const instanceName = this.container
+      .getServiceLocator()
+      .getInstanceIdentifier(this.token)
+    this.container
+      .getServiceLocator()
+      .getManager()
+      .storeCreatedHolder(
+        instanceName,
+        value,
+        InjectableType.Class,
+        InjectableScope.Singleton,
+      )
+    return this.container
+  }
+
+  /**
+   * Binds the token to a class constructor.
+   * @param target The class constructor to bind to
+   */
+  toClass(target: ClassType): TestContainer {
+    this.container['registry'].set(
+      this.token,
+      InjectableScope.Singleton,
+      target,
+      InjectableType.Class,
+    )
+    return this.container
+  }
+}
+
+/**
+ * TestContainer extends the base Container with additional methods useful for testing.
+ * It provides a simplified API for binding values and classes during test setup.
+ */
+@Injectable()
+export class TestContainer extends Container {
+  constructor(
+    registry: Registry = globalRegistry,
+    logger: Console | null = null,
+    injectors: Injectors = undefined as any,
+  ) {
+    super(registry, logger, injectors)
+  }
+
+  /**
+   * Creates a binding builder for the given token.
+   * This allows chaining binding operations like bind(Token).toValue(value).
+   * @param token The injection token to bind
+   * @returns A TestBindingBuilder for chaining binding operations
+   */
+  bind<T>(token: ClassType): TestBindingBuilder<T>
+  bind<T>(token: InjectionToken<T, any>): TestBindingBuilder<T>
+  bind(token: any): TestBindingBuilder<any> {
+    let realToken = token
+    if (typeof token === 'function') {
+      realToken = getInjectableToken(token)
+    }
+    return new TestBindingBuilder(this, realToken)
+  }
+
+  /**
+   * Binds a value directly to a token.
+   * This is a convenience method equivalent to bind(token).toValue(value).
+   * @param token The injection token to bind
+   * @param value The value to bind to the token
+   * @returns The TestContainer instance for chaining
+   */
+  bindValue<T>(token: ClassType, value: T): TestContainer
+  bindValue<T>(token: InjectionToken<T, any>, value: T): TestContainer
+  bindValue(token: any, value: any): TestContainer {
+    return this.bind(token).toValue(value)
+  }
+
+  /**
+   * Binds a class to a token.
+   * This is a convenience method equivalent to bind(token).toClass(target).
+   * @param token The injection token to bind
+   * @param target The class constructor to bind to
+   * @returns The TestContainer instance for chaining
+   */
+  bindClass(token: ClassType, target: ClassType): TestContainer
+  bindClass<T>(token: InjectionToken<T, any>, target: ClassType): TestContainer
+  bindClass(token: any, target: any): TestContainer {
+    return this.bind(token).toClass(target)
+  }
+
+  /**
+   * Creates a new TestContainer instance with the same configuration.
+   * This is useful for creating isolated test containers.
+   * @returns A new TestContainer instance
+   */
+  createChild(): TestContainer {
+    return new TestContainer(this.registry, this.logger, this.injectors)
+  }
+}

package/tsup.config.mts

@@ -1,7 +1,7 @@
 import { defineConfig } from 'tsup'
 
 export default defineConfig({
-  entry: ['src/index.mts'],
+  entry: ['src/index.mts', 'src/testing/index.mts'],
   outDir: 'lib',
   format: ['esm', 'cjs'],
   clean: true,