@dangao/bun-server 1.7.1 → 1.8.1

package/tests/events/event-emitter.test.ts

@@ -0,0 +1,373 @@
+import { describe, expect, test, beforeEach, mock } from 'bun:test';
+import { EventEmitterService } from '../../src/events/service';
+import type { EventEmitter, EventModuleOptions } from '../../src/events/types';
+
+describe('EventEmitterService', () => {
+  let emitter: EventEmitter;
+
+  beforeEach(() => {
+    emitter = new EventEmitterService();
+  });
+
+  describe('on() and emit()', () => {
+    test('should register and trigger listener', () => {
+      const listener = mock(() => {});
+      emitter.on('test.event', listener);
+      emitter.emit('test.event', { data: 'hello' });
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener).toHaveBeenCalledWith({ data: 'hello' });
+    });
+
+    test('should support multiple listeners for same event', () => {
+      const listener1 = mock(() => {});
+      const listener2 = mock(() => {});
+
+      emitter.on('test.event', listener1);
+      emitter.on('test.event', listener2);
+      emitter.emit('test.event', 'payload');
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    test('should not trigger listener for different event', () => {
+      const listener = mock(() => {});
+      emitter.on('test.event1', listener);
+      emitter.emit('test.event2', 'payload');
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    test('should support Symbol as event name', () => {
+      const eventSymbol = Symbol('test.event');
+      const listener = mock(() => {});
+
+      emitter.on(eventSymbol, listener);
+      emitter.emit(eventSymbol, { key: 'value' });
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener).toHaveBeenCalledWith({ key: 'value' });
+    });
+
+    test('should return unsubscribe function', () => {
+      const listener = mock(() => {});
+      const unsubscribe = emitter.on('test.event', listener);
+
+      emitter.emit('test.event', 'first');
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      emitter.emit('test.event', 'second');
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('once()', () => {
+    test('should only trigger listener once', () => {
+      const listener = mock(() => {});
+      emitter.once('test.event', listener);
+
+      emitter.emit('test.event', 'first');
+      emitter.emit('test.event', 'second');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener).toHaveBeenCalledWith('first');
+    });
+
+    test('should return unsubscribe function', () => {
+      const listener = mock(() => {});
+      const unsubscribe = emitter.once('test.event', listener);
+
+      unsubscribe();
+      emitter.emit('test.event', 'payload');
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('off()', () => {
+    test('should remove specific listener', () => {
+      const listener1 = mock(() => {});
+      const listener2 = mock(() => {});
+
+      emitter.on('test.event', listener1);
+      emitter.on('test.event', listener2);
+      emitter.off('test.event', listener1);
+      emitter.emit('test.event', 'payload');
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    test('should do nothing if listener not found', () => {
+      const listener = mock(() => {});
+      emitter.off('test.event', listener); // 不抛出错误
+    });
+  });
+
+  describe('removeAllListeners()', () => {
+    test('should remove all listeners for specific event', () => {
+      const listener1 = mock(() => {});
+      const listener2 = mock(() => {});
+
+      emitter.on('event1', listener1);
+      emitter.on('event2', listener2);
+      emitter.removeAllListeners('event1');
+
+      emitter.emit('event1', 'payload');
+      emitter.emit('event2', 'payload');
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    test('should remove all listeners when no event specified', () => {
+      const listener1 = mock(() => {});
+      const listener2 = mock(() => {});
+
+      emitter.on('event1', listener1);
+      emitter.on('event2', listener2);
+      emitter.removeAllListeners();
+
+      emitter.emit('event1', 'payload');
+      emitter.emit('event2', 'payload');
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('listenerCount()', () => {
+    test('should return correct listener count', () => {
+      expect(emitter.listenerCount('test.event')).toBe(0);
+
+      emitter.on('test.event', () => {});
+      expect(emitter.listenerCount('test.event')).toBe(1);
+
+      emitter.on('test.event', () => {});
+      expect(emitter.listenerCount('test.event')).toBe(2);
+    });
+  });
+
+  describe('eventNames()', () => {
+    test('should return all registered event names', () => {
+      const symbol = Symbol('symbol.event');
+      emitter.on('string.event', () => {});
+      emitter.on(symbol, () => {});
+
+      const names = emitter.eventNames();
+      expect(names).toContain('string.event');
+      expect(names).toContain(symbol);
+      expect(names.length).toBe(2);
+    });
+
+    test('should return empty array when no listeners', () => {
+      expect(emitter.eventNames()).toEqual([]);
+    });
+  });
+
+  describe('priority', () => {
+    test('should execute listeners in priority order (high to low)', () => {
+      const order: number[] = [];
+
+      emitter.on('test.event', () => order.push(1), { priority: 1 });
+      emitter.on('test.event', () => order.push(3), { priority: 3 });
+      emitter.on('test.event', () => order.push(2), { priority: 2 });
+
+      emitter.emit('test.event', null);
+
+      expect(order).toEqual([3, 2, 1]);
+    });
+
+    test('should use default priority 0 when not specified', () => {
+      const order: number[] = [];
+
+      emitter.on('test.event', () => order.push(1)); // priority: 0
+      emitter.on('test.event', () => order.push(2), { priority: 1 });
+      emitter.on('test.event', () => order.push(3), { priority: -1 });
+
+      emitter.emit('test.event', null);
+
+      expect(order).toEqual([2, 1, 3]);
+    });
+  });
+
+  describe('emitAsync()', () => {
+    test('should wait for all async listeners to complete', async () => {
+      const results: number[] = [];
+
+      emitter.on('test.event', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        results.push(1);
+      });
+
+      emitter.on('test.event', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        results.push(2);
+      });
+
+      await emitter.emitAsync('test.event', null);
+
+      expect(results.length).toBe(2);
+      expect(results).toContain(1);
+      expect(results).toContain(2);
+    });
+
+    test('should handle sync listeners in emitAsync', async () => {
+      const listener = mock(() => {});
+      emitter.on('test.event', listener);
+
+      await emitter.emitAsync('test.event', 'payload');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    test('should remove once listeners after emitAsync', async () => {
+      const listener = mock(() => {});
+      emitter.once('test.event', listener);
+
+      await emitter.emitAsync('test.event', 'first');
+      await emitter.emitAsync('test.event', 'second');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('error handling', () => {
+    test('should continue execution when listener throws sync error', () => {
+      const consoleSpy = mock(() => {});
+      const originalError = console.error;
+      console.error = consoleSpy;
+
+      const listener1 = mock(() => {
+        throw new Error('Test error');
+      });
+      const listener2 = mock(() => {});
+
+      emitter.on('test.event', listener1);
+      emitter.on('test.event', listener2);
+      emitter.emit('test.event', 'payload');
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(consoleSpy).toHaveBeenCalled();
+
+      console.error = originalError;
+    });
+
+    test('should use custom error handler when provided', () => {
+      const errorHandler = mock(() => {});
+      const emitterWithErrorHandler = new EventEmitterService({
+        onError: errorHandler,
+      });
+
+      emitterWithErrorHandler.on('test.event', () => {
+        throw new Error('Custom error');
+      });
+      emitterWithErrorHandler.emit('test.event', 'payload');
+
+      expect(errorHandler).toHaveBeenCalledTimes(1);
+      expect(errorHandler.mock.calls[0]?.[0]).toBeInstanceOf(Error);
+    });
+  });
+
+  describe('maxListeners warning', () => {
+    test('should warn when exceeding maxListeners', () => {
+      const consoleSpy = mock(() => {});
+      const originalWarn = console.warn;
+      console.warn = consoleSpy;
+
+      const emitterWithLimit = new EventEmitterService({ maxListeners: 2 });
+
+      emitterWithLimit.on('test.event', () => {});
+      emitterWithLimit.on('test.event', () => {});
+      emitterWithLimit.on('test.event', () => {}); // 超过限制
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(consoleSpy.mock.calls[0]?.[0]).toContain('Max listeners');
+
+      console.warn = originalWarn;
+    });
+  });
+
+  describe('globalPrefix', () => {
+    test('should add global prefix to event names', () => {
+      const emitterWithPrefix = new EventEmitterService({
+        globalPrefix: 'app',
+      });
+      const listener = mock(() => {});
+
+      emitterWithPrefix.on('user.created', listener);
+      emitterWithPrefix.emit('user.created', 'payload');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+});
+
+describe('EventEmitterService wildcard', () => {
+  let emitter: EventEmitter;
+
+  beforeEach(() => {
+    emitter = new EventEmitterService({ wildcard: true });
+  });
+
+  describe('single wildcard (*)', () => {
+    test('should match single segment', () => {
+      const listener = mock(() => {});
+      emitter.on('user.*', listener);
+
+      emitter.emit('user.created', 'payload1');
+      emitter.emit('user.updated', 'payload2');
+
+      expect(listener).toHaveBeenCalledTimes(2);
+    });
+
+    test('should not match multiple segments', () => {
+      const listener = mock(() => {});
+      emitter.on('user.*', listener);
+
+      emitter.emit('user.profile.updated', 'payload');
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('double wildcard (**)', () => {
+    test('should match any number of segments', () => {
+      const listener = mock(() => {});
+      emitter.on('user.**', listener);
+
+      emitter.emit('user.created', 'payload1');
+      emitter.emit('user.profile.updated', 'payload2');
+      emitter.emit('user.settings.privacy.changed', 'payload3');
+
+      expect(listener).toHaveBeenCalledTimes(3);
+    });
+
+    test('should match at end of pattern', () => {
+      const listener = mock(() => {});
+      emitter.on('app.**', listener);
+
+      emitter.emit('app.start', 'payload');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('mixed patterns', () => {
+    test('should handle exact match alongside wildcards', () => {
+      const exactListener = mock(() => {});
+      const wildcardListener = mock(() => {});
+
+      emitter.on('user.created', exactListener);
+      emitter.on('user.*', wildcardListener);
+
+      emitter.emit('user.created', 'payload');
+
+      expect(exactListener).toHaveBeenCalledTimes(1);
+      expect(wildcardListener).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/tests/events/event-listener-scanner.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { EventListenerScanner, EVENT_LISTENER_SCANNER_TOKEN } from '../../src/events/event-module';
+import { EventEmitterService } from '../../src/events/service';
+import { OnEvent } from '../../src/events/decorators';
+import { EVENT_LISTENER_CLASS_METADATA_KEY } from '../../src/events/types';
+import { Container } from '../../src/di/container';
+import { Injectable } from '../../src/di/decorators';
+
+describe('EventListenerScanner', () => {
+  let emitter: EventEmitterService;
+  let container: Container;
+  let scanner: EventListenerScanner;
+
+  beforeEach(() => {
+    emitter = new EventEmitterService();
+    container = new Container();
+    scanner = new EventListenerScanner(emitter, container);
+  });
+
+  describe('scanAndRegister', () => {
+    test('should register listeners from class with OnEvent decorator', () => {
+      @Injectable()
+      class TestListener {
+        public receivedPayload: any = null;
+
+        @OnEvent('test-event')
+        public handleTestEvent(payload: any): void {
+          this.receivedPayload = payload;
+        }
+      }
+
+      // Mark as event listener class
+      Reflect.defineMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, true, TestListener);
+
+      container.register(TestListener);
+      scanner.scanAndRegister([TestListener]);
+
+      expect(emitter.listenerCount('test-event')).toBe(1);
+    });
+
+    test('should skip non-listener classes', () => {
+      class NotAListener {
+        public someMethod(): void {}
+      }
+
+      scanner.scanAndRegister([NotAListener]);
+
+      // No listeners registered
+      expect(emitter.listenerCount('some-event')).toBe(0);
+    });
+
+    test('should handle multiple listeners', () => {
+      @Injectable()
+      class MultiListener {
+        @OnEvent('event1')
+        public handleEvent1(): void {}
+
+        @OnEvent('event2')
+        public handleEvent2(): void {}
+      }
+
+      Reflect.defineMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, true, MultiListener);
+
+      container.register(MultiListener);
+      scanner.scanAndRegister([MultiListener]);
+
+      expect(emitter.listenerCount('event1')).toBe(1);
+      expect(emitter.listenerCount('event2')).toBe(1);
+    });
+  });
+
+  describe('registerListenerClass', () => {
+    test('should register single listener class', () => {
+      @Injectable()
+      class SingleListener {
+        @OnEvent('single-event')
+        public handle(): void {}
+      }
+
+      Reflect.defineMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, true, SingleListener);
+      container.register(SingleListener);
+
+      scanner.registerListenerClass(SingleListener);
+
+      expect(emitter.listenerCount('single-event')).toBe(1);
+    });
+
+    test('should skip class without metadata', () => {
+      class NoMetadata {
+        public handle(): void {}
+      }
+
+      scanner.registerListenerClass(NoMetadata);
+
+      expect(emitter.eventNames().length).toBe(0);
+    });
+
+    test('should handle class not registered in container', () => {
+      @Injectable()
+      class UnregisteredListener {
+        @OnEvent('unreg-event')
+        public handle(): void {}
+      }
+
+      Reflect.defineMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, true, UnregisteredListener);
+      // Not registering in container
+
+      // Should not throw, just warn
+      expect(() => scanner.registerListenerClass(UnregisteredListener)).not.toThrow();
+    });
+  });
+});

package/tests/events/event-module.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { EventModule } from '../../src/events/event-module';
+import { EventEmitterService } from '../../src/events/service';
+import { EVENT_EMITTER_TOKEN, EVENT_OPTIONS_TOKEN } from '../../src/events/types';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+
+describe('EventModule', () => {
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, EventModule);
+  });
+
+  describe('forRoot', () => {
+    test('should create module with default options', () => {
+      EventModule.forRoot();
+
+      const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, EventModule);
+      expect(metadata.providers).toBeDefined();
+      expect(metadata.exports).toContain(EVENT_EMITTER_TOKEN);
+    });
+
+    test('should create module with custom options', () => {
+      EventModule.forRoot({
+        maxListeners: 50,
+        async: true,
+        errorHandler: (event, error) => {
+          console.error(`Event ${event} error:`, error);
+        },
+      });
+
+      const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, EventModule);
+      expect(metadata.providers).toBeDefined();
+
+      // Find options provider
+      const optionsProvider = metadata.providers.find(
+        (p: any) => p.provide === EVENT_OPTIONS_TOKEN,
+      );
+      expect(optionsProvider?.useValue?.maxListeners).toBe(50);
+      expect(optionsProvider?.useValue?.async).toBe(true);
+    });
+
+    test('should export EventService', () => {
+      EventModule.forRoot();
+
+      const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, EventModule);
+      expect(metadata.exports).toContain(EVENT_EMITTER_TOKEN);
+    });
+  });
+});
+
+describe('EventEmitterService', () => {
+  let service: EventEmitterService;
+
+  beforeEach(() => {
+    service = new EventEmitterService({ maxListeners: 10 });
+  });
+
+  afterEach(() => {
+    service.removeAllListeners();
+  });
+
+  describe('on', () => {
+    test('should register listener', () => {
+      const handler = () => {};
+      service.on('test-event', handler);
+
+      expect(service.listenerCount('test-event')).toBe(1);
+    });
+
+    test('should return unsubscribe function', () => {
+      const handler = () => {};
+      const unsubscribe = service.on('test-event', handler);
+
+      expect(typeof unsubscribe).toBe('function');
+      unsubscribe();
+      expect(service.listenerCount('test-event')).toBe(0);
+    });
+
+    test('should support multiple listeners', () => {
+      service.on('event', () => {});
+      service.on('event', () => {});
+      service.on('event', () => {});
+
+      expect(service.listenerCount('event')).toBe(3);
+    });
+  });
+
+  describe('once', () => {
+    test('should register one-time listener', async () => {
+      let callCount = 0;
+      service.once('one-time', () => {
+        callCount++;
+      });
+
+      await service.emit('one-time');
+      await service.emit('one-time');
+
+      expect(callCount).toBe(1);
+    });
+  });
+
+  describe('emit', () => {
+    test('should call listeners with payload', () => {
+      let receivedData: any;
+      service.on('data-event', (data) => {
+        receivedData = data;
+      });
+
+      service.emit('data-event', { value: 42 });
+
+      expect(receivedData).toEqual({ value: 42 });
+    });
+
+    test('should not throw when no listeners', () => {
+      // emit returns void, not boolean
+      expect(() => service.emit('no-listeners', null)).not.toThrow();
+    });
+
+    test('should call listener when registered', () => {
+      let called = false;
+      service.on('has-listeners', () => { called = true; });
+      service.emit('has-listeners', null);
+      expect(called).toBe(true);
+    });
+
+    test('should call multiple listeners in order', () => {
+      const order: number[] = [];
+      service.on('ordered', () => order.push(1));
+      service.on('ordered', () => order.push(2));
+      service.on('ordered', () => order.push(3));
+
+      service.emit('ordered', null);
+
+      expect(order).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('off', () => {
+    test('should remove specific listener', () => {
+      const handler = () => {};
+      service.on('removable', handler);
+      service.off('removable', handler);
+
+      expect(service.listenerCount('removable')).toBe(0);
+    });
+
+    test('should not affect other listeners', () => {
+      const handler1 = () => {};
+      const handler2 = () => {};
+
+      service.on('event', handler1);
+      service.on('event', handler2);
+      service.off('event', handler1);
+
+      expect(service.listenerCount('event')).toBe(1);
+    });
+  });
+
+  describe('removeAllListeners', () => {
+    test('should remove all listeners for event', () => {
+      service.on('event', () => {});
+      service.on('event', () => {});
+      service.removeAllListeners('event');
+
+      expect(service.listenerCount('event')).toBe(0);
+    });
+
+    test('should remove all listeners when no event specified', () => {
+      service.on('event1', () => {});
+      service.on('event2', () => {});
+      service.removeAllListeners();
+
+      expect(service.listenerCount('event1')).toBe(0);
+      expect(service.listenerCount('event2')).toBe(0);
+    });
+  });
+
+  describe('eventNames', () => {
+    test('should return all event names', () => {
+      service.on('event1', () => {});
+      service.on('event2', () => {});
+      service.on('event3', () => {});
+
+      const names = service.eventNames();
+      expect(names).toContain('event1');
+      expect(names).toContain('event2');
+      expect(names).toContain('event3');
+    });
+  });
+
+  describe('getListeners', () => {
+    test('should return listeners count via listenerCount', () => {
+      const handler1 = () => {};
+      const handler2 = () => {};
+
+      service.on('event', handler1);
+      service.on('event', handler2);
+
+      // Use listenerCount method instead
+      expect(service.listenerCount('event')).toBe(2);
+    });
+  });
+});