@silasfmartins/testhub 1.0.0

package/dist/src/utils/CustomReporter.js

@@ -0,0 +1,352 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { AutoDocs } from '../hubdocs/HubDocs.js';
+import { CoverageManager } from '../testContext/CoverageManager.js';
+import { UnifiedReportManager, } from '../testContext/UnifiedReportManager.js';
+import { Logger } from './Logger.js';
+import { UnifiedTeardown } from './UnifiedTeardown.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { ExecutionTracker } from '../hubdocs/ExecutionTracker.js';
+export default class CustomReporter {
+    testCount = 0;
+    completedTests = 0;
+    projectRoot = '';
+    // 🔧 NOVO: Rastrear CTs por CN para finalizar apenas quando todos terminarem
+    ctsByCN = new Map();
+    // 🔧 Cache local do StatementTracker para evitar múltiplas resoluções
+    statementTracker;
+    onBegin(config, suite) {
+        // ✅ CORRIGIDO: Contar testes corretamente
+        this.testCount = this.countAllTests(suite);
+        console.log(`🎯 Iniciando execução de ${this.testCount} testes`);
+        // 📡 NETWORK LOGS: Capturar projectRoot para copiar logs depois
+        this.projectRoot = config.rootDir;
+        if (this.projectRoot.endsWith('tests') || this.projectRoot.endsWith('tests/') || this.projectRoot.endsWith('tests\\')) {
+            this.projectRoot = path.dirname(this.projectRoot);
+        }
+        // 🔧 NOVO: Mapear CNs e seus CTs
+        this.mapCNsAndCTs(suite);
+        // ✅ ESSENCIAL: Inicializar o gerenciador unificado
+        UnifiedReportManager.registrarInicioExecucao();
+        // ✅ CRÍTICO: Inicializar ExecutionTracker para garantir persistência
+        // Fazer de forma assíncrona sem bloquear
+        import('../hubdocs/ExecutionTracker.js')
+            .then(({ ExecutionTracker }) => {
+            ExecutionTracker.initialize();
+        })
+            .catch((error) => {
+            console.warn(`⚠️ CustomReporter: Erro ao inicializar ExecutionTracker: ${String(error)}`);
+        });
+        // ✅ NOVO: Inicializar AutoDocs para documentação automática
+        try {
+            AutoDocs.initialize({
+                projectName: 'TestHUB Project',
+                outputDir: './docs',
+                config: {
+                    enabled: true,
+                    categories: ['api', 'ssh', 'db', 'ui', 'mobile'],
+                    generateSwagger: true,
+                    includeScreenshots: true,
+                },
+            })
+                .catch((error) => {
+                Logger.warning(`Erro ao inicializar AutoDocs: ${String(error)}`);
+            });
+        }
+        catch (error) {
+            Logger.warning(`Erro ao carregar AutoDocs: ${String(error)}`);
+        }
+    }
+    countAllTests(suite) {
+        let count = 0;
+        // Contar testes diretos da suite
+        if (suite.tests) {
+            count += suite.tests.length;
+        }
+        // Contar testes das suites filhas (recursivo)
+        if (suite.suites) {
+            for (const childSuite of suite.suites) {
+                count += this.countAllTests(childSuite);
+            }
+        }
+        return count;
+    }
+    // 🔧 NOVO: Mapear CNs (test.describe) e seus CTs (test)
+    mapCNsAndCTs(suite) {
+        // Se a suite tem suites filhas (test.describe), mapear os CTs dentro
+        if (suite.suites && suite.suites.length > 0) {
+            for (const childSuite of suite.suites) {
+                // childSuite.title = CN (ex: "CN001_Orquestrador FTTH")
+                const cnName = childSuite.title;
+                const ctCount = childSuite.tests?.length || 0;
+                if (ctCount > 0) {
+                    this.ctsByCN.set(cnName, {
+                        total: ctCount,
+                        completed: 0,
+                        lastStatus: 'passed',
+                    });
+                }
+                // Recursivo para test.describe aninhados
+                this.mapCNsAndCTs(childSuite);
+            }
+        }
+    }
+    detectProjectType(test) {
+        if (!test.location?.file) {
+            return 'Mixed';
+        }
+        const fileName = test.location.file.toLowerCase();
+        if (fileName.includes('frontend') || fileName.includes('page-object')) {
+            return 'Frontend';
+        }
+        if (fileName.includes('api') || fileName.includes('request')) {
+            return 'API';
+        }
+        if (fileName.includes('mobile')) {
+            return 'Mobile';
+        }
+        if (fileName.includes('ssh')) {
+            return 'SSH';
+        }
+        if (fileName.includes('banco') || fileName.includes('database')) {
+            return 'Banco';
+        }
+        if (fileName.includes('scenarios') || fileName.includes('cenarios')) {
+            return 'Scenarios';
+        }
+        return 'Mixed';
+    }
+    async getStatementTracker() {
+        if (this.statementTracker) {
+            return this.statementTracker;
+        }
+        let tracker = globalThis.statementTracker ||
+            globalThis.__SIMPLE_STATEMENT_TRACKER__;
+        if (!tracker) {
+            try {
+                tracker = new StatementTracker();
+            }
+            catch (error) {
+                console.log(`⚠️ [CustomReporter] Falha ao carregar StatementTracker dinamicamente: ${String(error)}`);
+                return undefined;
+            }
+        }
+        if (tracker && typeof tracker.finalizarCT === 'function') {
+            this.statementTracker = tracker;
+            globalThis.statementTracker = tracker;
+            return tracker;
+        }
+        return undefined;
+    }
+    onTestBegin(test) {
+        Logger.info(`     ${this.completedTests + 1} ${test.location?.file}:${test.location?.line}:${test.location?.column} › ${test.parent?.title} › ${test.title}`);
+        const projectType = this.detectProjectType(test);
+        // ✅ CRÍTICO: Usar CN (test.parent.title = test.describe) como identificador
+        // test.title = CT (test), test.parent.title = CN (test.describe)
+        const cnName = test.parent?.title || test.title;
+        UnifiedReportManager.setTestContext(cnName, projectType);
+        UnifiedReportManager.registrarTeste(cnName, projectType);
+        console.log(`🏷️  Teste registrado: ${cnName} (${projectType})`);
+    }
+    async onTestEnd(test, result) {
+        this.completedTests++;
+        // ✅ CRÍTICO: Usar CN (test.parent.title = test.describe) como identificador
+        // test.title = CT (test), test.parent.title = CN (test.describe)
+        const cnName = test.parent?.title || test.title;
+        const ctName = test.title;
+        // ✅ CRÍTICO: Registrar resultado do teste (mesmo se falhar)
+        let status;
+        if (result.status === 'passed') {
+            status = 'passed';
+        }
+        else if (result.status === 'failed') {
+            status = 'failed';
+        }
+        else {
+            status = 'skipped';
+        }
+        console.log(`ℹ️       ${this.completedTests} ${test.location?.file}:${test.location?.line}:${test.location?.column} › ${cnName}  › ${ctName}`);
+        globalThis.__SIMPLE_STATEMENT_CURRENT_TEST_NAME__ = cnName;
+        // ✅ CRÍTICO: Finalizar CT individual IMEDIATAMENTE
+        // Isso garante que CT001 seja marcado como PASSED antes de CT002 falhar
+        const errorMessage = result.errors && result.errors.length > 0
+            ? result.errors[0]?.message
+            : undefined;
+        try {
+            const tracker = await this.getStatementTracker();
+            if (tracker) {
+                // 🆕 CRÍTICO: Forçar carregamento dos dados do arquivo antes de finalizar
+                // O Reporter roda em processo separado dos testes, então precisamos
+                // garantir que os CTs criados nos testes estejam disponíveis aqui
+                if (typeof tracker.forceLoadFromFile === 'function') {
+                    tracker.forceLoadFromFile();
+                }
+                tracker.finalizarCT(ctName, status, {
+                    testName: cnName,
+                    errorMessage,
+                });
+            }
+            else {
+                console.log(`⚠️ [CustomReporter] StatementTracker não disponível para finalizar CT "${ctName}"`);
+            }
+        }
+        catch (error) {
+            console.log(`⚠️ [CustomReporter] Erro ao finalizar CT individual:`, error);
+        }
+        finally {
+            // Limpar global
+            ;
+            globalThis.__SIMPLE_STATEMENT_CURRENT_TEST_NAME__ = undefined;
+        }
+        // 🔧 NOVO: Rastrear CTs completados por CN
+        const cnData = this.ctsByCN.get(cnName);
+        if (cnData) {
+            cnData.completed++;
+            if (status === 'failed') {
+                cnData.lastStatus = 'failed'; // Se qualquer CT falhar, CN falha
+            }
+            // ✅ SÓ FINALIZAR quando TODOS os CTs do CN terminarem
+            if (cnData.completed === cnData.total) {
+                // ✅ IMPORTANTE: Finalizar o CN apenas quando todos os CTs terminarem
+                await UnifiedReportManager.marcarFimTeste(cnName, cnData.lastStatus);
+                // ✅ NOVO: Registrar coverage usando CN
+                const projectType = this.detectProjectType(test);
+                const coverageType = this.mapToCoverageType(projectType);
+                const duration = result.duration || 0;
+                try {
+                    await CoverageManager.registerTestCoverage(cnName, coverageType, undefined, // page não disponível no reporter
+                    duration);
+                    console.log(`📊 Coverage registrado para: ${cnName} (${coverageType})`);
+                }
+                catch (error) {
+                    Logger.warning(`Erro ao registrar coverage: ${String(error)}`);
+                }
+                // ✅ CONTINUAR COM LÓGICA ORIGINAL usando CN
+                UnifiedReportManager.setTestDuration(cnName, result.duration);
+                console.log(`📊 Teste ${this.completedTests}/${this.testCount} concluído: ${cnName} [${cnData.lastStatus.toUpperCase()}]`);
+                // ✅ IMPORTANTE: Coletar dados mesmo se o teste falhar
+                try {
+                    await UnifiedReportManager.coletarDadosDoTeste();
+                    await UnifiedReportManager.anexarRelatorioIndividual();
+                }
+                catch (error) {
+                    Logger.error(`❌ Erro ao processar teste ${cnName}`, error);
+                }
+            }
+        }
+        else {
+            // Teste individual sem test.describe - finalizar imediatamente
+            console.log(`ℹ️ [CustomReporter] Teste individual sem CN: "${ctName}"`);
+            await UnifiedReportManager.marcarFimTeste(ctName, status);
+        }
+    }
+    mapToCoverageType(projectType) {
+        switch (projectType) {
+            case 'Frontend':
+                return 'Frontend';
+            case 'API':
+                return 'API';
+            case 'Mobile':
+                return 'Mobile';
+            case 'SSH':
+                return 'SSH';
+            case 'Banco':
+                return 'Banco';
+            case 'Scenarios':
+                return 'Mixed'; // Scenarios mapeia para Mixed
+            case 'Mixed':
+                return 'Mixed';
+            default:
+                return 'Mixed';
+        }
+    }
+    async onEnd(_result) {
+        console.log('🏁 Finalizando execução dos testes...');
+        try {
+            // ✅ NOVO: Gerar documentação AutoDocs automaticamente ANTES do teardown
+            console.log('📚 Gerando documentação automática do projeto...');
+            // ✅ CRÍTICO: Garantir que ExecutionTracker FORCE um save final ANTES da geração
+            try {
+                // ✅ NOVO: Forçar save final dos dados ANTES de gerar documentação
+                console.log('📚 CustomReporter: Salvando dados finais...');
+                // Atualizar estatísticas finais
+                ExecutionTracker.updateTestStats(this.testCount, this.completedTests - (this.testCount - this.completedTests), this.testCount - this.completedTests);
+                // Verificar dados na memória antes da finalização
+                const memoryData = ExecutionTracker.getData();
+                // Finalizar APENAS para atualizar endTime - NÃO deve apagar dados
+                ExecutionTracker.finalize();
+                // Aguardar um pouco para garantir que o arquivo foi escrito
+                await new Promise((resolve) => setTimeout(resolve, 200));
+                // Verificar dados no arquivo após finalize
+                const fileData = ExecutionTracker.loadFromFile();
+                if (fileData) {
+                    //Teste
+                }
+                else {
+                    console.log('📊 CustomReporter: ⚠️ ERRO - Nenhum arquivo de dados encontrado após finalize!');
+                }
+            }
+            catch (error) {
+                console.log(`📊 CustomReporter: Erro ao preparar dados: ${String(error)}`);
+            }
+            try {
+                await AutoDocs.generateDocs();
+                console.log('📁 Documentação disponível em: docs/index.html');
+                console.log('🌐 Abra o arquivo docs/index.html no browser para visualizar');
+            }
+            catch (error) {
+                Logger.warning(`Erro ao gerar documentação AutoDocs: ${String(error)}`);
+            }
+            // ✅ IMPORTANTE: Chama UnifiedTeardown APÓS gerar documentação
+            // UnifiedTeardown será responsável por todos os relatórios finais para evitar duplicação
+            await UnifiedTeardown.run();
+            // 📡 NETWORK LOGS: Copiar para playwright-report/evidence/network-logs/
+            await this.copyNetworkLogsToReport();
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao processar relatórios finais', error);
+        }
+        console.log(`📋 Total: ${this.completedTests} testes processados`);
+    }
+    /**
+     * 📡 Copia os network logs de test-results/network-logs/ para playwright-report/evidence/network-logs/
+     * Isso acontece APÓS a geração do relatório HTML pelo Playwright
+     */
+    async copyNetworkLogsToReport() {
+        const sourceDir = path.join(this.projectRoot, 'test-results', 'network-logs');
+        const destDir = path.join(this.projectRoot, 'playwright-report', 'evidence', 'network-logs');
+        if (!fs.existsSync(sourceDir)) {
+            return;
+        }
+        try {
+            // Cria pasta destino se não existir
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+            // Lista arquivos na pasta source
+            const files = fs.readdirSync(sourceDir);
+            if (files.length === 0) {
+                return;
+            }
+            console.log('');
+            console.log('═══════════════════════════════════════════════════════════════════');
+            console.log('📡 [AutoCore] Copiando Network Logs para playwright-report/');
+            console.log('═══════════════════════════════════════════════════════════════════');
+            let copiedCount = 0;
+            for (const file of files) {
+                const sourcePath = path.join(sourceDir, file);
+                const destPath = path.join(destDir, file);
+                // Copia o arquivo (mantém original em test-results/)
+                fs.copyFileSync(sourcePath, destPath);
+                copiedCount++;
+            }
+            console.log(`   ✅ ${copiedCount} arquivo(s) copiado(s) para:`);
+            console.log(`      ${destDir}`);
+            console.log('═══════════════════════════════════════════════════════════════════');
+            console.log('');
+        }
+        catch (err) {
+            console.error('❌ [AutoCore] Erro ao copiar network logs:', err);
+        }
+    }
+}

