@navios/di 0.7.1 → 0.9.0

package/src/__tests__/event-emitter.spec.mts

@@ -1,163 +1,286 @@
-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { Container } from '../container/container.mjs'
 import { EventEmitter } from '../event-emitter.mjs'
 
 describe('EventEmitter', () => {
-  it('should create an instance', () => {
-    const emitter = new EventEmitter()
-    expect(emitter).toBeDefined()
+  let container: Container
+
+  beforeEach(() => {
+    container = new Container()
   })
 
-  it('should add and trigger event listeners', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+  afterEach(async () => {
+    await container.dispose()
+  })
 
-    emitter.on('test', mockListener)
-    await emitter.emit('test', 'hello')
+  describe('basic operations', () => {
+    it('should be injectable as transient', async () => {
+      const emitter1 = await container.get(EventEmitter)
+      const emitter2 = await container.get(EventEmitter)
 
-    expect(mockListener).toHaveBeenCalledWith('hello')
-    expect(mockListener).toHaveBeenCalledTimes(1)
-    emitter.off('test', mockListener)
+      expect(emitter1).toBeInstanceOf(EventEmitter)
+      expect(emitter2).toBeInstanceOf(EventEmitter)
+      expect(emitter1).not.toBe(emitter2)
+    })
   })
 
-  it('should support multiple listeners for the same event', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener1 = vi.fn()
-    const mockListener2 = vi.fn()
+  describe('on', () => {
+    it('should register event listener', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
 
-    emitter.on('test', mockListener1)
-    emitter.on('test', mockListener2)
-    await emitter.emit('test', 'hello')
+      emitter.on('test', listener)
+      await emitter.emit('test')
 
-    expect(mockListener1).toHaveBeenCalledWith('hello')
-    expect(mockListener2).toHaveBeenCalledWith('hello')
-  })
+      expect(listener).toHaveBeenCalledTimes(1)
+    })
 
-  it('should return unsubscribe function from on()', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+    it('should return unsubscribe function', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
 
-    const unsubscribe = emitter.on('test', mockListener)
-    await emitter.emit('test', 'hello1')
+      const unsubscribe = emitter.on('test', listener)
+      unsubscribe()
 
-    unsubscribe()
-    await emitter.emit('test', 'hello2')
+      await emitter.emit('test')
+      expect(listener).not.toHaveBeenCalled()
+    })
 
-    expect(mockListener).toHaveBeenCalledTimes(1)
-    expect(mockListener).toHaveBeenCalledWith('hello1')
-  })
+    it('should support multiple listeners for same event', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener1 = vi.fn()
+      const listener2 = vi.fn()
 
-  it('should support off() method to remove listeners', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+      emitter.on('test', listener1)
+      emitter.on('test', listener2)
+      await emitter.emit('test')
 
-    emitter.on('test', mockListener)
-    await emitter.emit('test', 'hello1')
+      expect(listener1).toHaveBeenCalledTimes(1)
+      expect(listener2).toHaveBeenCalledTimes(1)
+    })
 
-    emitter.off('test', mockListener)
-    await emitter.emit('test', 'hello2')
+    it('should support different event types', async () => {
+      const emitter = await container.get(
+        EventEmitter<{ eventA: []; eventB: [] }>,
+      )
+      const listenerA = vi.fn()
+      const listenerB = vi.fn()
 
-    expect(mockListener).toHaveBeenCalledTimes(1)
-    expect(mockListener).toHaveBeenCalledWith('hello1')
-  })
+      emitter.on('eventA', listenerA)
+      emitter.on('eventB', listenerB)
 
-  it('should handle off() for non-existent event', () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+      await emitter.emit('eventA')
 
-    expect(() => {
-      emitter.off('test', mockListener)
-    }).not.toThrow()
+      expect(listenerA).toHaveBeenCalledTimes(1)
+      expect(listenerB).not.toHaveBeenCalled()
+    })
   })
 
