@wutiange/log-listener-plugin 2.0.2-alpha.2 → 2.0.2-alpha.3

package/src/__tests__/utils.test.ts

@@ -1,114 +1,236 @@
-import logger from '../logger';
-import { createClassWithErrorHandling, hasPort } from '../utils';
+import { hasPort, formDataToString, sleep, typeReplacer } from '../utils';
 
-describe('createClassWithErrorHandling', () => {
-  class TestClass {
-    normalMethod(): string {
-      return 'normal';
-    }
+describe('hasPort function', () => {
+  it('should return true for URLs with explicit ports', () => {
+    expect(hasPort('http://example.com:8080')).toBe(true);
+    expect(hasPort('ftp://example.com:210')).toBe(true);
+  });
+
+  it('should return false for URLs without explicit ports', () => {
+    expect(hasPort('http://example.com')).toBe(false);
+    expect(hasPort('https://example.com')).toBe(false);
+    expect(hasPort('ftp://example.com')).toBe(false);
+  });
+
+  it('should return false for invalid URLs', () => {
+    expect(hasPort('not a url')).toBe(false);
+    expect(hasPort('http:/example.com')).toBe(false);
+    expect(hasPort('example.com:8080')).toBe(false);
+  });
+
+  it('should return false for empty input', () => {
+    expect(hasPort('')).toBe(false);
+  });
 
-    errorMethod(): void {
-      throw new Error('Test error');
-    }
+  it('should return false for non-string input', () => {
+    expect(hasPort(null as any)).toBe(false);
+    expect(hasPort(undefined as any)).toBe(false);
+    expect(hasPort(123 as any)).toBe(false);
+    expect(hasPort({} as any)).toBe(false);
+  });
 
-    async asyncMethod(): Promise<string> {
-      return 'async';
-    }
+  it('should handle URLs with default ports correctly', () => {
+    expect(hasPort('http://example.com:80')).toBe(false);
+    expect(hasPort('https://example.com:443')).toBe(false);
+  });
 
-    async asyncErrorMethod(): Promise<void> {
-      throw new Error('Async test error');
-    }
-  }
+  it('should handle URLs with IPv6 addresses', () => {
+    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
+    expect(hasPort('https://[2001:db8::1]')).toBe(false);
+  });
+
+  it('should handle URLs with userinfo', () => {
+    expect(hasPort('http://user:pass@example.com:8080')).toBe(true);
+    expect(hasPort('http://user:pass@example.com')).toBe(false);
+  });
+});
 
-  let consoleErrorSpy: jest.SpyInstance;
+describe('formDataToString', () => {
+  let mockFormData: FormData;
 
   beforeEach(() => {
-    consoleErrorSpy = jest.spyOn(logger, 'error').mockImplementation(() => {});
+    // 创建一个模拟的 FormData 对象
+    mockFormData = new FormData();
+    // 模拟 getParts 方法
+    (mockFormData as any).getParts = jest.fn();
   });
 
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
+  it('should convert form data with text fields to string', () => {
+    // 模拟 getParts 返回包含文本字段的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field1"',
+        },
+        string: 'value1',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    // 验证基本结构
+    expect(result).toMatch(/^------WebKitFormBoundary.*\r\n/);
+    expect(result).toMatch(/Content-Disposition: form-data; name="field1"\r\n/);
+    expect(result).toMatch(/Content-Length: 6\r\n/);
+    expect(result).toMatch(/value1\r\n/);
+    expect(result).toMatch(/----WebKitFormBoundary.*--\r\n$/);
   });
 
-  test('should not interfere with normal methods', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    expect(instance.normalMethod()).toBe('normal');
+  it('should handle form data with content-type header', () => {
+    // 模拟 getParts 返回包含 content-type 的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="file"; filename="test.txt"',
+          'content-type': 'text/plain',
+        },
+        string: 'file content',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(
+      /Content-Disposition: form-data; name="file"; filename="test.txt"\r\n/,
+    );
+    expect(result).toMatch(/Content-Type: text\/plain\r\n/);
+    expect(result).toMatch(/Content-Length: 12\r\n/);
+    expect(result).toMatch(/file content\r\n/);
   });
 
-  test('should catch and log errors from methods', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    expect(() => instance.errorMethod()).toThrow('Test error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in errorMethod:', expect.any(Error));
+  it('should handle multiple form fields', () => {
+    // 模拟 getParts 返回多个字段
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field1"',
+        },
+        string: 'value1',
+      },
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field2"',
+        },
+        string: 'value2',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(/field1.*value1.*field2.*value2/s);
+    expect((result.match(/----WebKitFormBoundary/g) || []).length).toBe(3); // 开始、中间、结束
   });
 
-  test('should not interfere with async methods that resolve', async () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    await expect(instance.asyncMethod()).resolves.toBe('async');
+  it('should handle URI parts', () => {
+    // 模拟 getParts 返回包含 URI 的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="file"',
+          'content-type': 'image/jpeg',
+        },
+        uri: 'file:///path/to/image.jpg',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(/Content-Type: image\/jpeg\r\n/);
+    expect(result).toMatch(/file:\/\/\/path\/to\/image.jpg\r\n/);
   });
+});
 
