@dangao/bun-server 1.0.0 → 1.0.3

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,48 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { Controller } from '../../src/controller/controller';
+import { GET, POST } from '../../src/router/decorators';
+import { getRouteMetadata } from '../../src/controller/metadata';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+
+describe('Router Decorators', () => {
+  afterEach(() => {
+    RouteRegistry.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 register handler immediately when not within controller', async () => {
+    class PlainHandlers {
+      @POST('/plain')
+      public handler(context: Context) {
+        return context.createResponse({ ok: true });
+      }
+    }
+
+    const registry = RouteRegistry.getInstance();
+    const router = registry.getRouter();
+    const request = new Request('http://localhost/plain', { method: 'POST' });
+    const context = new Context(request);
+    const response = await router.handle(context);
+
+    expect(response).toBeDefined();
+    expect(await response?.json()).toEqual({ ok: true });
+  });
+});
+

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();
+  });
+});
+

package/tests/router/route.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test';
+import { Route } from '../../src/router/route';
+import { Context } from '../../src/core/context';
+
+describe('Route', () => {
+  test('should create route', () => {
+    const handler = (ctx: Context) => ctx.createResponse({ message: 'Hello' });
+    const route = new Route('GET', '/api/users', handler);
+
+    expect(route.method).toBe('GET');
+    expect(route.path).toBe('/api/users');
+  });
+
+  test('should match exact path', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    const route = new Route('GET', '/api/users', handler);
+
+    const match = route.match('GET', '/api/users');
+    expect(match.matched).toBe(true);
+    expect(match.params).toEqual({});
+  });
+
+  test('should not match different method', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    const route = new Route('GET', '/api/users', handler);
+
+    const match = route.match('POST', '/api/users');
+    expect(match.matched).toBe(false);
+  });
+
+  test('should not match different path', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    const route = new Route('GET', '/api/users', handler);
+
+    const match = route.match('GET', '/api/posts');
+    expect(match.matched).toBe(false);
+  });
+
+  test('should match path with parameter', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    const route = new Route('GET', '/api/users/:id', handler);
+
+    const match = route.match('GET', '/api/users/123');
+    expect(match.matched).toBe(true);
+    expect(match.params).toEqual({ id: '123' });
+  });
+
+  test('should match path with multiple parameters', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    const route = new Route('GET', '/api/users/:userId/posts/:postId', handler);
+
+    const match = route.match('GET', '/api/users/123/posts/456');
+    expect(match.matched).toBe(true);
+    expect(match.params).toEqual({ userId: '123', postId: '456' });
+  });
+
+  test('should execute handler', async () => {
+    const handler = (ctx: Context) => ctx.createResponse({ message: 'Hello' });
+    const route = new Route('GET', '/api/users', handler);
+
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    const response = await route.execute(context);
+    expect(response.status).toBe(200);
+    
+    const data = await response.json();
+    expect(data.message).toBe('Hello');
+  });
+});
+

