@dangao/bun-server 2.3.0 → 3.0.1

package/src/websocket/registry.ts

@@ -1,5 +1,4 @@
-import type { ServerWebSocket } from 'bun';
-
+import type { IWebSocket } from '../platform/types';
 import { Container } from '../di/container';
 import { ControllerRegistry } from '../controller/controller';
 import { getGatewayMetadata, getHandlerMetadata } from './decorators';
@@ -161,7 +160,7 @@ export class WebSocketGatewayRegistry {
    * @param args - 原始参数（message, code, reason 等，不包括 ws）
    */
   private async invokeHandler(
-    ws: ServerWebSocket<WebSocketConnectionData>,
+    ws: IWebSocket<WebSocketConnectionData>,
     definition: GatewayDefinition,
     handlerName: string | undefined,
     ...args: unknown[]
@@ -266,7 +265,7 @@ export class WebSocketGatewayRegistry {
     }
   }
 
-  public async handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): Promise<void> {
+  public async handleOpen(ws: IWebSocket<WebSocketConnectionData>): Promise<void> {
     const path = ws.data?.path;
     const match = path ? this.getGateway(path) : undefined;
     if (!match) {
@@ -281,8 +280,8 @@ export class WebSocketGatewayRegistry {
   }
 
   public async handleMessage(
-    ws: ServerWebSocket<WebSocketConnectionData>,
-    message: string | ArrayBuffer | ArrayBufferView,
+    ws: IWebSocket<WebSocketConnectionData>,
+    message: string | ArrayBuffer | ArrayBufferView | Buffer,
   ): Promise<void> {
     const path = ws.data?.path;
     const match = path ? this.getGateway(path) : undefined;
@@ -298,7 +297,7 @@ export class WebSocketGatewayRegistry {
   }
 
   public async handleClose(
-    ws: ServerWebSocket<WebSocketConnectionData>,
+    ws: IWebSocket<WebSocketConnectionData>,
     code: number,
     reason: string,
   ): Promise<void> {

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

@@ -1,8 +1,8 @@
 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 { GET, POST, PUT, DELETE, PATCH } from '../../src/router/decorators';
+import { Param, Body } from '../../src/controller/decorators';
 import { RouteRegistry } from '../../src/router/registry';
 import { getTestPort } from '../utils/test-port';
 
@@ -203,6 +203,81 @@ describe('Controller Path Combination', () => {
     expect(rootResponse.status).toBe(404);
   });
 
+  test('should match GET POST PUT DELETE PATCH all registered on same dynamic route /api/:id independently', async () => {
+    @Controller('/api')
+    class ResourceController {
+      @GET('/:id')
+      public getResource(@Param('id') id: string) {
+        return { method: 'GET', id };
+      }
+
+      @POST('/:id')
+      public postResource(@Param('id') id: string) {
+        return { method: 'POST', id };
+      }
+
+      @PUT('/:id')
+      public putResource(@Param('id') id: string) {
+        return { method: 'PUT', id };
+      }
+
+      @DELETE('/:id')
+      public deleteResource(@Param('id') id: string) {
+        return { method: 'DELETE', id };
+      }
+
+      @PATCH('/:id')
+      public patchResource(@Param('id') id: string) {
+        return { method: 'PATCH', id };
+      }
+    }
+
+    app.registerController(ResourceController);
+    await app.listen();
+
+    const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const;
+    for (const method of methods) {
+      const res = await fetch(`http://localhost:${port}/api/123`, { method });
+      expect(res.status).toBe(200);
+      const data = await res.json() as { method: string; id: string };
+      expect(data.method).toBe(method);
+      expect(data.id).toBe('123');
+    }
+  });
+
+  test('should not cross-match methods: only registered methods respond 200, others respond 404/405', async () => {
+    @Controller('/items')
+    class ItemController {
+      @GET('/:id')
+      public getItem(@Param('id') id: string) {
+        return { method: 'GET', id };
+      }
+
+      @POST('/:id')
+      public createItem(@Param('id') id: string) {
+        return { method: 'POST', id };
+      }
+    }
+
+    app.registerController(ItemController);
+    await app.listen();
+
+    const getRes = await fetch(`http://localhost:${port}/items/42`);
+    expect(getRes.status).toBe(200);
+    expect((await getRes.json() as { method: string }).method).toBe('GET');
+
+    const postRes = await fetch(`http://localhost:${port}/items/42`, { method: 'POST' });
+    expect(postRes.status).toBe(200);
+    expect((await postRes.json() as { method: string }).method).toBe('POST');
+
+    // PUT and DELETE are not registered — should return a non-200 status
+    const putRes = await fetch(`http://localhost:${port}/items/42`, { method: 'PUT' });
+    expect(putRes.ok).toBe(false);
+
+    const deleteRes = await fetch(`http://localhost:${port}/items/42`, { method: 'DELETE' });
+    expect(deleteRes.ok).toBe(false);
+  });
+
   test('should correctly combine root controller "/" with method path "/health"', async () => {
     // 这是 metrics-rate-limit-app.ts 示例中的场景
     // @Controller('/') + @GET('/health') 应该映射到 /health，而不是 //health
@@ -275,6 +350,125 @@ describe('Controller Path Combination', () => {
     expect(dataResponse.status).toBe(200);
     expect((await dataResponse.json()).received).toBe(true);
   });
+
+  /**
+   * 模拟真实业务场景：ProjectController
+   *
+   * 路由表：
+   *   GET    /api/projects/         → list()
+   *   GET    /api/projects/:id      → get(id)
+   *   POST   /api/projects/         → create(dto)
+   *   PUT    /api/projects/:id      → update(id, dto)
+   *   DELETE /api/projects/:id      → remove(id)
+   *   GET    /api/projects/:id/pages → listPages(id)
+   */
+  test('ProjectController: all routes on /api/projects should match independently', async () => {
+    const db: Record<string, { id: string; name: string; description: string; pages: string[] }> = {
+      'proj-1': { id: 'proj-1', name: 'Alpha', description: 'desc-a', pages: ['page-1', 'page-2'] },
+      'proj-2': { id: 'proj-2', name: 'Beta',  description: 'desc-b', pages: [] },
+    };
+
+    @Controller('/api/projects')
+    class ProjectController {
+      @GET('/')
+      list() {
+        return Object.values(db);
+      }
+
+      @GET('/:id')
+      get(@Param('id') id: string) {
+        return db[id] ?? null;
+      }
+
+      @POST('/')
+      create(@Body() dto: { name: string; description?: string }) {
+        const id = `proj-new`;
+        db[id] = { id, name: dto.name, description: dto.description ?? '', pages: [] };
+        return db[id];
+      }
+
+      @PUT('/:id')
+      update(@Param('id') id: string, @Body() dto: { name?: string; description?: string }) {
+        if (!db[id]) return null;
+        db[id] = { ...db[id], ...dto };
+        return db[id];
+      }
+
+      @DELETE('/:id')
+      remove(@Param('id') id: string) {
+        const existed = !!db[id];
+        delete db[id];
+        return { success: existed };
+      }
+
+      @GET('/:id/pages')
+      listPages(@Param('id') id: string) {
+        return db[id]?.pages ?? [];
+      }
+    }
+
+    app.registerController(ProjectController);
+    await app.listen();
+
+    const base = `http://localhost:${port}/api/projects`;
+
+    // GET / → 列表
+    const listRes = await fetch(`${base}/`);
+    expect(listRes.status).toBe(200);
+    const list = await listRes.json() as { id: string }[];
+    expect(list.length).toBe(2);
+
+    // GET /:id → 单条
+    const getRes = await fetch(`${base}/proj-1`);
+    expect(getRes.status).toBe(200);
+    const item = await getRes.json() as { id: string; name: string };
+    expect(item.id).toBe('proj-1');
+    expect(item.name).toBe('Alpha');
+
+    // POST / → 创建
+    const createRes = await fetch(`${base}/`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Gamma', description: 'desc-c' }),
+    });
+    expect(createRes.status).toBe(200);
+    const created = await createRes.json() as { id: string; name: string };
+    expect(created.name).toBe('Gamma');
+
+    // PUT /:id → 更新
+    const updateRes = await fetch(`${base}/proj-1`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Alpha-Updated' }),
+    });
+    expect(updateRes.status).toBe(200);
+    const updated = await updateRes.json() as { name: string };
+    expect(updated.name).toBe('Alpha-Updated');
+
+    // GET /:id/pages → 子资源，不能被 GET /:id 拦截
+    const pagesRes = await fetch(`${base}/proj-2/pages`);
+    expect(pagesRes.status).toBe(200);
+    const pages = await pagesRes.json() as string[];
+    expect(Array.isArray(pages)).toBe(true);
+
+    // proj-1 pages（改名后仍可访问）
+    const pages1Res = await fetch(`${base}/proj-1/pages`);
+    expect(pages1Res.status).toBe(200);
+    const pages1 = await pages1Res.json() as string[];
+    expect(pages1).toEqual(['page-1', 'page-2']);
+
+    // DELETE /:id → 删除
+    const delRes = await fetch(`${base}/proj-2`, { method: 'DELETE' });
+    expect(delRes.status).toBe(200);
+    const delData = await delRes.json() as { success: boolean };
+    expect(delData.success).toBe(true);
+
+    // 删除后 GET /:id 返回 null（项目已不存在）
+    const afterDelRes = await fetch(`${base}/proj-2`);
+    expect(afterDelRes.status).toBe(200);
+    const afterDel = await afterDelRes.json();
+    expect(afterDel).toBeNull();
+  });
 });
 
 /**

package/tests/files/static-middleware.test.ts

@@ -1,17 +1,20 @@
 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 { createStaticFileMiddleware } from '../../src/files/static-middleware';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 describe('Static File Middleware', () => {
   let root: string;
 
   beforeEach(async () => {
     root = await mkdtemp(join(tmpdir(), 'bun-static-'));
-    await Bun.write(join(root, 'hello.txt'), 'hello world');
+    await writeFile(join(root, 'hello.txt'), 'hello world', 'utf-8');
   });
 
   afterEach(async () => {

package/tests/middleware/static-file.test.ts

@@ -1,14 +1,17 @@
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdir, rm } from 'fs/promises';
+import { mkdir, rm, writeFile as fsWriteFile } from 'fs/promises';
 import { join } from 'path';
 
 import { createStaticFileMiddleware } from '../../src/middleware/builtin/static-file';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 const TMP_DIR = join(process.cwd(), 'tmp-static-test');
 
 async function writeFile(path: string, content: string): Promise<void> {
-  await Bun.write(path, content);
+  await fsWriteFile(path, content, 'utf-8');
 }
 
 describe('StaticFileMiddleware', () => {

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

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

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

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

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

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

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

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

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

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

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

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

package/tests/platform/detector.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { resolvePlatform } from '../../src/platform/detector';
+
+describe('resolvePlatform priority chain', () => {
+  const originalArgv = process.argv.slice();
+  const originalEnv = process.env['BUN_SERVER_PLATFORM'];
+
+  afterEach(() => {
+    process.argv.length = 0;
+    for (const arg of originalArgv) process.argv.push(arg);
+    if (originalEnv === undefined) {
+      delete process.env['BUN_SERVER_PLATFORM'];
+    } else {
+      process.env['BUN_SERVER_PLATFORM'] = originalEnv;
+    }
+  });
+
+  test('bootstrap config takes highest priority over CLI arg', () => {
+    process.argv.push('--platform=node');
+    expect(resolvePlatform('bun')).toBe('bun');
+  });
+
+  test('CLI arg --platform=node', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=node');
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('CLI arg --platform=bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=node', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=bun', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'bun';
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('CLI arg takes priority over env var', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('auto-detect returns bun when running in Bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    // We're running in Bun (bun:test), so auto-detect should return 'bun'
+    const result = resolvePlatform();
+    expect(result).toBe('bun');
+  });
+});

package/tests/platform/node/build-smoke.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from 'vitest';
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * 烟雾测试：验证 bun build --target=node 的输出能被 Node.js 原生运行
+ *
+ * 测试流程：
+ * 1. 创建最小化 app fixture
+ * 2. 使用 bun build --target=node 编译
+ * 3. 用 node 运行编译产物
+ * 4. 验证应用启动成功
+ */
+describe('Build Smoke Test (bun build --target=node)', () => {
+  test('compiled output runs on Node.js', async () => {
+    const tmpDir = join(tmpdir(), `build-smoke-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+
+    const outDir = join(tmpDir, 'out');
+    mkdirSync(outDir, { recursive: true });
+
+    // Create a minimal fixture app using the framework
+    const fixturePath = join(tmpDir, 'fixture.ts');
+    const pkgRoot = resolve(__dirname, '../../..');
+
+    writeFileSync(fixturePath, `
+import { Application } from '${pkgRoot}/src/index.ts';
+import { Module } from '${pkgRoot}/src/index.ts';
+
+@Module({})
+class AppModule {}
+
+const app = new Application({ platform: 'node' });
+app.registerModule(AppModule);
+app.listen(0).then(() => {
+  const server = app.getServer()?.getServer();
+  console.log('SMOKE_OK port=' + (server?.port ?? 0));
+  process.exit(0);
+}).catch((err) => {
+  console.error('SMOKE_FAIL', err.message);
+  process.exit(1);
+});
+`);
+
+    const outFile = join(outDir, 'app.cjs');
+
+    // Build with bun
+    const buildResult = await runCommand('bun', [
+      'build',
+      fixturePath,
+      '--target=node',
+      '--outfile=' + outFile,
+      '--format=cjs',
+    ]);
+
+    if (buildResult.exitCode !== 0) {
+      // Build may fail in CI without Bun; skip gracefully
+      console.warn('[build-smoke] bun build failed, skipping test:', buildResult.stderr);
+      return;
+    }
+
+    // Run compiled file with node
+    const nodeResult = await runCommand('node', [outFile], 5000);
+
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+
+    expect(nodeResult.exitCode).toBe(0);
+    expect(nodeResult.stdout).toContain('SMOKE_OK');
+  }, 30000);
+});
+
+function runCommand(
+  cmd: string,
+  args: string[],
+  timeout = 15000,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { timeout });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (d) => { stdout += d.toString(); });
+    child.stderr?.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+    child.on('error', (err) => resolve({ exitCode: 1, stdout, stderr: err.message }));
+  });
+}

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