FigmaMind MCP Server

Verified
Overview InspectNew Schema Related Servers Reviews Score
FigmaMind
tests
/**
 * Teste para verificar se os endpoints MCP estão funcionando corretamente
 */

import axios from 'axios';
import { spawn } from 'child_process';
import dotenv from 'dotenv';
import fs from 'fs-extra';
import path from 'path';

// Carregar variáveis de ambiente
dotenv.config();

// URL base para os testes
const API_BASE_URL = 'http://localhost:3000';

// Diretório para salvar a saída do teste
const TEST_OUTPUT_DIR = path.resolve('tests/output');
fs.ensureDirSync(TEST_OUTPUT_DIR);

// Objeto para armazenar a instância do servidor
let serverProcess: any;

/**
 * Inicia o servidor para os testes
 */
async function startServer(): Promise<void> {
  return new Promise((resolve, reject) => {
    console.log('Iniciando o servidor...');
    
    // Inicia o servidor em um processo separado
    serverProcess = spawn('node', ['dist/src/index.js'], {
      env: { ...process.env, PORT: '3000' },
      stdio: 'inherit'
    });
    
    // Aguarda um tempo para o servidor iniciar
    setTimeout(() => {
      console.log('Servidor iniciado');
      resolve();
    }, 3000);
    
    // Lidar com erros
    serverProcess.on('error', (error: Error) => {
      console.error('Erro ao iniciar o servidor:', error);
      reject(error);
    });
  });
}

/**
 * Encerra o servidor após os testes
 */
function stopServer(): void {
  if (serverProcess) {
    console.log('Encerrando o servidor...');
    serverProcess.kill();
    serverProcess = null;
    console.log('Servidor encerrado');
  }
}

/**
 * Teste dos endpoints MCP
 */
