@dangao/bun-server 1.0.1 → 1.1.2

package/tests/controller/path-combination.test.ts

@@ -0,0 +1,207 @@
+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 { GET, POST } from '../../src/router/decorators';
+import { Param } from '../../src/controller/decorators';
+import { RouteRegistry } from '../../src/router/registry';
+import { getTestPort } from '../utils/test-port';
+
+describe('Controller Path Combination', () => {
+  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 correctly combine base path with method path starting with /', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { products: ['product1', 'product2'] };
+      }
+
+      @GET('/:id')
+      public getProduct(@Param('id') id: string) {
+        return { id, name: `Product ${id}` };
+      }
+    }
+
+    app.registerController(ProductController);
+    await app.listen();
+
+    // 应该访问 /api/products，而不是 /
+    const response = await fetch(`http://localhost:${port}/api/products`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.products).toBeDefined();
+
+    // 访问 / 应该返回 404，而不是访问到 listProducts
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+
+  test('should correctly combine base path with empty method path', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('')
+      public listUsers() {
+        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).toBeDefined();
+
+    // 访问 / 应该返回 404
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+
+  test('should correctly combine base path with method path without leading /', async () => {
+    @Controller('/api/orders')
+    class OrderController {
+      @GET('list')
+      public listOrders() {
+        return { orders: ['order1', 'order2'] };
+      }
+    }
+
+    app.registerController(OrderController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/orders/list`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.orders).toBeDefined();
+
+    // 访问 /api/orders 应该返回 404
+    const baseResponse = await fetch(`http://localhost:${port}/api/orders`);
+    expect(baseResponse.status).toBe(404);
+  });
+
+  test('should handle root controller with method path /', async () => {
+    @Controller('')
+    class RootController {
+      @GET('/')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('root');
+  });
+
+  test('should handle root controller with empty method path', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('root');
+  });
+
+  test('should not allow / to match when controller has base path', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { products: ['product1'] };
+      }
+    }
+
+    @Controller('/')
+    class RootController {
+      @GET('/')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(ProductController);
+    app.registerController(RootController);
+    await app.listen();
+
+    // /api/products 应该访问 ProductController
+    const productsResponse = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsResponse.status).toBe(200);
+    const productsData = await productsResponse.json();
+    expect(productsData.products).toBeDefined();
+
+    // / 应该访问 RootController
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(200);
+    const rootData = await rootResponse.json();
+    expect(rootData.message).toBe('root');
+  });
+
+  test('should handle multiple controllers with different base paths', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { source: 'products' };
+      }
+    }
+
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      public listUsers() {
+        return { source: 'users' };
+      }
+    }
+
+    app.registerController(ProductController);
+    app.registerController(UserController);
+    await app.listen();
+
+    // 访问 /api/products 应该返回 products
+    const productsResponse = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsResponse.status).toBe(200);
+    const productsData = await productsResponse.json();
+    expect(productsData.source).toBe('products');
+
+    // 访问 /api/users 应该返回 users
+    const usersResponse = await fetch(`http://localhost:${port}/api/users`);
+    expect(usersResponse.status).toBe(200);
+    const usersData = await usersResponse.json();
+    expect(usersData.source).toBe('users');
+
+    // 访问 / 应该返回 404
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+});
+

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

package/tests/core/context.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'bun:test';
+import { Context } from '../../src/core/context';
+
+describe('Context', () => {
+  test('should create context from request', () => {
+    const request = new Request('http://localhost:3000/api/users?id=1');
+    const context = new Context(request);
+
+    expect(context.request).toBe(request);
+    expect(context.method).toBe('GET');
+    expect(context.path).toBe('/api/users');
+    expect(context.getQuery('id')).toBe('1');
+  });
+
+  test('should get query parameters', () => {
+    const request = new Request('http://localhost:3000/api/users?name=John&age=30');
+    const context = new Context(request);
+
+    expect(context.getQuery('name')).toBe('John');
+    expect(context.getQuery('age')).toBe('30');
+    expect(context.getQuery('unknown')).toBeNull();
+  });
+
+  test('should get all query parameters', () => {
+    const request = new Request('http://localhost:3000/api/users?name=John&age=30');
+    const context = new Context(request);
+
+    const all = context.getQueryAll();
+    expect(all.name).toBe('John');
+    expect(all.age).toBe('30');
+  });
+
+  test('should get and set path parameters', () => {
+    const request = new Request('http://localhost:3000/api/users/123');
+    const context = new Context(request);
+
+    context.params = { id: '123' };
+    expect(context.getParam('id')).toBe('123');
+    expect(context.getParam('unknown')).toBeUndefined();
+  });
+
+  test('should get headers', () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const context = new Context(request);
+
+    expect(context.getHeader('Content-Type')).toBe('application/json');
+    expect(context.getHeader('Unknown')).toBeNull();
+  });
+
+  test('should set response headers', () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    context.setHeader('Content-Type', 'application/json');
+    expect(context.responseHeaders.get('Content-Type')).toBe('application/json');
+  });
+
+  test('should set status code', () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    context.setStatus(404);
+    expect(context.statusCode).toBe(404);
+  });
+
+  test('should create JSON response', () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    const response = context.createResponse({ message: 'Hello' });
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toBe('application/json');
+  });
+
+  test('should create response with custom status', () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+    context.setStatus(404);
+
+    const response = context.createResponse({ error: 'Not Found' });
+    expect(response.status).toBe(404);
+  });
+});
+