-  it('should clean up empty listener sets after removing all listeners', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener1 = vi.fn()
-    const mockListener2 = vi.fn()
+  describe('off', () => {
+    it('should remove specific listener', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener1 = vi.fn()
+      const listener2 = vi.fn()
 
-    emitter.on('test', mockListener1)
-    emitter.on('test', mockListener2)
+      emitter.on('test', listener1)
+      emitter.on('test', listener2)
+      emitter.off('test', listener1)
 
-    emitter.off('test', mockListener1)
-    emitter.off('test', mockListener2)
+      await emitter.emit('test')
 
-    // After removing all listeners, emitting should not call anything
-    await emitter.emit('test', 'hello')
+      expect(listener1).not.toHaveBeenCalled()
+      expect(listener2).toHaveBeenCalledTimes(1)
+    })
 
-    expect(mockListener1).not.toHaveBeenCalled()
-    expect(mockListener2).not.toHaveBeenCalled()
-  })
+    it('should handle removing non-existent listener gracefully', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
 
-  it('should support once() method for one-time listeners', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+      // Should not throw
+      emitter.off('test', listener)
+    })
 
-    emitter.once('test', mockListener)
-    await emitter.emit('test', 'hello1')
-    await emitter.emit('test', 'hello2')
+    it('should handle removing from non-existent event gracefully', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
 
-    expect(mockListener).toHaveBeenCalledTimes(1)
-    expect(mockListener).toHaveBeenCalledWith('hello1')
-  })
+      // Should not throw
+      emitter.off('test', () => {})
+    })
 
-  it('should return unsubscribe function from once()', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockListener = vi.fn()
+    it('should clean up empty event sets', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
 
-    const unsubscribe = emitter.once('test', mockListener)
-    unsubscribe() // Remove before emitting
-    await emitter.emit('test', 'hello')
+      emitter.on('test', listener)
+      emitter.off('test', listener)
 
-    expect(mockListener).not.toHaveBeenCalled()
+      // After removing the last listener, the event should be cleaned up
+      // We can verify this by checking that emit doesn't call anything
+      await emitter.emit('test')
+      expect(listener).not.toHaveBeenCalled()
+    })
   })
 
-  it('should handle emit() for non-existent event', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
+  describe('once', () => {
+    it('should only trigger listener once', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
 
-    const result = await emitter.emit('test', 'hello')
-    expect(result).toBeUndefined()
-  })
+      emitter.once('test', listener)
 
-  it('should handle multiple arguments in events', async () => {
-    const emitter = new EventEmitter<{ test: [string, number, boolean] }>()
-    const mockListener = vi.fn()
+      await emitter.emit('test')
+      await emitter.emit('test')
+      await emitter.emit('test')
 
-    emitter.on('test', mockListener)
-    await emitter.emit('test', 'hello', 42, true)
+      expect(listener).toHaveBeenCalledTimes(1)
+    })
 
-    expect(mockListener).toHaveBeenCalledWith('hello', 42, true)
+    it('should return unsubscribe function', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const listener = vi.fn()
+
+      const unsubscribe = emitter.once('test', listener)
+      unsubscribe()
+
+      await emitter.emit('test')
+      expect(listener).not.toHaveBeenCalled()
+    })
   })
 
