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

package/src/__tests__/Server.test.ts

@@ -1,150 +1,150 @@
-import Server from '../Server';
-import { sleep } from '../utils';
-
-// Mock dependencies
-jest.mock('../utils', () => {
-  const actual = jest.requireActual('../utils');
-  return {
-    ...actual,    // 保留所有真实实现
-    sleep: jest.fn() // 只模拟 sleep 函数
-  };
-});
-
-
-// Mock require for react-native-zeroconf
-jest.mock('react-native-zeroconf', () => undefined, { virtual: true });
-
-// Mock fetch
-global.fetch = jest.fn();
-
-describe('Server', () => {
-  let server: Server;
-  
-  beforeEach(() => {
-    // Clear all mocks before each test
-    jest.clearAllMocks();
-    (global.fetch as jest.Mock).mockReset();
-  });
-
-  describe('Constructor and URL Management', () => {
-    it('should initialize with default values', () => {
-      server = new Server();
-      expect(server.getBaseUrlArr()).toEqual(new Set([]));
-    });
-
-    it('should initialize with custom URL', () => {
-      server = new Server('localhost:8080');
-      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
-    });
-
-    it('should handle URLs with and without http prefix', () => {
-      server = new Server();
-      server.updateUrl('localhost:8080');
-      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
-      
-      server.updateUrl('http://localhost:8080');
-      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
-    });
-  });
-
-  describe('ZeroConf Handling', () => {
-    it('should handle case when zeroconf is not available', () => {
-      server = new Server();
-      const mockListener = jest.fn();
-      server.addUrlsListener(mockListener);
-      
-      // Since Zeroconf is not available, the listener should not be called
-      expect(mockListener).not.toHaveBeenCalled();
-    });
-
-    // Test with mock Zeroconf implementation
-    it('should handle case when zeroconf is available', () => {
-      // Temporarily mock require to return a mock Zeroconf implementation
-      const mockZeroconfInstance = {
-        on: jest.fn(),
-        scan: jest.fn()
-      };
-      
-      jest.doMock('react-native-zeroconf', () => ({
-        __esModule: true,
-        default: jest.fn(() => mockZeroconfInstance)
-      }), { virtual: true });
-
-      server = new Server();
-      const mockListener = jest.fn();
-      server.addUrlsListener(mockListener);
-
-      // Verify that Zeroconf methods were not called since module is mocked as undefined
-      expect(mockListener).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Data Sending', () => {
-    beforeEach(() => {
-      server = new Server('localhost:8080');
-      (global.fetch as jest.Mock).mockImplementation(() => 
-        Promise.resolve({ ok: true })
-      );
-    });
-
-    it('should send log data', async () => {
-      const testData = { message: 'test log' };
-      await server.log(testData);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'http://localhost:8080/log',
-        expect.objectContaining({
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json;charset=utf-8'
-          },
-          body: expect.any(String)
-        })
-      );
-    });
-
-    it('should send network data', async () => {
-      const testData = { url: 'test.com' };
-      await server.network(testData);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'http://localhost:8080/network',
-        expect.objectContaining({
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json;charset=utf-8'
-          },
-          body: expect.any(String)
-        })
-      );
-    });
-
-    it('should handle timeout', async () => {
-      server.updateTimeout(100);
-      (sleep as jest.Mock).mockImplementation(() => Promise.reject(new Error('Timeout')));
-      
-      const testData = { message: 'test' };
-      await server.log(testData);
-
-      expect(global.fetch).toHaveBeenCalled();
-      expect(sleep).toHaveBeenCalledWith(100, true);
-    });
-  });
-
-  describe('Base Data Management', () => {
-    it('should update base data', async () => {
-      server = new Server('localhost:8080');
-      const baseData = { userId: '123' };
-      server.updateBaseData(baseData);
-
-      await server.log({ message: 'test' });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"userId":"123"')
-        })
-      );
-    });
-  });
-});
+import Server from '../Server';
+import { sleep } from '../utils';
+
+// Mock dependencies
+jest.mock('../utils', () => {
+  const actual = jest.requireActual('../utils');
+  return {
+    ...actual,    // 保留所有真实实现
+    sleep: jest.fn() // 只模拟 sleep 函数
+  };
+});
+
+
+// Mock require for react-native-zeroconf
+jest.mock('react-native-zeroconf', () => undefined, { virtual: true });
+
+// Mock fetch
+global.fetch = jest.fn();
+
+describe('Server', () => {
+  let server: Server;
+  
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    (global.fetch as jest.Mock).mockReset();
+  });
+
+  describe('Constructor and URL Management', () => {
+    it('should initialize with default values', () => {
+      server = new Server();
+      expect(server.getBaseUrlArr()).toEqual(new Set([]));
+    });
+
+    it('should initialize with custom URL', () => {
+      server = new Server('localhost:8080');
+      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
+    });
+
+    it('should handle URLs with and without http prefix', () => {
+      server = new Server();
+      server.updateUrl('localhost:8080');
+      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
+      
+      server.updateUrl('http://localhost:8080');
+      expect(server.getBaseUrlArr()).toEqual(new Set(['http://localhost:8080']));
+    });
+  });
+
+  describe('ZeroConf Handling', () => {
+    it('should handle case when zeroconf is not available', () => {
+      server = new Server();
+      const mockListener = jest.fn();
+      server.addUrlsListener(mockListener);
+      
+      // Since Zeroconf is not available, the listener should not be called
+      expect(mockListener).not.toHaveBeenCalled();
+    });
+
+    // Test with mock Zeroconf implementation
+    it('should handle case when zeroconf is available', () => {
+      // Temporarily mock require to return a mock Zeroconf implementation
+      const mockZeroconfInstance = {
+        on: jest.fn(),
+        scan: jest.fn()
+      };
+      
+      jest.doMock('react-native-zeroconf', () => ({
+        __esModule: true,
+        default: jest.fn(() => mockZeroconfInstance)
+      }), { virtual: true });
+
+      server = new Server();
+      const mockListener = jest.fn();
+      server.addUrlsListener(mockListener);
+
+      // Verify that Zeroconf methods were not called since module is mocked as undefined
+      expect(mockListener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Data Sending', () => {
+    beforeEach(() => {
+      server = new Server('localhost:8080');
+      (global.fetch as jest.Mock).mockImplementation(() => 
+        Promise.resolve({ ok: true })
+      );
+    });
+
+    it('should send log data', async () => {
+      const testData = { message: 'test log' };
+      await server.log(testData);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'http://localhost:8080/log',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json;charset=utf-8'
+          },
+          body: expect.any(String)
+        })
+      );
+    });
+
+    it('should send network data', async () => {
+      const testData = { url: 'test.com' };
+      await server.network(testData);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'http://localhost:8080/network',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json;charset=utf-8'
+          },
+          body: expect.any(String)
+        })
+      );
+    });
+
+    it('should handle timeout', async () => {
+      server.updateTimeout(100);
+      (sleep as jest.Mock).mockImplementation(() => Promise.reject(new Error('Timeout')));
+      
+      const testData = { message: 'test' };
+      await server.log(testData);
+
+      expect(global.fetch).toHaveBeenCalled();
+      expect(sleep).toHaveBeenCalledWith(100, true);
+    });
+  });
+
+  describe('Base Data Management', () => {
+    it('should update base data', async () => {
+      server = new Server('localhost:8080');
+      const baseData = { userId: '123' };
+      server.updateBaseData(baseData);
+
+      await server.log({ message: 'test' });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"userId":"123"')
+        })
+      );
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -1,114 +1,236 @@
-import logger from '../logger';
-import { createClassWithErrorHandling, hasPort } from '../utils';
-
-describe('createClassWithErrorHandling', () => {
-  class TestClass {
-    normalMethod(): string {
-      return 'normal';
-    }
-
-    errorMethod(): void {
-      throw new Error('Test error');
-    }
-
-    async asyncMethod(): Promise<string> {
-      return 'async';
-    }
-
-    async asyncErrorMethod(): Promise<void> {
-      throw new Error('Async test error');
-    }
-  }
-
-  let consoleErrorSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    consoleErrorSpy = jest.spyOn(logger, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
-  });
-
-  test('should not interfere with normal methods', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    expect(instance.normalMethod()).toBe('normal');
-  });
-
-  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));
-  });
-
-  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');
-  });
-
-  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));
-  });
-
-  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));
-  });
-});
-
-
-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);
-  });
-
-  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);
-  });
-
-  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);
-  });
-
-  test('should return false for empty input', () => {
-    expect(hasPort('')).toBe(false);
-  });
-
-  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);
-  });
-
-  test('should handle URLs with default ports correctly', () => {
-    expect(hasPort('http://example.com:80')).toBe(false);
-    expect(hasPort('https://example.com:443')).toBe(false);
-  });
-
-  test('should handle URLs with IPv6 addresses', () => {
-    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
-    expect(hasPort('https://[2001:db8::1]')).toBe(false);
-  });
-
-  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);
-  });
-});
+import { hasPort, formDataToString, sleep, typeReplacer } from '../utils';
+
+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);
+  });
+
+  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);
+  });
+
+  it('should handle URLs with default ports correctly', () => {
+    expect(hasPort('http://example.com:80')).toBe(false);
+    expect(hasPort('https://example.com:443')).toBe(false);
+  });
+
+  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);
+  });
+});
+
+describe('formDataToString', () => {
+  let mockFormData: FormData;
+
+  beforeEach(() => {
+    // 创建一个模拟的 FormData 对象
+    mockFormData = new FormData();
+    // 模拟 getParts 方法
+    (mockFormData as any).getParts = jest.fn();
+  });
+
+  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$/);
+  });
+
+  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/);
+  });
+
+  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); // 开始、中间、结束
+  });
+
+  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/);
+  });
+});
+
+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 的误差
+  });
+
+  // 测试超时拒绝情况
+  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');
+  });
+
+  // 测试 Function 类型转换
+  it('should convert Function to string', () => {
+    const fn = function test() {
+      return 'hello';
+    };
+    const result = typeReplacer('fn', fn);
+    expect(result).toContain('function test()');
+  });
+
+  // 测试 Symbol 类型转换
+  it('should convert Symbol to string', () => {
+    const sym = Symbol('test');
+    expect(typeReplacer('symbol', sym)).toBe('Symbol(test)');
+  });
+
+  // 测试 BigInt 类型转换
+  it('should convert BigInt to string', () => {
+    const big = BigInt(9007199254740991);
+    expect(typeReplacer('bigint', big)).toBe('9007199254740991');
+  });
+
+  // 测试 RegExp 类型转换
+  it('should convert RegExp to string', () => {
+    const regex = /test/g;
+    expect(typeReplacer('regex', regex)).toBe('/test/g');
+  });
+
+  // 测试 Set 类型转换
+  it('should convert Set to array', () => {
+    const set = new Set([1, 2, 3]);
+    expect(typeReplacer('set', set)).toEqual([1, 2, 3]);
+  });
+
+  // 测试 Map 类型转换
+  it('should convert Map to object', () => {
+    const map = new Map([
+      ['key1', 'value1'],
+      ['key2', 'value2'],
+    ]);
+    expect(typeReplacer('map', map)).toEqual({
+      key1: 'value1',
+      key2: 'value2',
+    });
+  });
+
+  // 测试普通值不变
+  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);
+  });
+
+  // 测试普通对象不变
+  it('should return objects as is', () => {
+    const obj = { name: 'test', age: 25 };
+    expect(typeReplacer('object', obj)).toEqual(obj);
+  });
+});