@navios/di 0.9.1 → 1.0.0

package/src/__tests__/gc/memory-pressure.spec.mts

@@ -0,0 +1,542 @@
+/**
+ * Garbage Collection Tests: Memory Pressure
+ *
+ * Tests that verify the DI container properly handles memory under pressure
+ * and doesn't leak memory over time. These tests use process.memoryUsage()
+ * to measure actual heap usage.
+ *
+ * Run with: NODE_OPTIONS=--expose-gc yarn nx test @navios/di
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import type { OnServiceDestroy } from '../../interfaces/on-service-destroy.interface.mjs'
+
+import { Container } from '../../container/container.mjs'
+import { Injectable } from '../../decorators/injectable.decorator.mjs'
+import { InjectableScope } from '../../enums/injectable-scope.enum.mjs'
+import { InjectionToken } from '../../index.mjs'
+import { Registry } from '../../token/registry.mjs'
+import { inject } from '../../utils/index.mjs'
+import {
+  forceGC,
+  getHeapUsed,
+  getHeapUsedMB,
+  isGCAvailable,
+  measureMemoryDelta,
+} from './gc-test-utils.mjs'
+
+describe.skipIf(!isGCAvailable)('GC: Memory Pressure', () => {
+  let registry: Registry
+  let container: Container
+
+  beforeEach(() => {
+    registry = new Registry()
+    container = new Container(registry)
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('Container disposal memory reclamation', () => {
+    it.todo(
+      'should reclaim memory when container with many singletons is disposed',
+      async () => {
+        const SERVICE_COUNT = 50
+        const ALLOCATION_SIZE = 1024 * 100 // 100KB per service
+
+        // Create many singleton services
+        const services: Array<{ new (): { data: Uint8Array } }> = []
+        for (let i = 0; i < SERVICE_COUNT; i++) {
+          @Injectable({ registry })
+          class LargeService {
+            public readonly data = new Uint8Array(ALLOCATION_SIZE)
+          }
+          services.push(LargeService)
+        }
+
+        forceGC()
+        const beforeAllocation = getHeapUsed()
+
+        // Resolve all services
+        for (const Service of services) {
+          await container.get(Service)
+        }
+
+        forceGC()
+        const afterAllocation = getHeapUsed()
+        const allocated = afterAllocation - beforeAllocation
+
+        // Should have allocated approximately SERVICE_COUNT * ALLOCATION_SIZE
+        const expectedAllocation = SERVICE_COUNT * ALLOCATION_SIZE
+        expect(allocated).toBeGreaterThan(expectedAllocation * 0.8)
+
+        // Dispose container
+        await container.dispose()
+
+        // Create new container for afterEach cleanup
+        registry = new Registry()
+        container = new Container(registry)
+
+        forceGC()
+        const afterDisposal = getHeapUsed()
+        const reclaimed = afterAllocation - afterDisposal
+
+        // Should reclaim at least 80% of allocated memory
+        expect(reclaimed).toBeGreaterThan(allocated * 0.8)
+      },
+    )
+
+    it.todo('should measure memory baseline and peak correctly', async () => {
+      const ALLOCATION_SIZE = 1024 * 1024 // 1MB
+
+      @Injectable({ registry })
+      class LargeService {
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      const { after, delta } = await measureMemoryDelta(async () => {
+        await container.get(LargeService)
+      })
+
+      // Delta should be roughly the allocation size (with some overhead)
+      expect(delta).toBeGreaterThan(ALLOCATION_SIZE * 0.8)
+      expect(delta).toBeLessThan(ALLOCATION_SIZE * 1.5)
+
+      // Cleanup and measure reclamation
+      await container.dispose()
+      registry = new Registry()
+      container = new Container(registry)
+
+      forceGC()
+      const final = getHeapUsed()
+
+      // Memory should return close to baseline
+      const memoryReturn = after - final
+      expect(memoryReturn).toBeGreaterThan(ALLOCATION_SIZE * 0.8)
+    })
+  })
+
+  describe('Long-running container stress tests', () => {
+    it('should not accumulate memory with repeated service invalidation', async () => {
+      const ALLOCATION_SIZE = 1024 * 50 // 50KB
+      const ITERATIONS = 30
+
+      @Injectable({ registry })
+      class InvalidatableService implements OnServiceDestroy {
+        public readonly id = Math.random()
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+
+        onServiceDestroy(): void {
+          // Cleanup
+        }
+      }
+
+      forceGC()
+      const baselineMemory = getHeapUsed()
+
+      // Repeatedly create and invalidate
+      for (let i = 0; i < ITERATIONS; i++) {
+        const instance = await container.get(InvalidatableService)
+        await container.invalidate(instance)
+      }
+
+      // Get one final instance
+      await container.get(InvalidatableService)
+
+      forceGC()
+      const finalMemory = getHeapUsed()
+      const memoryGrowth = finalMemory - baselineMemory
+
+      // Memory growth should be roughly one service instance
+      // (only the latest should remain)
+      expect(memoryGrowth).toBeLessThan(ALLOCATION_SIZE * 3)
+    })
+
+    it('should handle many request lifecycles without leaking', async () => {
+      const ALLOCATION_SIZE = 1024 * 20 // 20KB
+      const REQUEST_COUNT = 50
+      const SERVICES_PER_REQUEST = 5
+
+      // Create request-scoped services
+      const services: Array<{ new (): { data: Uint8Array } }> = []
+      for (let i = 0; i < SERVICES_PER_REQUEST; i++) {
+        const token = InjectionToken.create<RequestService>(
+          `RequestService${i}`,
+        )
+        @Injectable({ registry, scope: InjectableScope.Request, token })
+        class RequestService {
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+        services.push(RequestService)
+      }
+
+      forceGC()
+      const baselineMemory = getHeapUsed()
+
+      // Simulate many request lifecycles
+      for (let reqId = 0; reqId < REQUEST_COUNT; reqId++) {
+        const scoped = container.beginRequest(`request-${reqId}`)
+
+        // Resolve all services in this request
+        for (const Service of services) {
+          await scoped.get(Service)
+        }
+
+        await scoped.endRequest()
+
+        // Periodically force GC to help cleanup
+        if (reqId % 10 === 0) {
+          forceGC()
+        }
+      }
+
+      forceGC()
+      const finalMemory = getHeapUsed()
+      const memoryGrowth = finalMemory - baselineMemory
+
+      // Memory growth should be minimal after all requests end
+      const maxExpectedGrowth = ALLOCATION_SIZE * SERVICES_PER_REQUEST * 2
+      expect(memoryGrowth).toBeLessThan(maxExpectedGrowth)
+    })
+  })
+
+  describe('High memory allocation scenarios', () => {
+    it.todo('should handle allocation spike and recovery', async () => {
+      const SPIKE_SIZE = 1024 * 1024 * 10 // 10MB spike
+
+      @Injectable({ registry })
+      class SpikeService {
+        public readonly data = new Uint8Array(SPIKE_SIZE)
+      }
+
+      forceGC()
+      const beforeSpike = getHeapUsedMB()
+
+      // Create spike
+      await container.get(SpikeService)
+
+      forceGC()
+      const atSpike = getHeapUsedMB()
+      const spikeDelta = atSpike - beforeSpike
+
+      // Verify spike occurred
+      expect(spikeDelta).toBeGreaterThan(8) // At least 8MB
+
+      // Release spike
+      await container.dispose()
+      registry = new Registry()
+      container = new Container(registry)
+
+      forceGC()
+      const afterRecovery = getHeapUsedMB()
+      const recovered = atSpike - afterRecovery
+
+      // Should recover most of the spike
+      expect(recovered).toBeGreaterThan(spikeDelta * 0.8)
+    })
+
+    it.todo(
+      'should handle multiple containers without cross-contamination',
+      async () => {
+        const ALLOCATION_SIZE = 1024 * 1024 // 1MB per container's services
+        const CONTAINER_COUNT = 5
+
+        forceGC()
+        const baselineMemory = getHeapUsed()
+
+        const containers: Array<{ container: Container; registry: Registry }> =
+          []
+
+        // Create multiple containers
+        for (let i = 0; i < CONTAINER_COUNT; i++) {
+          const localRegistry = new Registry()
+          const localContainer = new Container(localRegistry)
+
+          @Injectable({ registry: localRegistry })
+          class ContainerService {
+            public readonly containerId = i
+            public readonly data = new Uint8Array(ALLOCATION_SIZE)
+          }
+
+          await localContainer.get(ContainerService)
+          containers.push({
+            container: localContainer,
+            registry: localRegistry,
+          })
+        }
+
+        forceGC()
+        const peakMemory = getHeapUsed()
+        const totalAllocated = peakMemory - baselineMemory
+
+        // Should have allocated approximately CONTAINER_COUNT * ALLOCATION_SIZE
+        expect(totalAllocated).toBeGreaterThan(
+          ALLOCATION_SIZE * CONTAINER_COUNT * 0.8,
+        )
+
+        // Dispose containers one by one and verify memory reclamation
+        for (let i = 0; i < CONTAINER_COUNT; i++) {
+          await containers[i].container.dispose()
+          forceGC()
+
+          const currentMemory = getHeapUsed()
+          const remainingContainers = CONTAINER_COUNT - (i + 1)
+          const expectedMemory =
+            baselineMemory + ALLOCATION_SIZE * remainingContainers
+
+          // Memory should decrease as containers are disposed
+          // Allow 50% tolerance for GC timing
+          expect(currentMemory).toBeLessThan(expectedMemory * 1.5)
+        }
+      },
+    )
+  })
+
+  describe('Memory fragmentation prevention', () => {
+    it.todo(
+      'should handle alternating allocations without fragmentation issues',
+      async () => {
+        const SMALL_SIZE = 1024 * 10 // 10KB
+        const LARGE_SIZE = 1024 * 500 // 500KB
+        const ITERATIONS = 20
+
+        let smallServices: Array<{ new (): object }> = []
+        let largeServices: Array<{ new (): object }> = []
+
+        forceGC()
+        const baselineMemory = getHeapUsed()
+
+        // Alternate between small and large allocations
+        for (let i = 0; i < ITERATIONS; i++) {
+          @Injectable({ registry })
+          class SmallService {
+            public readonly data = new Uint8Array(SMALL_SIZE)
+          }
+          smallServices.push(SmallService)
+          await container.get(SmallService)
+
+          @Injectable({ registry })
+          class LargeService {
+            public readonly data = new Uint8Array(LARGE_SIZE)
+          }
+          largeServices.push(LargeService)
+          await container.get(LargeService)
+        }
+
+        forceGC()
+        const peakMemory = getHeapUsed()
+        const allocated = peakMemory - baselineMemory
+
+        // Dispose and verify reclamation
+        await container.dispose()
+        registry = new Registry()
+        container = new Container(registry)
+
+        // Clear references
+        smallServices = []
+        largeServices = []
+
+        forceGC()
+        const finalMemory = getHeapUsed()
+        const reclaimed = peakMemory - finalMemory
+
+        // Should reclaim at least 80% despite fragmentation potential
+        expect(reclaimed).toBeGreaterThan(allocated * 0.8)
+      },
+    )
+  })
+
+  describe('Dependency chain memory', () => {
+    it.todo('should properly reclaim deep dependency chains', async () => {
+      const ALLOCATION_SIZE = 1024 * 50 // 50KB per service
+
+      // Build a static chain of 10 services
+      @Injectable({ registry })
+      class Level10 {
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level9 {
+        public readonly next = inject(Level10)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level8 {
+        public readonly next = inject(Level9)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level7 {
+        public readonly next = inject(Level8)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level6 {
+        public readonly next = inject(Level7)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level5 {
+        public readonly next = inject(Level6)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level4 {
+        public readonly next = inject(Level5)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level3 {
+        public readonly next = inject(Level4)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level2 {
+        public readonly next = inject(Level3)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      @Injectable({ registry })
+      class Level1 {
+        public readonly next = inject(Level2)
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      const DEPTH = 10
+
+      forceGC()
+      const baselineMemory = getHeapUsed()
+
+      // Resolve the top of the chain (causes entire chain to resolve)
+      await container.get(Level1)
+
+      forceGC()
+      const peakMemory = getHeapUsed()
+      const allocated = peakMemory - baselineMemory
+
+      // Should have allocated approximately DEPTH * ALLOCATION_SIZE
+      expect(allocated).toBeGreaterThan(DEPTH * ALLOCATION_SIZE * 0.8)
+
+      // Dispose
+      await container.dispose()
+      registry = new Registry()
+      container = new Container(registry)
+
+      forceGC()
+      const finalMemory = getHeapUsed()
+      const reclaimed = peakMemory - finalMemory
+
+      // Should reclaim entire chain
+      expect(reclaimed).toBeGreaterThan(allocated * 0.8)
+    })
+
+    it.todo(
+      'should handle diamond dependency pattern without memory duplication',
+      async () => {
+        const ALLOCATION_SIZE = 1024 * 100 // 100KB
+
+        // Diamond pattern: A depends on B and C, both B and C depend on D
+        @Injectable({ registry })
+        class ServiceD {
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+
+        @Injectable({ registry })
+        class ServiceB {
+          public readonly d = inject(ServiceD)
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+
+        @Injectable({ registry })
+        class ServiceC {
+          public readonly d = inject(ServiceD)
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+
+        @Injectable({ registry })
+        class ServiceA {
+          public readonly b = inject(ServiceB)
+          public readonly c = inject(ServiceC)
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+
+        forceGC()
+        const baselineMemory = getHeapUsed()
+
+        const a = await container.get(ServiceA)
+
+        // Verify diamond - B and C should share same D instance
+        expect(a.b.d).toBe(a.c.d)
+
+        forceGC()
+        const peakMemory = getHeapUsed()
+        const allocated = peakMemory - baselineMemory
+
+        // Should be 4 services worth (not 5), since D is shared
+        const expectedMax = 4 * ALLOCATION_SIZE * 1.3 // 30% overhead tolerance
+        expect(allocated).toBeLessThan(expectedMax)
+
+        // Dispose and verify reclamation
+        await container.dispose()
+        registry = new Registry()
+        container = new Container(registry)
+
+        forceGC()
+        const finalMemory = getHeapUsed()
+        const reclaimed = peakMemory - finalMemory
+
+        expect(reclaimed).toBeGreaterThan(allocated * 0.8)
+      },
+    )
+  })
+
+  describe('Concurrent resolution memory', () => {
+    it.todo(
+      'should not duplicate memory with concurrent resolutions of same service',
+      async () => {
+        const ALLOCATION_SIZE = 1024 * 500 // 500KB
+        const CONCURRENT_REQUESTS = 10
+
+        @Injectable({ registry })
+        class ExpensiveService {
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+          public readonly createdAt = Date.now()
+        }
+
+        forceGC()
+        const baselineMemory = getHeapUsed()
+
+        // Request same singleton concurrently
+        const instances = await Promise.all(
+          Array.from({ length: CONCURRENT_REQUESTS }, () =>
+            container.get(ExpensiveService),
+          ),
+        )
+
+        // All should be same instance
+        const first = instances[0]
+        for (const instance of instances) {
+          expect(instance).toBe(first)
+        }
+
+        forceGC()
+        const peakMemory = getHeapUsed()
+        const allocated = peakMemory - baselineMemory
+
+        // Should only have allocated once, not CONCURRENT_REQUESTS times
+        const maxExpected = ALLOCATION_SIZE * 1.5 // Allow 50% overhead
+        expect(allocated).toBeLessThan(maxExpected)
+      },
+    )
+  })
+})