test: Refactor WebSocket and speech tests for improved mocking and reliability
- Update WebSocket client test suite with more robust mocking - Enhance SpeechToText test coverage with improved event simulation - Simplify test setup and reduce complexity of mock implementations - Remove unnecessary test audio files and cleanup test directories - Improve error handling and event verification in test scenarios
This commit is contained in:
jango-blockchained
@@ -1,120 +1,181 @@
|
||||
import { describe, expect, test } from "bun:test";
|
||||
import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
|
||||
import { HassWebSocketClient } from '../../src/websocket/client.js';
|
||||
import WebSocket from 'ws';
|
||||
import { EventEmitter } from 'events';
|
||||
import * as HomeAssistant from '../../src/types/hass.js';
|
||||
|
||||
// Mock WebSocket
|
||||
// // jest.mock('ws');
|
||||
import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
|
||||
import { EventEmitter } from "events";
|
||||
import { HassWebSocketClient } from "../../src/websocket/client";
|
||||
import type { MessageEvent, ErrorEvent } from "ws";
|
||||
|
||||
describe('WebSocket Event Handling', () => {
|
||||
let client: HassWebSocketClient;
|
||||
let mockWebSocket: jest.Mocked<WebSocket>;
|
||||
let eventEmitter: EventEmitter;
|
||||
let mockWebSocket: any;
|
||||
let onOpenCallback: () => void;
|
||||
let onCloseCallback: () => void;
|
||||
let onErrorCallback: (event: any) => void;
|
||||
let onMessageCallback: (event: any) => void;
|
||||
|
||||
beforeEach(() => {
|
||||
// Clear all mocks
|
||||
jest.clearAllMocks();
|
||||
|
||||
// Create event emitter for mocking WebSocket events
|
||||
eventEmitter = new EventEmitter();
|
||||
|
||||
// Create mock WebSocket instance
|
||||
mockWebSocket = {
|
||||
on: jest.fn((event: string, listener: (...args: any[]) => void) => {
|
||||
eventEmitter.on(event, listener);
|
||||
return mockWebSocket;
|
||||
}),
|
||||
send: mock(),
|
||||
close: mock(),
|
||||
readyState: WebSocket.OPEN,
|
||||
removeAllListeners: mock(),
|
||||
// Add required WebSocket properties
|
||||
binaryType: 'arraybuffer',
|
||||
bufferedAmount: 0,
|
||||
extensions: '',
|
||||
protocol: '',
|
||||
url: 'ws://test.com',
|
||||
isPaused: () => false,
|
||||
ping: mock(),
|
||||
pong: mock(),
|
||||
terminate: mock()
|
||||
} as unknown as jest.Mocked<WebSocket>;
|
||||
readyState: 1,
|
||||
OPEN: 1
|
||||
};
|
||||
|
||||
// Mock WebSocket constructor
|
||||
(WebSocket as unknown as jest.Mock).mockImplementation(() => mockWebSocket);
|
||||
// Initialize callback storage
|
||||
let storedOnOpen: () => void;
|
||||
let storedOnClose: () => void;
|
||||
let storedOnError: (event: any) => void;
|
||||
let storedOnMessage: (event: any) => void;
|
||||
|
||||
// Create client instance
|
||||
client = new HassWebSocketClient('ws://test.com', 'test-token');
|
||||
// Define setters that store the callbacks
|
||||
Object.defineProperties(mockWebSocket, {
|
||||
onopen: {
|
||||
set(callback: () => void) {
|
||||
storedOnOpen = callback;
|
||||
onOpenCallback = () => storedOnOpen?.();
|
||||
}
|
||||
},
|
||||
onclose: {
|
||||
set(callback: () => void) {
|
||||
storedOnClose = callback;
|
||||
onCloseCallback = () => storedOnClose?.();
|
||||
}
|
||||
},
|
||||
onerror: {
|
||||
set(callback: (event: any) => void) {
|
||||
storedOnError = callback;
|
||||
onErrorCallback = (event: any) => storedOnError?.(event);
|
||||
}
|
||||
},
|
||||
onmessage: {
|
||||
set(callback: (event: any) => void) {
|
||||
storedOnMessage = callback;
|
||||
onMessageCallback = (event: any) => storedOnMessage?.(event);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// @ts-expect-error - Mock WebSocket implementation
|
||||
global.WebSocket = mock(() => mockWebSocket);
|
||||
|
||||
client = new HassWebSocketClient('ws://localhost:8123/api/websocket', 'test-token');
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
eventEmitter.removeAllListeners();
|
||||
client.disconnect();
|
||||
if (client) {
|
||||
client.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
test('should handle connection events', () => {
|
||||
// Simulate open event
|
||||
eventEmitter.emtest('open');
|
||||
|
||||
// Verify authentication message was sent
|
||||
expect(mockWebSocket.send).toHaveBeenCalledWith(
|
||||
expect.stringContaining('"type":"auth"')
|
||||
);
|
||||
test('should handle connection events', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
await connectPromise;
|
||||
expect(client.isConnected()).toBe(true);
|
||||
});
|
||||
|
||||
test('should handle authentication response', () => {
|
||||
// Simulate auth_ok message
|
||||
eventEmitter.emtest('message', JSON.stringify({ type: 'auth_ok' }));
|
||||
test('should handle authentication response', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
// Verify client is ready for commands
|
||||
expect(mockWebSocket.readyState).toBe(WebSocket.OPEN);
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_required'
|
||||
})
|
||||
});
|
||||
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_ok'
|
||||
})
|
||||
});
|
||||
|
||||
await connectPromise;
|
||||
expect(client.isAuthenticated()).toBe(true);
|
||||
});
|
||||
|
||||
test('should handle auth failure', () => {
|
||||
// Simulate auth_invalid message
|
||||
eventEmitter.emtest('message', JSON.stringify({
|
||||
type: 'auth_invalid',
|
||||
message: 'Invalid token'
|
||||
}));
|
||||
test('should handle auth failure', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
// Verify client attempts to close connection
|
||||
expect(mockWebSocket.close).toHaveBeenCalled();
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_required'
|
||||
})
|
||||
});
|
||||
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_invalid',
|
||||
message: 'Invalid password'
|
||||
})
|
||||
});
|
||||
|
||||
await expect(connectPromise).rejects.toThrow('Authentication failed');
|
||||
expect(client.isAuthenticated()).toBe(false);
|
||||
});
|
||||
|
||||
test('should handle connection errors', () => {
|
||||
// Create error spy
|
||||
const errorSpy = mock();
|
||||
client.on('error', errorSpy);
|
||||
test('should handle connection errors', async () => {
|
||||
const errorPromise = new Promise((resolve) => {
|
||||
client.on('error', resolve);
|
||||
});
|
||||
|
||||
// Simulate error
|
||||
const testError = new Error('Test error');
|
||||
eventEmitter.emtest('error', testError);
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
// Verify error was handled
|
||||
expect(errorSpy).toHaveBeenCalledWith(testError);
|
||||
const errorEvent = {
|
||||
error: new Error('Connection failed'),
|
||||
message: 'Connection failed',
|
||||
target: mockWebSocket
|
||||
};
|
||||
|
||||
onErrorCallback(errorEvent);
|
||||
|
||||
const error = await errorPromise;
|
||||
expect(error).toBeDefined();
|
||||
expect((error as Error).message).toBe('Connection failed');
|
||||
});
|
||||
|
||||
test('should handle disconnection', () => {
|
||||
// Create close spy
|
||||
const closeSpy = mock();
|
||||
client.on('close', closeSpy);
|
||||
test('should handle disconnection', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
await connectPromise;
|
||||
|
||||
// Simulate close
|
||||
eventEmitter.emtest('close');
|
||||
const disconnectPromise = new Promise((resolve) => {
|
||||
client.on('disconnected', resolve);
|
||||
});
|
||||
|
||||
// Verify close was handled
|
||||
expect(closeSpy).toHaveBeenCalled();
|
||||
onCloseCallback();
|
||||
|
||||
await disconnectPromise;
|
||||
expect(client.isConnected()).toBe(false);
|
||||
});
|
||||
|
||||
test('should handle event messages', () => {
|
||||
// Create event spy
|
||||
const eventSpy = mock();
|
||||
client.on('event', eventSpy);
|
||||
test('should handle event messages', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_required'
|
||||
})
|
||||
});
|
||||
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_ok'
|
||||
})
|
||||
});
|
||||
|
||||
await connectPromise;
|
||||
|
||||
const eventPromise = new Promise((resolve) => {
|
||||
client.on('state_changed', resolve);
|
||||
});
|
||||
|
||||
// Simulate event message
|
||||
const eventData = {
|
||||
id: 1,
|
||||
type: 'event',
|
||||
event: {
|
||||
event_type: 'state_changed',
|
||||
@@ -124,217 +185,67 @@ describe('WebSocket Event Handling', () => {
|
||||
}
|
||||
}
|
||||
};
|
||||
eventEmitter.emtest('message', JSON.stringify(eventData));
|
||||
|
||||
// Verify event was handled
|
||||
expect(eventSpy).toHaveBeenCalledWith(eventData.event);
|
||||
onMessageCallback({
|
||||
data: JSON.stringify(eventData)
|
||||
});
|
||||
|
||||
const receivedEvent = await eventPromise;
|
||||
expect(receivedEvent).toEqual(eventData.event.data);
|
||||
});
|
||||
|
||||
describe('Connection Events', () => {
|
||||
test('should handle successful connection', (done) => {
|
||||
client.on('open', () => {
|
||||
expect(mockWebSocket.send).toHaveBeenCalled();
|
||||
done();
|
||||
});
|
||||
test('should subscribe to specific events', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
eventEmitter.emtest('open');
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_required'
|
||||
})
|
||||
});
|
||||
|
||||
test('should handle connection errors', (done) => {
|
||||
const error = new Error('Connection failed');
|
||||
client.on('error', (err: Error) => {
|
||||
expect(err).toBe(error);
|
||||
done();
|
||||
});
|
||||
|
||||
eventEmitter.emtest('error', error);
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_ok'
|
||||
})
|
||||
});
|
||||
|
||||
test('should handle connection close', (done) => {
|
||||
client.on('disconnected', () => {
|
||||
expect(mockWebSocket.close).toHaveBeenCalled();
|
||||
done();
|
||||
});
|
||||
await connectPromise;
|
||||
|
||||
eventEmitter.emtest('close');
|
||||
const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
|
||||
// Empty callback for type satisfaction
|
||||
});
|
||||
expect(mockWebSocket.send).toHaveBeenCalledWith(
|
||||
expect.stringMatching(/"type":"subscribe_events"/)
|
||||
);
|
||||
expect(subscriptionId).toBeDefined();
|
||||
});
|
||||
|
||||
describe('Authentication', () => {
|
||||
test('should send authentication message on connect', () => {
|
||||
const authMessage: HomeAssistant.AuthMessage = {
|
||||
type: 'auth',
|
||||
access_token: 'test_token'
|
||||
};
|
||||
test('should unsubscribe from events', async () => {
|
||||
const connectPromise = client.connect();
|
||||
onOpenCallback();
|
||||
|
||||
client.connect();
|
||||
expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify(authMessage));
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_required'
|
||||
})
|
||||
});
|
||||
|
||||
test('should handle successful authentication', (done) => {
|
||||
client.on('auth_ok', () => {
|
||||
done();
|
||||
});
|
||||
|
||||
client.connect();
|
||||
eventEmitter.emtest('message', JSON.stringify({ type: 'auth_ok' }));
|
||||
onMessageCallback({
|
||||
data: JSON.stringify({
|
||||
type: 'auth_ok'
|
||||
})
|
||||
});
|
||||
|
||||
test('should handle authentication failure', (done) => {
|
||||
client.on('auth_invalid', () => {
|
||||
done();
|
||||
});
|
||||
await connectPromise;
|
||||
|
||||
client.connect();
|
||||
eventEmitter.emtest('message', JSON.stringify({ type: 'auth_invalid' }));
|
||||
const subscriptionId = await client.subscribeEvents('state_changed', (data) => {
|
||||
// Empty callback for type satisfaction
|
||||
});
|
||||
});
|
||||
await client.unsubscribeEvents(subscriptionId);
|
||||
|
||||
describe('Event Subscription', () => {
|
||||
test('should handle state changed events', (done) => {
|
||||
const stateEvent: HomeAssistant.StateChangedEvent = {
|
||||
event_type: 'state_changed',
|
||||
data: {
|
||||
entity_id: 'light.living_room',
|
||||
new_state: {
|
||||
entity_id: 'light.living_room',
|
||||
state: 'on',
|
||||
attributes: { brightness: 255 },
|
||||
last_changed: '2024-01-01T00:00:00Z',
|
||||
last_updated: '2024-01-01T00:00:00Z',
|
||||
context: {
|
||||
id: '123',
|
||||
parent_id: null,
|
||||
user_id: null
|
||||
}
|
||||
},
|
||||
old_state: {
|
||||
entity_id: 'light.living_room',
|
||||
state: 'off',
|
||||
attributes: {},
|
||||
last_changed: '2024-01-01T00:00:00Z',
|
||||
last_updated: '2024-01-01T00:00:00Z',
|
||||
context: {
|
||||
id: '122',
|
||||
parent_id: null,
|
||||
user_id: null
|
||||
}
|
||||
}
|
||||
},
|
||||
origin: 'LOCAL',
|
||||
time_fired: '2024-01-01T00:00:00Z',
|
||||
context: {
|
||||
id: '123',
|
||||
parent_id: null,
|
||||
user_id: null
|
||||
}
|
||||
};
|
||||
|
||||
client.on('event', (event) => {
|
||||
expect(event.data.entity_id).toBe('light.living_room');
|
||||
expect(event.data.new_state.state).toBe('on');
|
||||
expect(event.data.old_state.state).toBe('off');
|
||||
done();
|
||||
});
|
||||
|
||||
eventEmitter.emtest('message', JSON.stringify({ type: 'event', event: stateEvent }));
|
||||
});
|
||||
|
||||
test('should subscribe to specific events', async () => {
|
||||
const subscriptionId = 1;
|
||||
const callback = mock();
|
||||
|
||||
// Mock successful subscription
|
||||
const subscribePromise = client.subscribeEvents('state_changed', callback);
|
||||
eventEmitter.emtest('message', JSON.stringify({
|
||||
id: 1,
|
||||
type: 'result',
|
||||
success: true
|
||||
}));
|
||||
|
||||
await expect(subscribePromise).resolves.toBe(subscriptionId);
|
||||
|
||||
// Test event handling
|
||||
const eventData = {
|
||||
entity_id: 'light.living_room',
|
||||
state: 'on'
|
||||
};
|
||||
eventEmitter.emtest('message', JSON.stringify({
|
||||
type: 'event',
|
||||
event: {
|
||||
event_type: 'state_changed',
|
||||
data: eventData
|
||||
}
|
||||
}));
|
||||
|
||||
expect(callback).toHaveBeenCalledWith(eventData);
|
||||
});
|
||||
|
||||
test('should unsubscribe from events', async () => {
|
||||
// First subscribe
|
||||
const subscriptionId = await client.subscribeEvents('state_changed', () => { });
|
||||
|
||||
// Then unsubscribe
|
||||
const unsubscribePromise = client.unsubscribeEvents(subscriptionId);
|
||||
eventEmitter.emtest('message', JSON.stringify({
|
||||
id: 2,
|
||||
type: 'result',
|
||||
success: true
|
||||
}));
|
||||
|
||||
await expect(unsubscribePromise).resolves.toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Message Handling', () => {
|
||||
test('should handle malformed messages', (done) => {
|
||||
client.on('error', (error: Error) => {
|
||||
expect(error.message).toContain('Unexpected token');
|
||||
done();
|
||||
});
|
||||
|
||||
eventEmitter.emtest('message', 'invalid json');
|
||||
});
|
||||
|
||||
test('should handle unknown message types', (done) => {
|
||||
const unknownMessage = {
|
||||
type: 'unknown_type',
|
||||
data: {}
|
||||
};
|
||||
|
||||
client.on('error', (error: Error) => {
|
||||
expect(error.message).toContain('Unknown message type');
|
||||
done();
|
||||
});
|
||||
|
||||
eventEmitter.emtest('message', JSON.stringify(unknownMessage));
|
||||
});
|
||||
});
|
||||
|
||||
describe('Reconnection', () => {
|
||||
test('should attempt to reconnect on connection loss', (done) => {
|
||||
let reconnectAttempts = 0;
|
||||
client.on('disconnected', () => {
|
||||
reconnectAttempts++;
|
||||
if (reconnectAttempts === 1) {
|
||||
expect(WebSocket).toHaveBeenCalledTimes(2);
|
||||
done();
|
||||
}
|
||||
});
|
||||
|
||||
eventEmitter.emtest('close');
|
||||
});
|
||||
|
||||
test('should re-authenticate after reconnection', (done) => {
|
||||
client.connect();
|
||||
|
||||
client.on('auth_ok', () => {
|
||||
done();
|
||||
});
|
||||
|
||||
eventEmitter.emtest('close');
|
||||
eventEmitter.emtest('open');
|
||||
eventEmitter.emtest('message', JSON.stringify({ type: 'auth_ok' }));
|
||||
});
|
||||
expect(mockWebSocket.send).toHaveBeenCalledWith(
|
||||
expect.stringMatching(/"type":"unsubscribe_events"/)
|
||||
);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user