@dangao/bun-server 2.2.0 → 3.0.0

package/tests/platform/node/crypto.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runCryptoCases } from '../shared/crypto.cases';
+
+describe('NodeCryptoAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runCryptoCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().crypto);
+});

package/tests/platform/node/database.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runDatabaseCases } from '../shared/database.cases';
+
+describe('NodeDatabase', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runDatabaseCases({ test, expect: expect as any, beforeEach: () => {} }, 'node');
+});

package/tests/platform/node/fs.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect, beforeEach } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+describe('NodeFsAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runFsCases({ test, expect: expect as any, beforeEach }, () => getRuntime().fs);
+});

package/tests/platform/node/parser.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runParserCases } from '../shared/parser.cases';
+
+describe('NodeParserAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runParserCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().parser);
+});

package/tests/platform/node/process.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runProcessCases } from '../shared/process.cases';
+
+describe('NodeProcessAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runProcessCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().process);
+});

package/tests/platform/node/websocket.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runWebSocketCases } from '../shared/websocket.cases';
+
+describe('NodeWebSocket', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runWebSocketCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime());
+});

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

@@ -0,0 +1,49 @@
+import type { TestSuite } from './suite';
+import type { ICryptoAdapter } from '../../../src/platform/types';
+
+export function runCryptoCases(suite: TestSuite, getAdapter: () => ICryptoAdapter): void {
+  const { test, expect } = suite;
+
+  test('sha256 hex digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const hex = hasher.digest('hex');
+    // Known sha256('hello')
+    expect(hex).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+  });
+
+  test('sha256 base64 digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const b64 = hasher.digest('base64');
+    expect(typeof b64).toBe('string');
+    expect(b64.length).toBeGreaterThan(0);
+  });
+
+  test('sha256 arrayBuffer digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const buf = hasher.digest();
+    // Both Bun and Node return Buffer (extends Uint8Array), not a plain ArrayBuffer
+    expect(buf instanceof Uint8Array).toBe(true);
+    expect(buf.byteLength).toBe(32);
+  });
+
+  test('chaining update calls', () => {
+    const adapter = getAdapter();
+    // sha256('helloworld') should equal updating with 'hello' then 'world' only if same bytes
+    // We simply test that the result is consistent
+    const h1 = adapter.createHasher('sha256');
+    h1.update('hello').update('world');
+    const hex1 = h1.digest('hex');
+
+    const h2 = adapter.createHasher('sha256');
+    h2.update('helloworld');
+    const hex2 = h2.digest('hex');
+
+    expect(hex1).toBe(hex2);
+  });
+}

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

