matterbridge-roborock-vacuum-plugin/dist/tests/roborockCommunication/broadcast/abstractClient.test.js

Matterbridge Roborock Vacuum Plugin

import { beforeEach, describe, expect, it, vi } from 'vitest';
import { MessageContext } from '../../../roborockCommunication/models/index.js';
import { AbstractClient } from '../../../roborockCommunication/routing/abstractClient.js';
import { V1ResponseBroadcaster } from '../../../roborockCommunication/routing/listeners/v1ResponseBroadcaster.js';
import { asPartial, asType, createMockLogger, mkUser } from '../../helpers/testUtils.js';
class TestClient extends AbstractClient {
    clientName = 'TestClient';
    shouldReconnect = false;
    connected = false;
    constructor(logger, context, responseBroadcaster) {
        super(logger, context, responseBroadcaster);
        this.initializeConnectionStateListener(asPartial({}));
    }
    isConnected() {
        return this.connected;
    }
    connect() {
        this.connected = true;
    }
    async disconnect() {
        this.connected = false;
    }
    sendInternal(_duid, _request) {
        // Mock implementation - do nothing
    }
}
describe('AbstractClient', () => {
    let client;
    let logger;
    let context;
    let responseBroadcaster;
    beforeEach(() => {
        logger = createMockLogger();
        const userdata = mkUser();
        context = new MessageContext(userdata);
        responseBroadcaster = new V1ResponseBroadcaster(logger);
        client = new TestClient(logger, context, responseBroadcaster);
    });
    it('query resolves when broadcaster dispatches a matching message', async () => {
        const request = asPartial({ messageId: 123, method: 'test_method' });
        const msg = asPartial({ duid: 'DUID123', isSimpleOkResponse: () => false });
        vi.spyOn(client, 'sendInternal').mockImplementation(() => {
            // Defer so waitFor() has a chance to set this.resolve before onMessage fires
            void Promise.resolve().then(() => responseBroadcaster.onMessage(msg));
        });
        const parseFn = vi.fn().mockReturnValue('parsed-value');
        const result = await client.query('DUID123', request, parseFn);
        expect(result).toBe('parsed-value');
    });
    it('query returns undefined when timeout occurs', async () => {
        const request = asPartial({ messageId: 456, method: 'failing_method' });
        vi.spyOn(client, 'sendInternal').mockImplementation(() => { });
        const result = await client.query('DUID456', request, () => undefined, 1);
        expect(result).toBeUndefined();
    });
    it('registerDevice delegates to context', () => {
        const spy = vi.spyOn(context, 'registerDevice');
        client.registerDevice('DUID789', 'localKey123', '1.0', 12345);
        expect(spy).toHaveBeenCalledWith('DUID789', 'localKey123', '1.0', 12345);
    });
    it('registerConnectionListener adds listener to chain', () => {
        const listener = asPartial({ onConnected: vi.fn() });
        client.registerConnectionListener(listener);
        expect(asType(client)['connectionBroadcaster']['listeners']).toContain(listener);
    });
    it('registerMessageListener adds listener to chain', () => {
        const listener = asPartial({
            name: 'test-listener',
            duid: 'DUID123',
            onMessage: vi.fn().mockResolvedValue(undefined),
        });
        client.registerMessageListener(listener);
        expect(asType(client)['responseBroadcaster']['listeners']).toContain(listener);
    });
    it('isConnected returns connection state', () => {
        expect(client.isConnected()).toBe(false);
        client.connect();
        expect(client.isConnected()).toBe(true);
    });
    it('isReady delegates to isConnected', () => {
        expect(client.isReady()).toBe(false);
        client.connect();
        expect(client.isReady()).toBe(true);
    });
});
//# sourceMappingURL=abstractClient.test.js.map