@dangao/bun-server 2.3.0 → 3.0.0

package/tests/platform/shared/websocket.cases.ts

@@ -0,0 +1,61 @@
+import type { TestSuite } from './suite';
+import type { IPlatform } from '../../../src/platform/types';
+
+export function runWebSocketCases(suite: TestSuite, getPlatform: () => IPlatform): void {
+  const { test, expect } = suite;
+
+  test('WebSocket server accepts connection and receives message', async () => {
+    const platform = getPlatform();
+    const messages: string[] = [];
+    let openCalled = false;
+
+    // Use a promise to track the server-side close event
+    let resolveServerClose!: () => void;
+    const serverClosePromise = new Promise<void>((r) => { resolveServerClose = r; });
+
+    const server = await platform.http.serve({
+      port: 0,
+      fetch: (req, handle) => {
+        const upgraded = handle.upgrade?.(req, { data: {} });
+        if (upgraded) return undefined as unknown as Response;
+        return new Response('not ws', { status: 400 });
+      },
+      websocket: {
+        open: (_ws) => { openCalled = true; },
+        message: (ws, msg) => {
+          messages.push(msg.toString());
+          ws.send('echo: ' + msg.toString());
+        },
+        close: (_ws) => { resolveServerClose(); },
+      },
+    });
+
+    const port = server.port;
+
+    // Connect using native WebSocket (available in both Bun and Node 22+)
+    await new Promise<void>((resolve, reject) => {
+      const ws = new WebSocket(`ws://localhost:${port}`);
+      ws.addEventListener('open', () => {
+        ws.send('hello');
+      });
+      ws.addEventListener('message', (e) => {
+        if (e.data === 'echo: hello') {
+          ws.close();
+        }
+      });
+      ws.addEventListener('close', () => {
+        resolve();
+      });
+      ws.addEventListener('error', reject);
+      setTimeout(reject, 5000);
+    });
+
+    // Wait for server-side close handler to fire before asserting
+    await serverClosePromise;
+
+    server.stop();
+
+    expect(openCalled).toBe(true);
+    expect(messages).toContain('hello');
+  });
+}

package/tests/request/response.test.ts

@@ -1,8 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { ResponseBuilder } from '../../src/request/response';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 describe('ResponseBuilder', () => {
   let tmpDir: string;
@@ -71,7 +74,7 @@ describe('ResponseBuilder', () => {
 
   test('should create file response from path', async () => {
     const filePath = join(tmpDir, 'hello.txt');
-    await Bun.write(filePath, 'file-content');
+    await writeFile(filePath, 'file-content', 'utf-8');
 
     const response = ResponseBuilder.file(filePath, {
       fileName: 'download.txt',

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

@@ -94,6 +94,42 @@ describe('Router', () => {
       const route = router.findRoute('POST', '/users');
       expect(route).toBeUndefined();
     });
+
+    test('should distinguish GET POST PUT DELETE PATCH on the same dynamic route', () => {
+      router.get('/api/:id', async () => new Response('get'));
+      router.post('/api/:id', async () => new Response('post'));
+      router.put('/api/:id', async () => new Response('put'));
+      router.delete('/api/:id', async () => new Response('delete'));
+      router.patch('/api/:id', async () => new Response('patch'));
+
+      const getRoute = router.findRoute('GET', '/api/123');
+      const postRoute = router.findRoute('POST', '/api/123');
+      const putRoute = router.findRoute('PUT', '/api/123');
+      const deleteRoute = router.findRoute('DELETE', '/api/123');
+      const patchRoute = router.findRoute('PATCH', '/api/123');
+
+      expect(getRoute).toBeDefined();
+      expect(postRoute).toBeDefined();
+      expect(putRoute).toBeDefined();
+      expect(deleteRoute).toBeDefined();
+      expect(patchRoute).toBeDefined();
+
+      expect(getRoute?.method).toBe('GET');
+      expect(postRoute?.method).toBe('POST');
+      expect(putRoute?.method).toBe('PUT');
+      expect(deleteRoute?.method).toBe('DELETE');
+      expect(patchRoute?.method).toBe('PATCH');
+    });
+
+    test('should not cross-match methods on same dynamic route', () => {
+      router.get('/api/:id', async () => new Response('get'));
+      router.post('/api/:id', async () => new Response('post'));
+
+      expect(router.findRoute('GET', '/api/123')).toBeDefined();
+      expect(router.findRoute('POST', '/api/123')).toBeDefined();
+      expect(router.findRoute('PUT', '/api/123')).toBeUndefined();
+      expect(router.findRoute('DELETE', '/api/123')).toBeUndefined();
+    });
   });
 
   describe('findRouteWithMatch', () => {
@@ -178,6 +214,23 @@ describe('Router', () => {
       expect((context as any).routeHandler.controller).toBe(MyController);
       expect((context as any).routeHandler.method).toBe('testMethod');
     });
+
+    test('should route each HTTP method to its own handler on the same dynamic path /api/:id', async () => {
+      router.get('/api/:id', async () => new Response('get'));
+      router.post('/api/:id', async () => new Response('post'));
+      router.put('/api/:id', async () => new Response('put'));
+      router.delete('/api/:id', async () => new Response('delete'));
+      router.patch('/api/:id', async () => new Response('patch'));
+
+      const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const;
+      for (const method of methods) {
+        const request = new Request('http://localhost/api/123', { method });
+        const context = new Context(request, new Container());
+        const response = await router.handle(context);
+        expect(response).toBeDefined();
+        expect(await response?.text()).toBe(method.toLowerCase());
+      }
+    });
   });
 
   describe('preHandle', () => {