@dangao/bun-server 1.0.0 → 1.0.3

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

@@ -0,0 +1,212 @@
+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 {
+  CacheModule,
+  CacheService,
+  CACHE_SERVICE_TOKEN,
+  MemoryCacheStore,
+  type CacheModuleOptions,
+} from '../../src/cache';
+
+describe('CacheModule', () => {
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, CacheModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  test('should register cache service provider', () => {
+    CacheModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const cacheProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CACHE_SERVICE_TOKEN,
+    );
+    expect(cacheProvider).toBeDefined();
+    expect(cacheProvider.useValue).toBeInstanceOf(CacheService);
+  });
+
+  test('should use custom store when provided', () => {
+    const customStore = new MemoryCacheStore();
+    CacheModule.forRoot({
+      store: customStore,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule);
+    const cacheProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CACHE_SERVICE_TOKEN,
+    );
+    const service = cacheProvider.useValue as CacheService;
+    expect(service).toBeInstanceOf(CacheService);
+  });
+
+  test('should use default TTL when provided', () => {
+    CacheModule.forRoot({
+      defaultTtl: 60000,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule);
+    const cacheProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CACHE_SERVICE_TOKEN,
+    );
+    expect(cacheProvider).toBeDefined();
+  });
+
+  test('should use key prefix when provided', () => {
+    CacheModule.forRoot({
+      keyPrefix: 'app:',
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule);
+    const cacheProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CACHE_SERVICE_TOKEN,
+    );
+    expect(cacheProvider).toBeDefined();
+  });
+});
+
+describe('CacheService', () => {
+  let service: CacheService;
+  let store: MemoryCacheStore;
+
+  beforeEach(() => {
+    store = new MemoryCacheStore();
+    service = new CacheService({
+      store,
+      defaultTtl: 3600000,
+      keyPrefix: '',
+    });
+  });
+
+  test('should get and set cache values', async () => {
+    await service.set('key1', 'value1');
+    const value = await service.get<string>('key1');
+    expect(value).toBe('value1');
+  });
+
+  test('should return undefined for non-existent key', async () => {
+    const value = await service.get('non-existent');
+    expect(value).toBeUndefined();
+  });
+
+  test('should delete cache value', async () => {
+    await service.set('key1', 'value1');
+    await service.delete('key1');
+    const value = await service.get('key1');
+    expect(value).toBeUndefined();
+  });
+
+  test('should check if key exists', async () => {
+    await service.set('key1', 'value1');
+    expect(await service.has('key1')).toBe(true);
+    expect(await service.has('non-existent')).toBe(false);
+  });
+
+  test('should clear all cache', async () => {
+    await service.set('key1', 'value1');
+    await service.set('key2', 'value2');
+    await service.clear();
+    expect(await service.has('key1')).toBe(false);
+    expect(await service.has('key2')).toBe(false);
+  });
+
+  test('should get or set cache value', async () => {
+    const value1 = await service.getOrSet('key1', () => 'computed');
+    expect(value1).toBe('computed');
+
+    const value2 = await service.getOrSet('key1', () => 'should-not-run');
+    expect(value2).toBe('computed');
+  });
+
+  test('should get many cache values', async () => {
+    await service.set('key1', 'value1');
+    await service.set('key2', 'value2');
+    const values = await service.getMany<string>(['key1', 'key2', 'key3']);
+    expect(values.get('key1')).toBe('value1');
+    expect(values.get('key2')).toBe('value2');
+    expect(values.get('key3')).toBeUndefined();
+  });
+
+  test('should set many cache values', async () => {
+    await service.setMany([
+      { key: 'key1', value: 'value1' },
+      { key: 'key2', value: 'value2' },
+    ]);
+    expect(await service.get('key1')).toBe('value1');
+    expect(await service.get('key2')).toBe('value2');
+  });
+
+  test('should delete many cache values', async () => {
+    await service.set('key1', 'value1');
+    await service.set('key2', 'value2');
+    await service.set('key3', 'value3');
+    const deleted = await service.deleteMany(['key1', 'key2']);
+    expect(deleted.length).toBe(2);
+    expect(await service.has('key1')).toBe(false);
+    expect(await service.has('key2')).toBe(false);
+    expect(await service.has('key3')).toBe(true);
+  });
+
+  test('should respect TTL', async () => {
+    await service.set('key1', 'value1', 100);
+    expect(await service.get('key1')).toBe('value1');
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const value = await service.get('key1');
+    expect(value).toBeUndefined();
+  });
+
+  test('should use key prefix', async () => {
+    const prefixedService = new CacheService({
+      store,
+      defaultTtl: 3600000,
+      keyPrefix: 'app:',
+    });
+    await prefixedService.set('key1', 'value1');
+    const value = await prefixedService.get('key1');
+    expect(value).toBe('value1');
+  });
+});
+
+describe('MemoryCacheStore', () => {
+  let store: MemoryCacheStore;
+
+  beforeEach(() => {
+    store = new MemoryCacheStore();
+  });
+
+  test('should store and retrieve values', async () => {
+    await store.set('key1', 'value1');
+    const value = await store.get('key1');
+    expect(value).toBe('value1');
+  });
+
+  test('should expire values after TTL', async () => {
+    await store.set('key1', 'value1', 100);
+    expect(await store.get('key1')).toBe('value1');
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const value = await store.get('key1');
+    expect(value).toBeUndefined();
+  });
+
+  test('should handle getMany and setMany', async () => {
+    await store.setMany([
+      { key: 'key1', value: 'value1' },
+      { key: 'key2', value: 'value2' },
+    ]);
+    const values = await store.getMany(['key1', 'key2', 'key3']);
+    expect(values.get('key1')).toBe('value1');
+    expect(values.get('key2')).toBe('value2');
+    expect(values.get('key3')).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,151 @@
+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 {
+  ConfigModule,
+  ConfigService,
+  CONFIG_SERVICE_TOKEN,
+  type ConfigModuleOptions,
+} from '../../src/config';
+
+describe('ConfigService', () => {
+  test('should get and set values via path', () => {
+    const service = new ConfigService({
+      db: {
+        host: 'localhost',
+        port: 5432,
+      },
+    });
+
+    expect(service.get<string>('db.host')).toBe('localhost');
+    expect(service.get<number>('db.port')).toBe(5432);
+    expect(service.get<string>('db.user', 'root')).toBe('root');
+    expect(service.get<string>('db.password')).toBeUndefined();
+  });
+
+  test('should throw when required value is missing', () => {
+    const service = new ConfigService({});
+
+    expect(() => service.getRequired('missing')).toThrow(
+      'Config value required for key: missing',
+    );
+  });
+
+  test('should support namespace', () => {
+    const service = new ConfigService({
+      logger: {
+        level: 'debug',
+      },
+    });
+
+    const loggerConfig = service.withNamespace('logger');
+    expect(loggerConfig.get<string>('level')).toBe('debug');
+    expect(loggerConfig.get<string>('logger.level')).toBe('debug');
+  });
+});
+
+describe('ConfigModule', () => {
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  test('should register config service provider', () => {
+    const options: ConfigModuleOptions = {
+      defaultConfig: {
+        appName: 'test-app',
+      },
+    };
+
+    ConfigModule.forRoot(options);
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConfigModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const configProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CONFIG_SERVICE_TOKEN,
+    );
+    expect(configProvider).toBeDefined();
+    expect(configProvider.useValue).toBeInstanceOf(ConfigService);
+  });
+
+  test('should merge defaultConfig and env-loaded config', () => {
+    const options: ConfigModuleOptions = {
+      defaultConfig: {
+        appName: 'default-app',
+        port: 3000,
+      },
+      load() {
+        return {
+          appName: 'env-app',
+        };
+      },
+    };
+
+    ConfigModule.forRoot(options);
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConfigModule);
+    const providers = metadata.providers.filter(
+      (p: any) => p.provide === CONFIG_SERVICE_TOKEN,
+    );
+    const service = providers[providers.length - 1].useValue as ConfigService;
+
+    expect(service.get<string>('appName')).toBe('env-app');
+    expect(service.get<number>('port')).toBe(3000);
+  });
+
+  test('should validate config', () => {
+    const options: ConfigModuleOptions = {
+      defaultConfig: {
+        appName: 'test-app',
+      },
+      validate(config) {
+        if (!config.appName) {
+          throw new Error('appName is required');
+        }
+      },
+    };
+
+    expect(() => ConfigModule.forRoot(options)).not.toThrow();
+  });
+
+  test('should throw when validation fails', () => {
+    const options: ConfigModuleOptions = {
+      defaultConfig: {},
+      validate(config) {
+        if (!config.appName) {
+          throw new Error('appName is required');
+        }
+      },
+    };
+
+    expect(() => ConfigModule.forRoot(options)).toThrow(
+      'appName is required',
+    );
+  });
+
+  test('should export config service to parent container', () => {
+    const options: ConfigModuleOptions = {
+      defaultConfig: {
+        appName: 'test-app',
+      },
+    };
+
+    ConfigModule.forRoot(options);
+
+    const rootContainer = new Container();
+    const { ModuleRegistry } = require('../../src/di/module-registry') as typeof import('../../src/di/module-registry');
+    const registry = ModuleRegistry.getInstance();
+    registry.clear();
+    registry.register(ConfigModule, rootContainer);
+
+    const configService = rootContainer.resolve<ConfigService>(CONFIG_SERVICE_TOKEN);
+    expect(configService).toBeInstanceOf(ConfigService);
+    expect(configService.get<string>('appName')).toBe('test-app');
+  });
+});
+
+

package/tests/controller/controller.test.ts

@@ -0,0 +1,189 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { Injectable, Inject } from '../../src/di/decorators';
+import { GET, POST } from '../../src/router/decorators';
+import { Body, Param, Query } from '../../src/controller/decorators';
+import { RouteRegistry } from '../../src/router/registry';
+import { getTestPort } from '../utils/test-port';
+
+describe('Controller Integration', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should register and handle controller with GET route', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      public getUsers() {
+        return { users: ['user1', 'user2'] };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.users).toEqual(['user1', 'user2']);
+  });
+
+  test('should handle controller with path parameter', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id')
+      public getUser(@Param('id') id: string) {
+        return { id, name: `User ${id}` };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/123`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.id).toBe('123');
+    expect(data.name).toBe('User 123');
+  });
+
+  test('should handle controller with query parameter', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/search')
+      public searchUsers(@Query('q') query: string | null) {
+        return { query, results: [`result for ${query}`] };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/search?q=test`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.query).toBe('test');
+  });
+
+  test('should handle controller with POST and body', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @POST('/')
+      public createUser(@Body() user: { name: string; email: string }) {
+        return { id: '1', ...user };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John', email: 'john@example.com' }),
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.id).toBe('1');
+    expect(data.name).toBe('John');
+    expect(data.email).toBe('john@example.com');
+  });
+
+  test('should handle controller with dependency injection', async () => {
+    @Injectable()
+    class UserService {
+      public findUser(id: string) {
+        return { id, name: 'John Doe' };
+      }
+    }
+
+    // 注册服务到容器（在控制器定义之前）
+    const container = app.getContainer();
+    container.register(UserService);
+
+    @Controller('/api/users-di')
+    class UserController {
+      public constructor(@Inject(UserService) private userService: UserService) {}
+
+      @GET('/:id')
+      public getUser(@Param('id') id: string) {
+        return this.userService.findUser(id);
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users-di/123`);
+    if (response.status !== 200) {
+      const errorText = await response.text();
+      console.error('Error response:', errorText);
+    }
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.id).toBe('123');
+    expect(data.name).toBe('John Doe');
+  });
+
+  test('should handle multiple routes in same controller', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      public getUsers() {
+        return { users: ['user1', 'user2'] };
+      }
+
+      @GET('/:id')
+      public getUser(@Param('id') id: string) {
+        return { id, name: `User ${id}` };
+      }
+
+      @POST('/')
+      public createUser(@Body() user: { name: string }) {
+        return { id: '1', ...user };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    // 测试 GET /
+    const listResponse = await fetch(`http://localhost:${port}/api/users`);
+    expect(listResponse.status).toBe(200);
+    const listData = await listResponse.json();
+    expect(listData.users).toEqual(['user1', 'user2']);
+
+    // 测试 GET /:id
+    const getResponse = await fetch(`http://localhost:${port}/api/users/123`);
+    expect(getResponse.status).toBe(200);
+    const getData = await getResponse.json();
+    expect(getData.id).toBe('123');
+
+    // 测试 POST /
+    const postResponse = await fetch(`http://localhost:${port}/api/users`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'New User' }),
+    });
+    expect(postResponse.status).toBe(200);
+    const postData = await postResponse.json();
+    expect(postData.name).toBe('New User');
+  });
+});
+

