FigmaMind MCP Server

Verified
Overview InspectNew Schema Related Servers Reviews Score
FigmaMind
tests
/**
 * Teste para verificar a funcionalidade de transformação do Figma
 */

import figmaService from '../src/services/figmaService';
import { processData } from '../src/processor/processor';
import fs from 'fs-extra';
import path from 'path';
import dotenv from 'dotenv';

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

// URL do arquivo Figma para testar
const FIGMA_URL = 'https://www.figma.com/design/Mlgjf3cCMzOIwM27GLx81Y/New-Onboarding?node-id=2367-11578&t=RSCjmnJyU6JsPpzQ-4';

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

async function runTest() {
  console.log('Iniciando teste de transformação do Figma...');
  console.log(`URL do Figma: ${FIGMA_URL}`);
  
  try {
    // 1. Buscar dados do Figma
    console.log('Buscando dados do Figma...');
    const figmaResult = await figmaService.fetchFigmaFromUrl(FIGMA_URL);
    
    if (!figmaResult || !figmaResult.data) {
      throw new Error('Falha ao buscar dados do Figma');
    }
    
    console.log(`Dados do Figma obtidos com sucesso. File key: ${figmaResult.fileKey}`);
    
    // Salvar dados brutos para inspeção
    await fs.writeJson(
      path.join(TEST_OUTPUT_DIR, 'raw-figma-data.json'),
      figmaResult.data,
      { spaces: 2 }
    );
    
    // 2. Processar dados
    console.log('Processando dados do Figma...');
    const processed = await processData(figmaResult.data, figmaResult.fileKey);
    
    if (!processed) {
      throw new Error('Falha ao processar dados do Figma');
    }
    
    console.log(`Processamento concluído. Componentes encontrados: ${processed.componentsCount}`);
    
    // Salvar dados processados para inspeção
    await fs.writeJson(
      path.join(TEST_OUTPUT_DIR, 'processed-figma-data.json'),
      processed,
      { spaces: 2 }
    );
    
    // 3. Verificar resultado
    const validationResults = validateProcessedData(processed);
    
    // 4. Exibir resultados
    console.log('\n==== RESULTADOS DO TESTE ====');
    console.log(`Total de componentes processados: ${processed.componentsCount}`);
    console.log(`Validações bem-sucedidas: ${validationResults.success}`);
    console.log(`Validações com falha: ${validationResults.failures.length}`);
    
    if (validationResults.failures.length > 0) {
      console.log('\nFalhas de validação:');
      validationResults.failures.forEach((failure, index) => {
        console.log(`${index + 1}. ${failure}`);
      });
    }
    
    console.log('\nTeste concluído com sucesso!');
    console.log(`Dados de saída salvos em: ${TEST_OUTPUT_DIR}`);
    
    return {
      success: validationResults.failures.length === 0,
      componentsCount: processed.componentsCount,
      validationResults
    };
  } catch (error) {
    console.error('Erro durante o teste:', error);
    throw error;
  }
}

function validateProcessedData(data: any) {
  const failures: string[] = [];
  
  // 1. Verificar estrutura básica
  if (!data.screen) {
    failures.push('Dados processados não contêm a propriedade "screen"');
  }
  
  if (!data.source) {
    failures.push('Dados processados não contêm a propriedade "source"');
  }
  
  if (!data.componentsCount || typeof data.componentsCount !== 'number') {
    failures.push('Propriedade "componentsCount" ausente ou inválida');
  }
  
  // 2. Verificar componentes
  if (data.screen && data.screen.layout && data.screen.layout.orderedElements) {
    const components = data.screen.layout.orderedElements;
    
    // Verificar se os componentes têm as propriedades necessárias
    components.forEach((component: any, index: number) => {
      if (!component.id) {
        failures.push(`Componente ${index} não tem ID`);
      }
      
      if (!component.type) {
        failures.push(`Componente ${index} não tem tipo`);
      }
      
      if (!component.size || !component.size.width || !component.size.height) {
        failures.push(`Componente ${index} não tem dimensões válidas`);
      }
      
      if (!component.position || typeof component.position.x !== 'number' || typeof component.position.y !== 'number') {
        failures.push(`Componente ${index} não tem posição válida`);
      }
    });
    
    // Verificar se existem componentes de tipos diferentes
    const types = new Set(components.map((c: any) => c.type));
    if (types.size === 0) {
      failures.push('Nenhum tipo de componente identificado');
    } else {
      console.log(`Tipos de componentes encontrados: ${Array.from(types).join(', ')}`);
    }
  } else {
    failures.push('Estrutura de componentes ausente ou inválida');
  }
  
  return {
    success: failures.length === 0,
    failures
  };
}

// Executar o teste
if (require.main === module) {
  runTest()
    .then(() => {
      process.exit(0);
    })
    .catch(error => {
      console.error('Teste falhou:', error);
      process.exit(1);
    });
}

export { runTest }; 