@silasfmartins/testhub 1.0.0

package/dist/src/testContext/UnifiedHtmlGenerator.js

@@ -0,0 +1,264 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { HTMLTemplate } from '../utils/HTMLTemplate.js';
+import { Logger } from '../utils/Logger.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+function getAutoCoreVersion() {
+    try {
+        const root = process.cwd();
+        const pkgPath = path.join(root, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return (pkg.dependencies?.['@silasfmartins/testhub'] ||
+            pkg.devDependencies?.['@silasfmartins/testhub'] ||
+            '1.1.X');
+    }
+    catch {
+        return '1.1.X';
+    }
+}
+export class UnifiedHtmlGenerator {
+    static async generate(testes, inicio, fim, isIndividual = false, tituloCustomizado, projectName, environment, autocoreVersion) {
+        // Garante que todos os testes tenham logs como array e preserva dados de CTs
+        const testesComLogs = testes.map((t) => ({
+            ...t,
+            logs: Array.isArray(t.logs) ? t.logs : [],
+            // ✅ CORRIGIDO: Preservar dados de CTs que vêm do UnifiedReportManager
+            cts: Array.isArray(t.cts) ? t.cts : [],
+            totalCTs: t.totalCTs || 0,
+            passedCTs: t.passedCTs || 0,
+            failedCTs: t.failedCTs || 0,
+            skippedCTs: t.skippedCTs || 0,
+        }));
+        const totalTestes = testesComLogs.length;
+        const testesPassaram = testesComLogs.filter((t) => t.resultado === 'PASS').length;
+        const testesFalharam = testesComLogs.filter((t) => t.resultado === 'FAIL').length;
+        const titulo = isIndividual
+            ? `Relatório Individual: ${tituloCustomizado || 'Teste'}`
+            : 'Relatório Geral Unificado de Testes';
+        const subtitulo = isIndividual
+            ? 'Relatório específico do teste selecionado'
+            : 'Relatório consolidado de todos os tipos de teste executados';
+        const estatisticasPorTipo = UnifiedHtmlGenerator.calcularEstatisticasPorTipo(testesComLogs);
+        const coresDosTipos = UnifiedHtmlGenerator.getCoresDosTipos();
+        const env = environment || process.env.ENV || process.env.NODE_ENV || 'N/A';
+        const version = autocoreVersion || getAutoCoreVersion();
+        const projName = projectName ||
+            process.env.PROJECT_NAME ||
+            (process.env.npm_package_name
+                ? process.env.npm_package_name
+                : 'TestHUB Project');
+        // 📋 Obter logs do terminal se disponível
+        let terminalLogs = null;
+        try {
+            if (globalThis.TerminalLogCapture) {
+                const logCapture = globalThis.TerminalLogCapture;
+                const logsByTest = logCapture.getLogsByTest();
+                const stats = logCapture.getStats();
+                // Converter Map para objeto simples
+                const logsObject = {};
+                for (const [testName, logs] of logsByTest.entries()) {
+                    logsObject[testName] = logs;
+                }
+                terminalLogs = {
+                    totalLogs: stats.totalLogs,
+                    byLevel: stats.byLevel,
+                    byTest: logsObject,
+                };
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao obter logs do terminal para relatório: ${error}`);
+        }
+        // 🆕 CRÍTICO: Buscar dados dos CTs do ARQUIVO JSON (fonte de verdade única)
+        let allCNsData = new Map();
+        try {
+            // ✅ CORREÇÃO: Ler do arquivo JSON ao invés da memória
+            const jsonPath = path.join(process.cwd(), '.rbqa', 'ct-execution-data.json');
+            if (fs.existsSync(jsonPath)) {
+                const jsonContent = fs.readFileSync(jsonPath, 'utf-8');
+                const jsonData = JSON.parse(jsonContent);
+                // Converter array de testes do JSON para Map
+                if (jsonData.tests && Array.isArray(jsonData.tests)) {
+                    for (const testData of jsonData.tests) {
+                        allCNsData.set(testData.testName, testData);
+                        Logger.info(`  📋 CN: "${testData.testName}" - ${testData.cts?.length || 0} CTs (${testData.totalCTs} total)`);
+                    }
+                }
+            }
+            else {
+                Logger.warning(`⚠️ [UnifiedHtmlGenerator] Arquivo JSON não encontrado: ${jsonPath}`);
+                Logger.warning('⚠️ [UnifiedHtmlGenerator] Usando dados da memória como fallback');
+                // Fallback: usar dados da memória
+                const allExecutions = StatementTracker.getExecutions();
+                allCNsData = new Map(allExecutions);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao buscar dados do arquivo JSON: ${error}`);
+            Logger.warning('⚠️ Tentando fallback para dados da memória...');
+            // Fallback: usar dados da memória
+            try {
+                const allExecutions = StatementTracker.getExecutions();
+                allCNsData = new Map(allExecutions);
+                Logger.info(`📊 [UnifiedHtmlGenerator] Fallback: ${allCNsData.size} CNs da memória`);
+            }
+            catch (fallbackError) {
+                Logger.error('❌ [UnifiedHtmlGenerator] Falha no fallback', fallbackError);
+            }
+        }
+        // 📊 Agregar totais globais de CTs (alinhado com envio para AutoCore Hub)
+        let globalTotalCTs = 0;
+        let globalPassedCTs = 0;
+        let globalFailedCTs = 0;
+        let globalSkippedCTs = 0;
+        const aggregateFromCTs = (ctList) => {
+            for (const ct of ctList) {
+                globalTotalCTs += 1;
+                const status = String(ct.status || '').toLowerCase();
+                if (status === 'passed') {
+                    globalPassedCTs += 1;
+                }
+                else if (status === 'skipped') {
+                    globalSkippedCTs += 1;
+                }
+                else {
+                    // Inclui failed, running, undefined -> tratado como falha (mesma lógica do payload batch)
+                    globalFailedCTs += 1;
+                }
+            }
+        };
+        if (allCNsData.size > 0) {
+            for (const cnData of allCNsData.values()) {
+                const cts = Array.isArray(cnData.cts)
+                    ? cnData.cts
+                    : [];
+                if (cts.length > 0) {
+                    aggregateFromCTs(cts);
+                }
+                else {
+                    const total = Number(cnData.totalCTs || 0);
+                    if (total > 0) {
+                        globalTotalCTs += total;
+                        const passed = Number(cnData.passedCTs || 0);
+                        const failed = Number(cnData.failedCTs || 0);
+                        const skipped = Number(cnData.skippedCTs || 0);
+                        const inferredFailed = Math.max(total - passed - skipped, failed);
+                        globalPassedCTs += passed;
+                        globalSkippedCTs += skipped;
+                        globalFailedCTs += Math.max(inferredFailed, 0);
+                    }
+                }
+            }
+        }
+        else {
+            Logger.info('⚠️ [CT-AGGREGATION] allCNsData vazio, usando fallback de testesComLogs');
+            // Fallback: utilizar dados agregados de testes (quando mapa ainda não está disponível)
+            testesComLogs.forEach((teste) => {
+                const ctList = Array.isArray(teste.cts)
+                    ? teste.cts
+                    : [];
+                if (ctList.length > 0) {
+                    aggregateFromCTs(ctList);
+                    return;
+                }
+                const total = Number(teste.totalCTs || 0);
+                if (total === 0)
+                    return;
+                globalTotalCTs += total;
+                const passed = Number(teste.passedCTs || 0);
+                const skipped = Number(teste.skippedCTs || 0);
+                const failed = Number(teste.failedCTs || 0);
+                const inferredFailed = Math.max(total - passed - skipped, failed);
+                globalPassedCTs += passed;
+                globalSkippedCTs += skipped;
+                globalFailedCTs += Math.max(inferredFailed, 0);
+            });
+        }
+        const data = {
+            testes: testesComLogs,
+            titulo,
+            subtitulo,
+            totalTestes,
+            testesPassaram,
+            testesFalharam,
+            estatisticasPorTipo,
+            coresDosTipos,
+            chartLabels: Object.keys(estatisticasPorTipo).filter((tipo) => estatisticasPorTipo[tipo].total > 0),
+            chartData: Object.keys(estatisticasPorTipo)
+                .filter((tipo) => estatisticasPorTipo[tipo].total > 0)
+                .map((tipo) => estatisticasPorTipo[tipo].total),
+            chartColors: Object.keys(estatisticasPorTipo)
+                .filter((tipo) => estatisticasPorTipo[tipo].total > 0)
+                .map((tipo) => coresDosTipos[tipo]),
+            barLabels: testesComLogs.map((t) => t.nome),
+            barData: testesComLogs.map((t) => t.duracao),
+            pieLabels: ['Passou', 'Falhou'],
+            pieData: [testesPassaram, testesFalharam],
+            logsLabels: testesComLogs.map((t) => t.nome),
+            logsData: testesComLogs.map((t) => Array.isArray(t.logs) ? t.logs.length : 0),
+            getIconePorTipo: UnifiedHtmlGenerator.getIconePorTipo,
+            projectName: projName,
+            environment: env,
+            executionDate: new Date().toLocaleString('pt-BR'),
+            autocoreVersion: version,
+            terminalLogs, // ✅ NOVO: Logs do terminal
+            allCNsData, // 🆕 CRÍTICO: Dados dos CTs do StatementTracker
+            globalTotalCTs,
+            globalPassedCTs,
+            globalFailedCTs,
+            globalSkippedCTs,
+        };
+        const html = HTMLTemplate(data);
+        return Buffer.from(html, 'utf-8');
+    }
+    static calcularEstatisticasPorTipo(testes) {
+        const tipos = [
+            'API',
+            'Frontend',
+            'Mobile',
+            'SSH',
+            'Banco',
+            'Mixed',
+            'Scenarios',
+        ];
+        const stats = {};
+        // Inicializa todos os tipos com zero
+        for (const tipo of tipos) {
+            stats[tipo] = { total: 0, passou: 0, falhou: 0 };
+        }
+        for (const teste of testes) {
+            if (!stats[teste.tipo]) {
+                stats[teste.tipo] = { total: 0, passou: 0, falhou: 0 };
+            }
+            stats[teste.tipo].total++;
+            if (teste.resultado === 'PASS')
+                stats[teste.tipo].passou++;
+            else
+                stats[teste.tipo].falhou++;
+        }
+        return stats;
+    }
+    static getCoresDosTipos() {
+        return {
+            API: '#3b82f6',
+            Frontend: '#10b981',
+            Mobile: '#f59e0b',
+            SSH: '#ef4444',
+            Banco: '#8b5cf6',
+            Mixed: '#6b7280',
+            Scenarios: '#6366f1',
+        };
+    }
+    static getIconePorTipo(tipo) {
+        const icones = {
+            API: '🔌',
+            Frontend: '🌐',
+            Mobile: '📱',
+            SSH: '🔧',
+            Banco: '🗄️',
+            Mixed: '🔀',
+            Scenarios: '📋',
+        };
+        return icones[tipo];
+    }
+}

