matterbridge-roborock-vacuum-plugin
Version:
Matterbridge Roborock Vacuum Plugin
88 lines • 3.94 kB
JavaScript
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 { V1PendingResponseTracker } from '../../../roborockCommunication/routing/services/v1PendingResponseTracker.js';
import { asPartial, asType, createMockLogger, mkUser } from '../../helpers/testUtils.js';
class TestClient extends AbstractClient {
clientName = 'TestClient';
shouldReconnect = false;
connected = false;
constructor(logger, context, responseBroadcaster, responseTracker) {
super(logger, context, responseBroadcaster, responseTracker);
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 responseTracker;
let responseBroadcaster;
beforeEach(() => {
logger = createMockLogger();
const userdata = mkUser();
context = new MessageContext(userdata);
responseTracker = new V1PendingResponseTracker(logger);
responseBroadcaster = new V1ResponseBroadcaster(responseTracker, logger);
client = new TestClient(logger, context, responseBroadcaster, responseTracker);
});
it('get resolves when responseTracker receives response', async () => {
const request = asPartial({ messageId: 123, method: 'test_method' });
const mockResponse = asPartial({
duid: 'DUID123',
header: asPartial({}),
get: () => 'response_data',
isForProtocol: () => true,
isForProtocols: () => true,
isForStatus: () => true,
});
vi.spyOn(responseTracker, 'waitFor').mockResolvedValue(mockResponse);
const result = await client.get('DUID123', request);
expect(result).toEqual(mockResponse);
});
it('get returns undefined when error occurs', async () => {
const request = asPartial({ messageId: 456, method: 'failing_method' });
vi.spyOn(responseTracker, 'waitFor').mockRejectedValue(new Error('test error'));
const result = await client.get('DUID456', request);
expect(result).toBeUndefined();
expect(vi.mocked(logger.error).mock.calls.some((args) => String(args[0]).includes('test error'))).toBe(true);
});
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);
});
});
//# sourceMappingURL=abstractClient.test.js.map