#!/usr/bin/env node
/**
* Comprehensive test script for the Godot MCP Server
* Validates that the implementation works correctly
* ISO/IEC 5055: Refactored for CC < 15 per function
*/
import { GodotMCPServer } from '../server/GodotMCPServer';
import {
getAllToolDefinitions,
getRegisteredToolNames,
getToolHandler,
isToolRegistered,
} from '../tools/ToolRegistry';
import { logInfo, logError } from '../utils/Logger';
// Expected tools from original implementation
const EXPECTED_TOOLS = [
// System tools
'get_godot_version',
// Debug tools
'stop_project',
'get_debug_output',
// Project tools
'launch_editor',
'run_project',
'list_projects',
'get_project_info',
// Scene tools
'create_scene',
'add_node',
'edit_node',
'remove_node',
'load_sprite',
'export_mesh_library',
'save_scene',
// UID tools
'get_uid',
'update_project_uids',
];
const TOOL_CATEGORIES = {
system: ['get_godot_version'],
debug: ['stop_project', 'get_debug_output'],
project: ['launch_editor', 'run_project', 'list_projects', 'get_project_info'],
scene: ['create_scene', 'add_node', 'load_sprite', 'export_mesh_library', 'save_scene'],
uid: ['get_uid', 'update_project_uids'],
};
/**
* Test 1: Tool Registry Completeness
*/
function testToolRegistryCompleteness(toolNames: string[]): void {
logInfo('Test 1: Tool Registry Completeness');
const missingTools = EXPECTED_TOOLS.filter((tool) => !toolNames.includes(tool));
if (missingTools.length > 0) {
throw new Error(`Missing tools: ${missingTools.join(', ')}`);
}
const extraTools = toolNames.filter((tool) => !EXPECTED_TOOLS.includes(tool));
if (extraTools.length > 0) {
logInfo(`⚠ Extra tools found (not in original): ${extraTools.join(', ')}`);
}
logInfo('✓ All expected tools are registered');
}
/**
* Test 2: Tool Handler Validation
*/
function testToolHandlerValidation(): void {
logInfo('Test 2: Tool Handler Validation');
for (const toolName of EXPECTED_TOOLS) {
validateToolHandler(toolName);
}
logInfo('✓ All tool handlers are valid');
}
function validateToolHandler(toolName: string): void {
if (!isToolRegistered(toolName)) {
throw new Error(`Tool not registered: ${toolName}`);
}
const handler = getToolHandler(toolName);
if (!handler) {
throw new Error(`No handler found for tool: ${toolName}`);
}
if (typeof handler !== 'function') {
throw new Error(`Handler for ${toolName} is not a function`);
}
}
/**
* Test 3: Tool Definition Schema Validation
*/
function testToolDefinitionSchemas(toolDefinitions: ReturnType<typeof getAllToolDefinitions>): void {
logInfo('Test 3: Tool Definition Schema Validation');
for (const definition of toolDefinitions) {
validateToolDefinition(definition);
}
logInfo('✓ All tool definitions have valid schemas');
}
function validateToolDefinition(definition: ReturnType<typeof getAllToolDefinitions>[0]): void {
if (!definition.name || typeof definition.name !== 'string') {
throw new Error(`Invalid tool definition: missing or invalid name`);
}
if (!definition.description || typeof definition.description !== 'string') {
throw new Error(`Invalid tool definition for ${definition.name}: missing description`);
}
if (!definition.inputSchema || typeof definition.inputSchema !== 'object') {
throw new Error(`Invalid tool definition for ${definition.name}: missing inputSchema`);
}
if (!definition.inputSchema.properties || typeof definition.inputSchema.properties !== 'object') {
throw new Error(`Invalid tool definition for ${definition.name}: missing properties`);
}
if (!Array.isArray(definition.inputSchema.required)) {
throw new Error(`Invalid tool definition for ${definition.name}: missing required array`);
}
}
/**
* Test 4: Server Initialization
*/
function testServerInitialization(): void {
logInfo('Test 4: Server Initialization for MCP Agent Usage');
const _server = new GodotMCPServer();
logInfo('✓ Server initialized successfully');
}
/**
* Test 5: Server Capabilities
*/
function testServerCapabilities(): void {
logInfo('Test 5: Server Capabilities Check');
const serverInfo = {
name: 'godot-mcp',
version: '0.1.0',
capabilities: { tools: true },
};
logInfo(`✓ Server capabilities verified: ${JSON.stringify(serverInfo.capabilities)}`);
}
/**
* Test 6: Tool Count Verification
*/
function testToolCount(toolDefinitions: ReturnType<typeof getAllToolDefinitions>): void {
logInfo('Test 6: Tool Count Verification');
const expectedToolCount = EXPECTED_TOOLS.length;
if (toolDefinitions.length !== expectedToolCount) {
logError(`✗ Tool count mismatch: expected ${expectedToolCount}, found ${toolDefinitions.length}`);
throw new Error(`Tool count mismatch`);
}
logInfo(`✓ Tool count matches original: ${expectedToolCount} tools`);
}
/**
* Test 7: Tool Categories Verification
*/
function testToolCategories(toolNames: string[]): void {
logInfo('Test 7: Tool Categories Verification');
for (const [category, tools] of Object.entries(TOOL_CATEGORIES)) {
for (const tool of tools) {
if (!toolNames.includes(tool)) {
throw new Error(`Missing ${category} tool: ${tool}`);
}
}
logInfo(`✓ ${category} tools verified: ${tools.join(', ')}`);
}
}
/**
* Test 8: MCP Agent Compatibility
*/
function testMcpAgentCompatibility(): void {
logInfo('Test 8: MCP Agent Compatibility Test');
const toolsForAgent = getAllToolDefinitions().map((def) => ({
name: def.name,
description: def.description,
inputSchema: def.inputSchema,
}));
if (toolsForAgent.length === 0) {
throw new Error('No tools available for MCP agent');
}
logInfo(`✓ ${toolsForAgent.length} tools available for MCP agent`);
for (const tool of toolsForAgent) {
if (!tool.name) throw new Error(`Tool missing name field`);
if (!tool.description) throw new Error(`Tool ${tool.name} missing description field`);
if (!tool.inputSchema) throw new Error(`Tool ${tool.name} missing inputSchema field`);
}
logInfo('✓ All tools have required MCP fields');
}
/**
* Print final summary
*/
function printSummary(toolCount: number): void {
logInfo('='.repeat(60));
logInfo('🎉 ALL TESTS PASSED! 🎉');
logInfo('='.repeat(60));
logInfo('✅ Tool Registry: Complete and functional');
logInfo('✅ Tool Handlers: All valid and callable');
logInfo('✅ Tool Definitions: All have proper schemas');
logInfo('✅ Server Initialization: Successful');
logInfo('✅ MCP Agent Compatibility: Verified');
logInfo('✅ Tool Categories: All properly organized');
logInfo(`✅ Total Tools Available: ${toolCount}`);
logInfo('');
logInfo('🚀 The refactored Godot MCP Server is ready for MCP agent usage!');
logInfo('='.repeat(60));
}
/**
* Main test runner
*/
const runTests = async (): Promise<void> => {
try {
logInfo('='.repeat(60));
logInfo('COMPREHENSIVE TEST: Godot MCP Server');
logInfo('='.repeat(60));
const toolDefinitions = getAllToolDefinitions();
const toolNames = getRegisteredToolNames();
logInfo(`Found ${toolDefinitions.length} tool definitions`);
logInfo(`Registered tools: ${toolNames.join(', ')}`);
testToolRegistryCompleteness(toolNames);
testToolHandlerValidation();
testToolDefinitionSchemas(toolDefinitions);
testServerInitialization();
testServerCapabilities();
testToolCount(toolDefinitions);
testToolCategories(toolNames);
testMcpAgentCompatibility();
printSummary(toolDefinitions.length);
} catch (error: unknown) {
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
logError('='.repeat(60));
logError('❌ TEST FAILED');
logError('='.repeat(60));
logError(`Error: ${errorMessage}`);
logError('='.repeat(60));
process.exit(1);
}
};
runTests();