package/dist/src/utils/DataStore.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Store compartilhado para transferência de dados entre projetos e testes
+ *
+ * Funcionalidades:
+ * - Cache em memória para performance
+ * - Persistência em arquivo JSON
+ * - Métodos especializados para diferentes tipos de dados
+ * - Limpeza automática com TTL
+ * - Thread-safe operations
+ * - Type-safe getters para evitar erros de null
+ *
+ * @example
+ * ```typescript
+ * // ✅ FORMA CORRETA - Armazenar dados
+ * DataStore.set('user_id', '12345')
+ * DataStore.set('URL_CLIENTE', 'https://example.com')
+ *
+ * // ✅ FORMA CORRETA - Recuperar com type safety
+ * const userId = DataStore.getString('user_id') // retorna string (nunca null)
+ * const url = DataStore.getString('URL_CLIENTE', 'https://default.com') // com fallback
+ * const count = DataStore.getNumber('attempts', 0) // retorna number
+ * const isActive = DataStore.getBoolean('active') // retorna boolean
+ *
+ * // ✅ FORMA CORRETA - Quando você TEM CERTEZA que o valor existe
+ * const token = DataStore.getOrThrow<string>('ACCESS_TOKEN') // lança erro se null
+ *
+ * // ❌ EVITE - Pode causar erro TypeScript "Type 'string | null' is not assignable to type 'string'"
+ * const url: string = DataStore.get('URL_CLIENTE') // ❌ ERRO!
+ * Logger.info(DataStore.get('URL_CLIENTE')) // ❌ ERRO!
+ *
+ * // ✅ CORRIJA USANDO - Operador de coalescência nula
+ * const url: string = DataStore.get('URL_CLIENTE') ?? 'default'
+ * Logger.info(DataStore.getString('URL_CLIENTE'))
+ *
+ * // Armazenar com TTL
+ * DataStore.setWithTTL('session_token', 'abc123', 3600) // expira em 1h
+ *
+ * // Armazenar resultado de query
+ * DataStore.storeQueryResult('user_details', userData)
+ *
+ * // Armazenar screenshot
+ * DataStore.storeScreenshot('login_page', screenshotBuffer)
+ * ```
+ */
+export declare class DataStore {
+    private static readonly dataFilePath;
+    private static readonly persistEnabled;
+    private static cache;
+    private static initialized;
+    private static lastSaveTime;
+    private static readonly SAVE_THROTTLE_MS;
+    /**
+     * Inicializa o DataStore carregando dados existentes
+     */
+    private static initialize;
+    /**
+     * Migra dados do formato antigo para o novo com metadados
+     */
+    private static migrateOldFormat;
+    /**
+     * Determina o tipo do item baseado na chave e valor
+     */
+    private static determineItemType;
+    /**
+     * Remove itens expirados baseado no TTL
+     */
+    private static cleanupExpiredItems;
+    /**
+     * Salva os dados no arquivo com throttling
+     */
+    private static save;
+    /**
+     * Armazena um valor com uma chave específica
+     */
+    static set(key: string, value: any): void;
+    /**
+     * Armazena um valor com TTL (Time To Live)
+     */
+    static setWithTTL(key: string, value: any, ttlSeconds: number): void;
+    /**
+     * Recupera um valor usando sua chave
+     */
+    static get<T = any>(key: string, defaultValue?: T | null): T | null;
+    /**
+     * Recupera um valor ou lança erro se não existir
+     * Útil quando você tem certeza que o valor existe
+     */
+    static getOrThrow<T = any>(key: string): T;
+    /**
+     * Recupera um valor string ou retorna string vazia
+     * Útil para evitar problemas com null
+     */
+    static getString(key: string, defaultValue?: string): string;
+    /**
+     * Recupera um valor number ou retorna 0
+     */
+    static getNumber(key: string, defaultValue?: number): number;
+    /**
+     * Recupera um valor boolean ou retorna false
+     */
+    static getBoolean(key: string, defaultValue?: boolean): boolean;
+    /**
+     * Verifica se uma chave existe e não expirou
+     */
+    static has(key: string): boolean;
+    /**
+     * Remove um valor específico
+     */
+    static remove(key: string): boolean;
+    /**
+     * Limpa todos os valores armazenados
+     */
+    static clear(): void;
+    /**
+     * Limpa apenas itens temporários
+     */
+    static clearTempItems(): void;
+    /**
+     * Retorna todos os dados armazenados com metadados
+     */
+    static getAll(): Record<string, any>;
+    /**
+     * Retorna estatísticas do DataStore
+     */
+    static getStats(): {
+        totalItems: number;
+        itemsByType: Record<string, number>;
+        expiredItems: number;
+        totalSizeKB: number;
+    };
+    /**
+     * Armazena resultado de consulta de banco para uso posterior
+     */
+    static storeQueryResult(queryName: string, data: any, ttlSeconds?: number): void;
+    /**
+     * Recupera resultado de consulta de banco
+     */
+    static getQueryResult<T = any>(queryName: string): T | null;
+    /**
+     * Armazena screenshot para evidências
+     */
+    static storeScreenshot(name: string, screenshotData: Buffer | string, metadata?: any): void;
+    /**
+     * Recupera screenshot
+     */
+    static getScreenshot(name: string): {
+        data: Buffer | string;
+        metadata: any;
+        timestamp: string;
+    } | null;
+    /**
+     * Armazena dados temporários com TTL curto
+     */
+    static setTemp(key: string, value: any, ttlSeconds?: number): void;
+    /**
+     * Recupera dados temporários
+     */
+    static getTemp<T = any>(key: string): T | null;
+    /**
+     * Força limpeza completa e remove arquivo
+     */
+    static cleanup(): void;
+    /**
+     * Backup dos dados para outro arquivo
+     */
+    static backup(backupPath?: string): string;
+    /**
+     * Restaura dados de um backup
+     */
+    static restore(backupPath: string): void;
+}