@qy_better_lib/hooks 0.1.9 → 0.2.0

package/__tests__/use-mqtt/index.test.ts

@@ -0,0 +1,392 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_mqtt } from '../../src/use-mqtt';
+
+// 模拟mqtt库
+const mockMqttClient: any = {
+  on: vi.fn(),
+  end: vi.fn(),
+  subscribe: vi.fn(),
+  unsubscribe: vi.fn(),
+  publish: vi.fn(),
+};
+
+const mockMqttModule: any = {
+  connect: vi.fn().mockReturnValue(mockMqttClient),
+};
+
+// 模拟动态导入
+vi.mock('mqtt', () => {
+  return {
+    __esModule: true,
+    default: mockMqttModule,
+  };
+});
+
+// 模拟setTimeout
+vi.useFakeTimers();
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.resetModules();
+  vi.useRealTimers();
+});
+
+describe('use_mqtt', () => {
+  it('should initialize with default values', () => {
+    const { status, connect, close, subscribe, unsubscribe, publish } = use_mqtt('mqtt://localhost:1883');
+    
+    expect(status).toBe('disconnected');
+    expect(typeof connect).toBe('function');
+    expect(typeof close).toBe('function');
+    expect(typeof subscribe).toBe('function');
+    expect(typeof unsubscribe).toBe('function');
+    expect(typeof publish).toBe('function');
+  });
+
+  it('should handle empty url', () => {
+    const { status } = use_mqtt('');
+    
+    expect(status).toBe('error');
+  });
+
+  it('should connect successfully', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    expect(mqttInstance.status).toBe('connecting');
+    
+    // 模拟连接成功 - 直接设置状态为connected
+    // 由于connect方法是异步的，我们需要等待一下
+    await new Promise(resolve => setTimeout(resolve, 0));
+    
+    // 直接检查success回调是否被调用
+    expect(mockSuccess).toHaveBeenCalled();
+  });
+
+  it('should handle connection error', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    expect(mqttInstance.status).toBe('connecting');
+    
+    // 模拟连接错误
+    const errorCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'error')?.[1];
+    if (errorCallback) {
+      errorCallback(new Error('Connection error'));
+    }
+    
+    await connectPromise;
+    
+    expect(mqttInstance.status).toBe('error');
+    expect(mockError).toHaveBeenCalled();
+  });
+
+  it('should handle connection close', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883', { reconnectPeriod: 1000 });
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    expect(mqttInstance.status).toBe('connected');
+    
+    // 模拟连接关闭
+    const closeCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'close')?.[1];
+    if (closeCallback) {
+      closeCallback();
+    }
+    
+    expect(mqttInstance.status).toBe('disconnected');
+    
+    // 验证重连定时器
+    vi.runAllTimers();
+  });
+
+  it('should handle reconnect event', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    expect(mqttInstance.status).toBe('connected');
+    
+    // 模拟重连事件
+    const reconnectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'reconnect')?.[1];
+    if (reconnectCallback) {
+      reconnectCallback();
+    }
+    
+    expect(mqttInstance.status).toBe('connecting');
+  });
+
+  it('should close connection', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockCloseCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    expect(mqttInstance.status).toBe('connected');
+    
+    // 关闭连接
+    mqttInstance.close(mockCloseCallback);
+    
+    expect(mockMqttClient.end).toHaveBeenCalledWith(false, undefined, expect.any(Function));
+    expect(mqttInstance.status).toBe('disconnected');
+  });
+
+  it('should subscribe to topic', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockSubscribeCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 订阅主题
+    mqttInstance.subscribe('test/topic', {}, mockSubscribeCallback);
+    
+    expect(mockMqttClient.subscribe).toHaveBeenCalledWith('test/topic', {}, expect.any(Function));
+  });
+
+  it('should unsubscribe from topic', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockUnsubscribeCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 取消订阅
+    mqttInstance.unsubscribe('test/topic', mockUnsubscribeCallback);
+    
+    expect(mockMqttClient.unsubscribe).toHaveBeenCalledWith('test/topic', expect.any(Function));
+  });
+
+  it('should publish message', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockPublishCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 发布消息
+    mqttInstance.publish('test/topic', 'test message', {}, mockPublishCallback);
+    
+    expect(mockMqttClient.publish).toHaveBeenCalledWith('test/topic', 'test message', {}, expect.any(Function));
+  });
+
+  it('should handle subscribe without connection', () => {
+    const { subscribe } = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSubscribeCallback = vi.fn();
+    
+    subscribe('test/topic', {}, mockSubscribeCallback);
+    
+    expect(mockSubscribeCallback).toHaveBeenCalledWith(new Error('客户端未连接'), []);
+  });
+
+  it('should handle unsubscribe without connection', () => {
+    const { unsubscribe } = use_mqtt('mqtt://localhost:1883');
+    
+    const mockUnsubscribeCallback = vi.fn();
+    
+    unsubscribe('test/topic', mockUnsubscribeCallback);
+    
+    expect(mockUnsubscribeCallback).toHaveBeenCalledWith(new Error('客户端未连接'));
+  });
+
+  it('should handle publish without connection', () => {
+    const { publish } = use_mqtt('mqtt://localhost:1883');
+    
+    const mockPublishCallback = vi.fn();
+    
+    publish('test/topic', 'test message', {}, mockPublishCallback);
+    
+    expect(mockPublishCallback).toHaveBeenCalledWith(new Error('客户端未连接'));
+  });
+
+  it('should handle empty topic in subscribe', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockSubscribeCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 订阅空主题
+    mqttInstance.subscribe('', {}, mockSubscribeCallback);
+    
+    expect(mockSubscribeCallback).toHaveBeenCalledWith(new Error('订阅主题不能为空'), []);
+  });
+
+  it('should handle empty topic in unsubscribe', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockUnsubscribeCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 取消订阅空主题
+    mqttInstance.unsubscribe('', mockUnsubscribeCallback);
+    
+    expect(mockUnsubscribeCallback).toHaveBeenCalledWith(new Error('取消订阅主题不能为空'));
+  });
+
+  it('should handle empty topic in publish', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockPublishCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 发布空主题
+    mqttInstance.publish('', 'test message', {}, mockPublishCallback);
+    
+    expect(mockPublishCallback).toHaveBeenCalledWith(new Error('发布主题不能为空'));
+  });
+
+  it('should handle empty message in publish', async () => {
+    const mqttInstance = use_mqtt('mqtt://localhost:1883');
+    
+    const mockSuccess = vi.fn();
+    const mockError = vi.fn();
+    const mockReceive = vi.fn();
+    const mockPublishCallback = vi.fn();
+    
+    // 开始连接
+    const connectPromise = mqttInstance.connect({ success: mockSuccess, error: mockError, receive: mockReceive });
+    
+    // 模拟连接成功
+    const connectCallback = mockMqttClient.on.mock.calls.find((call: any[]) => call[0] === 'connect')?.[1];
+    if (connectCallback) {
+      connectCallback();
+    }
+    
+    await connectPromise;
+    
+    // 发布空消息
+    mqttInstance.publish('test/topic', '', {}, mockPublishCallback);
+    
+    expect(mockPublishCallback).toHaveBeenCalledWith(new Error('发布消息不能为空'));
+  });
+});