test.js

#!/usr/bin/env node
import { spawn } from 'child_process';
import { createInterface } from 'readline';
import { writeFileSync, unlinkSync, existsSync } from 'fs';
import { join } from 'path';
import os from 'os';

// Create a temporary docker-compose.yml file for testing
const createTestComposeFile = () => {
  const composeContent = `
version: '3'
services:
  test-service:
    image: hello-world
`;
  const composePath = join(process.cwd(), 'test-docker-compose.yml');
  writeFileSync(composePath, composeContent);
  return composePath;
};

// Clean up temporary files
const cleanupTestFiles = (composePath) => {
  if (existsSync(composePath)) {
    unlinkSync(composePath);
  }
};

// Helper function to send requests to server - 确保每个请求以换行符结束
const sendRequest = (server, request) => {
  const requestStr = JSON.stringify(request) + '\n';
  server.stdin.write(requestStr);
  console.log('Sent request:', JSON.stringify(request, null, 2));
};

// Create test compose file
const testComposePath = createTestComposeFile();

// Start the MCP server
const server = spawn('node', ['dist/index.js'], {
  stdio: ['pipe', 'pipe', 'inherit']
});

// Create a temporary docker-compose.yml file for testing
const tempFilePath = join(os.tmpdir(), 'test-docker-compose.yml');
const composeFileContent = `
  version: '3'
  services:
    nginx:
      image: nginx:latest
      ports:
        - "8080:80"
`;
// 创建文件
writeFileSync(tempFilePath, composeFileContent);

// Create readline interface for reading server output
const rl = createInterface({
  input: server.stdout,
  crlfDelay: Infinity
});

// 跟踪测试步骤
let testStep = 0;

// Wait for server to start
setTimeout(() => {
  console.log('Testing Docker MCP server...');
  
  // 初始化请求
  testStep = 1;
  const initializeRequest = {
    jsonrpc: '2.0',
    id: '1',
    method: 'initialize',
    params: {
      protocolVersion: '2024-11-05',
      clientInfo: {
        name: 'test-client',
        version: '0.3.0'
      },
      capabilities: {
        tools: {}
      }
    }
  };
  sendRequest(server, initializeRequest);
}, 1000);

// Handle server responses
rl.on('line', (line) => {
  try {
    // 忽略非JSON输出，比如"Docker MCP server running on stdio"
    if (line.trim().startsWith('{') && line.trim().endsWith('}')) {
      const response = JSON.parse(line);
      console.log('Server response:', JSON.stringify(response, null, 2));
      
      // 根据测试步骤进行下一步测试
      if (testStep === 1 && response.id === '1') {
        // 初始化成功，发送initialized通知
        testStep = 2;
        const initializedNotification = {
          jsonrpc: '2.0',
          method: 'initialized',
          params: {}
        };
        sendRequest(server, initializedNotification);
        
        // 请求工具列表
        setTimeout(() => {
          testStep = 3;
          const listToolsRequest = {
            jsonrpc: '2.0',
            id: '2',
            method: 'tools/list',
            params: {}
          };
          sendRequest(server, listToolsRequest);
        }, 500);
      } 
      else if (testStep === 3 && response.id === '2') {
        // 获取工具列表成功，测试容器运行
        testStep = 4;
        const runContainerRequest = {
          jsonrpc: '2.0',
          id: '3',
          method: 'tools/call',
          params: {
            name: 'run_container',
            arguments: {
              image: 'hello-world'
            }
          }
        };
        sendRequest(server, runContainerRequest);
      }
      else if (testStep === 4 && response.id === '3') {
        // 运行容器成功，测试Docker Compose命令
        testStep = 5;
        console.log('Testing Docker Compose commands...');
        const composeUpRequest = {
          jsonrpc: '2.0',
          id: '4',
          method: 'tools/call',
          params: {
            name: 'compose_up',
            arguments: {
              file: testComposePath,
              detach: true
            }
          }
        };
        sendRequest(server, composeUpRequest);
      }
      else if (testStep === 5 && response.id === '4') {
        // compose up成功，测试compose ps
        testStep = 6;
        const composePsRequest = {
          jsonrpc: '2.0',
          id: '5',
          method: 'tools/call',
          params: {
            name: 'compose_ps',
            arguments: {
              file: testComposePath
            }
          }
        };
        sendRequest(server, composePsRequest);
      }
      else if (testStep === 6 && response.id === '5') {
        // compose ps成功，测试compose down
        testStep = 7;
        const composeDownRequest = {
          jsonrpc: '2.0',
          id: '6',
          method: 'tools/call',
          params: {
            name: 'compose_down',
            arguments: {
              file: testComposePath
            }
          }
        };
        sendRequest(server, composeDownRequest);
      }
      else if (testStep === 7 && response.id === '6') {
        // 所有测试完成，退出
        testStep = 8;
        console.log('Tests completed. Exiting...');
        cleanupTestFiles(testComposePath);
        // 清理临时文件
        if (existsSync(tempFilePath)) {
          unlinkSync(tempFilePath);
        }
        server.kill();
        process.exit(0);
      }
    } else {
      console.log('Server message (non-JSON):', line);
    }
  } catch (error) {
    console.error('Error parsing response:', error.message);
    console.error('Raw line:', line);
  }
});

// 设置超时，避免测试卡住
setTimeout(() => {
  console.log('Test timeout reached. Exiting...');
  cleanupTestFiles(testComposePath);
  if (existsSync(tempFilePath)) {
    unlinkSync(tempFilePath);
  }
  server.kill();
  process.exit(1);
}, 30000);

// Handle server exit
server.on('exit', (code) => {
  console.log(`Server exited with code ${code}`);
  cleanupTestFiles(testComposePath);
  // 清理临时文件
  if (existsSync(tempFilePath)) {
    unlinkSync(tempFilePath);
  }
});

// Handle process termination
process.on('SIGINT', () => {
  cleanupTestFiles(testComposePath);
  // 清理临时文件
  if (existsSync(tempFilePath)) {
    unlinkSync(tempFilePath);
  }
  server.kill();
  process.exit(0);
});