@dangao/bun-server 1.0.1 → 1.1.2

package/tests/perf/regression.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+import { PerformanceHarness } from '../../src/testing/harness';
+import { getTestPort } from '../utils/test-port';
+
+/**
+ * 性能回归测试
+ * 确保关键路径的性能不会退化
+ */
+describe('Performance Regression Tests', () => {
+  test('router handle should be fast', async () => {
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/test', (ctx: Context) => {
+      return ctx.createResponse({ message: 'ok' });
+    });
+
+    const router = registry.getRouter();
+    const context = new Context(
+      new Request('http://localhost:3000/api/test'),
+    );
+    context.params = {};
+
+    const result = await PerformanceHarness.benchmark(
+      'router handle',
+      1000,
+      async () => {
+        await router.preHandle(context);
+        return await router.handle(context);
+      },
+    );
+
+    // 路由处理应该快速完成
+    expect(result.durationMs).toBeLessThan(1000); // 1000次操作应该在1秒内完成
+    expect(result.opsPerSecond).toBeGreaterThan(1000);
+  });
+
+  test('application request handling should be fast', async () => {
+    const port = getTestPort();
+    const app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/ping', (ctx: Context) => {
+      return ctx.createResponse({ status: 'ok' });
+    });
+
+    await app.listen();
+
+    try {
+      const result = await PerformanceHarness.benchmark(
+        'application request',
+        100,
+        async () => {
+          const response = await fetch(`http://localhost:${port}/api/ping`);
+          await response.text();
+          return response;
+        },
+      );
+
+      // HTTP 请求处理应该快速完成（包含网络开销）
+      expect(result.durationMs).toBeLessThan(2000); // 100次请求应该在2秒内完成
+      expect(result.opsPerSecond).toBeGreaterThan(50);
+    } finally {
+      await app.stop();
+    }
+  });
+
+  test('DI container resolve should be fast', async () => {
+    const { Container } = await import('../../src/di/container');
+    const { Injectable } = await import('../../src/di/decorators');
+
+    @Injectable()
+    class TestService {
+      public value = 'test';
+    }
+
+    const container = new Container();
+    container.register(TestService);
+
+    const result = await PerformanceHarness.benchmark(
+      'DI resolve',
+      10000,
+      () => {
+        return container.resolve(TestService);
+      },
+    );
+
+    // DI 解析应该非常快（单例缓存）
+    expect(result.durationMs).toBeLessThan(100); // 10000次解析应该在100ms内完成
+    expect(result.opsPerSecond).toBeGreaterThan(10000);
+  });
+
+  test('middleware pipeline should be fast', async () => {
+    const { MiddlewarePipeline } = await import('../../src/middleware/pipeline');
+    const { Context } = await import('../../src/core/context');
+
+    const pipeline = new MiddlewarePipeline();
+    pipeline.use(async (ctx, next) => {
+      return await next();
+    });
+    pipeline.use(async (ctx, next) => {
+      return await next();
+    });
+
+    const context = new Context(new Request('http://localhost:3000/test'));
+    const result = await PerformanceHarness.benchmark(
+      'middleware pipeline',
+      1000,
+      async () => {
+        return await pipeline.run(context, async () => {
+          return new Response('ok');
+        });
+      },
+    );
+
+    // 中间件管道应该快速完成
+    expect(result.durationMs).toBeLessThan(500); // 1000次操作应该在500ms内完成
+    expect(result.opsPerSecond).toBeGreaterThan(1000);
+  });
+});