package/tests/router/router-normalization.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import { Router } from '../../src/router/router';
+import { Context } from '../../src/core/context';
+
+/**
+ * 测试路由路径规范化行为
+ * 确保带尾部斜杠的路径能正确匹配
+ */
+describe('Router Path Normalization', () => {
+  test('findRoute should normalize path with trailing slash', () => {
+    const router = new Router();
+    const handler = (ctx: Context) => ctx.createResponse({ ok: true });
+    
+    // 注册路由（无尾部斜杠）
+    router.get('/api/users', handler);
+
+    // 使用带尾部斜杠的路径查找应该能匹配
+    const route1 = router.findRoute('GET', '/api/users/');
+    expect(route1).toBeDefined();
+    expect(route1?.path).toBe('/api/users');
+
+    // 使用无尾部斜杠的路径查找应该能匹配
+    const route2 = router.findRoute('GET', '/api/users');
+    expect(route2).toBeDefined();
+    expect(route2?.path).toBe('/api/users');
+
+    // 两者应该返回相同的路由
+    expect(route1).toBe(route2);
+  });
+
+  test('findRoute should normalize root path correctly', () => {
+    const router = new Router();
+    const handler = (ctx: Context) => ctx.createResponse({ ok: true });
+    
+    // 注册根路径
+    router.get('/', handler);
+
+    // 根路径应该始终匹配（无论是否有尾部斜杠）
+    const route1 = router.findRoute('GET', '/');
+    expect(route1).toBeDefined();
+    expect(route1?.path).toBe('/');
+  });
+
+  test('findRoute should use cache for normalized paths', () => {
+    const router = new Router();
+    const handler = (ctx: Context) => ctx.createResponse({ ok: true });
+    
+    router.get('/api/test', handler);
+
+    // 第一次查找（带尾部斜杠）
+    const route1 = router.findRoute('GET', '/api/test/');
+    expect(route1).toBeDefined();
+
+    // 第二次查找（无尾部斜杠）- 应该使用缓存
+    const route2 = router.findRoute('GET', '/api/test');
+    expect(route2).toBeDefined();
+    expect(route2).toBe(route1);
+  });
+
+  test('findRouteWithMatch should normalize path before caching', () => {
+    const router = new Router();
+    const handler = (ctx: Context) => ctx.createResponse({ ok: true });
+    
+    router.get('/api/users', handler);
+
+    // 使用带尾部斜杠的路径
+    const result1 = router.findRouteWithMatch('GET', '/api/users/');
+    expect(result1).toBeDefined();
+    expect(result1?.route.path).toBe('/api/users');
+
+    // 使用无尾部斜杠的路径 - 应该从缓存获取
+    const result2 = router.findRouteWithMatch('GET', '/api/users');
+    expect(result2).toBeDefined();
+    expect(result2?.route.path).toBe('/api/users');
+    
+    // 两者应该返回相同的结果（缓存命中）
+    expect(result1).toBe(result2);
+  });
+
+  test('findRoute should handle dynamic routes with trailing slash', async () => {
+    const router = new Router();
+    const handler = (ctx: Context) => ctx.createResponse({ id: ctx.getParam('id') });
+    
+    router.get('/api/users/:id', handler);
+
+    // 使用带尾部斜杠的路径查找应该能匹配
+    const route1 = router.findRoute('GET', '/api/users/123/');
+    expect(route1).toBeDefined();
+
+    // 使用无尾部斜杠的路径查找应该能匹配
+    const route2 = router.findRoute('GET', '/api/users/123');
+    expect(route2).toBeDefined();
+
+    // 两者应该返回相同的路由
+    expect(route1).toBe(route2);
+
+    // 验证参数提取
+    const context = new Context(new Request('http://localhost:3000/api/users/123/'));
+    const response = await router.handle(context);
+    expect(response).toBeDefined();
+    if (response) {
+      const data = await response.json();
+      expect(data.id).toBe('123');
+    }
+  });
+});