-  test('should catch and log errors from async methods that reject', async () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    await expect(instance.asyncErrorMethod()).rejects.toThrow('Async test error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in asyncErrorMethod:', expect.any(Error));
+describe('sleep function', () => {
+  // 测试正常延迟情况
+  it('should resolve after specified delay', async () => {
+    const startTime = Date.now();
+    const delay = 100;
+
+    await sleep(delay);
+    const endTime = Date.now();
+    const actualDelay = endTime - startTime;
+
+    // 由于 JavaScript 定时器的不精确性，我们允许一个小的误差范围
+    expect(actualDelay).toBeGreaterThanOrEqual(delay);
+    expect(actualDelay).toBeLessThan(delay + 50); // 允许 50ms 的误差
   });
 
-  test('should handle methods added after instantiation', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    (instance as any).dynamicMethod = function(): void {
-      throw new Error('Dynamic method error');
-    };
-    expect(() => (instance as any).dynamicMethod()).toThrow('Dynamic method error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in dynamicMethod:', expect.any(Error));
+  // 测试超时拒绝情况
+  it('should reject with timeout error when isReject is true', async () => {
+    const delay = 100;
+
+    await expect(sleep(delay, true)).rejects.toEqual({
+      code: 11001,
+      key: '@wutiange/log-listener-plugin%%timeout',
+      message: 'Timeout',
+    });
   });
 });
 
+describe('typeReplacer', () => {
+  // 测试 Error 类型转换
+  it('should convert Error to string', () => {
+    const error = new Error('test error');
+    expect(typeReplacer('error', error)).toBe('Error: test error');
+  });
 
-describe('hasPort function', () => {
-  test('should return true for URLs with explicit ports', () => {
-    expect(hasPort('http://example.com:8080')).toBe(true);
-    expect(hasPort('ftp://example.com:210')).toBe(true);
+  // 测试 Function 类型转换
+  it('should convert Function to string', () => {
+    const fn = function test() {
+      return 'hello';
+    };
+    const result = typeReplacer('fn', fn);
+    expect(result).toContain('function test()');
   });
 
-  test('should return false for URLs without explicit ports', () => {
-    expect(hasPort('http://example.com')).toBe(false);
-    expect(hasPort('https://example.com')).toBe(false);
-    expect(hasPort('ftp://example.com')).toBe(false);
+  // 测试 Symbol 类型转换
+  it('should convert Symbol to string', () => {
+    const sym = Symbol('test');
+    expect(typeReplacer('symbol', sym)).toBe('Symbol(test)');
   });
 
-  test('should return false for invalid URLs', () => {
-    expect(hasPort('not a url')).toBe(false);
-    expect(hasPort('http:/example.com')).toBe(false);
-    expect(hasPort('example.com:8080')).toBe(false);
+  // 测试 BigInt 类型转换
+  it('should convert BigInt to string', () => {
+    const big = BigInt(9007199254740991);
+    expect(typeReplacer('bigint', big)).toBe('9007199254740991');
   });
 
-  test('should return false for empty input', () => {
-    expect(hasPort('')).toBe(false);
+  // 测试 RegExp 类型转换
+  it('should convert RegExp to string', () => {
+    const regex = /test/g;
+    expect(typeReplacer('regex', regex)).toBe('/test/g');
   });
 
-  test('should return false for non-string input', () => {
-    expect(hasPort(null as any)).toBe(false);
-    expect(hasPort(undefined as any)).toBe(false);
-    expect(hasPort(123 as any)).toBe(false);
-    expect(hasPort({} as any)).toBe(false);
+  // 测试 Set 类型转换
+  it('should convert Set to array', () => {
+    const set = new Set([1, 2, 3]);
+    expect(typeReplacer('set', set)).toEqual([1, 2, 3]);
   });
 
-  test('should handle URLs with default ports correctly', () => {
-    expect(hasPort('http://example.com:80')).toBe(false);
-    expect(hasPort('https://example.com:443')).toBe(false);
+  // 测试 Map 类型转换
+  it('should convert Map to object', () => {
+    const map = new Map([
+      ['key1', 'value1'],
+      ['key2', 'value2'],
+    ]);
+    expect(typeReplacer('map', map)).toEqual({
+      key1: 'value1',
+      key2: 'value2',
+    });
   });
 
-  test('should handle URLs with IPv6 addresses', () => {
-    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
-    expect(hasPort('https://[2001:db8::1]')).toBe(false);
+  // 测试普通值不变
+  it('should return primitive values as is', () => {
+    expect(typeReplacer('string', 'test')).toBe('test');
+    expect(typeReplacer('number', 42)).toBe(42);
+    expect(typeReplacer('boolean', true)).toBe(true);
+    expect(typeReplacer('null', null)).toBe(null);
+    expect(typeReplacer('undefined', undefined)).toBe(undefined);
   });
 
-  test('should handle URLs with userinfo', () => {
-    expect(hasPort('http://user:pass@example.com:8080')).toBe(true);
-    expect(hasPort('http://user:pass@example.com')).toBe(false);
+  // 测试普通对象不变
+  it('should return objects as is', () => {
+    const obj = { name: 'test', age: 25 };
+    expect(typeReplacer('object', obj)).toEqual(obj);
   });
 });

package/src/logPlugin.ts

@@ -1,5 +1,4 @@
 import Server from './Server';
-import { createClassWithErrorHandling } from './utils';
 import { httpInterceptor } from './HTTPInterceptor';
 import {
   DEFAULT_TIMEOUT,
@@ -232,7 +231,5 @@ class LogPlugin {
     this._log(Level.ERROR, Tag.DEFAULT, ...data);
   };
 }
-const SafeLogPlugin = createClassWithErrorHandling(LogPlugin);
-const logPlugin = new SafeLogPlugin();
-export { SafeLogPlugin };
+const logPlugin = new LogPlugin();
 export default logPlugin;

package/src/utils.ts

@@ -24,75 +24,12 @@ export function hasPort(url: string) {
     return false;
   }
 
-  try {
-    // 使用 URL 构造函数解析 URL
-    const parsedUrl = new URL(url);
+  // 使用 URL 构造函数解析 URL
+  const parsedUrl = new URL(url);
 
-    // 检查 port 属性是否为空
-    // 注意：如果使用默认端口（如 HTTP 的 80 或 HTTPS 的 443），port 会是空字符串
-    return parsedUrl.port !== '';
-  } catch (error) {
-    logger.error(error);
-    // 如果 URL 无效，捕获错误并返回 false
-    return false;
-  }
-}
-
-type Constructor<T = {}> = new (...args: any[]) => T;
-
-export function createClassWithErrorHandling<T extends Constructor>(
-  BaseClass: T,
-): T {
-  return new Proxy(BaseClass, {
-    construct(target: T, args: any[]): object {
-      const instance = new target(...args);
-      return new Proxy(instance, {
-        get(target: any, prop: string | symbol): any {
-          const value = target[prop];
-          if (typeof value === 'function') {
-            return function (this: any, ...args: any[]): any {
-              try {
-                const result = value.apply(this, args);
-                if (result instanceof Promise) {
-                  return result.catch((error: Error) => {
-                    logger.error(`Error in ${String(prop)}:`, error);
-                    throw error; // 重新抛出错误，以便调用者可以捕获它
-                  });
-                }
-                return result;
-              } catch (error) {
-                logger.error(`Error in ${String(prop)}:`, error);
-                throw error; // 重新抛出错误，以便调用者可以捕获它
-              }
-            };
-          }
-          return value;
-        },
-        set(target: any, prop: string | symbol, value: any): boolean {
-          if (typeof value === 'function') {
-            target[prop] = function (this: any, ...args: any[]): any {
-              try {
-                const result = value.apply(this, args);
-                if (result instanceof Promise) {
-                  return result.catch((error: Error) => {
-                    logger.error(`Error in ${String(prop)}:`, error);
-                    throw error;
-                  });
-                }
-                return result;
-              } catch (error) {
-                logger.error(`Error in ${String(prop)}:`, error);
-                throw error;
-              }
-            };
-          } else {
-            target[prop] = value;
-          }
-          return true;
-        },
-      });
-    },
-  });
+  // 检查 port 属性是否为空
+  // 注意：如果使用默认端口（如 HTTP 的 80 或 HTTPS 的 443），port 会是空字符串
+  return parsedUrl.port !== '';
 }
 
 export function formDataToString(formData: FormData): string {
@@ -120,7 +57,7 @@ export function typeReplacer(key: string, val: any) {
     return val.toString();
   } else if (val instanceof Function) {
     return Function.prototype.toString.call(val);
-  } else if (val instanceof Symbol) {
+  } else if (typeof val === 'symbol') {
     return val.toString();
   } else if (typeof val === 'bigint') {
     return val.toString();