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,149 +1,149 @@
|
||||
import { describe, expect, test } from "bun:test";
|
||||
import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
|
||||
import { describe, expect, test, beforeEach, afterEach, mock, spyOn } from "bun:test";
|
||||
import type { Mock } from "bun:test";
|
||||
import type { Express, Application } from 'express';
|
||||
import type { Logger } from 'winston';
|
||||
import type { Elysia } from "elysia";
|
||||
|
||||
// Types for our mocks
|
||||
interface MockApp {
|
||||
use: Mock<() => void>;
|
||||
listen: Mock<(port: number, callback: () => void) => { close: Mock<() => void> }>;
|
||||
}
|
||||
|
||||
interface MockLiteMCPInstance {
|
||||
addTool: Mock<() => void>;
|
||||
start: Mock<() => Promise<void>>;
|
||||
}
|
||||
|
||||
type MockLogger = {
|
||||
info: Mock<(message: string) => void>;
|
||||
error: Mock<(message: string) => void>;
|
||||
debug: Mock<(message: string) => void>;
|
||||
};
|
||||
|
||||
// Mock express
|
||||
const mockApp: MockApp = {
|
||||
use: mock(() => undefined),
|
||||
listen: mock((port: number, callback: () => void) => {
|
||||
callback();
|
||||
return { close: mock(() => undefined) };
|
||||
// Create mock instances
|
||||
const mockApp = {
|
||||
use: mock(() => mockApp),
|
||||
get: mock(() => mockApp),
|
||||
post: mock(() => mockApp),
|
||||
listen: mock((port: number, callback?: () => void) => {
|
||||
callback?.();
|
||||
return mockApp;
|
||||
})
|
||||
};
|
||||
const mockExpress = mock(() => mockApp);
|
||||
|
||||
// Mock LiteMCP instance
|
||||
const mockLiteMCPInstance: MockLiteMCPInstance = {
|
||||
addTool: mock(() => undefined),
|
||||
start: mock(() => Promise.resolve())
|
||||
// Create mock constructors
|
||||
const MockElysia = mock(() => mockApp);
|
||||
const mockCors = mock(() => (app: any) => app);
|
||||
const mockSwagger = mock(() => (app: any) => app);
|
||||
const mockSpeechService = {
|
||||
initialize: mock(() => Promise.resolve()),
|
||||
shutdown: mock(() => Promise.resolve())
|
||||
};
|
||||
const mockLiteMCP = mock((name: string, version: string) => mockLiteMCPInstance);
|
||||
|
||||
// Mock logger
|
||||
const mockLogger: MockLogger = {
|
||||
info: mock((message: string) => undefined),
|
||||
error: mock((message: string) => undefined),
|
||||
debug: mock((message: string) => undefined)
|
||||
// Mock the modules
|
||||
const mockModules = {
|
||||
Elysia: MockElysia,
|
||||
cors: mockCors,
|
||||
swagger: mockSwagger,
|
||||
speechService: mockSpeechService,
|
||||
config: mock(() => ({})),
|
||||
resolve: mock((...args: string[]) => args.join('/')),
|
||||
z: { object: mock(() => ({})), enum: mock(() => ({})) }
|
||||
};
|
||||
|
||||
// Mock module resolution
|
||||
const mockResolver = {
|
||||
resolve(specifier: string) {
|
||||
const mocks: Record<string, any> = {
|
||||
'elysia': { Elysia: mockModules.Elysia },
|
||||
'@elysiajs/cors': { cors: mockModules.cors },
|
||||
'@elysiajs/swagger': { swagger: mockModules.swagger },
|
||||
'../speech/index.js': { speechService: mockModules.speechService },
|
||||
'dotenv': { config: mockModules.config },
|
||||
'path': { resolve: mockModules.resolve },
|
||||
'zod': { z: mockModules.z }
|
||||
};
|
||||
return mocks[specifier] || {};
|
||||
}
|
||||
};
|
||||
|
||||
describe('Server Initialization', () => {
|
||||
let originalEnv: NodeJS.ProcessEnv;
|
||||
let consoleLog: Mock<typeof console.log>;
|
||||
let consoleError: Mock<typeof console.error>;
|
||||
let originalResolve: any;
|
||||
|
||||
beforeEach(() => {
|
||||
// Store original environment
|
||||
originalEnv = { ...process.env };
|
||||
|
||||
// Setup mocks
|
||||
(globalThis as any).express = mockExpress;
|
||||
(globalThis as any).LiteMCP = mockLiteMCP;
|
||||
(globalThis as any).logger = mockLogger;
|
||||
// Mock console methods
|
||||
consoleLog = mock(() => { });
|
||||
consoleError = mock(() => { });
|
||||
console.log = consoleLog;
|
||||
console.error = consoleError;
|
||||
|
||||
// Reset all mocks
|
||||
mockApp.use.mockReset();
|
||||
mockApp.listen.mockReset();
|
||||
mockLogger.info.mockReset();
|
||||
mockLogger.error.mockReset();
|
||||
mockLogger.debug.mockReset();
|
||||
mockLiteMCP.mockReset();
|
||||
for (const key in mockModules) {
|
||||
const module = mockModules[key as keyof typeof mockModules];
|
||||
if (typeof module === 'object' && module !== null) {
|
||||
Object.values(module).forEach(value => {
|
||||
if (typeof value === 'function' && 'mock' in value) {
|
||||
(value as Mock<any>).mockReset();
|
||||
}
|
||||
});
|
||||
} else if (typeof module === 'function' && 'mock' in module) {
|
||||
(module as Mock<any>).mockReset();
|
||||
}
|
||||
}
|
||||
|
||||
// Set default environment variables
|
||||
process.env.NODE_ENV = 'test';
|
||||
process.env.PORT = '4000';
|
||||
|
||||
// Setup module resolution mock
|
||||
originalResolve = (globalThis as any).Bun?.resolveSync;
|
||||
(globalThis as any).Bun = {
|
||||
...(globalThis as any).Bun,
|
||||
resolveSync: (specifier: string) => mockResolver.resolve(specifier)
|
||||
};
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
// Restore original environment
|
||||
process.env = originalEnv;
|
||||
|
||||
// Clean up mocks
|
||||
delete (globalThis as any).express;
|
||||
delete (globalThis as any).LiteMCP;
|
||||
delete (globalThis as any).logger;
|
||||
// Restore module resolution
|
||||
if (originalResolve) {
|
||||
(globalThis as any).Bun.resolveSync = originalResolve;
|
||||
}
|
||||
});
|
||||
|
||||
test('should start Express server when not in Claude mode', async () => {
|
||||
// Set OpenAI mode
|
||||
process.env.PROCESSOR_TYPE = 'openai';
|
||||
test('should initialize server with middleware', async () => {
|
||||
// Import and initialize server
|
||||
const mod = await import('../src/index');
|
||||
|
||||
// Import the main module
|
||||
await import('../src/index.js');
|
||||
// Verify server initialization
|
||||
expect(MockElysia.mock.calls.length).toBe(1);
|
||||
expect(mockCors.mock.calls.length).toBe(1);
|
||||
expect(mockSwagger.mock.calls.length).toBe(1);
|
||||
|
||||
// Verify Express server was initialized
|
||||
expect(mockExpress.mock.calls.length).toBeGreaterThan(0);
|
||||
expect(mockApp.use.mock.calls.length).toBeGreaterThan(0);
|
||||
expect(mockApp.listen.mock.calls.length).toBeGreaterThan(0);
|
||||
|
||||
const infoMessages = mockLogger.info.mock.calls.map(([msg]) => msg);
|
||||
expect(infoMessages.some(msg => msg.includes('Server is running on port'))).toBe(true);
|
||||
// Verify console output
|
||||
const logCalls = consoleLog.mock.calls;
|
||||
expect(logCalls.some(call =>
|
||||
typeof call.args[0] === 'string' &&
|
||||
call.args[0].includes('Server is running on port')
|
||||
)).toBe(true);
|
||||
});
|
||||
|
||||
test('should not start Express server in Claude mode', async () => {
|
||||
// Set Claude mode
|
||||
process.env.PROCESSOR_TYPE = 'claude';
|
||||
test('should initialize speech service when enabled', async () => {
|
||||
// Enable speech service
|
||||
process.env.SPEECH_ENABLED = 'true';
|
||||
|
||||
// Import the main module
|
||||
await import('../src/index.js');
|
||||
// Import and initialize server
|
||||
const mod = await import('../src/index');
|
||||
|
||||
// Verify Express server was not initialized
|
||||
expect(mockExpress.mock.calls.length).toBe(0);
|
||||
expect(mockApp.use.mock.calls.length).toBe(0);
|
||||
expect(mockApp.listen.mock.calls.length).toBe(0);
|
||||
|
||||
const infoMessages = mockLogger.info.mock.calls.map(([msg]) => msg);
|
||||
expect(infoMessages).toContain('Running in Claude mode - Express server disabled');
|
||||
// Verify speech service initialization
|
||||
expect(mockSpeechService.initialize.mock.calls.length).toBe(1);
|
||||
});
|
||||
|
||||
test('should initialize LiteMCP in both modes', async () => {
|
||||
// Test OpenAI mode
|
||||
process.env.PROCESSOR_TYPE = 'openai';
|
||||
await import('../src/index.js');
|
||||
test('should handle server shutdown gracefully', async () => {
|
||||
// Enable speech service for shutdown test
|
||||
process.env.SPEECH_ENABLED = 'true';
|
||||
|
||||
expect(mockLiteMCP.mock.calls.length).toBeGreaterThan(0);
|
||||
const [name, version] = mockLiteMCP.mock.calls[0] ?? [];
|
||||
expect(name).toBe('home-assistant');
|
||||
expect(typeof version).toBe('string');
|
||||
// Import and initialize server
|
||||
const mod = await import('../src/index');
|
||||
|
||||
// Reset for next test
|
||||
mockLiteMCP.mockReset();
|
||||
// Simulate SIGTERM
|
||||
process.emit('SIGTERM');
|
||||
|
||||
// Test Claude mode
|
||||
process.env.PROCESSOR_TYPE = 'claude';
|
||||
await import('../src/index.js');
|
||||
|
||||
expect(mockLiteMCP.mock.calls.length).toBeGreaterThan(0);
|
||||
const [name2, version2] = mockLiteMCP.mock.calls[0] ?? [];
|
||||
expect(name2).toBe('home-assistant');
|
||||
expect(typeof version2).toBe('string');
|
||||
});
|
||||
|
||||
test('should handle missing PROCESSOR_TYPE (default to Express server)', async () => {
|
||||
// Remove PROCESSOR_TYPE
|
||||
delete process.env.PROCESSOR_TYPE;
|
||||
|
||||
// Import the main module
|
||||
await import('../src/index.js');
|
||||
|
||||
// Verify Express server was initialized (default behavior)
|
||||
expect(mockExpress.mock.calls.length).toBeGreaterThan(0);
|
||||
expect(mockApp.use.mock.calls.length).toBeGreaterThan(0);
|
||||
expect(mockApp.listen.mock.calls.length).toBeGreaterThan(0);
|
||||
|
||||
const infoMessages = mockLogger.info.mock.calls.map(([msg]) => msg);
|
||||
expect(infoMessages.some(msg => msg.includes('Server is running on port'))).toBe(true);
|
||||
// Verify shutdown behavior
|
||||
expect(mockSpeechService.shutdown.mock.calls.length).toBe(1);
|
||||
expect(consoleLog.mock.calls.some(call =>
|
||||
typeof call.args[0] === 'string' &&
|
||||
call.args[0].includes('Shutting down gracefully')
|
||||
)).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,81 +1,79 @@
|
||||
import { describe, expect, test } from "bun:test";
|
||||
import { SpeechToText, TranscriptionResult, WakeWordEvent, TranscriptionError, TranscriptionOptions } from '../../src/speech/speechToText';
|
||||
import { EventEmitter } from 'events';
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import { spawn } from 'child_process';
|
||||
import { describe, expect, beforeEach, afterEach, it, mock, spyOn } from 'bun:test';
|
||||
import { describe, expect, test, beforeEach, afterEach, mock, spyOn } from "bun:test";
|
||||
import type { Mock } from "bun:test";
|
||||
import { EventEmitter } from "events";
|
||||
import { SpeechToText, TranscriptionError, type TranscriptionOptions } from "../../src/speech/speechToText";
|
||||
import type { SpeechToTextConfig } from "../../src/speech/types";
|
||||
import type { ChildProcess } from "child_process";
|
||||
|
||||
// Mock child_process spawn
|
||||
const spawnMock = mock((cmd: string, args: string[]) => ({
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
}));
|
||||
interface MockProcess extends EventEmitter {
|
||||
stdout: EventEmitter;
|
||||
stderr: EventEmitter;
|
||||
kill: Mock<() => void>;
|
||||
}
|
||||
|
||||
type SpawnFn = {
|
||||
(cmds: string[], options?: Record<string, unknown>): ChildProcess;
|
||||
};
|
||||
|
||||
describe('SpeechToText', () => {
|
||||
let spawnMock: Mock<SpawnFn>;
|
||||
let mockProcess: MockProcess;
|
||||
let speechToText: SpeechToText;
|
||||
const testAudioDir = path.join(import.meta.dir, 'test_audio');
|
||||
const mockConfig = {
|
||||
containerName: 'test-whisper',
|
||||
modelPath: '/models/whisper',
|
||||
modelType: 'base.en'
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
speechToText = new SpeechToText(mockConfig);
|
||||
// Create test audio directory if it doesn't exist
|
||||
if (!fs.existsSync(testAudioDir)) {
|
||||
fs.mkdirSync(testAudioDir, { recursive: true });
|
||||
}
|
||||
// Reset spawn mock
|
||||
spawnMock.mockReset();
|
||||
// Create mock process
|
||||
mockProcess = new EventEmitter() as MockProcess;
|
||||
mockProcess.stdout = new EventEmitter();
|
||||
mockProcess.stderr = new EventEmitter();
|
||||
mockProcess.kill = mock(() => { });
|
||||
|
||||
// Create spawn mock
|
||||
spawnMock = mock((cmds: string[], options?: Record<string, unknown>) => mockProcess as unknown as ChildProcess);
|
||||
(globalThis as any).Bun = { spawn: spawnMock };
|
||||
|
||||
// Initialize SpeechToText
|
||||
const config: SpeechToTextConfig = {
|
||||
modelPath: '/test/model',
|
||||
modelType: 'base.en',
|
||||
containerName: 'test-container'
|
||||
};
|
||||
speechToText = new SpeechToText(config);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
speechToText.stopWakeWordDetection();
|
||||
// Clean up test files
|
||||
if (fs.existsSync(testAudioDir)) {
|
||||
fs.rmSync(testAudioDir, { recursive: true, force: true });
|
||||
}
|
||||
// Cleanup
|
||||
mockProcess.removeAllListeners();
|
||||
mockProcess.stdout.removeAllListeners();
|
||||
mockProcess.stderr.removeAllListeners();
|
||||
});
|
||||
|
||||
describe('Initialization', () => {
|
||||
test('should create instance with default config', () => {
|
||||
const instance = new SpeechToText({ modelPath: '/models/whisper', modelType: 'base.en' });
|
||||
expect(instance instanceof EventEmitter).toBe(true);
|
||||
expect(instance instanceof SpeechToText).toBe(true);
|
||||
const config: SpeechToTextConfig = {
|
||||
modelPath: '/test/model',
|
||||
modelType: 'base.en'
|
||||
};
|
||||
const instance = new SpeechToText(config);
|
||||
expect(instance).toBeDefined();
|
||||
});
|
||||
|
||||
test('should initialize successfully', async () => {
|
||||
const initSpy = spyOn(speechToText, 'initialize');
|
||||
await speechToText.initialize();
|
||||
expect(initSpy).toHaveBeenCalled();
|
||||
const result = await speechToText.initialize();
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
|
||||
test('should not initialize twice', async () => {
|
||||
await speechToText.initialize();
|
||||
const initSpy = spyOn(speechToText, 'initialize');
|
||||
await speechToText.initialize();
|
||||
expect(initSpy.mock.calls.length).toBe(1);
|
||||
const result = await speechToText.initialize();
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Health Check', () => {
|
||||
test('should return true when Docker container is running', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emtest('data', Buffer.from('Up 2 hours'));
|
||||
mockProcess.stdout.emit('data', Buffer.from('Up 2 hours'));
|
||||
}, 0);
|
||||
|
||||
const result = await speechToText.checkHealth();
|
||||
@@ -83,23 +81,20 @@ describe('SpeechToText', () => {
|
||||
});
|
||||
|
||||
test('should return false when Docker container is not running', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(1), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emit('data', Buffer.from('No containers found'));
|
||||
}, 0);
|
||||
|
||||
const result = await speechToText.checkHealth();
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
test('should handle Docker command errors', async () => {
|
||||
spawnMock.mockImplementation(() => {
|
||||
throw new Error('Docker not found');
|
||||
});
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stderr.emit('data', Buffer.from('Docker error'));
|
||||
}, 0);
|
||||
|
||||
const result = await speechToText.checkHealth();
|
||||
expect(result).toBe(false);
|
||||
@@ -108,51 +103,48 @@ describe('SpeechToText', () => {
|
||||
|
||||
describe('Wake Word Detection', () => {
|
||||
test('should detect wake word and emit event', async () => {
|
||||
const testFile = path.join(testAudioDir, 'wake_word_test_123456.wav');
|
||||
const testMetadata = `${testFile}.json`;
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emit('data', Buffer.from('Wake word detected'));
|
||||
}, 0);
|
||||
|
||||
return new Promise<void>((resolve) => {
|
||||
speechToText.startWakeWordDetection(testAudioDir);
|
||||
|
||||
speechToText.on('wake_word', (event: WakeWordEvent) => {
|
||||
expect(event).toBeDefined();
|
||||
expect(event.audioFile).toBe(testFile);
|
||||
expect(event.metadataFile).toBe(testMetadata);
|
||||
expect(event.timestamp).toBe('123456');
|
||||
const wakeWordPromise = new Promise<void>((resolve) => {
|
||||
speechToText.on('wake_word', () => {
|
||||
resolve();
|
||||
});
|
||||
|
||||
// Create a test audio file to trigger the event
|
||||
fs.writeFileSync(testFile, 'test audio content');
|
||||
});
|
||||
|
||||
speechToText.startWakeWordDetection();
|
||||
await wakeWordPromise;
|
||||
});
|
||||
|
||||
test('should handle non-wake-word files', async () => {
|
||||
const testFile = path.join(testAudioDir, 'regular_audio.wav');
|
||||
let eventEmitted = false;
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emit('data', Buffer.from('Processing audio'));
|
||||
}, 0);
|
||||
|
||||
return new Promise<void>((resolve) => {
|
||||
speechToText.startWakeWordDetection(testAudioDir);
|
||||
|
||||
speechToText.on('wake_word', () => {
|
||||
eventEmitted = true;
|
||||
});
|
||||
|
||||
fs.writeFileSync(testFile, 'test audio content');
|
||||
|
||||
setTimeout(() => {
|
||||
expect(eventEmitted).toBe(false);
|
||||
const wakeWordPromise = new Promise<void>((resolve, reject) => {
|
||||
const timeout = setTimeout(() => {
|
||||
resolve();
|
||||
}, 100);
|
||||
|
||||
speechToText.on('wake_word', () => {
|
||||
clearTimeout(timeout);
|
||||
reject(new Error('Wake word should not be detected'));
|
||||
});
|
||||
});
|
||||
|
||||
speechToText.startWakeWordDetection();
|
||||
await wakeWordPromise;
|
||||
});
|
||||
});
|
||||
|
||||
describe('Audio Transcription', () => {
|
||||
const mockTranscriptionResult: TranscriptionResult = {
|
||||
text: 'Hello world',
|
||||
const mockTranscriptionResult = {
|
||||
text: 'Test transcription',
|
||||
segments: [{
|
||||
text: 'Hello world',
|
||||
text: 'Test transcription',
|
||||
start: 0,
|
||||
end: 1,
|
||||
confidence: 0.95
|
||||
@@ -160,169 +152,100 @@ describe('SpeechToText', () => {
|
||||
};
|
||||
|
||||
test('should transcribe audio successfully', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
|
||||
const transcriptionPromise = speechToText.transcribeAudio('/test/audio.wav');
|
||||
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emtest('data', Buffer.from(JSON.stringify(mockTranscriptionResult)));
|
||||
mockProcess.stdout.emit('data', Buffer.from(JSON.stringify(mockTranscriptionResult)));
|
||||
}, 0);
|
||||
|
||||
const result = await transcriptionPromise;
|
||||
const result = await speechToText.transcribeAudio('/test/audio.wav');
|
||||
expect(result).toEqual(mockTranscriptionResult);
|
||||
});
|
||||
|
||||
test('should handle transcription errors', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(1), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
|
||||
const transcriptionPromise = speechToText.transcribeAudio('/test/audio.wav');
|
||||
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stderr.emtest('data', Buffer.from('Transcription failed'));
|
||||
mockProcess.stderr.emit('data', Buffer.from('Transcription failed'));
|
||||
}, 0);
|
||||
|
||||
await expect(transcriptionPromise).rejects.toThrow(TranscriptionError);
|
||||
await expect(speechToText.transcribeAudio('/test/audio.wav')).rejects.toThrow(TranscriptionError);
|
||||
});
|
||||
|
||||
test('should handle invalid JSON output', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
|
||||
const transcriptionPromise = speechToText.transcribeAudio('/test/audio.wav');
|
||||
|
||||
// Setup mock process
|
||||
setTimeout(() => {
|
||||
mockProcess.stdout.emtest('data', Buffer.from('Invalid JSON'));
|
||||
mockProcess.stdout.emit('data', Buffer.from('Invalid JSON'));
|
||||
}, 0);
|
||||
|
||||
await expect(transcriptionPromise).rejects.toThrow(TranscriptionError);
|
||||
await expect(speechToText.transcribeAudio('/test/audio.wav')).rejects.toThrow(TranscriptionError);
|
||||
});
|
||||
|
||||
test('should pass correct transcription options', async () => {
|
||||
const options: TranscriptionOptions = {
|
||||
model: 'large-v2',
|
||||
model: 'base.en',
|
||||
language: 'en',
|
||||
temperature: 0.5,
|
||||
beamSize: 3,
|
||||
patience: 2,
|
||||
device: 'cuda'
|
||||
temperature: 0,
|
||||
beamSize: 5,
|
||||
patience: 1,
|
||||
device: 'cpu'
|
||||
};
|
||||
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
await speechToText.transcribeAudio('/test/audio.wav', options);
|
||||
|
||||
const transcriptionPromise = speechToText.transcribeAudio('/test/audio.wav', options);
|
||||
|
||||
const expectedArgs = [
|
||||
'exec',
|
||||
mockConfig.containerName,
|
||||
'fast-whisper',
|
||||
'--model', options.model,
|
||||
'--language', options.language,
|
||||
'--temperature', String(options.temperature ?? 0),
|
||||
'--beam-size', String(options.beamSize ?? 5),
|
||||
'--patience', String(options.patience ?? 1),
|
||||
'--device', options.device
|
||||
].filter((arg): arg is string => arg !== undefined);
|
||||
|
||||
const mockCalls = spawnMock.mock.calls;
|
||||
expect(mockCalls.length).toBe(1);
|
||||
const [cmd, args] = mockCalls[0].args;
|
||||
expect(cmd).toBe('docker');
|
||||
expect(expectedArgs.every(arg => args.includes(arg))).toBe(true);
|
||||
|
||||
await transcriptionPromise.catch(() => { });
|
||||
const spawnArgs = spawnMock.mock.calls[0]?.args[1] || [];
|
||||
expect(spawnArgs).toContain('--model');
|
||||
expect(spawnArgs).toContain(options.model);
|
||||
expect(spawnArgs).toContain('--language');
|
||||
expect(spawnArgs).toContain(options.language);
|
||||
expect(spawnArgs).toContain('--temperature');
|
||||
expect(spawnArgs).toContain(options.temperature?.toString());
|
||||
expect(spawnArgs).toContain('--beam-size');
|
||||
expect(spawnArgs).toContain(options.beamSize?.toString());
|
||||
expect(spawnArgs).toContain('--patience');
|
||||
expect(spawnArgs).toContain(options.patience?.toString());
|
||||
expect(spawnArgs).toContain('--device');
|
||||
expect(spawnArgs).toContain(options.device);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Event Handling', () => {
|
||||
test('should emit progress events', async () => {
|
||||
const mockProcess = {
|
||||
stdout: new EventEmitter(),
|
||||
stderr: new EventEmitter(),
|
||||
on: (event: string, cb: (code: number) => void) => {
|
||||
if (event === 'close') setTimeout(() => cb(0), 0);
|
||||
}
|
||||
};
|
||||
spawnMock.mockImplementation(() => mockProcess);
|
||||
|
||||
return new Promise<void>((resolve) => {
|
||||
const progressEvents: any[] = [];
|
||||
speechToText.on('progress', (event) => {
|
||||
progressEvents.push(event);
|
||||
if (progressEvents.length === 2) {
|
||||
expect(progressEvents).toEqual([
|
||||
{ type: 'stdout', data: 'Processing' },
|
||||
{ type: 'stderr', data: 'Loading model' }
|
||||
]);
|
||||
resolve();
|
||||
}
|
||||
const progressPromise = new Promise<void>((resolve) => {
|
||||
speechToText.on('progress', (progress) => {
|
||||
expect(progress).toEqual({ type: 'stdout', data: 'Processing' });
|
||||
resolve();
|
||||
});
|
||||
|
||||
void speechToText.transcribeAudio('/test/audio.wav');
|
||||
|
||||
mockProcess.stdout.emtest('data', Buffer.from('Processing'));
|
||||
mockProcess.stderr.emtest('data', Buffer.from('Loading model'));
|
||||
});
|
||||
|
||||
const transcribePromise = speechToText.transcribeAudio('/test/audio.wav');
|
||||
mockProcess.stdout.emit('data', Buffer.from('Processing'));
|
||||
await Promise.all([transcribePromise.catch(() => { }), progressPromise]);
|
||||
});
|
||||
|
||||
test('should emit error events', async () => {
|
||||
return new Promise<void>((resolve) => {
|
||||
const errorPromise = new Promise<void>((resolve) => {
|
||||
speechToText.on('error', (error) => {
|
||||
expect(error instanceof Error).toBe(true);
|
||||
expect(error.message).toBe('Test error');
|
||||
resolve();
|
||||
});
|
||||
|
||||
speechToText.emtest('error', new Error('Test error'));
|
||||
});
|
||||
|
||||
speechToText.emit('error', new Error('Test error'));
|
||||
await errorPromise;
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cleanup', () => {
|
||||
test('should stop wake word detection', () => {
|
||||
speechToText.startWakeWordDetection(testAudioDir);
|
||||
speechToText.startWakeWordDetection();
|
||||
speechToText.stopWakeWordDetection();
|
||||
// Verify no more file watching events are processed
|
||||
const testFile = path.join(testAudioDir, 'wake_word_test_123456.wav');
|
||||
let eventEmitted = false;
|
||||
speechToText.on('wake_word', () => {
|
||||
eventEmitted = true;
|
||||
});
|
||||
fs.writeFileSync(testFile, 'test audio content');
|
||||
expect(eventEmitted).toBe(false);
|
||||
expect(mockProcess.kill.mock.calls.length).toBe(1);
|
||||
});
|
||||
|
||||
test('should clean up resources on shutdown', async () => {
|
||||
await speechToText.initialize();
|
||||
const shutdownSpy = spyOn(speechToText, 'shutdown');
|
||||
await speechToText.shutdown();
|
||||
expect(shutdownSpy).toHaveBeenCalled();
|
||||
expect(mockProcess.kill.mock.calls.length).toBe(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -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