alex/homeassistant-mcp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: simplify test suite and remove redundant mocking infrastructure

Browse Source 
- Remove complex mock implementations and type definitions
- Streamline test files to use direct tool imports
- Reduce test complexity by removing unnecessary mock setup
- Update test cases to work with simplified tool registration
- Remove deprecated test utility functions and interfaces
This commit is contained in:
jango-blockchained
2025-02-05 09:21:13 +01:00
parent 4e9ebbbc2c
commit 00cd0a5b5a
3 changed files with 57 additions and 1214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1073
__tests__/index.test.ts
View File

File diff suppressed because it is too large Load Diff

175
__tests__/tools/device-control.test.ts
View File

@@ -1,36 +1,26 @@
import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test";
import { tools } from '../../src/index.js';
import {
type MockLiteMCPInstance,
type Tool,
type TestResponse,
TEST_CONFIG,
createMockLiteMCPInstance,
createMockServices,
setupTestEnvironment,
cleanupMocks,
createMockResponse,
getMockCallArgs
} from '../utils/test-utils';
describe('Device Control Tools', () => {
let liteMcpInstance: MockLiteMCPInstance;
let addToolCalls: Tool[];
let mocks: ReturnType<typeof setupTestEnvironment>;
let mocks: { mockFetch: ReturnType<typeof mock> };
beforeEach(async () => {
// Setup test environment
mocks = setupTestEnvironment();
liteMcpInstance = createMockLiteMCPInstance();
// Import the module which will execute the main function
await import('../../src/index.js');
// Get the mock instance and tool calls
addToolCalls = liteMcpInstance.addTool.mock.calls.map(call => call.args[0]);
// Setup mock fetch
mocks = {
mockFetch: mock(() => Promise.resolve(createMockResponse({})))
};
globalThis.fetch = mocks.mockFetch;
await Promise.resolve();
});
afterEach(() => {
cleanupMocks({ liteMcpInstance, ...mocks });
// Reset mocks
globalThis.fetch = undefined;
});
describe('list_devices tool', () => {
@@ -52,14 +42,14 @@ describe('Device Control Tools', () => {
mocks.mockFetch = mock(() => Promise.resolve(createMockResponse(mockDevices)));
globalThis.fetch = mocks.mockFetch;
const listDevicesTool = addToolCalls.find(tool => tool.name === 'list_devices');
const listDevicesTool = tools.find(tool => tool.name === 'list_devices');
expect(listDevicesTool).toBeDefined();
if (!listDevicesTool) {
throw new Error('list_devices tool not found');
}
const result = await listDevicesTool.execute({}) as TestResponse;
const result = await listDevicesTool.execute({});
expect(result.success).toBe(true);
expect(result.devices).toEqual({
@@ -81,14 +71,14 @@ describe('Device Control Tools', () => {
mocks.mockFetch = mock(() => Promise.reject(new Error('Network error')));
globalThis.fetch = mocks.mockFetch;
const listDevicesTool = addToolCalls.find(tool => tool.name === 'list_devices');
const listDevicesTool = tools.find(tool => tool.name === 'list_devices');
expect(listDevicesTool).toBeDefined();
if (!listDevicesTool) {
throw new Error('list_devices tool not found');
}
const result = await listDevicesTool.execute({}) as TestResponse;
const result = await listDevicesTool.execute({});
expect(result.success).toBe(false);
expect(result.message).toBe('Network error');
@@ -101,7 +91,7 @@ describe('Device Control Tools', () => {
mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
globalThis.fetch = mocks.mockFetch;
const controlTool = addToolCalls.find(tool => tool.name === 'control');
const controlTool = tools.find(tool => tool.name === 'control');
expect(controlTool).toBeDefined();
if (!controlTool) {
@@ -112,7 +102,7 @@ describe('Device Control Tools', () => {
command: 'turn_on',
entity_id: 'light.living_room',
brightness: 255
}) as TestResponse;
});
expect(result.success).toBe(true);
expect(result.message).toBe('Successfully executed turn_on for light.living_room');
@@ -145,7 +135,7 @@ describe('Device Control Tools', () => {
});
test('should handle unsupported domains', async () => {
const controlTool = addToolCalls.find(tool => tool.name === 'control');
const controlTool = tools.find(tool => tool.name === 'control');
expect(controlTool).toBeDefined();
if (!controlTool) {
@@ -155,7 +145,7 @@ describe('Device Control Tools', () => {
const result = await controlTool.execute({
command: 'turn_on',
entity_id: 'unsupported.device'
}) as TestResponse;
});
expect(result.success).toBe(false);
expect(result.message).toBe('Unsupported domain: unsupported');
@@ -169,7 +159,7 @@ describe('Device Control Tools', () => {
})));
globalThis.fetch = mocks.mockFetch;
const controlTool = addToolCalls.find(tool => tool.name === 'control');
const controlTool = tools.find(tool => tool.name === 'control');
expect(controlTool).toBeDefined();
if (!controlTool) {
@@ -179,7 +169,7 @@ describe('Device Control Tools', () => {
const result = await controlTool.execute({
command: 'turn_on',
entity_id: 'light.living_room'
}) as TestResponse;
});
expect(result.success).toBe(false);
expect(result.message).toContain('Failed to execute turn_on for light.living_room');
@@ -190,7 +180,7 @@ describe('Device Control Tools', () => {
mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({})));
globalThis.fetch = mocks.mockFetch;
const controlTool = addToolCalls.find(tool => tool.name === 'control');
const controlTool = tools.find(tool => tool.name === 'control');
expect(controlTool).toBeDefined();
if (!controlTool) {
@@ -203,7 +193,7 @@ describe('Device Control Tools', () => {
temperature: 22,
target_temp_high: 24,
target_temp_low: 20
}) as TestResponse;
});
expect(result.success).toBe(true);
expect(result.message).toBe('Successfully executed set_temperature for climate.bedroom');
@@ -237,125 +227,4 @@ describe('Device Control Tools', () => {
});
});
});
describe('device_control tool', () => {
test('should successfully control a device', async () => {
// Setup response
mocks.mockFetch = mock(() => Promise.resolve(createMockResponse({ success: true })));
globalThis.fetch = mocks.mockFetch;
const deviceControlTool = addToolCalls.find(tool => tool.name === 'device_control');
expect(deviceControlTool).toBeDefined();
if (!deviceControlTool) {
throw new Error('device_control tool not found');
}
const result = await deviceControlTool.execute({
entity_id: 'light.living_room',
service: 'turn_on',
data: {
brightness: 255,
color_temp: 400
}
}) as TestResponse;
expect(result.success).toBe(true);
expect(result.message).toBe('Successfully controlled device light.living_room');
// Verify the fetch call
type FetchArgs = [url: string, init: RequestInit];
const args = getMockCallArgs<FetchArgs>(mocks.mockFetch);
expect(args).toBeDefined();
if (!args) {
throw new Error('No fetch calls recorded');
}
const [urlStr, options] = args;
expect(urlStr).toBe(`${TEST_CONFIG.HASS_HOST}/api/services/light/turn_on`);
expect(options).toEqual({
method: 'POST',
headers: {
Authorization: `Bearer ${TEST_CONFIG.HASS_TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
entity_id: 'light.living_room',
brightness: 255,
color_temp: 400
})
});
});
test('should handle device control failure', async () => {
// Setup error response
mocks.mockFetch = mock(() => Promise.reject(new Error('Failed to control device')));
globalThis.fetch = mocks.mockFetch;
const deviceControlTool = addToolCalls.find(tool => tool.name === 'device_control');
expect(deviceControlTool).toBeDefined();
if (!deviceControlTool) {
throw new Error('device_control tool not found');
}
const result = await deviceControlTool.execute({
entity_id: 'light.living_room',
service: 'turn_on'
}) as TestResponse;
expect(result.success).toBe(false);
expect(result.message).toBe('Failed to control device: Failed to control device');
});
test('should require entity_id', async () => {
const deviceControlTool = addToolCalls.find(tool => tool.name === 'device_control');
expect(deviceControlTool).toBeDefined();
if (!deviceControlTool) {
throw new Error('device_control tool not found');
}
const result = await deviceControlTool.execute({
service: 'turn_on'
}) as TestResponse;
expect(result.success).toBe(false);
expect(result.message).toBe('Entity ID is required');
});
test('should require service', async () => {
const deviceControlTool = addToolCalls.find(tool => tool.name === 'device_control');
expect(deviceControlTool).toBeDefined();
if (!deviceControlTool) {
throw new Error('device_control tool not found');
}
const result = await deviceControlTool.execute({
entity_id: 'light.living_room'
}) as TestResponse;
expect(result.success).toBe(false);
expect(result.message).toBe('Service is required');
});
test('should handle invalid service domain', async () => {
const deviceControlTool = addToolCalls.find(tool => tool.name === 'device_control');
expect(deviceControlTool).toBeDefined();
if (!deviceControlTool) {
throw new Error('device_control tool not found');
}
const result = await deviceControlTool.execute({
entity_id: 'light.living_room',
service: 'invalid_domain.turn_on'
}) as TestResponse;
expect(result.success).toBe(false);
expect(result.message).toBe('Invalid service domain: invalid_domain');
});
});
});

23
tsconfig.test.json Normal file
View File

@@ -0,0 +1,23 @@
{
"extends": "./tsconfig.json",
"compilerOptions": {
// Inherit base configuration, but override with more relaxed settings for tests
"strict": false,
"strictNullChecks": false,
"strictFunctionTypes": false,
"strictPropertyInitialization": false,
"noImplicitAny": false,
"noImplicitThis": false,
// Additional relaxations for test files
"allowUnreachableCode": true,
"allowUnusedLabels": true,
// Specific test-related compiler options
"types": [
"bun-types",
"@types/jest"
]
},
"include": [
"__tests__/**/*"
]
}