@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,476 @@
+import type { TestInfo } from '@playwright/test';
+import type { IPage } from '../interfaces.js';
+/**
+ * Classe unificada para configurar contextos de teste e integração com UnifiedReportManager.
+ * Permite configurar automaticamente o contexto do teste (API, Frontend, Mobile, SSH, Banco, Mixed),
+ * registrar logs, metadados, screenshots e garantir limpeza automática de sessões mobile.
+ *
+ * ✅ AGORA COM SISTEMA AUTOMÁTICO - Não precisa configurar nada manualmente!
+ */
+export declare class TestAnnotations {
+    /**
+     * Opções do runner para testes desktop
+     * - attachWindow: se true, tentará iniciar/atacar uma janela da aplicação
+     * - closeWindow: se true, fechará a aplicação ao final do CT
+     * - app_path: caminho para o executável a ser iniciado
+     */
+    private static runnerOptions;
+    /**
+     * Define opções do runner (attachWindow, closeWindow, app_path)
+     */
+    static setRunnerOptions(options: {
+        attachWindow?: boolean;
+        closeWindow?: boolean;
+        app_path?: string;
+    }): Promise<void>;
+    /**
+     * ✅ REMOVIDO: inicializarAutoCore - Agora é automático!
+     * O sistema se inicializa sozinho quando o módulo é carregado.
+     */
+    /**
+     * 🛑 Ativa o modo "parar ao falhar" globalmente.
+     * Quando ativado, se um CT falhar, os próximos CTs não serão executados.
+     * Pode ser chamado no escopo do test.describe() para aplicar a todos os CTs do CN.
+     * @param enabled - true para ativar, false para desativar (padrão: true)
+     */
+    static stopOnFailure(enabled?: boolean): void;
+    /**
+     * 🛑 Verifica se o modo "parar ao falhar" está ativo.
+     * @returns true se stopOnFailure está ativo
+     */
+    static isStopOnFailureEnabled(): boolean;
+    /**
+     * 🎯 NOVO: Captura CT diretamente do contexto do Playwright e registra automaticamente
+     */
+    private static capturarCTDoPlaywright;
+    /**
+     * Detecta automaticamente o contexto principal do projeto a partir das variáveis de ambiente.
+     * @returns O tipo de contexto principal detectado.
+     */
+    private static detectProjectContext;
+    /**
+     * Configuração automática do contexto do teste.
+     * Detecta o contexto, configura interceptadores e registra logs/metadados.
+     */
+    static Auto: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Detecta se o projeto é realmente mixed (múltiplos contextos).
+     * @returns true se for mixed, false caso contrário.
+     */
+    private static detectIfMixed;
+    /**
+     * Configura interceptador seguro para um contexto específico.
+     * @param testName Nome do teste.
+     * @param contexto Contexto do teste.
+     */
+    private static setupSpecificInterceptor;
+    /**
+     * Configura interceptadores para todos os contextos (usado em projetos mixed).
+     * @param testName Nome do teste.
+     */
+    private static setupAllInterceptors;
+    /**
+     * Configura finalização automática do teste para registrar duração.
+     * @param testInfo TestInfo do Playwright.
+     */
+    private static setupTestFinalization;
+    /**
+     * ✅ NOVO: Configura cobertura automática para teste Frontend
+     * @param testInfo TestInfo do Playwright
+     */
+    private static setupFrontendCoverage;
+    /**
+     * ✅ NOVO: Finaliza e registra cobertura para um teste
+     * @param testName Nome do teste
+     * @param testInfo TestInfo do teste
+     * @param duration Duração do teste em ms
+     */
+    private static finalizeCoverageForTest;
+    /**
+     * 🆕 Configura interceptação automática de todas as classes Statements
+     */
+    private static setupStatementInterception;
+    /**
+     * 🚨 Interceptação imediata - Configurada ANTES de qualquer import
+     */
+    private static setupImmediateInterception;
+    /**
+     * 🔥 Interceptação em tempo real de métodos Statement
+     */
+    private static setupRealTimeMethodInterception;
+    /**
+     * 🆕 Intercepta constructors de classes Statement para capturar instanciações
+     */
+    private static setupConstructorInterception;
+    /**
+     * 🚀 Detecta automaticamente classes Statement via análise de arquivo .spec.ts
+     */
+    private static detectStatementClassesFromCallStack;
+    /**
+     * 🎯 Detecta classes Statement de um arquivo .spec.ts específico
+     */
+    private static detectStatementClassesFromSpecFile;
+    /**
+     * 🌐 Interceptar classes Statement disponíveis no globalThis
+     */
+    private static interceptGlobalStatements;
+    /**
+     * ✨ NOVO: Interceptação dinâmica de construtores Statement
+     */
+    private static setupDynamicConstructorInterception;
+    /**
+     * ✨ NOVO: Interceptar classes Statement já importadas nos módulos
+     */
+    private static interceptImportedStatements;
+    /**
+     * 🔄 Detecta classes Statement do contexto atual do teste (fallback ESM)
+     */
+    private static detectStatementClassesFromTestContext;
+    /**
+     * 🛠️ Obtém módulo fs compatível com ESM
+     */
+    private static getFileSystemModule;
+    /**
+     * 🛠️ Obtém módulo path compatível com ESM
+     */
+    private static getPathModule;
+    /**
+     * 🌐 Detecta classes Statement do contexto global - APENAS análise real
+     */
+    private static detectStatementClassesFromGlobal;
+    /**
+     * 🌐 Configuração universal que intercepta qualquer instanciação de classe com padrão Statement
+     */
+    private static setupUniversalStatementInterception;
+    /**
+     * 🎯 Intercepta uma classe diretamente no momento da descoberta
+     */
+    private static interceptClassDirectly;
+    /**
+     * 🏗️ Criar instância interceptada
+     */
+    private static createInterceptedInstance;
+    /**
+     * 🌐 Configuração universal de interceptação de constructor
+     */
+    private static setupUniversalConstructorInterception;
+    /**
+     * 🚀 Monitoramento contínuo de instanciações de Statement durante o teste
+     */
+    private static setupContinuousStatementMonitoring;
+    /**
+     * 🆕 Configuração dinâmica para interceptar instanciações em tempo real
+     */
+    private static setupDynamicInterception;
+    /**
+     * Configura interceptador seguro para registrar logs no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param className Nome da classe/contexto.
+     * @param originalMethod Método original de log.
+     * @param targetClass Classe alvo.
+     * @param methodName Nome do método.
+     */
+    static setupSafeInterceptor(testName: string, className: string, originalMethod: any, targetClass: any, methodName: string): void;
+    /**
+     * 🌐 Seleciona o sistema do TestHub para o teste.
+     * O sistema deve ser selecionado ANTES de usar qualquer ação (API, Frontend, SSH, Banco).
+     * As configurações (URLs, credenciais, hosts) serão injetadas automaticamente.
+     *
+     * @param systemName Nome do sistema (use o enum Systems para IntelliSense)
+     * @param environmentName Nome do ambiente (opcional, usa process.env.ENV se não fornecido)
+     *
+     * @example
+     * // IMPORTANTE: Na primeira execução, use string diretamente:
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     *
+     * // Após primeira execução, o enum será gerado e você pode usar:
+     * import { Systems } from "../.rbqa/SystemsEnum"
+     * await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML) // 👈 IntelliSense disponível
+     *
+     * // Exemplo completo:
+     * test("CT001", async ({}, testInfo) => {
+     *   TestAnnotations.Api.testInfo = testInfo
+     *   await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)
+     *
+     *   // Agora as URLs e credenciais estão configuradas automaticamente
+     *   await new StatementsToken().getToken()
+     * })
+     */
+    static setSystem(systemName: string, environmentName?: string): Promise<void>;
+    /**
+     * 🌐 Obtém a URL do sistema atualmente configurado.
+     * Deve ser chamado APÓS setSystem().
+     *
+     * @returns URL do sistema ou undefined se nenhum sistema foi configurado
+     *
+     * @example
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     * const url = TestAnnotations.getSystemUrl()
+     * console.log(url) // "https://autenticainthml.redecorp.br"
+     */
+    static getSystemUrl(): string | undefined;
+    /**
+     * 🌐 Obtém as configurações completas do sistema atualmente configurado.
+     * Deve ser chamado APÓS setSystem().
+     *
+     * @returns Configurações do sistema ou null se nenhum sistema foi configurado
+     *
+     * @example
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     * const config = TestAnnotations.getSystemConfig()
+     * console.log(config?.baseUrl) // "https://autenticainthml.redecorp.br"
+     * console.log(config?.username) // "usuario"
+     */
+    static getSystemConfig(): {
+        baseUrl: string;
+        username?: string;
+        password?: string;
+        host?: string;
+        port?: string;
+        serviceName?: string;
+        privateKeyPath?: string;
+    } | null;
+    /**
+     * Configura um teste como API, com interceptador e logs.
+     */
+    static Api: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Configura um teste como Frontend, com logs e cobertura automática.
+     */
+    static Frontend: {
+        /**
+         * Configura contexto Frontend com TestInfo e cobertura automática
+         * @param testInfo TestInfo do Playwright
+         * @param enableCoverage Se deve habilitar cobertura automática (padrão: true)
+         */
+        configure(testInfo: TestInfo, enableCoverage?: boolean): void;
+        /**
+         * 🆕 Inicializa contexto Frontend com page e testInfo em uma única chamada
+         * @param options Objeto com page e testInfo do Playwright
+         * @example
+         * test('CT001', async ({ page }, testInfo) => {
+         *   TestAnnotations.Frontend.init({ page, testInfo })
+         *   await TestAnnotations.setSystem('MEU_SISTEMA')
+         *   await new MinhaPage().minhaAcao()
+         * })
+         */
+        init(options: {
+            page: IPage;
+            testInfo: TestInfo;
+            enableCoverage?: boolean;
+        }): void;
+        testInfo: TestInfo;
+    };
+    /**
+     * Configura um teste como Mobile, com limpeza automática de sessão.
+     */
+    static Mobile: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Configura limpeza automática para testes mobile.
+     * @param testInfo TestInfo do Playwright.
+     */
+    private static setupMobileAutoCleanup;
+    /**
+     * Método utilitário para configurar mobile capabilities.
+     * @param capabilities Objeto de capabilities do dispositivo.
+     */
+    static setupMobileCapabilities(capabilities: {
+        deviceId: string;
+        platformName: 'Android' | 'iOS';
+        appPackage?: string;
+        appActivity?: string;
+        bundleId?: string;
+    }): Promise<void>;
+    /**
+     * Configura um teste como SSH, com interceptador e logs.
+     */
+    static SSH: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Configura um teste como Banco, com interceptador e logs.
+     */
+    static Banco: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Configura um teste como Mixed, com interceptadores e limpeza automática.
+     */
+    static Mixed: {
+        testInfo: TestInfo;
+    };
+    /**
+     * Adiciona um log ao UnifiedReportManager para o teste.
+     * @param testName Nome do teste.
+     * @param message Mensagem de log.
+     * @param tipo Tipo do log ('info', 'success', 'error', 'warning').
+     */
+    static addLog(testName: string, message: string, tipo?: 'info' | 'success' | 'error' | 'warning'): void;
+    /**
+     * Define metadados para o teste no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param metadata Objeto de metadados.
+     */
+    static setMetadata(testName: string, metadata: any): void;
+    /**
+     * Define a duração do teste no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param duracao Duração em segundos.
+     */
+    static setDuration(testName: string, duracao: number): void;
+    /**
+     * Obtém o contexto atual do teste.
+     * @returns O tipo de contexto ou null.
+     */
+    static getCurrentTestContext(): string | null;
+    /**
+     * Marca o teste como falha no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param reason Motivo da falha (opcional).
+     */
+    static markTestAsFailed(testName: string, reason?: string): void;
+    /**
+     * Marca o teste como sucesso no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param message Mensagem de sucesso (opcional).
+     */
+    static markTestAsSuccess(testName: string, message?: string): void;
+    /**
+     * Adiciona um screenshot ao relatório do teste.
+     * @param testName Nome do teste.
+     * @param screenshotName Nome do screenshot.
+     * @param buffer Buffer da imagem.
+     */
+    static addScreenshot(testName: string, screenshotName: string, buffer: Buffer): Promise<void>;
+    /**
+     * Obtém estatísticas globais dos testes.
+     * @returns Objeto com total, concluídos, ativos e por tipo.
+     */
+    static getGlobalStats(): {
+        totalTests: number;
+        completedTests: number;
+        activeTests: number;
+        testsByType: Record<string, number>;
+    };
+    /**
+     * Limpa interceptadores ativos (debug).
+     */
+    static clearInterceptors(): void;
+    /**
+     * Obtém interceptadores ativos (debug).
+     * @returns Array de chaves de interceptadores ativos.
+     */
+    static getActiveInterceptors(): string[];
+    /**
+     * 🔥 FORÇA interceptação direta das classes Statement do projeto real
+     */
+    private static forceInterceptRealProjectStatements;
+    /**
+     * 🎯 Cria uma versão completamente interceptada de uma classe Statement
+     */
+    private static createForceInterceptedClass;
+    /**
+     * 🚀 Gerencia execução de métodos CT detectados via log
+     */
+    private static handleMethodExecution;
+    /**
+     * 🚨 NOVO: Gerencia erros de validação detectados via log
+     */
+    private static handleValidationError;
+    /**
+     * 🏁 Finaliza o CT ativo quando o teste termina
+     */
+    static finalizarCTAtivo(): void;
+    /**
+     * 🆕 Restaurar console original e limpar dados
+     */
+    static restaurarConsoleOriginal(): void;
+    /**
+     * 🆕 Obter logs capturados (para debugging)
+     */
+    static getLogsCapturados(): string[];
+    /**
+     * 💾 Salva o estado de autenticação atual (cookies + localStorage + sessionStorage)
+     * @param filePath Caminho opcional para salvar (padrão: ./test-results/auth/auth-state.json)
+     * @example
+     * // Após fazer login
+     * await TestAnnotations.saveAuthState('./auth/admin-user.json')
+     */
+    static saveAuthState(filePath?: string): Promise<string>;
+    /**
+     * 🔄 Restaura o estado de autenticação salvo
+     * @param filePath Caminho do arquivo de estado
+     * @example
+     * // Antes de rodar testes
+     * await TestAnnotations.restoreAuthState('./auth/admin-user.json')
+     */
+    static restoreAuthState(filePath?: string): Promise<void>;
+    /**
+     * 🧹 Limpa todo o estado de autenticação
+     * @example
+     * // Logout completo
+     * await TestAnnotations.clearAuthState()
+     */
+    static clearAuthState(): Promise<void>;
+    /**
+     * 📄 Verifica se existe um arquivo de estado salvo
+     * @param filePath Caminho do arquivo
+     */
+    static authStateExists(filePath?: string): boolean;
+    /**
+     * 🔍 Lê o estado salvo sem aplicar
+     * @param filePath Caminho do arquivo
+     */
+    static readAuthState(filePath?: string): import("./AuthStateManager.js").AuthState | null;
+    /**
+     * 🗑️ Remove um arquivo de estado
+     * @param filePath Caminho do arquivo
+     */
+    static deleteAuthState(filePath?: string): boolean;
+    /**
+     * 📋 Lista todos os estados salvos
+     */
+    static listAuthStates(): string[];
+}
+export declare const Api: {
+    testInfo: TestInfo;
+}, Frontend: {
+    /**
+     * Configura contexto Frontend com TestInfo e cobertura automática
+     * @param testInfo TestInfo do Playwright
+     * @param enableCoverage Se deve habilitar cobertura automática (padrão: true)
+     */
+    configure(testInfo: TestInfo, enableCoverage?: boolean): void;
+    /**
+     * 🆕 Inicializa contexto Frontend com page e testInfo em uma única chamada
+     * @param options Objeto com page e testInfo do Playwright
+     * @example
+     * test('CT001', async ({ page }, testInfo) => {
+     *   TestAnnotations.Frontend.init({ page, testInfo })
+     *   await TestAnnotations.setSystem('MEU_SISTEMA')
+     *   await new MinhaPage().minhaAcao()
+     * })
+     */
+    init(options: {
+        page: IPage;
+        testInfo: TestInfo;
+        enableCoverage?: boolean;
+    }): void;
+    testInfo: TestInfo;
+}, Mobile: {
+    testInfo: TestInfo;
+}, SSH: {
+    testInfo: TestInfo;
+}, Banco: {
+    testInfo: TestInfo;
+}, Mixed: {
+    testInfo: TestInfo;
+}, Auto: {
+    testInfo: TestInfo;
+};