@dangao/bun-server 1.7.0 → 1.7.1

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

@@ -203,5 +203,358 @@ describe('Controller Path Combination', () => {
     const rootResponse = await fetch(`http://localhost:${port}/`);
     expect(rootResponse.status).toBe(404);
   });
+
+  test('should correctly combine root controller "/" with method path "/health"', async () => {
+    // 这是 metrics-rate-limit-app.ts 示例中的场景
+    // @Controller('/') + @GET('/health') 应该映射到 /health，而不是 //health
+    @Controller('/')
+    class HealthController {
+      @GET('/health')
+      public health() {
+        return { status: 'ok' };
+      }
+
+      @GET('/')
+      public index() {
+        return { message: 'index' };
+      }
+    }
+
+    app.registerController(HealthController);
+    await app.listen();
+
+    // /health 应该正常访问（修复前会得到 404，因为注册的路径是 //health）
+    const healthResponse = await fetch(`http://localhost:${port}/health`);
+    expect(healthResponse.status).toBe(200);
+    const healthData = await healthResponse.json();
+    expect(healthData.status).toBe('ok');
+
+    // / 应该正常访问
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(200);
+    const rootData = await rootResponse.json();
+    expect(rootData.message).toBe('index');
+
+    // //health 不应该被访问到（或者应该重定向/返回 404）
+    // 注：大多数 HTTP 服务器会规范化 //health 为 /health，所以这里可能返回 200
+  });
+
+  test('should correctly combine root controller "/" with multiple method paths', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('/api/status')
+      public status() {
+        return { status: 'running' };
+      }
+
+      @GET('/api/info')
+      public info() {
+        return { info: 'test' };
+      }
+
+      @POST('/api/data')
+      public data() {
+        return { received: true };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    // 所有路径都应该正常工作
+    const statusResponse = await fetch(`http://localhost:${port}/api/status`);
+    expect(statusResponse.status).toBe(200);
+    expect((await statusResponse.json()).status).toBe('running');
+
+    const infoResponse = await fetch(`http://localhost:${port}/api/info`);
+    expect(infoResponse.status).toBe(200);
+    expect((await infoResponse.json()).info).toBe('test');
+
+    const dataResponse = await fetch(`http://localhost:${port}/api/data`, {
+      method: 'POST',
+    });
+    expect(dataResponse.status).toBe(200);
+    expect((await dataResponse.json()).received).toBe(true);
+  });
+});
+
+/**
+ * 路径规范化测试
+ * 根据图片中的测试矩阵，验证各种路径组合是否都能正确映射到 /api/base
+ *
+ * 配置组合          | 拼接结果       | 规范化后路径  | 是否命中 /api/base
+ * [/ + /api/base]   | //api/base    | /api/base    | 是
+ * [// + /api/base]  | ///api/base   | /api/base    | 是
+ * [/api + /base]    | /api/base     | /api/base    | 是
+ * [/api/ + base]    | /api/base     | /api/base    | 是
+ * [/api/base + ""]  | /api/base     | /api/base    | 是
+ */
+describe('Controller Path Normalization', () => {
+  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();
+  });
+
+  // 场景 1: [/ + /api/base] -> //api/base -> /api/base
+  test('should normalize "/" + "/api/base" to "/api/base"', async () => {
+    @Controller('/')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 1 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(1);
+  });
+
+  // 场景 2: [// + /api/base] -> ///api/base -> /api/base
+  test('should normalize "//" + "/api/base" to "/api/base"', async () => {
+    @Controller('//')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 2 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(2);
+  });
+
+  // 场景 3: [/api + /base] -> /api/base -> /api/base
+  test('should normalize "/api" + "/base" to "/api/base"', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/base')
+      public handler() {
+        return { success: true, scenario: 3 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(3);
+  });
+
+  // 场景 4: [/api/ + base] -> /api/base -> /api/base
+  test('should normalize "/api/" + "base" to "/api/base"', async () => {
+    @Controller('/api/')
+    class TestController {
+      @GET('base')
+      public handler() {
+        return { success: true, scenario: 4 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(4);
+  });
+
+  // 场景 5: [/api/base + ""] -> /api/base -> /api/base
+  test('should normalize "/api/base" + "" to "/api/base"', async () => {
+    @Controller('/api/base')
+    class TestController {
+      @GET('')
+      public handler() {
+        return { success: true, scenario: 5 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(5);
+  });
+
+  // 额外场景: [/api/base + /] -> /api/base/ 或 /api/base
+  test('should normalize "/api/base" + "/" to "/api/base"', async () => {
+    @Controller('/api/base')
+    class TestController {
+      @GET('/')
+      public handler() {
+        return { success: true, scenario: 6 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(6);
+  });
+
+  // 场景: [/// + /api/base] -> /api/base (多个前导斜杠)
+  test('should normalize "///" + "/api/base" to "/api/base"', async () => {
+    @Controller('///')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 'triple-slash' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 场景: [/api// + //base] -> /api/base (多个连续斜杠)
+  test('should normalize "/api//" + "//base" to "/api/base"', async () => {
+    @Controller('/api//')
+    class TestController {
+      @GET('//base')
+      public handler() {
+        return { success: true, scenario: 'double-slashes' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 场景: ["" + /api/base] -> /api/base (空基础路径)
+  test('should normalize "" + "/api/base" to "/api/base"', async () => {
+    @Controller('')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 'empty-base' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 测试所有场景在同一应用中同时工作
+  test('should handle all path normalization scenarios simultaneously', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('/health')
+      public health() {
+        return { endpoint: 'health' };
+      }
+    }
+
+    @Controller('/api')
+    class ApiController {
+      @GET('/users')
+      public users() {
+        return { endpoint: 'users' };
+      }
+
+      @GET('products')
+      public products() {
+        return { endpoint: 'products' };
+      }
+    }
+
+    @Controller('/api/')
+    class ApiSlashController {
+      @GET('orders')
+      public orders() {
+        return { endpoint: 'orders' };
+      }
+    }
+
+    @Controller('/v1/api')
+    class V1Controller {
+      @GET('')
+      public root() {
+        return { endpoint: 'v1-root' };
+      }
+
+      @GET('/')
+      public index() {
+        return { endpoint: 'v1-index' };
+      }
+    }
+
+    app.registerController(RootController);
+    app.registerController(ApiController);
+    app.registerController(ApiSlashController);
+    app.registerController(V1Controller);
+    await app.listen();
+
+    // 验证所有端点
+    const healthRes = await fetch(`http://localhost:${port}/health`);
+    expect(healthRes.status).toBe(200);
+    expect((await healthRes.json()).endpoint).toBe('health');
+
+    const usersRes = await fetch(`http://localhost:${port}/api/users`);
+    expect(usersRes.status).toBe(200);
+    expect((await usersRes.json()).endpoint).toBe('users');
+
+    const productsRes = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsRes.status).toBe(200);
+    expect((await productsRes.json()).endpoint).toBe('products');
+
+    const ordersRes = await fetch(`http://localhost:${port}/api/orders`);
+    expect(ordersRes.status).toBe(200);
+    expect((await ordersRes.json()).endpoint).toBe('orders');
+
+    const v1Res = await fetch(`http://localhost:${port}/v1/api`);
+    expect(v1Res.status).toBe(200);
+    // v1-root 或 v1-index，取决于哪个先注册
+    const v1Data = await v1Res.json();
+    expect(['v1-root', 'v1-index']).toContain(v1Data.endpoint);
+  });
 });