@dangao/bun-server 1.0.1 → 1.0.3

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

@@ -0,0 +1,307 @@
+import { describe, expect, test, beforeEach } 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 {
+  SessionModule,
+  SessionService,
+  SESSION_SERVICE_TOKEN,
+  MemorySessionStore,
+  type SessionModuleOptions,
+} from '../../src/session';
+
+describe('SessionModule', () => {
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, SessionModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  test('should register session service provider', () => {
+    SessionModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const sessionProvider = metadata.providers.find(
+      (provider: any) => provider.provide === SESSION_SERVICE_TOKEN,
+    );
+    expect(sessionProvider).toBeDefined();
+    expect(sessionProvider.useValue).toBeInstanceOf(SessionService);
+  });
+
+  test('should use custom store when provided', () => {
+    const customStore = new MemorySessionStore();
+    SessionModule.forRoot({
+      store: customStore,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule);
+    const sessionProvider = metadata.providers.find(
+      (provider: any) => provider.provide === SESSION_SERVICE_TOKEN,
+    );
+    expect(sessionProvider).toBeDefined();
+  });
+
+  test('should configure session options', () => {
+    SessionModule.forRoot({
+      name: 'custom-session',
+      maxAge: 7200000,
+      rolling: false,
+      cookie: {
+        secure: true,
+        httpOnly: true,
+        path: '/api',
+      },
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule);
+    expect(metadata).toBeDefined();
+  });
+});
+
+describe('SessionService', () => {
+  let service: SessionService;
+  let store: MemorySessionStore;
+
+  beforeEach(() => {
+    store = new MemorySessionStore();
+    service = new SessionService({
+      store,
+      name: 'sessionId',
+      maxAge: 86400000,
+      rolling: true,
+      cookie: {
+        secure: false,
+        httpOnly: true,
+        path: '/',
+        sameSite: 'lax',
+      },
+    });
+  });
+
+  test('should create new session', async () => {
+    const session = await service.create({ userId: '123' });
+    expect(session).toBeDefined();
+    expect(session.id).toBeDefined();
+    expect(session.data.userId).toBe('123');
+    expect(session.createdAt).toBeGreaterThan(0);
+    expect(session.lastAccessedAt).toBeGreaterThan(0);
+    expect(session.expiresAt).toBeGreaterThan(Date.now());
+  });
+
+  test('should get session by id', async () => {
+    const session = await service.create({ userId: '123' });
+    const retrieved = await service.get(session.id);
+    expect(retrieved).toBeDefined();
+    expect(retrieved?.id).toBe(session.id);
+    expect(retrieved?.data.userId).toBe('123');
+  });
+
+  test('should return undefined for non-existent session', async () => {
+    const session = await service.get('non-existent-id');
+    expect(session).toBeUndefined();
+  });
+
+  test('should update session data', async () => {
+    const session = await service.create({ userId: '123' });
+    const updated = await service.set(session.id, { userId: '456', role: 'admin' });
+    expect(updated).toBe(true);
+
+    const retrieved = await service.get(session.id);
+    expect(retrieved?.data.userId).toBe('456');
+    expect(retrieved?.data.role).toBe('admin');
+  });
+
+  test('should get session value', async () => {
+    const session = await service.create({ userId: '123', role: 'admin' });
+    const userId = await service.getValue<string>(session.id, 'userId');
+    expect(userId).toBe('123');
+  });
+
+  test('should set session value', async () => {
+    const session = await service.create({ userId: '123' });
+    const set = await service.setValue(session.id, 'role', 'admin');
+    expect(set).toBe(true);
+
+    const role = await service.getValue<string>(session.id, 'role');
+    expect(role).toBe('admin');
+  });
+
+  test('should delete session value', async () => {
+    const session = await service.create({ userId: '123', role: 'admin' });
+    const deleted = await service.deleteValue(session.id, 'role');
+    expect(deleted).toBe(true);
+
+    const role = await service.getValue(session.id, 'role');
+    expect(role).toBeUndefined();
+    const userId = await service.getValue(session.id, 'userId');
+    expect(userId).toBe('123');
+  });
+
+  test('should delete session', async () => {
+    const session = await service.create({ userId: '123' });
+    const deleted = await service.delete(session.id);
+    expect(deleted).toBe(true);
+
+    const retrieved = await service.get(session.id);
+    expect(retrieved).toBeUndefined();
+  });
+
+  test('should touch session to update lastAccessedAt', async () => {
+    const session = await service.create({ userId: '123' });
+    const originalTime = session.lastAccessedAt;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const touched = await service.touch(session.id);
+    expect(touched).toBe(true);
+
+    const retrieved = await service.get(session.id);
+    expect(retrieved?.lastAccessedAt).toBeGreaterThan(originalTime);
+  });
+
+  test('should get cookie name and options', () => {
+    const cookieName = service.getCookieName();
+    expect(cookieName).toBe('sessionId');
+
+    const cookieOptions = service.getCookieOptions();
+    expect(cookieOptions).toBeDefined();
+    expect(cookieOptions.httpOnly).toBe(true);
+    expect(cookieOptions.path).toBe('/');
+  });
+
+  test('should respect maxAge', async () => {
+    const shortLivedService = new SessionService({
+      store,
+      name: 'sessionId',
+      maxAge: 100,
+      rolling: false,
+      cookie: {},
+    });
+
+    const session = await shortLivedService.create({ userId: '123' });
+    expect(session.expiresAt).toBeLessThanOrEqual(Date.now() + 100);
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const retrieved = await shortLivedService.get(session.id);
+    expect(retrieved).toBeUndefined();
+  });
+});
+
+describe('MemorySessionStore', () => {
+  let store: MemorySessionStore;
+
+  beforeEach(() => {
+    store = new MemorySessionStore();
+  });
+
+  test('should store and retrieve session', async () => {
+    const session = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+
+    await store.set(session, 86400000);
+    const retrieved = await store.get('session-1');
+    expect(retrieved).toBeDefined();
+    expect(retrieved?.id).toBe('session-1');
+    expect(retrieved?.data.userId).toBe('123');
+  });
+
+  test('should expire sessions after maxAge', async () => {
+    const session = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 100,
+    };
+
+    await store.set(session, 100);
+    expect(await store.get('session-1')).toBeDefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const retrieved = await store.get('session-1');
+    expect(retrieved).toBeUndefined();
+  });
+
+  test('should check if session exists', async () => {
+    const session = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+
+    await store.set(session, 86400000);
+    expect(await store.has('session-1')).toBe(true);
+    expect(await store.has('non-existent')).toBe(false);
+  });
+
+  test('should touch session', async () => {
+    const session = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+
+    await store.set(session, 86400000);
+    const originalTime = session.lastAccessedAt;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const touched = await store.touch('session-1');
+    expect(touched).toBe(true);
+
+    const retrieved = await store.get('session-1');
+    expect(retrieved?.lastAccessedAt).toBeGreaterThan(originalTime);
+  });
+
+  test('should delete session', async () => {
+    const session = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+
+    await store.set(session, 86400000);
+    const deleted = await store.delete('session-1');
+    expect(deleted).toBe(true);
+    expect(await store.has('session-1')).toBe(false);
+  });
+
+  test('should clear all sessions', async () => {
+    const session1 = {
+      id: 'session-1',
+      data: { userId: '123' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+    const session2 = {
+      id: 'session-2',
+      data: { userId: '456' },
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now(),
+      expiresAt: Date.now() + 86400000,
+    };
+
+    await store.set(session1, 86400000);
+    await store.set(session2, 86400000);
+    await store.clear();
+    expect(await store.has('session-1')).toBe(false);
+    expect(await store.has('session-2')).toBe(false);
+  });
+});

package/tests/stress/di-stress.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test';
+
+import { StressTester } from '../../src/testing/harness';
+import { Container } from '../../src/di/container';
+import { Injectable } from '../../src/di/decorators';
+
+describe('DI Stress', () => {
+  test('should resolve services under concurrent stress', async () => {
+    const container = new Container();
+
+    @Injectable()
+    class HeavyService {
+      public readonly createdAt = Date.now();
+      public getValue() {
+        return 'heavy';
+      }
+    }
+
+    container.register(HeavyService);
+
+    const result = await StressTester.run('di:resolve', 60, 6, async () => {
+      const service = container.resolve(HeavyService);
+      expect(service.getValue()).toBe('heavy');
+    });
+
+    expect(result.errors).toBe(0);
+    expect(result.iterations).toBe(60);
+  });
+});
+

package/tests/swagger/decorators.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from 'bun:test';
+import 'reflect-metadata';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiParam,
+  ApiBody,
+  ApiResponse,
+  getApiTags,
+  getApiOperation,
+  getApiParams,
+  getApiBody,
+  getApiResponses,
+} from '../../src/swagger/decorators';
+
+describe('Swagger Decorators', () => {
+  describe('ApiTags', () => {
+    test('should set tags on class', () => {
+      @ApiTags('Users', 'Admin')
+      class UserController {}
+
+      const tags = getApiTags(UserController);
+      expect(tags).toEqual(['Users', 'Admin']);
+    });
+
+    test('should set tags on method', () => {
+      class UserController {
+        @ApiTags('Public')
+        public getUsers() {}
+      }
+
+      const tags = getApiTags(UserController.prototype, 'getUsers');
+      expect(tags).toEqual(['Public']);
+    });
+
+    test('should merge tags on method', () => {
+      class UserController {
+        @ApiTags('Users')
+        @ApiTags('Admin')
+        public getUsers() {}
+      }
+
+      const tags = getApiTags(UserController.prototype, 'getUsers');
+      // 顺序可能不同，但应该包含两个标签
+      expect(tags).toContain('Users');
+      expect(tags).toContain('Admin');
+      expect(tags.length).toBe(2);
+    });
+  });
+
+  describe('ApiOperation', () => {
+    test('should set operation metadata', () => {
+      class UserController {
+        @ApiOperation({ summary: 'Get users', description: 'Get all users' })
+        public getUsers() {}
+      }
+
+      const operation = getApiOperation(UserController.prototype, 'getUsers');
+      expect(operation).toBeDefined();
+      expect(operation?.summary).toBe('Get users');
+      expect(operation?.description).toBe('Get all users');
+    });
+  });
+
+  describe('ApiParam', () => {
+    test('should set param metadata', () => {
+      class UserController {
+        public getUser(
+          @ApiParam({ name: 'id', description: 'User ID', required: true })
+          id: string,
+        ) {}
+      }
+
+      const params = getApiParams(UserController.prototype, 'getUser');
+      expect(params).toBeDefined();
+      expect(params.length).toBe(1);
+      expect(params[0].metadata.name).toBe('id');
+      expect(params[0].metadata.description).toBe('User ID');
+      expect(params[0].metadata.required).toBe(true);
+    });
+
+    test('should handle multiple params', () => {
+      class UserController {
+        public getUserPost(
+          @ApiParam({ name: 'id', description: 'User ID' })
+          id: string,
+          @ApiParam({ name: 'postId', description: 'Post ID' })
+          postId: string,
+        ) {}
+      }
+
+      const params = getApiParams(UserController.prototype, 'getUserPost');
+      expect(params.length).toBe(2);
+      // 参数顺序可能不同，但应该包含两个参数
+      const paramNames = params.map((p) => p.metadata.name);
+      expect(paramNames).toContain('id');
+      expect(paramNames).toContain('postId');
+    });
+  });
+
+  describe('ApiBody', () => {
+    test('should set body metadata', () => {
+      class UserController {
+        @ApiBody({
+          description: 'User data',
+          schema: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+            },
+          },
+        })
+        public createUser() {}
+      }
+
+      const body = getApiBody(UserController.prototype, 'createUser');
+      expect(body).toBeDefined();
+      expect(body?.description).toBe('User data');
+      expect(body?.schema).toBeDefined();
+    });
+  });
+
+  describe('ApiResponse', () => {
+    test('should set response metadata', () => {
+      class UserController {
+        @ApiResponse({ status: 200, description: 'Success' })
+        public getUsers() {}
+      }
+
+      const responses = getApiResponses(UserController.prototype, 'getUsers');
+      expect(responses).toBeDefined();
+      expect(responses.length).toBe(1);
+      expect(responses[0].status).toBe(200);
+      expect(responses[0].description).toBe('Success');
+    });
+
+    test('should handle multiple responses', () => {
+      class UserController {
+        @ApiResponse({ status: 200, description: 'Success' })
+        @ApiResponse({ status: 404, description: 'Not found' })
+        public getUser() {}
+      }
+
+      const responses = getApiResponses(UserController.prototype, 'getUser');
+      expect(responses.length).toBe(2);
+      // 响应顺序可能不同，但应该包含两个响应
+      const statuses = responses.map((r) => r.status);
+      expect(statuses).toContain(200);
+      expect(statuses).toContain(404);
+    });
+  });
+});
+

