api-stats-logger/test-endpoint.js

SDK completo de logging e monitoramento de APIs com auto-instrumentação, dashboard em tempo real e CLI para configuração automática

#!/usr/bin/env node

/**
 * Script para testar conectividade e funcionamento do endpoint de logs
 * Verifica se não há bloqueios além da API key
 */

const axios = require('axios');

class EndpointTester {
  constructor() {
    this.baseUrl = 'https://apistats.squareweb.app';
    this.apiKey = process.env.API_STATS_API_KEY || 'aa783aa5dcbc7f2687b662c998007c928c921277711bfe04403309edbbc511af';
    this.tests = [];
    this.results = [];
  }

  addTest(name, testFunction) {
    this.tests.push({ name, testFunction });
  }

  async runTests() {
    console.log('🧪 Testando conectividade do endpoint de logs...\n');
    console.log(`📡 Base URL: ${this.baseUrl}`);
    console.log(`🔑 API Key: ${this.apiKey.substring(0, 8)}...`);
    console.log('');

    for (const test of this.tests) {
      try {
        console.log(`▶️  ${test.name}`);
        const result = await test.testFunction();
        this.results.push({ name: test.name, status: 'PASSOU', result });
        console.log(`✅ PASSOU: ${JSON.stringify(result)}\n`);
      } catch (error) {
        this.results.push({ name: test.name, status: 'FALHOU', error: error.message });
        console.log(`❌ FALHOU: ${error.message}\n`);
      }
    }

    this.printSummary();
  }

  printSummary() {
    console.log('📊 Resumo dos Testes:\n');
    
    let passed = 0;
    let failed = 0;

    for (const result of this.results) {
      const icon = result.status === 'PASSOU' ? '✅' : '❌';
      console.log(`${icon} ${result.name}`);
      if (result.error) {
        console.log(`   └── ${result.error}`);
      }
      
      if (result.status === 'PASSOU') passed++;
      else failed++;
    }

    console.log(`\n📈 Total: ${this.results.length} testes`);
    console.log(`✅ Passaram: ${passed}`);
    console.log(`❌ Falharam: ${failed}`);
    
    if (failed === 0) {
      console.log('\n🎉 Endpoint funcionando perfeitamente!');
      console.log('✅ Não há bloqueios além da validação de API key');
    } else {
      console.log('\n⚠️  Alguns testes falharam. Verifique a conectividade.');
    }
  }

  async makeRequest(data, headers = {}) {
    const config = {
      method: 'POST',
      url: `${this.baseUrl}/logs`,
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey,
        ...headers
      },
      data,
      timeout: 10000
    };

    const response = await axios(config);
    return {
      status: response.status,
      data: response.data,
      headers: response.headers
    };
  }
}

// Criar tester e adicionar testes
const tester = new EndpointTester();

// Teste 1: Array vazio
tester.addTest('Array vazio', async () => {
  return await tester.makeRequest([]);
});

// Teste 2: Log simples
tester.addTest('Log simples', async () => {
  return await tester.makeRequest([{
    level: 'info',
    message: 'Teste de log simples',
    timestamp: new Date().toISOString()
  }]);
});

// Teste 3: Log completo
tester.addTest('Log completo', async () => {
  return await tester.makeRequest([{
    level: 'info',
    message: 'Teste de log completo',
    timestamp: new Date().toISOString(),
    service: 'teste-endpoint',
    environment: 'development',
    metadata: {
      test: true,
      requestId: `test_${Date.now()}`,
      source: 'endpoint-tester'
    }
  }]);
});

// Teste 4: Múltiplos logs
tester.addTest('Múltiplos logs', async () => {
  return await tester.makeRequest([
    {
      level: 'info',
      message: 'Log 1',
      timestamp: new Date().toISOString(),
      service: 'teste-batch',
      environment: 'development'
    },
    {
      level: 'warn',
      message: 'Log 2',
      timestamp: new Date().toISOString(),
      service: 'teste-batch',
      environment: 'development'
    },
    {
      level: 'error',
      message: 'Log 3',
      timestamp: new Date().toISOString(),
      service: 'teste-batch',
      environment: 'development'
    }
  ]);
});