package/tests/queue/queue-module.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { Container } from '../../src/di/container';
+import { ModuleRegistry } from '../../src/di/module-registry';
+import {
+  QueueModule,
+  QueueService,
+  QUEUE_SERVICE_TOKEN,
+  MemoryQueueStore,
+  type QueueModuleOptions,
+  type Job,
+} from '../../src/queue';
+
+describe('QueueModule', () => {
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, QueueModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  test('should register queue service provider', () => {
+    QueueModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const queueProvider = metadata.providers.find(
+      (provider: any) => provider.provide === QUEUE_SERVICE_TOKEN,
+    );
+    expect(queueProvider).toBeDefined();
+    expect(queueProvider.useValue).toBeInstanceOf(QueueService);
+  });
+
+  test('should use custom store when provided', () => {
+    const customStore = new MemoryQueueStore();
+    QueueModule.forRoot({
+      store: customStore,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    const queueProvider = metadata.providers.find(
+      (provider: any) => provider.provide === QUEUE_SERVICE_TOKEN,
+    );
+    expect(queueProvider).toBeDefined();
+  });
+
+  test('should configure default queue name', () => {
+    QueueModule.forRoot({
+      defaultQueue: 'custom-queue',
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+  });
+
+  test('should configure worker settings', () => {
+    QueueModule.forRoot({
+      enableWorker: false,
+      concurrency: 5,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+  });
+});
+
+describe('QueueService', () => {
+  let service: QueueService;
+  let store: MemoryQueueStore;
+
+  beforeEach(() => {
+    store = new MemoryQueueStore();
+    service = new QueueService({
+      store,
+      defaultQueue: 'default',
+      enableWorker: false, // 禁用工作进程以便测试
+      concurrency: 1,
+    });
+  });
+
+  afterEach(() => {
+    service.destroy();
+  });
+
+  test('should add job to queue', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    expect(jobId).toBeDefined();
+    expect(typeof jobId).toBe('string');
+  });
+
+  test('should get job by id', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    const job = await service.get(jobId);
+    expect(job).toBeDefined();
+    expect(job?.name).toBe('test-job');
+    expect(job?.data).toEqual({ data: 'test' });
+  });
+
+  test('should delete job', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    const deleted = await service.delete(jobId);
+    expect(deleted).toBe(true);
+    const job = await service.get(jobId);
+    expect(job).toBeUndefined();
+  });
+
+  test('should clear queue', async () => {
+    await service.add('test-job', { data: 'test' });
+    await service.add('test-job2', { data: 'test2' });
+    const cleared = await service.clear();
+    expect(cleared).toBe(true);
+    const count = await service.count();
+    expect(count).toBe(0);
+  });
+
+  test('should count jobs in queue', async () => {
+    await service.add('test-job', { data: 'test' });
+    await service.add('test-job2', { data: 'test2' });
+    const count = await service.count();
+    expect(count).toBe(2);
+  });
+
+  test('should register job handler', async () => {
+    let handlerCalled = false;
+    await service.registerHandler('test-job', async (job) => {
+      handlerCalled = true;
+      expect(job.name).toBe('test-job');
+    });
+    expect(handlerCalled).toBe(false); // Handler not called yet
+  });
+
+  test('should add job with options', async () => {
+    const jobId = await service.add(
+      'test-job',
+      { data: 'test' },
+      {
+        delay: 1000,
+        priority: 10,
+        attempts: 3,
+      },
+    );
+    const job = await service.get(jobId);
+    expect(job).toBeDefined();
+    expect(job?.options?.delay).toBe(1000);
+    expect(job?.options?.priority).toBe(10);
+    expect(job?.options?.attempts).toBe(3);
+  });
+});
+
+describe('MemoryQueueStore', () => {
+  let store: MemoryQueueStore;
+
+  beforeEach(() => {
+    store = new MemoryQueueStore();
+  });
+
+  test('should add and get job', async () => {
+    const jobId = await store.add('test-queue', {
+      name: 'test-job',
+      data: { test: 'data' },
+    });
+    expect(jobId).toBeDefined();
+
+    const job = await store.get('test-queue', jobId);
+    expect(job).toBeDefined();
+    expect(job?.name).toBe('test-job');
+    expect(job?.data).toEqual({ test: 'data' });
+  });
+
+  test('should get next job', async () => {
+    await store.add('test-queue', {
+      name: 'job1',
+      data: { id: 1 },
+    });
+    await store.add('test-queue', {
+      name: 'job2',
+      data: { id: 2 },
+    });
+
+    const nextJob = await store.getNext('test-queue');
+    expect(nextJob).toBeDefined();
+    expect(nextJob?.name).toBe('job1');
+  });
+
+  test('should update job status', async () => {
+    const jobId = await store.add('test-queue', {
+      name: 'test-job',
+      data: {},
+    });
+    const updated = await store.updateStatus('test-queue', jobId, 'active');
+    expect(updated).toBe(true);
+
+    const job = await store.get('test-queue', jobId);
+    expect(job?.status).toBe('active');
+  });
+
+  test('should count jobs', async () => {
+    await store.add('test-queue', { name: 'job1', data: {} });
+    await store.add('test-queue', { name: 'job2', data: {} });
+    const count = await store.count('test-queue');
+    expect(count).toBe(2);
+  });
+
+  test('should clear queue', async () => {
+    await store.add('test-queue', { name: 'job1', data: {} });
+    await store.clear('test-queue');
+    const count = await store.count('test-queue');
+    expect(count).toBe(0);
+  });
+});

package/tests/request/body-parser.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from 'bun:test';
+import { BodyParser } from '../../src/request/body-parser';
+
+describe('BodyParser', () => {
+  test('should parse JSON body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John', age: 30 }),
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John', age: 30 });
+  });
+
+  test('should parse URLEncoded body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: 'name=John&age=30',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John', age: '30' });
+  });
+
+  test('should parse text body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: 'Hello World',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('Hello World');
+  });
+
+  test('should return undefined for empty body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'GET',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should parse JSON as default', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: JSON.stringify({ name: 'John' }),
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John' });
+  });
+
+  test('should fall back to text when JSON parse fails', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: 'plain-text',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('plain-text');
+  });
+
+  test('should respect explicit zero content-length', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Length': '0' },
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should return undefined for HEAD requests', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'HEAD',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should parse text content when content headers missing but body exists', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: 'fallback text',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('fallback text');
+  });
+});
+