async function testMcpEndpoints(): Promise<any> {
  console.log('Iniciando teste dos endpoints MCP...');
  
  const results = {
    healthCheck: false,
    apiInfo: false,
    toolsList: false,
    toolInfo: false,
    runTool: false,
    failures: [] as string[]
  };
  
  try {
    // 1. Verificar health check
    console.log('Testando endpoint de health check...');
    const healthResponse = await axios.get(`${API_BASE_URL}/health`);
    
    if (healthResponse.status === 200 && healthResponse.data && healthResponse.data.status === 'ok') {
      console.log('Health check OK');
      results.healthCheck = true;
    } else {
      results.failures.push('Falha no health check');
    }
    
    // 2. Verificar informações da API
    console.log('Testando endpoint de informações da API...');
    const apiInfoResponse = await axios.get(`${API_BASE_URL}/api`);
    
    if (apiInfoResponse.status === 200 && apiInfoResponse.data && apiInfoResponse.data.name) {
      console.log('Informações da API OK');
      results.apiInfo = true;
      
      // Salvar para inspeção
      await fs.writeJson(
        path.join(TEST_OUTPUT_DIR, 'api-info.json'),
        apiInfoResponse.data,
        { spaces: 2 }
      );
    } else {
      results.failures.push('Falha ao obter informações da API');
    }
    
    // 3. Listar ferramentas disponíveis
    console.log('Testando endpoint de listagem de ferramentas...');
    const toolsListResponse = await axios.post(
      `${API_BASE_URL}/tools/list`,
      {
        jsonrpc: '2.0',
        method: 'tools.list',
        id: 1
      }
    );
    
    if (
      toolsListResponse.status === 200 && 
      toolsListResponse.data && 
      toolsListResponse.data.result && 
      Array.isArray(toolsListResponse.data.result)
    ) {
      console.log(`Ferramentas disponíveis: ${toolsListResponse.data.result.length}`);
      results.toolsList = true;
      
      // Salvar para inspeção
      await fs.writeJson(
        path.join(TEST_OUTPUT_DIR, 'tools-list.json'),
        toolsListResponse.data,
        { spaces: 2 }
      );
      
      // Verificar se há pelo menos uma ferramenta
      if (toolsListResponse.data.result.length === 0) {
        results.failures.push('Nenhuma ferramenta disponível');
      }
    } else {
      results.failures.push('Falha ao listar ferramentas');
    }
    
    // 4. Obter informações de uma ferramenta específica
    if (results.toolsList && toolsListResponse.data.result.length > 0) {
      const firstTool = toolsListResponse.data.result[0];
      
      console.log(`Testando endpoint de informações da ferramenta "${firstTool.name}"...`);
      const toolInfoResponse = await axios.post(
        `${API_BASE_URL}/tools/get`,
        {
          jsonrpc: '2.0',
          method: 'tools.get',
          id: 2,
          params: { name: firstTool.name }
        }
      );
      
      if (
        toolInfoResponse.status === 200 && 
        toolInfoResponse.data && 
        toolInfoResponse.data.result && 
        toolInfoResponse.data.result.name === firstTool.name
      ) {
        console.log(`Informações da ferramenta "${firstTool.name}" OK`);
        results.toolInfo = true;
        
        // Salvar para inspeção
        await fs.writeJson(
          path.join(TEST_OUTPUT_DIR, 'tool-info.json'),
          toolInfoResponse.data,
          { spaces: 2 }
        );
      } else {
        results.failures.push(`Falha ao obter informações da ferramenta "${firstTool.name}"`);
      }
      
      // 5. Executar a ferramenta figmamind.info (que é rápida e não requer parâmetros)
      if (toolsListResponse.data.result.some((t: any) => t.name === 'figmamind.info')) {
        console.log('Testando execução da ferramenta "figmamind.info"...');
        const runToolResponse = await axios.post(
          `${API_BASE_URL}/run`,
          {
            jsonrpc: '2.0',
            method: 'run',
            id: 3,
            params: { name: 'figmamind.info' }
          }
        );
        
        if (
          runToolResponse.status === 200 && 
          runToolResponse.data && 
          runToolResponse.data.result && 
          runToolResponse.data.result.success
        ) {
          console.log('Execução da ferramenta "figmamind.info" OK');
          results.runTool = true;
          
          // Salvar para inspeção
          await fs.writeJson(
            path.join(TEST_OUTPUT_DIR, 'tool-execution.json'),
            runToolResponse.data,
            { spaces: 2 }
          );
        } else {
          results.failures.push('Falha ao executar a ferramenta "figmamind.info"');
        }
      }
    }
    
    // Exibir resultados
    console.log('\n==== RESULTADOS DO TESTE MCP ====');
    console.log(`Health Check: ${results.healthCheck ? 'OK' : 'FALHA'}`);
    console.log(`Informações da API: ${results.apiInfo ? 'OK' : 'FALHA'}`);
    console.log(`Listagem de Ferramentas: ${results.toolsList ? 'OK' : 'FALHA'}`);
    console.log(`Informações de Ferramenta: ${results.toolInfo ? 'OK' : 'FALHA'}`);
    console.log(`Execução de Ferramenta: ${results.runTool ? 'OK' : 'FALHA'}`);
    
    if (results.failures.length > 0) {
      console.log('\nFalhas encontradas:');
      results.failures.forEach((failure, index) => {
        console.log(`${index + 1}. ${failure}`);
      });
    } else {
      console.log('\nTodos os testes passaram com sucesso!');
    }
    
    return {
      success: results.failures.length === 0,
      results
    };
  } catch (error) {
    console.error('Erro durante os testes MCP:', error);
    throw error;
  }
}

/**
 * Função principal para executar todos os testes
 */
async function runAllTests(): Promise<void> {
  try {
    // Iniciar o servidor
    await startServer();
    
    // Executar os testes
    await testMcpEndpoints();
    
    console.log('\nTodos os testes foram concluídos!');
  } catch (error) {
    console.error('Erro ao executar os testes:', error);
  } finally {
    // Parar o servidor
    stopServer();
  }
}

// Executar os testes se este arquivo for executado diretamente
if (require.main === module) {
  runAllTests()
    .then(() => {
      process.exit(0);
    })
    .catch(error => {
      console.error('Testes falharam:', error);
      stopServer();
      process.exit(1);
    });
}

export { runAllTests, testMcpEndpoints }; 