package/tests/swagger/generator.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { SwaggerGenerator } from '../../src/swagger/generator';
+import { Controller } from '../../src/controller';
+import { GET, POST } from '../../src/router/decorators';
+import { Body, Param, Query } from '../../src/controller/decorators';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiParam,
+  ApiBody,
+  ApiResponse,
+} from '../../src/swagger/decorators';
+import { ControllerRegistry } from '../../src/controller/controller';
+import { RouteRegistry } from '../../src/router/registry';
+
+describe('SwaggerGenerator', () => {
+  let generator: SwaggerGenerator;
+
+  beforeEach(() => {
+    generator = new SwaggerGenerator({
+      info: {
+        title: 'Test API',
+        version: '1.0.0',
+      },
+    });
+    ControllerRegistry.getInstance().clear();
+    RouteRegistry.getInstance().clear();
+  });
+
+  afterEach(() => {
+    ControllerRegistry.getInstance().clear();
+    RouteRegistry.getInstance().clear();
+  });
+
+  test('should generate basic swagger document', () => {
+    const document = generator.generate();
+
+    expect(document.openapi).toBe('3.0.0');
+    expect(document.info.title).toBe('Test API');
+    expect(document.info.version).toBe('1.0.0');
+    expect(document.paths).toBeDefined();
+  });
+
+  test('should generate paths from controllers', () => {
+    @Controller('/api/users')
+    @ApiTags('Users')
+    class UserController {
+      @GET('/')
+      @ApiOperation({ summary: 'Get all users' })
+      public getAllUsers() {
+        return [];
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    expect(document.paths).toBeDefined();
+    expect(document.paths['/api/users']).toBeDefined();
+    expect(document.paths['/api/users'].get).toBeDefined();
+    expect(document.paths['/api/users'].get?.summary).toBe('Get all users');
+  });
+
+  test('should include controller tags in path items', () => {
+    @Controller('/api/users')
+    @ApiTags('Users')
+    class UserController {
+      @GET('/')
+      public getAllUsers() {
+        return [];
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    const path = document.paths['/api/users'];
+    expect(path).toBeDefined();
+    expect(path.get?.tags).toBeDefined();
+    expect(path.get?.tags).toContain('Users');
+  });
+
+  test('should include path parameters', () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id')
+      @ApiParam({ name: 'id', description: 'User ID', required: true })
+      public getUser(@Param('id') id: string) {
+        return { id };
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    const path = document.paths['/api/users/{id}'];
+    expect(path).toBeDefined();
+    expect(path.get?.parameters).toBeDefined();
+    const param = path.get?.parameters?.find((p) => p.name === 'id');
+    expect(param).toBeDefined();
+    expect(param?.required).toBe(true);
+  });
+
+  test('should include request body', () => {
+    @Controller('/api/users')
+    class UserController {
+      @POST('/')
+      @ApiBody({
+        description: 'User data',
+        schema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            email: { type: 'string' },
+          },
+        },
+      })
+      public createUser(@Body() data: { name: string; email: string }) {
+        return data;
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    const path = document.paths['/api/users'];
+    expect(path.post?.requestBody).toBeDefined();
+    expect(path.post?.requestBody?.content).toBeDefined();
+  });
+
+  test('should include responses', () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      @ApiResponse({ status: 200, description: 'Success' })
+      @ApiResponse({ status: 404, description: 'Not found' })
+      public getAllUsers() {
+        return [];
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    const path = document.paths['/api/users'];
+    expect(path.get?.responses).toBeDefined();
+    expect(path.get?.responses?.['200']).toBeDefined();
+    expect(path.get?.responses?.['404']).toBeDefined();
+  });
+
+  test('should handle query parameters', () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      public getUsers(@Query('page') page?: number) {
+        return [];
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    const path = document.paths['/api/users'];
+    expect(path.get).toBeDefined();
+  });
+
+  test('should convert path parameters to OpenAPI format', () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id/posts/:postId')
+      public getUserPost(
+        @Param('id') id: string,
+        @Param('postId') postId: string,
+      ) {
+        return { id, postId };
+      }
+    }
+
+    ControllerRegistry.getInstance().register(UserController);
+    const document = generator.generate();
+
+    // 应该转换为 /api/users/{id}/posts/{postId}
+    const pathKey = Object.keys(document.paths).find((key) =>
+      key.includes('{id}'),
+    );
+    expect(pathKey).toBeDefined();
+    expect(pathKey).toContain('{id}');
+    expect(pathKey).toContain('{postId}');
+  });
+
+  test('should handle empty controllers', () => {
+    @Controller('/api/empty')
+    class EmptyController {}
+
+    ControllerRegistry.getInstance().register(EmptyController);
+    const document = generator.generate();
+
+    // 没有路由的控制器不应该生成路径
+    expect(document.paths['/api/empty']).toBeUndefined();
+  });
+});
+