@navios/di 0.7.1 → 0.9.0

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

@@ -0,0 +1,405 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { Injectable } from '../decorators/injectable.decorator.mjs'
+import { InjectionToken } from '../token/injection-token.mjs'
+import { UnitTestContainer } from '../testing/unit-test-container.mjs'
+
+describe('UnitTestContainer', () => {
+  describe('Strict Mode (default)', () => {
+    it('should resolve services from providers list', async () => {
+      @Injectable()
+      class UserService {
+        getUser(): string {
+          return 'user'
+        }
+      }
+
+      const container = new UnitTestContainer({
+        providers: [{ token: UserService }],
+      })
+
+      const service = await container.get(UserService)
+      expect(service.getUser()).toBe('user')
+
+      await container.dispose()
+    })
+
+    it('should throw when resolving unregistered service', async () => {
+      @Injectable()
+      class NotProvided {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+      })
+
+      await expect(container.get(NotProvided)).rejects.toThrow(/not in the providers list/)
+
+      await container.dispose()
+    })
+
+    it('should use provided value', async () => {
+      const TOKEN = InjectionToken.create<{ value: string }>('config')
+
+      const container = new UnitTestContainer({
+        providers: [{ token: TOKEN, useValue: { value: 'test-config' } }],
+      })
+
+      const config = await container.get(TOKEN)
+      expect(config.value).toBe('test-config')
+
+      await container.dispose()
+    })
+
+    it('should use provided class', async () => {
+      const TOKEN = InjectionToken.create<{ getName(): string }>('service')
+
+      class MockService {
+        getName(): string {
+          return 'mock'
+        }
+      }
+
+      const container = new UnitTestContainer({
+        providers: [{ token: TOKEN, useClass: MockService }],
+      })
+
+      const service = await container.get(TOKEN)
+      expect(service.getName()).toBe('mock')
+
+      await container.dispose()
+    })
+
+    it('should use provided factory', async () => {
+      const TOKEN = InjectionToken.create<{ id: number }>('factory')
+
+      const container = new UnitTestContainer({
+        providers: [{ token: TOKEN, useFactory: () => ({ id: 42 }) }],
+      })
+
+      const result = await container.get(TOKEN)
+      expect(result.id).toBe(42)
+
+      await container.dispose()
+    })
+  })
+
+  describe('Auto-Mock Mode', () => {
+    it('should auto-mock unregistered services when enabled', async () => {
+      @Injectable()
+      class UnregisteredService {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      const service = await container.get(UnregisteredService)
+      expect(service).toBeDefined()
+
+      container.expectAutoMocked(UnregisteredService)
+
+      await container.dispose()
+    })
+
+    it('should throw when accessing methods on auto-mocked service', async () => {
+      @Injectable()
+      class AutoMocked {
+        doSomething(): void {}
+      }
+
+      const container = new UnitTestContainer({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      const service = await container.get(AutoMocked) as any
+
+      expect(() => service.doSomething()).toThrow(/auto-mocked service/)
+
+      await container.dispose()
+    })
+
+    it('should enable auto-mocking dynamically', async () => {
+      @Injectable()
+      class DynamicService {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+      })
+
+      // Should throw initially
+      await expect(container.get(DynamicService)).rejects.toThrow()
+
+      // Enable auto-mocking
+      container.enableAutoMocking()
+
+      // Should work now
+      const service = await container.get(DynamicService)
+      expect(service).toBeDefined()
+
+      await container.dispose()
+    })
+
+    it('should disable auto-mocking dynamically', async () => {
+      @Injectable()
+      class AnotherService {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      container.disableAutoMocking()
+
+      await expect(container.get(AnotherService)).rejects.toThrow()
+
+      await container.dispose()
+    })
+  })
+
+  describe('Automatic Call Tracking', () => {
+    let container: UnitTestContainer
+
+    beforeEach(() => {
+      container = new UnitTestContainer({
+        providers: [],
+      })
+    })
+
+    afterEach(async () => {
+      await container.dispose()
+    })
+
+    it('should automatically track method calls via proxy', async () => {
+      @Injectable()
+      class TrackedService {
+        process(data: string): string {
+          return `processed: ${data}`
+        }
+      }
+
+      const localContainer = new UnitTestContainer({
+        providers: [{ token: TrackedService }],
+      })
+
+      const service = await localContainer.get(TrackedService)
+      const result = service.process('test')
+
+      expect(result).toBe('processed: test')
+      localContainer.expectCalled(TrackedService, 'process')
+      localContainer.expectCalledWith(TrackedService, 'process', ['test'])
+
+      await localContainer.dispose()
+    })
+
+    it('should track multiple calls', async () => {
+      @Injectable()
+      class MultiCallService {
+        action(): void {}
+      }
+
+      const localContainer = new UnitTestContainer({
+        providers: [{ token: MultiCallService }],
+      })
+
+      const service = await localContainer.get(MultiCallService)
+      service.action()
+      service.action()
+      service.action()
+
+      localContainer.expectCallCount(MultiCallService, 'action', 3)
+
+      await localContainer.dispose()
+    })
+
+    it('should track async method calls', async () => {
+      @Injectable()
+      class AsyncService {
+        async fetchData(id: string): Promise<{ id: string }> {
+          return { id }
+        }
+      }
+
+      const localContainer = new UnitTestContainer({
+        providers: [{ token: AsyncService }],
+      })
+
+      const service = await localContainer.get(AsyncService)
+      const result = await service.fetchData('123')
+
+      expect(result.id).toBe('123')
+      localContainer.expectCalled(AsyncService, 'fetchData')
+      localContainer.expectCalledWith(AsyncService, 'fetchData', ['123'])
+
+      await localContainer.dispose()
+    })
+
+    it('should assert method was NOT called', async () => {
+      @Injectable()
+      class SomeService {
+        neverCalled(): void {}
+        called(): void {}
+      }
+
+      const localContainer = new UnitTestContainer({
+        providers: [{ token: SomeService }],
+      })
+
+      const service = await localContainer.get(SomeService)
+      service.called()
+
+      localContainer.expectNotCalled(SomeService, 'neverCalled')
+      localContainer.expectCalled(SomeService, 'called')
+
+      await localContainer.dispose()
+    })
+  })
+
+  describe('Assertion Helpers', () => {
+    it('should assert service is resolved', async () => {
+      @Injectable()
+      class ResolvedService {}
+
+      const container = new UnitTestContainer({
+        providers: [{ token: ResolvedService }],
+      })
+
+      await container.get(ResolvedService)
+
+      expect(() => container.expectResolved(ResolvedService)).not.toThrow()
+
+      await container.dispose()
+    })
+
+    it('should assert service is NOT resolved', async () => {
+      @Injectable()
+      class NotResolvedService {}
+
+      const container = new UnitTestContainer({
+        providers: [{ token: NotResolvedService }],
+      })
+
+      expect(() => container.expectNotResolved(NotResolvedService)).not.toThrow()
+
+      await container.dispose()
+    })
+
+    it('should assert service is auto-mocked', async () => {
+      @Injectable()
+      class AutoMockedService {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      await container.get(AutoMockedService)
+
+      expect(() => container.expectAutoMocked(AutoMockedService)).not.toThrow()
+
+      await container.dispose()
+    })
+
+    it('should assert service is NOT auto-mocked', async () => {
+      @Injectable()
+      class RealService {}
+
+      const container = new UnitTestContainer({
+        providers: [{ token: RealService }],
+      })
+
+      await container.get(RealService)
+
+      expect(() => container.expectNotAutoMocked(RealService)).not.toThrow()
+
+      await container.dispose()
+    })
+  })
+
+  describe('Service Stats', () => {
+    it('should get service stats', async () => {
+      @Injectable()
+      class StatsService {
+        method1(): void {}
+        method2(arg: string): string {
+          return arg
+        }
+      }
+
+      const container = new UnitTestContainer({
+        providers: [{ token: StatsService }],
+      })
+
+      const service = await container.get(StatsService)
+      service.method1()
+      service.method2('test')
+
+      const stats = container.getServiceStats(StatsService)
+      expect(stats.methodCalls.length).toBe(2)
+
+      await container.dispose()
+    })
+
+    it('should get registered token IDs', async () => {
+      @Injectable()
+      class Service1 {}
+
+      @Injectable()
+      class Service2 {}
+
+      const container = new UnitTestContainer({
+        providers: [{ token: Service1 }, { token: Service2 }],
+      })
+
+      const tokenIds = container.getRegisteredTokenIds()
+      expect(tokenIds.size).toBe(2)
+
+      await container.dispose()
+    })
+
+    it('should get auto-mocked token IDs', async () => {
+      @Injectable()
+      class Mock1 {}
+
+      @Injectable()
+      class Mock2 {}
+
+      const container = new UnitTestContainer({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      await container.get(Mock1)
+      await container.get(Mock2)
+
+      const autoMocked = container.getAutoMockedTokenIds()
+      expect(autoMocked.size).toBe(2)
+
+      await container.dispose()
+    })
+  })
+
+  describe('Clear', () => {
+    it('should clear all state', async () => {
+      @Injectable()
+      class ClearableService {
+        action(): void {}
+      }
+
+      const container = new UnitTestContainer({
+        providers: [{ token: ClearableService }],
+      })
+
+      const service = await container.get(ClearableService)
+      service.action()
+
+      container.expectResolved(ClearableService)
+      container.expectCalled(ClearableService, 'action')
+
+      await container.clear()
+
+      container.expectNotResolved(ClearableService)
+      expect(container.getMethodCalls(ClearableService)).toHaveLength(0)
+    })
+  })
+})

package/src/__type-tests__/container.spec-d.mts

@@ -0,0 +1,180 @@
+import { assertType, describe, test } from 'vitest'
+import { z } from 'zod/v4'
+
+import type { Factorable } from '../interfaces/index.mjs'
+
+import { Container } from '../container/container.mjs'
+import { ScopedContainer } from '../container/scoped-container.mjs'
+import { Injectable, Factory } from '../decorators/index.mjs'
+import { InjectionToken } from '../token/injection-token.mjs'
+
+interface FooService {
+  makeFoo(): string
+}
+
+const simpleObjectSchema = z.object({
+  foo: z.string(),
+})
+const simpleOptionalObjectSchema = z
+  .object({
+    foo: z.string(),
+  })
+  .optional()
+
+const typelessObjectToken = InjectionToken.create(
+  Symbol.for('Typeless object token'),
+  simpleObjectSchema,
+)
+const typelessOptionalObjectToken = InjectionToken.create(
+  Symbol.for('Typeless optional object token'),
+  simpleOptionalObjectSchema,
+)
+
+const typedObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleObjectSchema
+>(Symbol.for('Typed object token'), simpleObjectSchema)
+const typedOptionalObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleOptionalObjectSchema
+>(Symbol.for('Typed optional object token'), simpleOptionalObjectSchema)
+
+const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
+
+describe('Container.get', () => {
+  describe('#1 Classes', () => {
+    test('simple class', async () => {
+      @Injectable()
+      class Foo {
+        makeFoo() {
+          return 'foo'
+        }
+      }
+
+      const container = new Container()
+      assertType<Foo>(await container.get(Foo))
+    })
+
+    test('class with required argument', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      const container = new Container()
+      assertType<Foo>(await container.get(Foo, { foo: 'bar' }))
+    })
+
+    test('should fail if not compatible', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      const container = new Container()
+      // @ts-expect-error Should fail if not compatible
+      await container.get(Foo, { test: 'bar' })
+    })
+
+    test('factory class returns unwrapped type', async () => {
+      @Factory()
+      class FooFactory implements Factorable<string> {
+        create() {
+          return 'created'
+        }
+      }
+
+      const container = new Container()
+      // When getting a Factorable class, we get the created type, not the factory
+      assertType<string>(await container.get(FooFactory))
+    })
+  })
+
+  test('#2 Token with required Schema', async () => {
+    const container = new Container()
+
+    const result = await container.get(typelessObjectToken, { foo: 'bar' })
+    assertType<unknown>(result)
+
+    const result2 = await container.get(typedObjectToken, { foo: 'bar' })
+    assertType<FooService>(result2)
+
+    // @ts-expect-error We show error when we pass the wrong type
+    await container.get(typedObjectToken, undefined)
+  })
+
+  test('#3 Token with optional Schema', async () => {
+    const container = new Container()
+
+    const result = await container.get(typelessOptionalObjectToken)
+    assertType<unknown>(result)
+
+    const result2 = await container.get(typedOptionalObjectToken)
+    assertType<FooService>(result2)
+
+    const result3 = await container.get(typedObjectToken)
+    // Special case when we pass the token without args
+    // We can only return an error string
+    assertType<'Error: Your token requires args: foo'>(result3)
+  })
+
+  test('#4 Token with no Schema', async () => {
+    const container = new Container()
+
+    const result = await container.get(typedToken)
+    assertType<FooService>(result)
+  })
+
+  test('#5 BoundInjectionToken', async () => {
+    const container = new Container()
+
+    const boundToken = InjectionToken.bound(typedObjectToken, { foo: 'bar' })
+    const result = await container.get(boundToken)
+    assertType<FooService>(result)
+  })
+
+  test('#6 FactoryInjectionToken', async () => {
+    const container = new Container()
+
+    const factoryToken = InjectionToken.factory(
+      typedObjectToken,
+      async () => ({ foo: 'bar' }),
+    )
+    const result = await container.get(factoryToken)
+    assertType<FooService>(result)
+  })
+})
+
+describe('Container methods', () => {
+  test('beginRequest returns ScopedContainer', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('request-1')
+    assertType<ScopedContainer>(scopedContainer)
+  })
+
+  test('getActiveRequestIds returns ReadonlySet<string>', () => {
+    const container = new Container()
+    const activeIds = container.getActiveRequestIds()
+    assertType<ReadonlySet<string>>(activeIds)
+  })
+
+  test('hasActiveRequest returns boolean', () => {
+    const container = new Container()
+    const hasRequest = container.hasActiveRequest('request-1')
+    assertType<boolean>(hasRequest)
+  })
+
+  test('dispose returns Promise<void>', async () => {
+    const container = new Container()
+    assertType<Promise<void>>(container.dispose())
+  })
+
+  test('invalidate returns Promise<void>', async () => {
+    const container = new Container()
+    assertType<Promise<void>>(container.invalidate({}))
+  })
+})

package/src/__type-tests__/factory.spec-d.mts

@@ -34,7 +34,10 @@ class TestFactory3 implements Factorable<boolean> {
 
 // Test factory with token and schema
 const schema = z.object({ name: z.string() })
-const tokenWithSchema = InjectionToken.create('TestTokenWithSchema', schema)
+const tokenWithSchema = InjectionToken.create<{ name: string }, typeof schema>(
+  'TestTokenWithSchema',
+  schema,
+)
 @Factory({ token: tokenWithSchema })
 class TestFactory4
   implements FactorableWithArgs<{ name: string }, typeof schema>
@@ -53,7 +56,15 @@ class TestFactory5 implements Factorable<object> {
   }
 }
 
-// Type tests
+// Test factory with async create
+@Factory()
+class TestFactory6 implements Factorable<string[]> {
+  async create() {
+    return ['async', 'result']
+  }
+}
+
+// Type tests - verify return types
 const test1: string = new TestFactory1().create()
 const test2: number = new TestFactory2().create()
 const test3: boolean = new TestFactory3().create()
@@ -61,5 +72,6 @@ const test4: { name: string } = new TestFactory4().create(undefined, {
   name: 'test',
 })
 const test5: object = new TestFactory5().create()
+const test6: Promise<string[]> = new TestFactory6().create()
 
-export { test1, test2, test3, test4, test5 }
+export { test1, test2, test3, test4, test5, test6 }