@navios/di 0.8.0 → 0.9.0

package/src/__tests__/scoped-container.spec.mts

@@ -0,0 +1,595 @@
+/**
+ * Comprehensive tests for ScopedContainer
+ *
+ * These tests cover:
+ * 1. Basic ScopedContainer functionality
+ * 2. Request-scoped service resolution
+ * 3. addInstance method with various token types
+ * 4. Error handling and validation
+ * 5. Integration with parent Container
+ * 6. Disposal and cleanup
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { z } from 'zod/v4'
+
+import { Container } from '../container/container.mjs'
+import { Injectable } from '../decorators/injectable.decorator.mjs'
+import { InjectableScope } from '../enums/index.mjs'
+import { DIError, DIErrorCode } from '../errors/di-error.mjs'
+import { InjectionToken } from '../token/injection-token.mjs'
+import { Registry } from '../token/registry.mjs'
+import { getInjectors } from '../utils/get-injectors.mjs'
+
+// ============================================================================
+// TEST UTILITIES
+// ============================================================================
+
+function createTestSetup() {
+  const registry = new Registry()
+  const injectors = getInjectors()
+  const container = new Container(registry, null, injectors)
+
+  return { registry, injectors, container }
+}
+
+// ============================================================================
+// SECTION 1: BASIC FUNCTIONALITY
+// ============================================================================
+
+describe('ScopedContainer: Basic Functionality', () => {
+  let registry: Registry
+  let container: Container
+
+  beforeEach(() => {
+    const setup = createTestSetup()
+    registry = setup.registry
+    container = setup.container
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('Container creation and lifecycle', () => {
+    it('should create a scoped container with request ID', () => {
+      const scoped = container.beginRequest('test-request-1')
+      expect(scoped).toBeDefined()
+      expect(scoped.getRequestId()).toBe('test-request-1')
+      expect(scoped.getParent()).toBe(container)
+    })
+
+    it('should track active request IDs', async () => {
+      const scoped1 = container.beginRequest('request-1')
+      const scoped2 = container.beginRequest('request-2')
+
+      expect(container.hasActiveRequest('request-1')).toBe(true)
+      expect(container.hasActiveRequest('request-2')).toBe(true)
+      expect(container.getActiveRequestIds().size).toBe(2)
+
+      await scoped1.endRequest()
+      expect(container.hasActiveRequest('request-1')).toBe(false)
+      expect(container.hasActiveRequest('request-2')).toBe(true)
+
+      await scoped2.endRequest()
+      expect(container.getActiveRequestIds().size).toBe(0)
+    })
+
+    it('should prevent duplicate request IDs', () => {
+      container.beginRequest('duplicate-id')
+      expect(() => container.beginRequest('duplicate-id')).toThrow()
+    })
+
+    it('should support metadata', () => {
+      const metadata = { userId: '123', sessionId: 'abc' }
+      const scoped = container.beginRequest('request-1', metadata)
+
+      expect(scoped.getMetadata('userId')).toBe('123')
+      expect(scoped.getMetadata('sessionId')).toBe('abc')
+      expect(scoped.getMetadata('nonExistent')).toBeUndefined()
+
+      scoped.setMetadata('newKey', 'newValue')
+      expect(scoped.getMetadata('newKey')).toBe('newValue')
+    })
+  })
+
+  describe('Request-scoped service resolution', () => {
+    it('should resolve request-scoped services from scoped container', async () => {
+      let instanceCount = 0
+
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class RequestService {
+        id = ++instanceCount
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance1 = await scoped.get(RequestService)
+      const instance2 = await scoped.get(RequestService)
+
+      expect(instance1).toBeInstanceOf(RequestService)
+      expect(instance1).toBe(instance2) // Same instance within request
+      expect(instance1.id).toBe(1)
+
+      await scoped.endRequest()
+    })
+
+    it('should create different instances for different requests', async () => {
+      let instanceCount = 0
+
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class RequestService {
+        id = ++instanceCount
+      }
+
+      const scoped1 = container.beginRequest('request-1')
+      const instance1 = await scoped1.get(RequestService)
+
+      const scoped2 = container.beginRequest('request-2')
+      const instance2 = await scoped2.get(RequestService)
+
+      expect(instance1).not.toBe(instance2)
+      expect(instance1.id).toBe(1)
+      expect(instance2.id).toBe(2)
+
+      await scoped1.endRequest()
+      await scoped2.endRequest()
+    })
+
+    it('should delegate singleton services to parent', async () => {
+      @Injectable({ scope: InjectableScope.Singleton, registry })
+      class SingletonService {
+        id = Math.random()
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance1 = await scoped.get(SingletonService)
+      const instance2 = await container.get(SingletonService)
+
+      expect(instance1).toBe(instance2) // Same singleton instance
+
+      await scoped.endRequest()
+    })
+
+    it('should delegate transient services to parent', async () => {
+      @Injectable({ scope: InjectableScope.Transient, registry })
+      class TransientService {
+        id = Math.random()
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance1 = await scoped.get(TransientService)
+      const instance2 = await scoped.get(TransientService)
+
+      expect(instance1).not.toBe(instance2) // Different instances
+
+      await scoped.endRequest()
+    })
+  })
+
+  describe('Disposal and cleanup', () => {
+    it('should clean up request-scoped services on endRequest', async () => {
+      let destroyCount = 0
+
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class RequestService {
+        onServiceDestroy() {
+          destroyCount++
+        }
+      }
+
+      const scoped = container.beginRequest('request-1')
+      await scoped.get(RequestService)
+      await scoped.endRequest()
+
+      expect(destroyCount).toBe(1)
+    })
+
+    it('should prevent operations after disposal', async () => {
+      const scoped = container.beginRequest('request-1')
+      await scoped.endRequest()
+
+      await expect(scoped.get(Container)).rejects.toThrow(
+        'ScopedContainer has been disposed',
+      )
+    })
+
+    it('should support dispose alias', async () => {
+      const scoped = container.beginRequest('request-1')
+      await scoped.dispose()
+
+      await expect(scoped.get(Container)).rejects.toThrow(
+        'ScopedContainer has been disposed',
+      )
+    })
+  })
+})
+
+// ============================================================================
+// SECTION 2: addInstance METHOD TESTS
+// ============================================================================
+
+describe('ScopedContainer: addInstance Method', () => {
+  let registry: Registry
+  let container: Container
+
+  beforeEach(() => {
+    const setup = createTestSetup()
+    registry = setup.registry
+    container = setup.container
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('addInstance with class types', () => {
+    it('should throw an error for unregistered class type', () => {
+      class UnregisteredService {
+        value = 'test'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance = new UnregisteredService()
+      expect(() => scoped.addInstance(UnregisteredService, instance)).toThrow(
+        DIError,
+      )
+
+      scoped.endRequest()
+    })
+
+    it('should add instance for registered class type', async () => {
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class RegisteredService {
+        value = 'default'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const customInstance = new RegisteredService()
+      customInstance.value = 'custom'
+
+      scoped.addInstance(RegisteredService, customInstance)
+
+      // Should retrieve the added instance, not create a new one
+      const retrieved = await scoped.get(RegisteredService)
+      expect(retrieved).toBe(customInstance)
+      expect(retrieved.value).toBe('custom')
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('addInstance with InjectionToken (no schema)', () => {
+    it('should add instance for InjectionToken without schema', async () => {
+      interface TestService {
+        value: string
+      }
+
+      const token = InjectionToken.create<TestService>('TestService')
+      const instance: TestService = { value: 'test' }
+
+      const scoped = container.beginRequest('request-1')
+      scoped.addInstance(token, instance)
+
+      const retrieved = await scoped.get(token)
+      expect(retrieved).toBe(instance)
+      expect(retrieved.value).toBe('test')
+
+      scoped.endRequest()
+    })
+
+    it('should add instance for InjectionToken with optional schema', async () => {
+      interface TestService {
+        value: string
+      }
+
+      const optionalSchema = z
+        .object({
+          name: z.string(),
+        })
+        .optional()
+
+      const token = InjectionToken.create<TestService, typeof optionalSchema>(
+        'TestService',
+        optionalSchema,
+      )
+      const instance: TestService = { value: 'test' }
+
+      const scoped = container.beginRequest('request-1')
+      scoped.addInstance(token, instance)
+
+      const retrieved = await scoped.get(token)
+      expect(retrieved).toBe(instance)
+
+      scoped.endRequest()
+    })
+
+    it('should reject InjectionToken with required schema', () => {
+      interface TestService {
+        value: string
+      }
+
+      const requiredSchema = z.object({
+        name: z.string(),
+        age: z.number(),
+      })
+
+      const token = InjectionToken.create<TestService, typeof requiredSchema>(
+        'TestService',
+        requiredSchema,
+      )
+      const instance: TestService = { value: 'test' }
+
+      const scoped = container.beginRequest('request-1')
+
+      expect(() => {
+        scoped.addInstance(token, instance)
+      }).toThrow(DIError)
+
+      const error = (() => {
+        try {
+          scoped.addInstance(token, instance)
+        } catch (e) {
+          return e
+        }
+      })() as DIError
+
+      expect(error.code).toBe(DIErrorCode.TokenSchemaRequiredError)
+      expect(error.message).toContain('requires schema arguments')
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('addInstance with BoundInjectionToken', () => {
+    it('should add instance for BoundInjectionToken with required schema', async () => {
+      interface TestService {
+        value: string
+      }
+
+      const requiredSchema = z.object({
+        name: z.string(),
+        age: z.number(),
+      })
+
+      const token = InjectionToken.create<TestService, typeof requiredSchema>(
+        'TestService',
+        requiredSchema,
+      )
+
+      const boundToken = InjectionToken.bound(token, {
+        name: 'John',
+        age: 30,
+      })
+
+      const instance: TestService = { value: 'test' }
+
+      const scoped = container.beginRequest('request-1')
+      scoped.addInstance(boundToken, instance)
+      console.log(scoped.getStorage().getAllNames())
+
+      const retrieved = await scoped.get(boundToken)
+      expect(retrieved).toBe(instance)
+      expect(retrieved.value).toBe('test')
+
+      scoped.endRequest()
+    })
+
+    it('should use bound value for instance name generation', async () => {
+      interface TestService {
+        value: string
+      }
+
+      const schema = z.object({
+        id: z.string(),
+      })
+
+      const token = InjectionToken.create<TestService, typeof schema>(
+        'TestService',
+        schema,
+      )
+
+      const boundToken1 = InjectionToken.bound(token, { id: '1' })
+      const boundToken2 = InjectionToken.bound(token, { id: '2' })
+
+      const instance1: TestService = { value: 'instance1' }
+      const instance2: TestService = { value: 'instance2' }
+
+      const scoped = container.beginRequest('request-1')
+      scoped.addInstance(boundToken1, instance1)
+      scoped.addInstance(boundToken2, instance2)
+
+      const retrieved1 = await scoped.get(boundToken1)
+      const retrieved2 = await scoped.get(boundToken2)
+
+      expect(retrieved1).toBe(instance1)
+      expect(retrieved2).toBe(instance2)
+      expect(retrieved1.value).toBe('instance1')
+      expect(retrieved2.value).toBe('instance2')
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('addInstance error cases', () => {
+    it('should reject addInstance on disposed container', async () => {
+      class TestService {
+        value = 'test'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      await scoped.endRequest()
+
+      const instance = new TestService()
+      expect(() => {
+        scoped.addInstance(TestService, instance)
+      }).toThrow('ScopedContainer has been disposed')
+    })
+
+    it('should handle multiple addInstance calls for same token', async () => {
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class TestService {
+        value = 'test'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance1 = new TestService()
+      instance1.value = 'first'
+      scoped.addInstance(TestService, instance1)
+
+      // Second addInstance should overwrite (or throw if storage prevents it)
+      const instance2 = new TestService()
+      instance2.value = 'second'
+
+      // Storage.storeInstance throws if instance already exists
+      expect(() => {
+        scoped.addInstance(TestService, instance2)
+      }).toThrow()
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('addInstance integration with get', () => {
+    it('should retrieve added instance via get method', async () => {
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class TestService {
+        value = 'custom'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance = new TestService()
+      scoped.addInstance(TestService, instance)
+
+      const retrieved = await scoped.get(TestService)
+      expect(retrieved).toBe(instance)
+      expect(retrieved.value).toBe('custom')
+
+      scoped.endRequest()
+    })
+  })
+})
+
+// ============================================================================
+// SECTION 3: COMPLEX SCENARIOS
+// ============================================================================
+
+describe('ScopedContainer: Complex Scenarios', () => {
+  let registry: Registry
+  let container: Container
+  let injectors: ReturnType<typeof getInjectors>
+
+  beforeEach(() => {
+    const setup = createTestSetup()
+    registry = setup.registry
+    container = setup.container
+    injectors = setup.injectors
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('Mixed scopes with addInstance', () => {
+    it('should handle singleton depending on request-scoped added instance', async () => {
+      @Injectable({ scope: InjectableScope.Singleton, registry })
+      class SingletonService {
+        public requestService = injectors.inject(RequestService)
+      }
+
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class RequestService {
+        value = 'request'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const requestInstance = new RequestService()
+      scoped.addInstance(RequestService, requestInstance)
+
+      // Singleton should be able to get the request-scoped instance
+      const singleton = await scoped.get(SingletonService)
+      expect(singleton.requestService).toBe(requestInstance)
+
+      scoped.endRequest()
+    })
+
+    it('should handle multiple addInstance calls with different token types', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class ClassService {
+        value = 'class'
+      }
+
+      interface TokenService {
+        value: string
+      }
+      const token = InjectionToken.create<TokenService>('TokenService')
+
+      const schema = z.object({ id: z.string() })
+      interface BoundService {
+        value: string
+      }
+      const boundToken = InjectionToken.bound(
+        InjectionToken.create<BoundService, typeof schema>(
+          'BoundService',
+          schema,
+        ),
+        { id: '123' },
+      )
+
+      const scoped = container.beginRequest('request-1')
+
+      const classInstance = new ClassService()
+      scoped.addInstance(ClassService, classInstance)
+
+      const tokenInstance: TokenService = { value: 'token' }
+      scoped.addInstance(token, tokenInstance)
+
+      const boundInstance: BoundService = { value: 'bound' }
+      scoped.addInstance(boundToken, boundInstance)
+
+      expect(await scoped.get(ClassService)).toBe(classInstance)
+      expect(await scoped.get(token)).toBe(tokenInstance)
+      expect(await scoped.get(boundToken)).toBe(boundInstance)
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('Invalidation with addInstance', () => {
+    it('should invalidate added instances', async () => {
+      let destroyCount = 0
+
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class TestService {
+        onServiceDestroy() {
+          destroyCount++
+        }
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance = new TestService()
+      scoped.addInstance(TestService, instance)
+
+      await scoped.invalidate(instance)
+      expect(destroyCount).toBe(1)
+
+      scoped.endRequest()
+    })
+  })
+
+  describe('Ready state with addInstance', () => {
+    it('should wait for ready state after adding instances', async () => {
+      @Injectable({ scope: InjectableScope.Request, registry })
+      class TestService {
+        value = 'test'
+      }
+
+      const scoped = container.beginRequest('request-1')
+      const instance = new TestService()
+      scoped.addInstance(TestService, instance)
+
+      await scoped.ready() // Should complete without hanging
+
+      scoped.endRequest()
+    })
+  })
+})