package/tests/request/response.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ResponseBuilder } from '../../src/request/response';
+
+describe('ResponseBuilder', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'response-builder-'));
+  });
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should create JSON response', async () => {
+    const response = ResponseBuilder.json({ message: 'Hello' });
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toBe('application/json');
+
+    const data = await response.json();
+    expect(data.message).toBe('Hello');
+  });
+
+  test('should create JSON response with custom status', async () => {
+    const response = ResponseBuilder.json({ error: 'Not Found' }, 404);
+    expect(response.status).toBe(404);
+  });
+
+  test('should create text response', async () => {
+    const response = ResponseBuilder.text('Hello World');
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toBe('text/plain');
+
+    const text = await response.text();
+    expect(text).toBe('Hello World');
+  });
+
+  test('should create HTML response', async () => {
+    const response = ResponseBuilder.html('<h1>Hello</h1>');
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toBe('text/html');
+
+    const html = await response.text();
+    expect(html).toBe('<h1>Hello</h1>');
+  });
+
+  test('should create empty response', () => {
+    const response = ResponseBuilder.empty(204);
+    expect(response.status).toBe(204);
+    expect(response.body).toBeNull();
+  });
+
+  test('should create redirect response', () => {
+    const response = ResponseBuilder.redirect('http://example.com');
+    expect(response.status).toBe(302);
+    expect(response.headers.get('Location')).toBe('http://example.com');
+  });
+
+  test('should create error response', async () => {
+    const response = ResponseBuilder.error('Internal Server Error', 500);
+    expect(response.status).toBe(500);
+
+    const data = await response.json();
+    expect(data.error).toBe('Internal Server Error');
+  });
+
+  test('should create file response from path', async () => {
+    const filePath = join(tmpDir, 'hello.txt');
+    await Bun.write(filePath, 'file-content');
+
+    const response = ResponseBuilder.file(filePath, {
+      fileName: 'download.txt',
+      contentType: 'text/plain',
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Disposition')).toBe('attachment; filename="download.txt"');
+    expect(response.headers.get('Content-Type')).toBe('text/plain');
+    expect(await response.text()).toBe('file-content');
+  });
+
+  test('should create file response from binary source', async () => {
+    const buffer = new TextEncoder().encode('binary-content');
+    const response = ResponseBuilder.file(buffer, {
+      status: 206,
+      headers: { ETag: '123' },
+    });
+
+    expect(response.status).toBe(206);
+    expect(response.headers.get('ETag')).toBe('123');
+    expect(await response.text()).toBe('binary-content');
+  });
+});
+

package/tests/router/decorators.test.ts

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { getRouteMetadata } from '../../src/controller/metadata';
+import { RouteRegistry } from '../../src/router/registry';
+
+describe('Router Decorators', () => {
+  afterEach(() => {
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should record metadata for controller methods', () => {
+    @Controller('/decorator')
+    class DecoratedController {
+      @GET('/list')
+      public list() {
+        return 'ok';
+      }
+    }
+
+    const metadata = getRouteMetadata(DecoratedController.prototype);
+    expect(metadata.length).toBe(1);
+    expect(metadata[0]?.path).toBe('/list');
+    expect(metadata[0]?.method).toBe('GET');
+    expect(typeof metadata[0]?.handler).toBe('function');
+  });
+
+  test('should throw error when registering class without @Controller decorator', () => {
+    // 注意：由于装饰器应用顺序，@GET 装饰器会保存元数据，不会立即报错
+    class PlainHandlers {
+      @GET('/plain')
+      public handler() {
+        return { ok: true };
+      }
+    }
+
+    // 但尝试注册时会报错，因为类没有 @Controller 装饰器
+    const registry = ControllerRegistry.getInstance();
+    expect(() => {
+      registry.register(PlainHandlers);
+    }).toThrow('Controller PlainHandlers must be decorated with @Controller()');
+  });
+});
+

package/tests/router/registry.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+
+describe('RouteRegistry', () => {
+  beforeEach(() => {
+    // 重置单例（在实际使用中，单例会保持状态）
+    // 这里我们只是测试基本功能
+  });
+
+  test('should get singleton instance', () => {
+    const instance1 = RouteRegistry.getInstance();
+    const instance2 = RouteRegistry.getInstance();
+
+    expect(instance1).toBe(instance2);
+  });
+
+  test('should register route', () => {
+    const registry = RouteRegistry.getInstance();
+    const handler = (ctx: Context) => ctx.createResponse({});
+    
+    registry.register('GET', '/api/users', handler);
+
+    const router = registry.getRouter();
+    const route = router.findRoute('GET', '/api/users');
+    expect(route).toBeDefined();
+  });
+
+  test('should register GET route', () => {
+    const registry = RouteRegistry.getInstance();
+    const handler = (ctx: Context) => ctx.createResponse({});
+    
+    registry.get('/api/users', handler);
+
+    const router = registry.getRouter();
+    const route = router.findRoute('GET', '/api/users');
+    expect(route).toBeDefined();
+  });
+
+  test('should register POST route', () => {
+    const registry = RouteRegistry.getInstance();
+    const handler = (ctx: Context) => ctx.createResponse({});
+    
+    registry.post('/api/users', handler);
+
+    const router = registry.getRouter();
+    const route = router.findRoute('POST', '/api/users');
+    expect(route).toBeDefined();
+  });
+});
+