@dangao/bun-server 1.0.0 → 1.0.3

package/tests/swagger/swagger-extension.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test';
+import { SwaggerExtension } from '../../src/swagger/swagger-extension';
+import { Container } from '../../src/di/container';
+
+describe('SwaggerExtension', () => {
+  test('should create extension with options', () => {
+    const extension = new SwaggerExtension({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    expect(extension).toBeDefined();
+  });
+
+  test('should register extension', () => {
+    const container = new Container();
+    const extension = new SwaggerExtension({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    expect(() => extension.register(container)).not.toThrow();
+  });
+
+  test('should get generator', () => {
+    const extension = new SwaggerExtension({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    const generator = extension.getGenerator();
+    expect(generator).toBeDefined();
+  });
+
+  test('should generate JSON', () => {
+    const extension = new SwaggerExtension({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    const json = extension.generateJSON();
+    expect(json).toBeDefined();
+    expect(() => JSON.parse(json)).not.toThrow();
+
+    const document = JSON.parse(json);
+    expect(document.openapi).toBe('3.0.0');
+    expect(document.info.title).toBe('Test API');
+  });
+
+  test('should create generator on first access', () => {
+    const extension = new SwaggerExtension({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    // 访问两次应该返回同一个实例
+    const generator1 = extension.getGenerator();
+    const generator2 = extension.getGenerator();
+    expect(generator1).toBe(generator2);
+  });
+});
+

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

@@ -0,0 +1,79 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { SwaggerModule } from '../../src/swagger/swagger-module';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import 'reflect-metadata';
+
+describe('SwaggerModule', () => {
+  beforeEach(() => {
+    // 清除模块元数据
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, SwaggerModule);
+  });
+
+  test('should create module with forRoot', () => {
+    const module = SwaggerModule.forRoot({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    expect(module).toBe(SwaggerModule);
+  });
+
+  test('should register extensions and middlewares', () => {
+    SwaggerModule.forRoot({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+      enableUI: true,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SwaggerModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions).toBeDefined();
+    expect(metadata.extensions.length).toBeGreaterThan(0);
+    expect(metadata.middlewares).toBeDefined();
+    expect(metadata.middlewares.length).toBeGreaterThan(0);
+  });
+
+  test('should not register UI middleware when disabled', () => {
+    SwaggerModule.forRoot({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+      enableUI: false,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SwaggerModule);
+    expect(metadata.middlewares.length).toBe(0);
+  });
+
+  test('should use custom UI path', () => {
+    SwaggerModule.forRoot({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+      uiPath: '/api-docs',
+      jsonPath: '/api-docs.json',
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SwaggerModule);
+    expect(metadata).toBeDefined();
+  });
+
+  test('should use default paths when not specified', () => {
+    SwaggerModule.forRoot({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SwaggerModule);
+    expect(metadata).toBeDefined();
+  });
+});
+

package/tests/utils/test-port.ts

@@ -0,0 +1,10 @@
+/**
+ * 获取测试专用端口
+ * 使用随机高位端口，降低并行测试的端口冲突概率
+ * @returns 不同测试之间不冲突的端口号
+ */
+export function getTestPort(): number {
+  // 选择 30000-59999 之间的随机端口，避免常用端口冲突
+  return 30000 + Math.floor(Math.random() * 30000);
+}
+

package/tests/validation/controller-validation.test.ts

@@ -0,0 +1,64 @@
+import 'reflect-metadata';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { Query } from '../../src/controller/decorators';
+import { Validate, IsEmail, IsString, MinLength } from '../../src/validation';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+
+describe('Controller Validation Integration', () => {
+  beforeEach(() => {
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  afterEach(() => {
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should accept valid input', async () => {
+    @Controller('/api/validation')
+    class ValidationController {
+      @GET('/email')
+      public getUser(@Query('email') @Validate(IsEmail()) email: string) {
+        return { email };
+      }
+    }
+
+    ControllerRegistry.getInstance().register(ValidationController);
+
+    const router = RouteRegistry.getInstance().getRouter();
+    const context = new Context(
+      new Request('http://localhost/api/validation/email?email=test@example.com'),
+    );
+    const response = await router.handle(context);
+    expect(response?.status).toBe(200);
+    const data = await response?.json();
+    expect(data).toEqual({ email: 'test@example.com' });
+  });
+
+  test('should reject invalid input with 400', async () => {
+    @Controller('/api/validation')
+    class ValidationController {
+      @GET('/name')
+      public getUser(@Query('name') @Validate(IsString(), MinLength(1)) name: string) {
+        return { name };
+      }
+    }
+
+    ControllerRegistry.getInstance().register(ValidationController);
+
+    const router = RouteRegistry.getInstance().getRouter();
+    const context = new Context(new Request('http://localhost/api/validation/name?name='));
+    const response = await router.handle(context);
+    expect(response?.status).toBe(400);
+    const data = await response?.json();
+    expect(data.error).toBe('Validation failed');
+    expect(data.issues.length).toBeGreaterThan(0);
+  });
+});
+
+

package/tests/validation/validation.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  Validate,
+  IsString,
+  IsEmail,
+  IsOptional,
+  getValidationMetadata,
+  validateParameters,
+  ValidationError,
+} from '../../src/validation';
+
+class TestClass {
+  public method(@Validate(IsString()) value: unknown): void {
+    void value;
+  }
+}
+
+describe('Validation Decorators', () => {
+  test('should store validation metadata', () => {
+    const metadata = getValidationMetadata(TestClass.prototype, 'method');
+    expect(metadata.length).toBe(1);
+    expect(metadata[0].index).toBe(0);
+    expect(metadata[0].rules[0].name).toBe('isString');
+  });
+
+  test('validateParameters should throw ValidationError on failure', () => {
+    const metadata = [
+      { index: 0, rules: [IsEmail()] },
+      { index: 1, rules: [IsOptional(), IsString()] },
+    ];
+
+    expect(() => validateParameters(['not-email', undefined], metadata)).toThrow(ValidationError);
+  });
+
+  test('validateParameters should allow optional values', () => {
+    const metadata = [{ index: 0, rules: [IsOptional(), IsString()] }];
+    expect(() => validateParameters([undefined], metadata)).not.toThrow();
+  });
+});
+
+

package/tests/websocket/gateway.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import type { ServerWebSocket } from 'bun';
+
+import { WebSocketGateway, OnOpen, OnMessage, OnClose } from '../../src/websocket/decorators';
+import { WebSocketGatewayRegistry } from '../../src/websocket/registry';
+import { ControllerRegistry } from '../../src/controller/controller';
+import type { WebSocketConnectionData } from '../../src/websocket/registry';
+
+function createFakeSocket(path: string): ServerWebSocket<WebSocketConnectionData> {
+  return {
+    data: { path },
+    send() {},
+    close() {},
+  } as unknown as ServerWebSocket<WebSocketConnectionData>;
+}
+
+describe('WebSocketGatewayRegistry', () => {
+  const registry = WebSocketGatewayRegistry.getInstance();
+
+  beforeEach(() => {
+    registry.clear();
+    ControllerRegistry.getInstance().clear();
+    TestGateway.events = [];
+  });
+
+  afterEach(() => {
+    registry.clear();
+    ControllerRegistry.getInstance().clear();
+    TestGateway.events = [];
+  });
+
+  @WebSocketGateway('/ws/test')
+  class TestGateway {
+    public static events: string[] = [];
+
+    @OnOpen
+    public handleOpen(): void {
+      TestGateway.events.push('open');
+    }
+
+    @OnMessage
+    public handleMessage(
+      _ws: ServerWebSocket<WebSocketConnectionData>,
+      message: unknown,
+    ): void {
+      TestGateway.events.push(`message:${message}`);
+    }
+
+    @OnClose
+    public handleClose(_ws: ServerWebSocket<WebSocketConnectionData>): void {
+      TestGateway.events.push('close');
+    }
+  }
+
+  test('should register gateway and handle events', () => {
+    registry.register(TestGateway);
+
+    const ws = createFakeSocket('/ws/test');
+    registry.handleOpen(ws);
+    registry.handleMessage(ws, 'hello');
+    registry.handleClose(ws, 1000, 'normal');
+
+    expect(registry.hasGateway('/ws/test')).toBe(true);
+    expect(TestGateway.events).toEqual(['open', 'message:hello', 'close']);
+  });
+});
+
+