package/dist/src/testContext/UnifiedReportManager.d.ts

@@ -0,0 +1,211 @@
+export type TestContextType = 'API' | 'Frontend' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed' | 'Scenarios';
+/**
+ * 🆕 CT Individual (Cenário de Teste)
+ */
+export interface CTExecution {
+    ctId: string;
+    ctName: string;
+    ctOrder: number;
+    status: 'running' | 'passed' | 'failed' | 'skipped';
+    duration: number;
+    timestamp: Date;
+    error?: string;
+    className: string;
+    methodName: string;
+}
+export interface TestResult {
+    nome: string;
+    resultado: 'PASS' | 'FAIL';
+    tipo: TestContextType;
+    duracao: number;
+    logs: string[];
+    timestamp: Date;
+    metadata?: {
+        requests?: number;
+        validations?: number;
+        screenshots?: number;
+        [key: string]: any;
+    };
+    cts?: CTExecution[];
+    totalCTs?: number;
+    passedCTs?: number;
+    failedCTs?: number;
+    skippedCTs?: number;
+}
+export interface UnifiedMetrics {
+    totalTestes: number;
+    testesPorTipo: Record<TestContextType, number>;
+    resultadosPorTipo: Record<TestContextType, {
+        passou: number;
+        falhou: number;
+    }>;
+    inicio: Date | null;
+    fim: Date | null;
+    duracao: number;
+    testes: TestResult[];
+}
+/**
+ * ✅ Interface para dados globais dos testes
+ */
+interface TestData {
+    nome: string;
+    tipo: TestContextType;
+    inicio: Date;
+    fim: Date | null;
+    duracao: number;
+    status: 'running' | 'passed' | 'failed' | 'skipped';
+    logs: string[];
+    screenshots: string[];
+    dados: any;
+    cts?: any[];
+}
+type FinalizeTestOptions = {
+    cnName?: string;
+    ctName?: string;
+    errorMessage?: string;
+};
+/**
+ * Gerenciador unificado de relatórios para todos os tipos de teste
+ */
+export declare class UnifiedReportManager {
+    private static inicioExecucao;
+    private static fimExecucao;
+    private static testes;
+    private static contextoPorTeste;
+    private static logsPorTeste;
+    private static metadataPorTeste;
+    private static duracoesPorTeste;
+    private static ctToCnMap;
+    /**
+     * ✅ Dados globais estruturados
+     */
+    private static dadosGlobais;
+    /**
+     * ✅ NOVO: Sistema de detecção automática
+     */
+    private static autoDetectionActive;
+    private static currentTestName;
+    private static testStartTime;
+    private static monitoringInterval;
+    /**
+     * Registra relacionamento entre CT (test.title) e CN (test.describe)
+     */
+    static registrarCtParaCn(ctName: string, cnName: string): void;
+    private static obterCnRegistrado;
+    private static limparRegistroCt;
+    /**
+     * ❌ DESABILITADO: Auto-inicialização que causava registro duplicado
+     * O registro correto já é feito via TestAnnotations.Api/SSH/Banco/etc
+     */
+    private static autoInit;
+    /**
+     * ✅ NOVO: Monitoramento automático de mudanças de teste
+     */
+    private static iniciarMonitoramentoAutomatico;
+    /**
+     * ✅ NOVO: Interceptar TestContext para detectar mudanças automaticamente
+     */
+    private static interceptarTestContext;
+    /**
+     * ✅ NOVO: Detectar novo teste automaticamente
+     */
+    private static detectarNovoTeste;
+    /**
+     * ✅ NOVO: Iniciar teste automaticamente
+     */
+    private static iniciarTesteAutomatico;
+    /**
+     * ✅ NOVO: Finalizar teste automaticamente
+     */
+    private static finalizarTesteAutomatico;
+    static setTestContext(testeName: string, contexto: TestContextType): void;
+    static iniciarTeste(testeName: string, contexto?: TestContextType): void;
+    static registrarInicioExecucao(): void;
+    /**
+     * Registra informações do ambiente CI (Azure Pipelines, GitHub Actions, etc)
+     * e as anexa como metadados globais para o relatório.
+     */
+    static registrarCIInfo(): void;
+    static registrarFimExecucao(): void;
+    /**
+     * ✅ NOVO: Registra explicitamente um teste no sistema
+     */
+    static registrarTeste(testName: string, contextType: TestContextType): void;
+    /**
+     * 🆕 HELPER: Obter o nome correto do CN (test.describe) do TestInfo
+     */
+    private static getCNNameFromTestInfo;
+    /**
+     * ✅ NOVO: Marca explicitamente o fim de um teste
+     */
+    static marcarFimTeste(testName: string, status: 'passed' | 'failed' | 'skipped', options?: FinalizeTestOptions): Promise<void>;
+    /**
+     * ✅ NOVO: Corrige status dos CTs quando teste PASSA
+     * Marca todos os CTs "running" do teste como "passed"
+     */
+    private static corrigirStatusCTsQuandoTestePassou;
+    /**
+     * ✅ NOVO: Corrige status dos CTs quando teste FALHA
+     * Marca todos os CTs "running" do teste como "failed"
+     */
+    private static corrigirStatusCTsQuandoTesteFalha;
+    static coletarDadosDoTeste(testeName?: string): Promise<any>;
+    static adicionarLog(testeName: string, message: string): void;
+    static setTestMetadata(testeName: string, metadata: any): void;
+    static setTestDuration(testeName: string, duracao: number): void;
+    /**
+     * ✅ NOVO: Obter logs de um teste específico
+     */
+    static getTestLogs(testName: string): string[];
+    static anexarRelatorioIndividual(): Promise<void>;
+    /**
+     * ✅ CORRIGIDO: Anexa relatório geral unificado
+     */
+    static anexarRelatorioGeral(): Promise<void>;
+    /**
+     * 🔍 DEBUG: Método para acessar dados globais
+     */
+    static getDadosGlobais(): {
+        totalTestes: number;
+        testesPassados: number;
+        testesFalharam: number;
+        testes: Record<string, TestData>;
+    };
+    /**
+     * ✅ ÚNICO: Método getMetrics unificado
+     */
+    static getMetrics(): UnifiedMetrics;
+    static reset(): void;
+    static finalizarTeste(testName?: string, status?: 'passed' | 'failed' | 'skipped'): Promise<void>;
+    /**
+     * ✅ NOVO: Interceptar e registrar erros de teste automaticamente
+     * @param testName Nome do teste
+     * @param error Erro capturado
+     */
+    static registrarErroTeste(testName: string, error: Error | string): Promise<void>;
+    /**
+     * ✅ NOVO: Configurar interceptação global de erros para testes AutoCore
+     */
+    static configurarInterceptacaoErros(): void;
+    /**
+     * ✅ NOVO: Interceptar logs do console para detectar ações automaticamente
+     */
+    private static interceptarConsole;
+    /**
+     * ✅ NOVO: Adiciona um CT ao teste
+     */
+    static adicionarCT(testName: string, ct: any): void;
+    /**
+     * ✅ NOVO: Gera o relatório unificado final
+     */
+    static gerarRelatorioUnificado(): Promise<string>;
+    /**
+     * ✅ HELPER: Calcula duração total
+     */
+    private static calcularDuracaoTotal;
+    /**
+     * ✅ HELPER: Pega contextos únicos
+     */
+    private static getContextosUnicos;
+}
+export {};