package/tests/router/router.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Router } from '../../src/router/router';
+import { Context } from '../../src/core/context';
+
+describe('Router', () => {
+  let router: Router;
+
+  beforeEach(() => {
+    router = new Router();
+  });
+
+  test('should register route', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    router.register('GET', '/api/users', handler);
+
+    const routes = router.getRoutes();
+    expect(routes.length).toBe(1);
+  });
+
+  test('should register GET route', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    router.get('/api/users', handler);
+
+    const route = router.findRoute('GET', '/api/users');
+    expect(route).toBeDefined();
+  });
+
+  test('should register POST route', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    router.post('/api/users', handler);
+
+    const route = router.findRoute('POST', '/api/users');
+    expect(route).toBeDefined();
+  });
+
+  test('should find route by method and path', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    router.get('/api/users', handler);
+
+    const route = router.findRoute('GET', '/api/users');
+    expect(route).toBeDefined();
+    expect(route?.method).toBe('GET');
+    expect(route?.path).toBe('/api/users');
+  });
+
+  test('should not find non-existent route', () => {
+    const route = router.findRoute('GET', '/api/users');
+    expect(route).toBeUndefined();
+  });
+
+  test('should handle request', async () => {
+    const handler = (ctx: Context) => ctx.createResponse({ message: 'Hello' });
+    router.get('/api/users', handler);
+
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    const response = await router.handle(context);
+    expect(response).toBeDefined();
+    
+    if (response) {
+      const data = await response.json();
+      expect(data.message).toBe('Hello');
+    }
+  });
+
+  test('should return undefined for non-existent route', async () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    const response = await router.handle(context);
+    expect(response).toBeUndefined();
+  });
+
+  test('should extract path parameters', async () => {
+    const handler = (ctx: Context) => {
+      return ctx.createResponse({ id: ctx.getParam('id') });
+    };
+    router.get('/api/users/:id', handler);
+
+    const request = new Request('http://localhost:3000/api/users/123');
+    const context = new Context(request);
+
+    const response = await router.handle(context);
+    expect(response).toBeDefined();
+    
+    if (response) {
+      const data = await response.json();
+      expect(data.id).toBe('123');
+    }
+  });
+
+  test('should handle multiple routes', () => {
+    const handler1 = (ctx: Context) => ctx.createResponse({});
+    const handler2 = (ctx: Context) => ctx.createResponse({});
+    
+    router.get('/api/users', handler1);
+    router.post('/api/users', handler2);
+
+    const getRoute = router.findRoute('GET', '/api/users');
+    const postRoute = router.findRoute('POST', '/api/users');
+
+    expect(getRoute).toBeDefined();
+    expect(postRoute).toBeDefined();
+    expect(getRoute?.method).toBe('GET');
+    expect(postRoute?.method).toBe('POST');
+  });
+
+  test('should cache static routes for faster lookup', () => {
+    const handler = (ctx: Context) => ctx.createResponse({});
+    router.get('/static/path', handler);
+
+    const internalMap = (router as unknown as { staticRoutes: Map<string, unknown> }).staticRoutes;
+    expect(internalMap.size).toBe(1);
+    expect(router.findRoute('GET', '/static/path')).toBeDefined();
+
+    // dynamic route should still work via fallback iteration
+    router.get('/api/items/:id', handler);
+    expect(router.findRoute('GET', '/api/items/1')).toBeDefined();
+  });
+
+  test('should clear registered routes and caches', () => {
+    router.get('/cache/test', (ctx: Context) => ctx.createResponse({}));
+    expect(router.getRoutes().length).toBe(1);
+
+    router.clear();
+    expect(router.getRoutes().length).toBe(0);
+    const internalMap = (router as unknown as { staticRoutes: Map<string, unknown> }).staticRoutes;
+    expect(internalMap.size).toBe(0);
+    expect(router.findRoute('GET', '/cache/test')).toBeUndefined();
+  });
+});
+