package/tests/core/application.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { getTestPort } from '../utils/test-port';
+
+describe('Application', () => {
+  let app: Application;
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+  });
+
+  test('should create application instance', () => {
+    app = new Application();
+    expect(app).toBeInstanceOf(Application);
+  });
+
+  test('should create application with options', () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    expect(app).toBeInstanceOf(Application);
+  });
+
+  test('should start server', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    await app.listen();
+    
+    const server = app.getServer();
+    expect(server).toBeDefined();
+    expect(server?.isRunning()).toBe(true);
+  });
+
+  test('should stop server', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    await app.listen();
+    await app.stop();
+    
+    const server = app.getServer();
+    expect(server?.isRunning()).toBe(false);
+  });
+
+  test('should handle request with 404 by default', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    await app.listen();
+    
+    const response = await fetch(`http://localhost:${port}/api/users`);
+    expect(response.status).toBe(404);
+    
+    const data = await response.json();
+    expect(data.error).toBe('Not Found');
+  });
+});
+

package/tests/core/context-body.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test';
+import { Context } from '../../src/core/context';
+
+describe('Context Body Parsing', () => {
+  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 context = new Context(request);
+    const body = await context.getBody();
+
+    expect(body).toEqual({ name: 'John', age: 30 });
+    expect(context.body).toEqual({ name: 'John', age: 30 });
+  });
+
+  test('should parse body only once', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John' }),
+    });
+
+    const context = new Context(request);
+    const body1 = await context.getBody();
+    const body2 = await context.getBody();
+
+    expect(body1).toEqual(body2);
+  });
+
+  test('should return undefined for GET request', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'GET',
+    });
+
+    const context = new Context(request);
+    const body = await context.getBody();
+
+    expect(body).toBeUndefined();
+  });
+});
+