@dangao/bun-server 1.8.0 → 1.8.2

package/tests/extensions/logger-module.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { Container } from '../../src/di/container';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { LoggerModule, type LoggerModuleOptions } from '../../src/extensions/logger-module';
+import { LOGGER_TOKEN, LogLevel, type LogEntry } from '../../src/extensions';
+import type { Logger } from '@dangao/logsmith';
+
+describe('LoggerModule', () => {
+  beforeEach(() => {
+    // 清除模块元数据
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, LoggerModule);
+  });
+
+  test('should create logger module with default options', () => {
+    LoggerModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions).toBeDefined();
+    expect(metadata.extensions.length).toBe(1);
+    // 默认启用请求日志
+    expect(metadata.middlewares).toBeDefined();
+    expect(metadata.middlewares.length).toBe(1);
+  });
+
+  test('should create logger module with custom logger options', () => {
+    const entries: LogEntry[] = [];
+    const options: LoggerModuleOptions = {
+      logger: {
+        prefix: 'TestApp',
+        level: LogLevel.DEBUG,
+        sink(entry) {
+          entries.push(entry);
+        },
+      },
+    };
+
+    LoggerModule.forRoot(options);
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions).toBeDefined();
+    expect(metadata.extensions.length).toBe(1);
+  });
+
+  test('should disable request logging when enableRequestLogging is false', () => {
+    LoggerModule.forRoot({
+      enableRequestLogging: false,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions.length).toBe(1);
+    // 禁用请求日志时，middlewares 应该为空
+    expect(metadata.middlewares.length).toBe(0);
+  });
+
+  test('should enable request logging with custom prefix', () => {
+    LoggerModule.forRoot({
+      enableRequestLogging: true,
+      requestLoggingPrefix: '[HTTP]',
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.middlewares.length).toBe(1);
+  });
+
+  test('should register logger into container via extension', () => {
+    const entries: LogEntry[] = [];
+    LoggerModule.forRoot({
+      logger: {
+        prefix: 'Test',
+        level: LogLevel.DEBUG,
+        sink(entry) {
+          entries.push(entry);
+        },
+      },
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    const extension = metadata.extensions[0];
+
+    // 模拟扩展注册到容器
+    const container = new Container();
+    extension.register(container);
+
+    const logger = container.resolve<Logger>(LOGGER_TOKEN);
+    expect(logger).toBeDefined();
+
+    logger.info('test message');
+    expect(entries.length).toBe(1);
+    expect(entries[0].message).toBe('test message');
+  });
+
+  test('should work with container via extension registration', async () => {
+    const entries: LogEntry[] = [];
+    LoggerModule.forRoot({
+      logger: {
+        sink(entry) {
+          entries.push(entry);
+        },
+      },
+      enableRequestLogging: false,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    const container = new Container();
+
+    // 模拟模块注册过程：手动注册扩展
+    for (const extension of metadata.extensions) {
+      if (extension && typeof extension.register === 'function') {
+        extension.register(container);
+      }
+    }
+
+    const logger = container.resolve<Logger>(LOGGER_TOKEN);
+    expect(logger).toBeDefined();
+
+    logger.warn('warning message');
+    expect(entries.length).toBe(1);
+    expect(entries[0].level).toBe(LogLevel.WARN);
+  });
+
+  test('should preserve existing metadata when calling forRoot multiple times', () => {
+    // 第一次调用
+    LoggerModule.forRoot({
+      enableRequestLogging: false,
+    });
+
+    const metadata1 = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata1.extensions.length).toBe(1);
+    expect(metadata1.middlewares.length).toBe(0);
+
+    // 清除元数据模拟重新配置
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, LoggerModule);
+
+    // 第二次调用使用不同选项
+    LoggerModule.forRoot({
+      enableRequestLogging: true,
+      requestLoggingPrefix: '[API]',
+    });
+
+    const metadata2 = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    expect(metadata2.extensions.length).toBe(1);
+    expect(metadata2.middlewares.length).toBe(1);
+  });
+
+  test('should use default values when options are not provided', () => {
+    LoggerModule.forRoot({});
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule);
+    // enableRequestLogging 默认不是 false，所以应该启用
+    expect(metadata.middlewares.length).toBe(1);
+  });
+});

package/tests/files/file-storage.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { rmdir, unlink, readdir, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { FileStorage } from '../../src/files/storage';
+
+describe('FileStorage', () => {
+  const testDir = '/tmp/bun-server-test-uploads';
+
+  beforeEach(async () => {
+    // Clean up before each test to ensure isolation
+    try {
+      const files = await readdir(testDir);
+      for (const file of files) {
+        await unlink(join(testDir, file));
+      }
+      await rmdir(testDir);
+    } catch {
+      // Directory may not exist yet
+    }
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      // Clean up test directory
+      const files = await readdir(testDir);
+      for (const file of files) {
+        await unlink(join(testDir, file));
+      }
+      await rmdir(testDir);
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('saveFile', () => {
+    test('should save file to destination', async () => {
+      const uniqueName = `test-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`;
+      const file = new File(['test content'], uniqueName, { type: 'text/plain' });
+
+      const result = await FileStorage.saveFile(
+        file,
+        { dest: testDir },
+        'testField',
+      );
+
+      expect(result.fieldName).toBe('testField');
+      expect(result.filename).toBe(uniqueName);
+      expect(result.originalName).toBe(uniqueName);
+      expect(result.mimeType).toContain('text/plain');
+      expect(result.size).toBe(12);
+      expect(result.path).toContain(testDir);
+    });
+
+    test('should use custom filename', async () => {
+      const file = new File(['content'], 'original.txt');
+
+      const result = await FileStorage.saveFile(
+        file,
+        { dest: testDir, filename: 'custom.txt' },
+        'myField',
+      );
+
+      expect(result.filename).toBe('custom.txt');
+    });
+
+    test('should sanitize filename', async () => {
+      const file = new File(['content'], 'file with spaces & chars!.txt');
+
+      const result = await FileStorage.saveFile(
+        file,
+        { dest: testDir },
+        'field',
+      );
+
+      // Should not contain spaces or special chars
+      expect(result.filename).not.toContain(' ');
+      expect(result.filename).not.toContain('&');
+      expect(result.filename).not.toContain('!');
+    });
+
+    test('should handle file without extension', async () => {
+      // File without extension still gets default mime type from Bun
+      const file = new File(['data'], 'noext');
+
+      const result = await FileStorage.saveFile(
+        file,
+        { dest: testDir },
+        'field',
+      );
+
+      // mimeType should be defined
+      expect(result.mimeType).toBeDefined();
+    });
+
+    test('should prevent overwrite by default', async () => {
+      const file1 = new File(['content1'], 'same.txt');
+      const file2 = new File(['content2'], 'same.txt');
+
+      await FileStorage.saveFile(file1, { dest: testDir }, 'field1');
+      const result2 = await FileStorage.saveFile(file2, { dest: testDir }, 'field2');
+
+      // Second file should have a different name
+      expect(result2.filename).not.toBe('same.txt');
+      expect(result2.filename).toContain('same');
+    });
+
+    test('should allow overwrite when specified', async () => {
+      const file1 = new File(['content1'], 'overwrite.txt');
+      const file2 = new File(['content2'], 'overwrite.txt');
+
+      await FileStorage.saveFile(file1, { dest: testDir }, 'field1');
+      const result2 = await FileStorage.saveFile(
+        file2,
+        { dest: testDir, overwrite: true },
+        'field2',
+      );
+
+      expect(result2.filename).toBe('overwrite.txt');
+    });
+
+    test('should create destination directory if not exists', async () => {
+      const newDir = join(testDir, 'subdir', 'nested');
+      const file = new File(['content'], 'test.txt');
+
+      const result = await FileStorage.saveFile(
+        file,
+        { dest: newDir },
+        'field',
+      );
+
+      expect(result.path).toContain(newDir);
+    });
+  });
+});