@@ -0,0 +1,43 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { TestSuite } from './suite';
+import type { PlatformEngine } from '../../../src/platform/types';
+import { SqliteManager } from '../../../src/database/sqlite-adapter';
+
+export function runDatabaseCases(suite: TestSuite, engine: PlatformEngine): void {
+  const { test, expect } = suite;
+
+  // better-sqlite3 is not supported when running Node-platform tests under Bun runtime
+  const skipBetterSqlite = engine === 'node' && typeof (globalThis as any).Bun !== 'undefined';
+
+  test('SqliteAdapter: create table, insert and query', () => {
+    if (skipBetterSqlite) {
+      // better-sqlite3 is not supported in Bun — this test must run under Node.js
+      console.log('[skip] better-sqlite3 not available in Bun runtime; run with vitest for Node platform');
+      return;
+    }
+    const dbPath = join(tmpdir(), `platform-db-test-${engine}-${Date.now()}.db`);
+    const manager = new SqliteManager();
+    const adapter = manager.getOrCreate('test', { database: dbPath, wal: false });
+
+    adapter.query('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+    adapter.query("INSERT INTO users (name) VALUES ('Alice')");
+    const rows = adapter.query<{ id: number; name: string }>('SELECT * FROM users');
+
+    expect(rows.length).toBeGreaterThanOrEqual(1);
+    expect(rows[0]!.name).toBe('Alice');
+
+    manager.destroy('test');
+  });
+
+  test('SqliteManager.getDefault() throws when not initialized', () => {
+    const manager = new SqliteManager();
+    let threw = false;
+    try {
+      manager.getDefault();
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+}

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

@@ -0,0 +1,82 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync } from 'node:fs';
+import type { TestSuite } from './suite';
+import type { IFsAdapter } from '../../../src/platform/types';
+
+export function runFsCases(suite: TestSuite, getAdapter: () => IFsAdapter): void {
+  const { test, expect, beforeEach } = suite;
+
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `platform-fs-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  test('write and read text', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'hello.txt');
+    await adapter.write(filePath, 'hello world');
+    const content = await adapter.file(filePath).text();
+    expect(content).toBe('hello world');
+  });
+
+  test('write and read bytes', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'bytes.bin');
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    await adapter.write(filePath, data);
+    const result = await adapter.file(filePath).bytes();
+    expect(result[0]).toBe(1);
+    expect(result[4]).toBe(5);
+  });
+
+  test('file.exists() returns true for existing file', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'exists.txt');
+    await adapter.write(filePath, 'content');
+    const exists = await adapter.file(filePath).exists();
+    expect(exists).toBe(true);
+  });
+
+  test('file.exists() returns false for missing file', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'does-not-exist.txt');
+    const exists = await adapter.file(filePath).exists();
+    expect(exists).toBe(false);
+  });
+
+  test('file.type returns MIME type', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'image.png');
+    await adapter.write(filePath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
+    const mime = adapter.file(filePath).type;
+    expect(mime).toContain('png');
+  });
+
+  test('stream() produces readable stream with correct content', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'stream.txt');
+    await adapter.write(filePath, 'stream content');
+    const stream = adapter.file(filePath).stream();
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const combined = Buffer.concat(chunks).toString('utf-8');
+    expect(combined).toBe('stream content');
+  });
+
+  test('glob finds matching files', async () => {
+    const adapter = getAdapter();
+    await adapter.write(join(tmpDir, 'a.json'), '{}');
+    await adapter.write(join(tmpDir, 'b.json'), '{}');
+    await adapter.write(join(tmpDir, 'c.txt'), 'text');
+    const files = adapter.glob('*.json', tmpDir);
+    expect(files.length).toBeGreaterThanOrEqual(2);
+  });
+}

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

@@ -0,0 +1,55 @@
+import type { TestSuite } from './suite';
+import type { IParserAdapter } from '../../../src/platform/types';
+
+export function runParserCases(suite: TestSuite, getAdapter: () => IParserAdapter): void {
+  const { test, expect } = suite;
+
+  test('parseJSONC parses standard JSON', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSONC('{"a": 1, "b": "hello"}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+    expect(result['b']).toBe('hello');
+  });
+
+  test('parseJSONC ignores line comments', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSONC('{\n// comment\n"a": 1}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+  });
+
+  test('parseJSON5 parses JSON5 with trailing commas', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSON5('{a: 1, b: "hello",}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+  });
+
+  test('parseJSONL parses multiple JSON lines', () => {
+    const adapter = getAdapter();
+    const content = '{"id":1}\n{"id":2}\n{"id":3}';
+    const records = adapter.parseJSONL(content);
+    expect(records.length).toBe(3);
+    expect((records[0] as Record<string, unknown>)['id']).toBe(1);
+    expect((records[2] as Record<string, unknown>)['id']).toBe(3);
+  });
+
+  test('parseJSONL ignores empty lines', () => {
+    const adapter = getAdapter();
+    const content = '{"id":1}\n\n{"id":2}\n';
+    const records = adapter.parseJSONL(content);
+    expect(records.length).toBe(2);
+  });
+
+  test('renderMarkdown converts h1 heading', () => {
+    const adapter = getAdapter();
+    const html = adapter.renderMarkdown('# Hello World');
+    expect(html).toContain('<h1');
+    expect(html).toContain('Hello World');
+  });
+
+  test('renderMarkdown converts bold text', () => {
+    const adapter = getAdapter();
+    const html = adapter.renderMarkdown('**bold**');
+    expect(html).toContain('<strong>');
+    expect(html).toContain('bold');
+  });
+}

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

@@ -0,0 +1,26 @@
+import type { TestSuite } from './suite';
+import type { IProcessAdapter } from '../../../src/platform/types';
+
+export function runProcessCases(suite: TestSuite, getAdapter: () => IProcessAdapter): void {
+  const { test, expect } = suite;
+
+  test('sleep waits at least the specified time', async () => {
+    const adapter = getAdapter();
+    const start = Date.now();
+    await adapter.sleep(100);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(90);
+  });
+
+  test('spawn runs a process and returns exit code 0', async () => {
+    const adapter = getAdapter();
+    const child = adapter.spawn({
+      cmd: ['node', '--version'],
+      stdout: 'pipe',
+      stderr: 'ignore',
+    });
+    expect(child.pid).toBeGreaterThan(0);
+    const exitCode = await child.exited;
+    expect(exitCode).toBe(0);
+  });
+}

package/tests/platform/shared/suite.ts

@@ -0,0 +1,33 @@
+/**
+ * 框架无关的测试套件接口
+ * 让 shared cases 文件在 bun:test 和 vitest 中都能运行，无需任何适配层
+ */
+export interface TestSuite {
+  test: (name: string, fn: () => void | Promise<void>) => void;
+  expect: (actual: unknown) => {
+    toBe(e: unknown): void;
+    toEqual(e: unknown): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toContain(e: unknown): void;
+    toBeGreaterThan(e: number): void;
+    toBeGreaterThanOrEqual(e: number): void;
+    toBeLessThan(e: number): void;
+    toBeLessThanOrEqual(e: number): void;
+    toBeInstanceOf(e: unknown): void;
+    toHaveLength(e: number): void;
+    not: {
+      toBe(e: unknown): void;
+      toBeNull(): void;
+      toBeUndefined(): void;
+      toThrow(): void;
+    };
+    resolves: {
+      toBeTruthy(): Promise<void>;
+    };
+    rejects: {
+      toThrow(): Promise<void>;
+    };
+  };
+  beforeEach: (fn: () => void | Promise<void>) => void;
+}

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', () => {