// Teste 5: Log com metadados complexos
tester.addTest('Log com metadados complexos', async () => {
  return await tester.makeRequest([{
    level: 'info',
    message: 'Requisição HTTP processada',
    timestamp: new Date().toISOString(),
    service: 'api-backend',
    environment: 'production',
    metadata: {
      request: {
        method: 'POST',
        url: '/api/users',
        headers: {
          'content-type': 'application/json',
          'user-agent': 'API-Stats-Tester/1.0'
        },
        body: {
          email: 'test@example.com',
          name: 'Test User'
        }
      },
      response: {
        statusCode: 201,
        duration: 150,
        size: 342
      },
      user: {
        id: 123,
        role: 'user'
      }
    }
  }]);
});

// Teste 6: Diferentes níveis de log
tester.addTest('Diferentes níveis de log', async () => {
  const levels = ['debug', 'info', 'warn', 'error'];
  const logs = levels.map(level => ({
    level,
    message: `Teste de log ${level}`,
    timestamp: new Date().toISOString(),
    service: 'teste-levels',
    environment: 'development',
    metadata: { testLevel: level }
  }));
  
  return await tester.makeRequest(logs);
});

// Teste 7: Sem API key (deve falhar)
tester.addTest('Sem API key (deve falhar)', async () => {
  try {
    const config = {
      method: 'POST',
      url: `${tester.baseUrl}/logs`,
      headers: {
        'Content-Type': 'application/json'
        // Sem x-api-key
      },
      data: [{ level: 'info', message: 'teste', timestamp: new Date().toISOString() }],
      timeout: 10000
    };

    await axios(config);
    throw new Error('Deveria ter falhado sem API key');
  } catch (error) {
    if (error.response && error.response.status === 401) {
      return { message: 'Corretamente rejeitado sem API key', status: 401 };
    }
    throw error;
  }
});

// Teste 8: API key inválida (deve falhar)
tester.addTest('API key inválida (deve falhar)', async () => {
  try {
    const config = {
      method: 'POST',
      url: `${tester.baseUrl}/logs`,
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'invalid-api-key-123'
      },
      data: [{ level: 'info', message: 'teste', timestamp: new Date().toISOString() }],
      timeout: 10000
    };

    await axios(config);
    throw new Error('Deveria ter falhado com API key inválida');
  } catch (error) {
    if (error.response && error.response.status === 401) {
      return { message: 'Corretamente rejeitado com API key inválida', status: 401 };
    }
    throw error;
  }
});

// Teste 9: Headers adicionais
tester.addTest('Headers adicionais', async () => {
  return await tester.makeRequest([{
    level: 'info',
    message: 'Teste com headers extras',
    timestamp: new Date().toISOString(),
    service: 'teste-headers',
    environment: 'development'
  }], {
    'User-Agent': 'API-Stats-Tester/1.0',
    'X-Custom-Header': 'test-value',
    'X-Request-ID': `req_${Date.now()}`
  });
});

// Teste 10: Performance (tempo de resposta)
tester.addTest('Performance (tempo de resposta)', async () => {
  const startTime = Date.now();
  
  const result = await tester.makeRequest([{
    level: 'info',
    message: 'Teste de performance',
    timestamp: new Date().toISOString(),
    service: 'teste-performance',
    environment: 'development',
    metadata: {
      performanceTest: true,
      startTime
    }
  }]);
  
  const duration = Date.now() - startTime;
  
  return {
    ...result,
    duration,
    performance: duration < 1000 ? 'ÓTIMA' : duration < 2000 ? 'BOA' : 'LENTA'
  };
});

// Executar todos os testes
async function main() {
  try {
    await tester.runTests();
  } catch (error) {
    console.error('❌ Erro fatal nos testes:', error.message);
    process.exit(1);
  }
}

// Verificar se há API key configurada
if (!tester.apiKey || tester.apiKey === 'your-api-key-here') {
  console.log('⚠️  API Key não configurada!');
  console.log('Configure a variável de ambiente API_STATS_API_KEY ou edite o script.');
  console.log('');
  console.log('Exemplo:');
  console.log('export API_STATS_API_KEY=sua-api-key-aqui');
  console.log('node test-endpoint.js');
  process.exit(1);
}

// Executar se chamado diretamente
if (require.main === module) {
  main();
}

module.exports = EndpointTester;