@wutiange/log-listener-plugin 2.0.1-alpha.2 → 2.0.1-alpha.4

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.getUrls()).toEqual([]);
-    });
-
-    it('should initialize with custom URL', () => {
-      server = new Server('localhost:8080');
-      expect(server.getUrls()).toEqual(['http://localhost:8080']);
-    });
-
-    it('should handle URLs with and without http prefix', () => {
-      server = new Server();
-      server.updateUrl('localhost:8080');
-      expect(server.getUrls()).toEqual(['http://localhost:8080']);
-      
-      server.updateUrl('http://localhost:8080');
-      expect(server.getUrls()).toEqual(['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,113 +1,114 @@
-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(console, '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 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);
+  });
 });