@wutiange/log-listener-plugin 1.3.1 → 2.0.1-alpha.1

package/src/__tests__/HTTPInterceptor.test.ts

@@ -0,0 +1,322 @@
+import { httpInterceptor } from '../HTTPInterceptor';
+import XHRInterceptor from 'react-native/Libraries/Network/XHRInterceptor';
+import { formDataToString } from '../utils';
+
+// Mock dependencies
+jest.mock('buffer', () => ({
+  Blob: jest.fn(),
+}));
+jest.mock('../utils', () => ({
+  createClassWithErrorHandling: jest.fn(Class => Class),
+  formDataToString: jest.fn(),
+}));
+
+// 在文件顶部添加这个模拟
+class MockFormData {
+  private data: Record<string, string> = {};
+
+  append(key: string, value: string) {
+    this.data[key] = value;
+  }
+
+  get(key: string) {
+    return this.data[key];
+  }
+
+  // 可以根据需要添加更多方法
+}
+
+class MockBlob {
+  private content: string;
+  type: any
+  constructor(parts: any, options: any = {}) {
+    this.content = parts ? parts.join('') : '';
+    this.type = options.type || '';
+  }
+
+  text(): Promise<string> {
+    return Promise.resolve(this.content);
+  }
+
+  arrayBuffer() {
+    return Promise.resolve(new ArrayBuffer(0));
+  }
+}
+// 全局声明，以避免 TypeScript 错误
+declare global {
+  // @ts-ignore
+  var FormData: typeof MockFormData;
+}
+
+// 在测试套件开始前设置全局 FormData
+beforeAll(() => {
+  // @ts-ignore
+  global.FormData = MockFormData;
+});
+
+// 在测试套件结束后清理
+afterAll(() => {
+  // @ts-ignore
+  delete global.FormData;
+});
+
+describe('HTTPInterceptor', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    console.warn = jest.fn();
+    httpInterceptor.reset();
+    (XHRInterceptor.isInterceptorEnabled as jest.Mock).mockReturnValue(false);
+  });
+
+  describe('enable', () => {
+    it('should enable interception', () => {
+      httpInterceptor.enable();
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalled();
+    });
+
+    it('should not enable if already enabled', () => {
+      httpInterceptor.enable();
+      httpInterceptor.enable();
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle ignored hosts', () => {
+      httpInterceptor.enable({ ignoredHosts: ['example.com'] });
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalled();
+    });
+
+    it('should handle ignored patterns', () => {
+      httpInterceptor.enable({ ignoredPatterns: [/^GET https:\/\/test\.com/] });
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalled();
+    });
+
+    it('should handle ignored URLs', () => {
+      httpInterceptor.enable({ ignoredUrls: ['https://example.com/api'] });
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalled();
+    });
+
+    it('should warn if another interceptor is running', () => {
+      (XHRInterceptor.isInterceptorEnabled as jest.Mock).mockReturnValue(true);
+      console.warn = jest.fn();
+      httpInterceptor.enable();
+      expect(console.warn).toHaveBeenCalled();
+    });
+
+    it('should force enable if specified', () => {
+      (XHRInterceptor.isInterceptorEnabled as jest.Mock).mockReturnValue(true);
+      httpInterceptor.enable({ forceEnable: true });
+      expect(XHRInterceptor.enableInterception).toHaveBeenCalled();
+    });
+  });
+
+  describe('disable', () => {
+    it('should disable interception', () => {
+      httpInterceptor.enable();
+      httpInterceptor.disable();
+      expect(XHRInterceptor.disableInterception).toHaveBeenCalled();
+    });
+
+    it('should not disable if not enabled', () => {
+      httpInterceptor.disable();
+      expect(XHRInterceptor.disableInterception).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('listeners', () => {
+    it('should add and remove listeners', () => {
+      const listener = jest.fn();
+      const removeListener = httpInterceptor.addListener('open', listener);
+      expect(httpInterceptor['userListeners'].length).toBe(1);
+      removeListener();
+      expect(httpInterceptor['userListeners'].length).toBe(0);
+    });
+
+    it('should not add duplicate listeners', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('open', listener);
+      httpInterceptor.addListener('open', listener);
+      expect(httpInterceptor['userListeners'].length).toBe(1);
+    });
+
+    it('should remove specific listener', () => {
+      const listener1 = jest.fn();
+      const listener2 = jest.fn();
+      httpInterceptor.addListener('open', listener1);
+      httpInterceptor.addListener('open', listener2);
+      httpInterceptor.removeListener('open', listener1);
+      expect(httpInterceptor['userListeners'].length).toBe(1);
+      expect(httpInterceptor['userListeners'][0][1]).toBe(listener2);
+    });
+
+    it('should remove all listeners', () => {
+      httpInterceptor.addListener('open', jest.fn());
+      httpInterceptor.addListener('send', jest.fn());
+      httpInterceptor.removeAllListener();
+      expect(httpInterceptor['userListeners'].length).toBe(0);
+    });
+  });
+
+  describe('request handling', () => {
+    let openCallback: Function;
+    let requestHeaderCallback: Function;
+    let headerReceivedCallback: Function;
+    let sendCallback: Function;
+    let responseCallback: Function;
+
+    beforeEach(() => {
+      httpInterceptor.enable();
+      openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      requestHeaderCallback = (XHRInterceptor.setRequestHeaderCallback as jest.Mock).mock.calls[0][0];
+      headerReceivedCallback = (XHRInterceptor.setHeaderReceivedCallback as jest.Mock).mock.calls[0][0];
+      sendCallback = (XHRInterceptor.setSendCallback as jest.Mock).mock.calls[0][0];
+      responseCallback = (XHRInterceptor.setResponseCallback as jest.Mock).mock.calls[0][0];
+    });
+
+    it('should handle open event', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('open', listener);
+      const xhr = {}
+      openCallback('GET', 'https://example.com', xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        method: 'GET',
+        url: 'https://example.com',
+      }));
+    });
+
+    it('should handle request header event', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('requestHeader', listener);
+      const xhr = {}
+      openCallback('GET', 'https://example.com', xhr);
+      requestHeaderCallback('Content-Type', 'application/json', xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        requestHeaders: { 'Content-Type': 'application/json' },
+      }));
+    });
+
+    it('should handle header received event', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('headerReceived', listener);
+      const xhr: {[key in string]: any} = {}
+      openCallback('GET', 'https://example.com', xhr);
+      xhr.responseHeaders = { 'Content-Type': 'application/json' }
+      headerReceivedCallback('application/json', 100, {}, xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        responseContentType: 'application/json',
+        responseSize: 100,
+        responseHeaders: { 'Content-Type': 'application/json' },
+      }));
+    });
+
+    it('should handle send event with JSON data', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('send', listener);
+      const xhr = {}
+      openCallback('POST', 'https://example.com', xhr);
+      sendCallback(JSON.stringify({ key: 'value' }), xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        requestData: { key: 'value' },
+      }));
+    });
+
+    it('should handle send event with FormData', () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('send', listener);
+      const xhr = {}
+      openCallback('POST', 'https://example.com', xhr);
+      const formData = new FormData();
+      formData.append('key', 'value');
+      (formDataToString as jest.Mock).mockReturnValue('key=value');
+      sendCallback(formData, xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        requestData: 'key=value',
+      }));
+    });
+
+    it('should handle response event', async () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('response', listener);
+      const xhr = {}
+      openCallback('GET', 'https://example.com', xhr);
+      await responseCallback(200, 1000, { data: 'response' }, 'https://example.com', 'json', xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        status: 200,
+        timeout: 1000,
+        responseData: { data: 'response' },
+        responseURL: 'https://example.com',
+        responseType: 'json',
+      }));
+    });
+
+    it('should handle response event with blob data', async () => {
+      const listener = jest.fn();
+      httpInterceptor.addListener('response', listener);
+      const xhr = {}
+      openCallback('GET', 'https://example.com', xhr);
+      const mockBlob = new MockBlob(['blob content']);
+      await responseCallback(200, 1000, mockBlob, 'https://example.com', 'blob', xhr);
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+        responseData: 'blob content',
+      }));
+    });
+  });
+
+  describe('error handling', () => {
+    beforeEach(() => {
+      httpInterceptor.enable();
+    })
+    it('should handle errors in listeners', async () => {
+      const errorListener = jest.fn(() => {
+        throw new Error('Listener error');
+      });
+      httpInterceptor.addListener('open', errorListener);
+      console.warn = jest.fn();
+      const xhr = {}
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      openCallback('GET', 'https://example.com', xhr);
+      
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Listener error'));
+    });
+  });
+
+  describe('ignored requests', () => {
+    it('should ignore requests to ignored hosts', () => {
+      httpInterceptor.enable({ ignoredHosts: ['ignored.com'] });
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const listener = jest.fn();
+      httpInterceptor.addListener('open', listener);
+      
+      openCallback('GET', 'https://ignored.com', { uniqueId: '123' });
+      expect(listener).not.toHaveBeenCalled();
+
+      openCallback('GET', 'https://example.com', { uniqueId: '124' });
+      expect(listener).toHaveBeenCalled();
+    });
+
+    it('should ignore requests to ignored URLs', () => {
+      httpInterceptor.enable({ ignoredUrls: ['https://example.com/ignored'] });
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const listener = jest.fn();
+      httpInterceptor.addListener('open', listener);
+      
+      openCallback('GET', 'https://example.com/ignored', { uniqueId: '123' });
+      expect(listener).not.toHaveBeenCalled();
+
+      openCallback('GET', 'https://example.com/api', { uniqueId: '124' });
+      expect(listener).toHaveBeenCalled();
+    });
+
+    it('should ignore requests matching ignored patterns', () => {
+      httpInterceptor.enable({ ignoredPatterns: [/^GET https:\/\/test\.com/] });
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const listener = jest.fn();
+      httpInterceptor.addListener('open', listener);
+      
+      openCallback('GET', 'https://test.com/api', { uniqueId: '123' });
+      expect(listener).not.toHaveBeenCalled();
+
+      openCallback('POST', 'https://test.com/api', { uniqueId: '124' });
+      expect(listener).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/Server.test.ts

@@ -0,0 +1,175 @@
+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);
+    });
+
+    it('should handle errors and send error data', async () => {
+      (global.fetch as jest.Mock).mockImplementation(() => 
+        Promise.reject(new Error('Network error'))
+      );
+  
+      const testData = { message: 'test' };
+      await server.log(testData);
+  
+      // 修改这里的断言来匹配实际的错误格式
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('log-plugin-internal-error')
+        })
+      );
+  
+      // 如果需要更精确的检查，可以添加以下断言
+      const lastCall = (global.fetch as jest.Mock).mock.calls[(global.fetch as jest.Mock).mock.calls.length - 1];
+      const body = JSON.parse(lastCall[1].body);
+      expect(body).toMatchObject({
+        tag: 'log-plugin-internal-error',
+        level: 'error'
+      });
+    });
+  });
+
+  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