-  it('should handle async listeners', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockAsyncListener = vi.fn().mockResolvedValue('async result')
+  describe('emit', () => {
+    it('should pass arguments to listeners', async () => {
+      const emitter = await container.get(
+        EventEmitter<{ test: [string, number] }>,
+      )
+      const listener = vi.fn()
+
+      emitter.on('test', listener)
+      await emitter.emit('test', 'hello', 42)
+
+      expect(listener).toHaveBeenCalledWith('hello', 42)
+    })
+
+    it('should return undefined for non-existent event', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+
+      const result = await emitter.emit('test')
+      expect(result).toBeUndefined()
+    })
+
+    it('should wait for async listeners', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      let completed = false
 
-    emitter.on('test', mockAsyncListener)
-    const results = await emitter.emit('test', 'hello')
+      emitter.on('test', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        completed = true
+      })
 
-    expect(mockAsyncListener).toHaveBeenCalledWith('hello')
-    expect(results).toEqual(['async result'])
+      await emitter.emit('test')
+      expect(completed).toBe(true)
+    })
+
+    it('should execute all listeners concurrently', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+      const order: number[] = []
+
+      emitter.on('test', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 30))
+        order.push(1)
+      })
+
+      emitter.on('test', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        order.push(2)
+      })
+
+      emitter.on('test', async () => {
+        order.push(3)
+      })
+
+      await emitter.emit('test')
+
+      // All should complete, but order depends on timing
+      expect(order).toHaveLength(3)
+      // The sync one should complete first
+      expect(order[0]).toBe(3)
+    })
+
+    it('should return array of results from Promise.all', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+
+      // @ts-expect-error - not a documented feature
+      emitter.on('test', async () => 'result1')
+      // @ts-expect-error - not a documented feature
+      emitter.on('test', async () => 'result2')
+
+      const results = await emitter.emit('test')
+      expect(results).toEqual(['result1', 'result2'])
+    })
+  })
+
+  describe('type safety', () => {
+    it('should enforce correct event argument types', async () => {
+      type Events = {
+        userCreated: [string, number]
+        orderPlaced: [{ id: string; total: number }]
+        empty: []
+      }
+
+      const emitter = await container.get(EventEmitter<Events>)
+      const userListener = vi.fn()
+      const orderListener = vi.fn()
+      const emptyListener = vi.fn()
+
+      emitter.on('userCreated', userListener)
+      emitter.on('orderPlaced', orderListener)
+      emitter.on('empty', emptyListener)
+
+      await emitter.emit('userCreated', 'user123', 25)
+      await emitter.emit('orderPlaced', { id: 'order1', total: 100 })
+      await emitter.emit('empty')
+
+      expect(userListener).toHaveBeenCalledWith('user123', 25)
+      expect(orderListener).toHaveBeenCalledWith({ id: 'order1', total: 100 })
+      expect(emptyListener).toHaveBeenCalledWith()
+    })
   })
 
-  it('should handle multiple async listeners and return all results', async () => {
-    const emitter = new EventEmitter<{ test: [string] }>()
-    const mockAsyncListener1 = vi.fn().mockResolvedValue('result1')
-    const mockAsyncListener2 = vi.fn().mockResolvedValue('result2')
+  describe('error handling', () => {
+    it('should propagate errors from sync listeners', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
+
+      emitter.on('test', () => {
+        throw new Error('Sync error')
+      })
+
+      await expect(emitter.emit('test')).rejects.toThrow('Sync error')
+    })
+
+    it('should propagate errors from async listeners', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
 
-    emitter.on('test', mockAsyncListener1)
-    emitter.on('test', mockAsyncListener2)
-    const results = await emitter.emit('test', 'hello')
+      emitter.on('test', async () => {
+        throw new Error('Async error')
+      })
 
-    expect(results).toEqual(['result1', 'result2'])
+      await expect(emitter.emit('test')).rejects.toThrow('Async error')
+    })
   })
 
-  it('should work with no-argument events', async () => {
-    const emitter = new EventEmitter<{ test: [] }>()
-    const mockListener = vi.fn()
+  describe('memory management', () => {
+    it('should allow garbage collection after unsubscribe', async () => {
+      const emitter = await container.get(EventEmitter<{ test: [] }>)
 
-    emitter.on('test', mockListener)
-    await emitter.emit('test')
+      // Add and remove many listeners
+      for (let i = 0; i < 100; i++) {
+        const unsubscribe = emitter.on('test', () => {})
+        unsubscribe()
+      }
 
-    expect(mockListener).toHaveBeenCalledWith()
+      // The event should be cleaned up (empty listeners set removed)
+      await emitter.emit('test')
+    })
   })
 })