package/tests/security/access-decision-manager.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { RoleBasedAccessDecisionManager } from '../../src/security/access-decision-manager';
+import type { Authentication } from '../../src/security/types';
+
+describe('RoleBasedAccessDecisionManager', () => {
+  let manager: RoleBasedAccessDecisionManager;
+
+  beforeEach(() => {
+    manager = new RoleBasedAccessDecisionManager();
+  });
+
+  test('should allow access when no roles required', () => {
+    const authentication: Authentication = {
+      authenticated: true,
+      principal: { id: 'user-1', username: 'test', roles: [] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: [],
+    };
+
+    const result = manager.decide(authentication, []);
+    expect(result).toBe(true);
+  });
+
+  test('should deny access when not authenticated', () => {
+    const authentication: Authentication = {
+      authenticated: false,
+      principal: { id: 'user-1', username: 'test', roles: [] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: [],
+    };
+
+    const result = manager.decide(authentication, ['admin']);
+    expect(result).toBe(false);
+  });
+
+  test('should allow access when user has required role', () => {
+    const authentication: Authentication = {
+      authenticated: true,
+      principal: { id: 'user-1', username: 'test', roles: ['admin'] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: ['admin'],
+    };
+
+    const result = manager.decide(authentication, ['admin']);
+    expect(result).toBe(true);
+  });
+
+  test('should allow access when user has one of required roles', () => {
+    const authentication: Authentication = {
+      authenticated: true,
+      principal: { id: 'user-1', username: 'test', roles: ['user'] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: ['user'],
+    };
+
+    const result = manager.decide(authentication, ['admin', 'user']);
+    expect(result).toBe(true);
+  });
+
+  test('should deny access when user does not have required role', () => {
+    const authentication: Authentication = {
+      authenticated: true,
+      principal: { id: 'user-1', username: 'test', roles: ['user'] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: ['user'],
+    };
+
+    const result = manager.decide(authentication, ['admin']);
+    expect(result).toBe(false);
+  });
+
+  test('should handle empty authorities', () => {
+    const authentication: Authentication = {
+      authenticated: true,
+      principal: { id: 'user-1', username: 'test', roles: [] },
+      credentials: { type: 'jwt', data: 'token' },
+      authorities: [],
+    };
+
+    const result = manager.decide(authentication, ['admin']);
+    expect(result).toBe(false);
+  });
+});
+

package/tests/security/authentication-manager.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { AuthenticationManager } from '../../src/security/authentication-manager';
+import { JwtAuthenticationProvider } from '../../src/security/providers/jwt-provider';
+import { JWTUtil } from '../../src/auth/jwt';
+
+describe('AuthenticationManager', () => {
+  let manager: AuthenticationManager;
+  let jwtUtil: JWTUtil;
+  let jwtProvider: JwtAuthenticationProvider;
+
+  beforeEach((done) => {
+    manager = new AuthenticationManager();
+    jwtUtil = new JWTUtil({
+      secret: 'test-secret-key',
+      accessTokenExpiresIn: 3600,
+    });
+    jwtProvider = new JwtAuthenticationProvider(jwtUtil);
+    done();
+  });
+
+  test('should register provider', (done) => {
+    manager.registerProvider(jwtProvider);
+    const providers = manager.getProviders();
+    expect(providers.length).toBe(1);
+    expect(providers[0]).toBe(jwtProvider);
+    done();
+  });
+
+  test('should register multiple providers', (done) => {
+    const provider2 = new JwtAuthenticationProvider(jwtUtil);
+    manager.registerProvider(jwtProvider);
+    manager.registerProvider(provider2);
+    expect(manager.getProviders().length).toBe(2);
+    done();
+  });
+
+  test('should authenticate with registered provider', async (done) => {
+    manager.registerProvider(jwtProvider);
+    const token = jwtUtil.generateAccessToken({
+      sub: 'user-1',
+      username: 'testuser',
+      roles: ['user'],
+    });
+
+    const authentication = await manager.authenticate({
+      principal: '',
+      credentials: token,
+      type: 'jwt',
+    });
+
+    expect(authentication).not.toBeNull();
+    expect(authentication?.authenticated).toBe(true);
+    done();
+  });
+
+  test('should throw error for unsupported type', async (done) => {
+    manager.registerProvider(jwtProvider);
+
+    await expect(
+      manager.authenticate({
+        principal: '',
+        credentials: 'token',
+        type: 'unsupported',
+      }),
+    ).rejects.toThrow('No authentication provider found for type: unsupported');
+    done();
+  });
+
+  test('should use default type when not specified', async (done) => {
+    manager.registerProvider(jwtProvider);
+
+    await expect(
+      manager.authenticate({
+        principal: '',
+        credentials: 'token',
+      }),
+    ).rejects.toThrow('No authentication provider found for type: default');
+    done();
+  });
+});
+