@@ -0,0 +1,113 @@
+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);
+  });
+});

package/src/common.ts

@@ -0,0 +1,70 @@
+import logger from "./logger";
+
+export const URLS_KEY = 'log-listener-plugin-urls$$key'
+export const DEFAULT_TIMEOUT = 3000
+export const LOG_KEY = '[@wutiange/log-listener-plugin 日志]'
+export enum Level {
+  LOG = 'log',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export enum Tag {
+  LOG_PLUGIN_INTERNAL_ERROR = 'log-plugin-internal-error',
+  DEFAULT = 'default',
+}
+
+const getDefaultDeviceINfo = () => {
+  try {
+    const {Platform} = require('react-native')
+    return {
+      SystemName: Platform.OS,
+      Version: Platform.Version,
+      ...Platform.constants
+    }
+  } catch (error) {
+    logger.warn(LOG_KEY, '这个插件只能在 react-native 中使用')
+    return {}
+  }
+}
+
+export const getBaseData = (): Record<string, string> => {
+  
+  try {
+    const DeviceInfo = require("react-native-device-info")?.default;
+    return {
+      Brand: DeviceInfo.getBrand(),
+      Model: DeviceInfo.getModel(),
+      AppVersion: DeviceInfo.getVersion(),
+      Carrier: DeviceInfo.getCarrierSync(),
+      Manufacturer: DeviceInfo.getManufacturerSync(),
+      SystemName: DeviceInfo.getSystemName(),
+      ...getDefaultDeviceINfo()
+    };
+  } catch (error) {
+    return getDefaultDeviceINfo()
+  }
+}
+
+export const getDefaultStorage = (): Storage => {
+  try {
+    const AsyncStorage = require("@react-native-async-storage/async-storage")?.default;
+    return AsyncStorage;
+  } catch (error) {
+    return null;
+  }
+}
+
+
+export const getErrMsg = (error: any) => {
+  return {
+    message: [
+      `${
+        error?.message ?? error
+      }--->这是@wutiange/log-listener-plugin内部错误，请提issue反馈，issue地址：https://github.com/wutiange/log-listener-plugin/issues`,
+    ],
+    tag: Tag.LOG_PLUGIN_INTERNAL_ERROR,
+    level: Level.ERROR,
+    createTime: Date.now(),
+  }
+}