@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,138 @@
+import type { TestInfo } from '@playwright/test';
+import { type APIRequestContext, request as playwrightRequest } from '@playwright/test';
+import type { IPage } from '../interfaces.js';
+/**
+ * Contexto compartilhado para informações de teste
+ * SIMPLIFICADO: Removida lógica de conexão mobile para MobileConnection
+ */
+export declare class TestContext {
+    private static _testInfo;
+    private static _page;
+    private static _apiContext;
+    private static _sessionId;
+    /**
+     * Tipo de teste configurado por TestAnnotations (API, Frontend, Mixed, SSH, Banco, Mobile).
+     * Definido pelos setters TestAnnotations.Api/Frontend/Mixed/SSH/Banco/Mobile.
+     * Usado pelo fixture autoInjectPage para saber se deve criar browser e como anexar logs.
+     */
+    private static _testType;
+    static setTestType(type: 'API' | 'Frontend' | 'Mixed' | 'SSH' | 'Banco' | 'Mobile'): void;
+    static getTestType(): 'API' | 'Frontend' | 'Mixed' | 'SSH' | 'Banco' | 'Mobile' | null;
+    /**
+     * Retorna true se o tipo de teste NÃO requer browser (API, SSH, Banco).
+     */
+    static isNonBrowserTest(): boolean;
+    /**
+     * Reseta o tipo de teste (chamado no cleanup do fixture).
+     */
+    static resetTestType(): void;
+    private static _pageFactory;
+    private static _pagePromise;
+    /**
+     * Armazena factory para criação lazy de browser+page.
+     * Chamado pelo fixture autoInjectPage antes do body do teste.
+     */
+    static setPageFactory(factory: (() => Promise<any>) | null): void;
+    /**
+     * Dispara criação assíncrona de browser+page (fire-and-forget).
+     * Chamado sync por TestAnnotations.Frontend/Mixed setters.
+     */
+    static requestBrowserCreation(): void;
+    /**
+     * Aguarda criação do page se foi solicitada via requestBrowserCreation().
+     * Retorna o page se disponível, undefined caso contrário.
+     */
+    static ensurePage(): Promise<IPage | undefined>;
+    static setTestInfo(testInfo: TestInfo): void;
+    /**
+     * Obtém o sessionId atual ou cria um novo se não existir
+     */
+    static getOrCreateSessionId(): string;
+    /**
+     * Define explicitamente o sessionId a ser usado nas chamadas ao Hub
+     */
+    static setSessionId(id: string): void;
+    /**
+     * Apenas lê o sessionId se presente (não cria)
+     */
+    static getSessionId(): string | null;
+    static get testInfo(): TestInfo | null;
+    static getSafeTestInfo(): TestInfo | null;
+    static setPage(page: IPage): void;
+    static getPage(): IPage;
+    static get page(): IPage;
+    /**
+     * ✅ NOVO: Verifica se a página está inicializada sem lançar erro
+     */
+    static isPageInitialized(): boolean;
+    /**
+     * ✅ NOVO: Obtém timeout do projeto (usado por todos os módulos)
+     * Lê do playwright.config.ts do consumidor, com fallbacks para variáveis de ambiente
+     * @returns Timeout em ms (padrão: 600000ms = 10 minutos)
+     */
+    static getProjectTimeout(): number;
+    static initApiContext(options?: Parameters<typeof playwrightRequest.newContext>[0]): Promise<void>;
+    static get apiContext(): APIRequestContext;
+    static getOrCreateApiContext(): Promise<APIRequestContext>;
+    static get appiumDriver(): any;
+    static createMobileSession(capabilities: {
+        deviceId: string;
+        platformName: 'Android' | 'iOS';
+        appPackage: string;
+        appActivity?: string;
+        bundleId?: string;
+    }): Promise<void>;
+    static resetAppiumDriver(): Promise<void>;
+    static captureScreenshot(nome?: string): Promise<Buffer | null>;
+    static clear(): void;
+    static finalizeAll(): Promise<void>;
+    static forceCleanup(): void;
+    /**
+     * 🆕 CRÍTICO: Garantir disponibilidade global em projetos consumidores
+     * Este método força a exportação do TestContext no globalThis
+     * para que funcione em qualquer projeto, mesmo sem import direto
+     */
+    static ensureGlobalAvailability(): void;
+    /**
+     * 💾 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 TestContext.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 TestContext.restoreAuthState('./auth/admin-user.json')
+     */
+    static restoreAuthState(filePath?: string): Promise<void>;
+    /**
+     * 🧹 Limpa todo o estado de autenticação
+     * @example
+     * // Logout completo
+     * await TestContext.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[];
+}

package/dist/src/testContext/TestContext.js

@@ -0,0 +1,369 @@
+import { request as playwrightRequest, } from '@playwright/test';
+import { randomUUID } from 'crypto';
+import { MobileConnection } from '../appium/MobileConnection.js';
+import { AuthStateManager } from './AuthStateManager.js';
+import { Logger } from '../utils/Logger.js';
+// Interceptação agora é automática via StatementTracker
+// import '../hubdocs/AutoStatementInterceptor.js'
+// import '../hubdocs/DirectStatementInterceptor.js'
+/**
+ * Contexto compartilhado para informações de teste
+ * SIMPLIFICADO: Removida lógica de conexão mobile para MobileConnection
+ */
+export class TestContext {
+    static _testInfo = null;
+    static _page = null;
+    static _apiContext = null;
+    static _sessionId = null;
+    /**
+     * Tipo de teste configurado por TestAnnotations (API, Frontend, Mixed, SSH, Banco, Mobile).
+     * Definido pelos setters TestAnnotations.Api/Frontend/Mixed/SSH/Banco/Mobile.
+     * Usado pelo fixture autoInjectPage para saber se deve criar browser e como anexar logs.
+     */
+    static _testType = null;
+    static setTestType(type) {
+        TestContext._testType = type;
+    }
+    static getTestType() {
+        return TestContext._testType;
+    }
+    /**
+     * Retorna true se o tipo de teste NÃO requer browser (API, SSH, Banco).
+     */
+    static isNonBrowserTest() {
+        return TestContext._testType === 'API' || TestContext._testType === 'SSH' || TestContext._testType === 'Banco';
+    }
+    /**
+     * Reseta o tipo de teste (chamado no cleanup do fixture).
+     */
+    static resetTestType() {
+        TestContext._testType = null;
+    }
+    // Lazy browser/page factory — set by fixtures.ts, triggered by TestAnnotations.Frontend/Mixed
+    // biome-ignore lint/suspicious/noExplicitAny: generic factory
+    static _pageFactory = null;
+    // biome-ignore lint/suspicious/noExplicitAny: generic promise
+    static _pagePromise = null;
+    /**
+     * Armazena factory para criação lazy de browser+page.
+     * Chamado pelo fixture autoInjectPage antes do body do teste.
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: generic factory
+    static setPageFactory(factory) {
+        TestContext._pageFactory = factory;
+        TestContext._pagePromise = null;
+    }
+    /**
+     * Dispara criação assíncrona de browser+page (fire-and-forget).
+     * Chamado sync por TestAnnotations.Frontend/Mixed setters.
+     */
+    static requestBrowserCreation() {
+        if (TestContext._pageFactory && !TestContext._pagePromise && !TestContext._page) {
+            TestContext._pagePromise = TestContext._pageFactory();
+        }
+    }
+    /**
+     * Aguarda criação do page se foi solicitada via requestBrowserCreation().
+     * Retorna o page se disponível, undefined caso contrário.
+     */
+    static async ensurePage() {
+        if (TestContext._page)
+            return TestContext._page;
+        if (TestContext._pagePromise) {
+            await TestContext._pagePromise;
+            return TestContext._page ?? undefined;
+        }
+        return undefined;
+    }
+    static setTestInfo(testInfo) {
+        TestContext._testInfo = testInfo;
+        // ❌ REMOVIDO: setTestName() agora é chamado em TestAnnotations.Api/SSH/Banco/etc
+        // Não chamar aqui para evitar sobrescrever o nome correto do CN
+    }
+    /**
+     * Obtém o sessionId atual ou cria um novo se não existir
+     */
+    static getOrCreateSessionId() {
+        if (TestContext._sessionId)
+            return TestContext._sessionId;
+        try {
+            TestContext._sessionId = (randomUUID && randomUUID()) || `sid-${Date.now()}`;
+        }
+        catch {
+            TestContext._sessionId = `sid-${Date.now()}`;
+        }
+        return TestContext._sessionId;
+    }
+    /**
+     * Define explicitamente o sessionId a ser usado nas chamadas ao Hub
+     */
+    static setSessionId(id) {
+        TestContext._sessionId = id;
+    }
+    /**
+     * Apenas lê o sessionId se presente (não cria)
+     */
+    static getSessionId() {
+        return TestContext._sessionId;
+    }
+    static get testInfo() {
+        return TestContext._testInfo;
+    }
+    static getSafeTestInfo() {
+        return TestContext._testInfo;
+    }
+    // ✅ ADICIONADO: Suporte a Page
+    static setPage(page) {
+        TestContext._page = page;
+    }
+    static getPage() {
+        if (!TestContext._page) {
+            throw new Error('TestContext.page não foi inicializado');
+        }
+        return TestContext._page;
+    }
+    static get page() {
+        if (!TestContext._page) {
+            throw new Error('TestContext.page não foi inicializado');
+        }
+        return TestContext._page;
+    }
+    /**
+     * ✅ NOVO: Verifica se a página está inicializada sem lançar erro
+     */
+    static isPageInitialized() {
+        return TestContext._page !== null;
+    }
+    /**
+     * ✅ NOVO: Obtém timeout do projeto (usado por todos os módulos)
+     * Lê do playwright.config.ts do consumidor, com fallbacks para variáveis de ambiente
+     * @returns Timeout em ms (padrão: 600000ms = 10 minutos)
+     */
+    static getProjectTimeout() {
+        const DEFAULT_TIMEOUT = 600_000; // 10 minutos
+        try {
+            // 1. Tentar pegar do TestInfo (playwright.config.ts)
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.timeout) {
+                return testInfo.timeout;
+            }
+        }
+        catch {
+            // Ignorar erro silenciosamente
+        }
+        try {
+            // 2. Fallback: variável de ambiente
+            const envTimeout = process.env.PLAYWRIGHT_TIMEOUT || process.env.TIMEOUT;
+            if (envTimeout) {
+                const timeout = Number.parseInt(envTimeout, 10);
+                if (!Number.isNaN(timeout)) {
+                    return timeout;
+                }
+            }
+        }
+        catch {
+            // Ignorar erro silenciosamente
+        }
+        // 3. Padrão: 10 minutos
+        return DEFAULT_TIMEOUT;
+    }
+    // ✅ ADICIONADO: Suporte a API Context
+    static async initApiContext(options) {
+        if (!TestContext._apiContext) {
+            TestContext._apiContext = await playwrightRequest.newContext({
+                ignoreHTTPSErrors: true,
+                ...options,
+            });
+        }
+    }
+    static get apiContext() {
+        if (!TestContext._apiContext) {
+            throw new Error('TestContext.apiContext não foi inicializado. Chame TestContext.initApiContext() primeiro.');
+        }
+        return TestContext._apiContext;
+    }
+    static async getOrCreateApiContext() {
+        if (!TestContext._apiContext) {
+            await TestContext.initApiContext();
+        }
+        return TestContext._apiContext;
+    }
+    // ✅ SIMPLIFICADO: Delegar para MobileConnection
+    static get appiumDriver() {
+        try {
+            return MobileConnection.getDriver();
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    // ✅ SIMPLIFICADO: Usar MobileConnection
+    static async createMobileSession(capabilities) {
+        const fullCapabilities = {
+            ...capabilities,
+            deviceName: capabilities.deviceId, // deviceName é obrigatório
+        };
+        await MobileConnection.createSession(fullCapabilities);
+    }
+    // ✅ SIMPLIFICADO: Usar MobileConnection
+    static async resetAppiumDriver() {
+        await MobileConnection.closeSession();
+    }
+    // ✅ SIMPLIFICADO: Captura de screenshot delegada
+    static async captureScreenshot(nome = 'screenshot') {
+        try {
+            // Frontend screenshot
+            if (TestContext._page &&
+                typeof TestContext._page.screenshot === 'function') {
+                return await TestContext._page.screenshot({
+                    fullPage: true,
+                    type: 'png',
+                });
+            }
+            // Mobile screenshot
+            return await MobileConnection.captureScreenshotBuffer();
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    static clear() {
+        TestContext._testInfo = null;
+        TestContext._page = null;
+        TestContext._apiContext = null;
+        TestContext._pageFactory = null;
+        TestContext._pagePromise = null;
+        // Mobile connection é gerenciada pela MobileConnection
+    }
+    static async finalizeAll() {
+        if (TestContext._apiContext) {
+            await TestContext._apiContext.dispose();
+            TestContext._apiContext = null;
+        }
+        await MobileConnection.closeSession();
+        TestContext.clear();
+    }
+    static forceCleanup() {
+        try {
+            // Limpeza geral
+            TestContext._testInfo = null;
+            TestContext._page = null;
+            TestContext._pageFactory = null;
+            TestContext._pagePromise = null;
+            // Limpeza API context
+            if (TestContext._apiContext) {
+                TestContext._apiContext.dispose().catch(() => { }); // Silenciosamente ignorar erros
+                TestContext._apiContext = null;
+            }
+            // Limpeza mobile delegada
+            MobileConnection.forceCleanup();
+            Logger.info('🔧 Limpeza forçada do TestContext aplicada');
+        }
+        catch (error) {
+            // Silenciosamente ignorar erros na limpeza forçada
+        }
+    }
+    /**
+     * 🆕 CRÍTICO: Garantir disponibilidade global em projetos consumidores
+     * Este método força a exportação do TestContext no globalThis
+     * para que funcione em qualquer projeto, mesmo sem import direto
+     */
+    static ensureGlobalAvailability() {
+        try {
+            // Garantir que TestContext está disponível globalmente
+            if (!globalThis.__TEST_CONTEXT__) {
+                ;
+                globalThis.__TEST_CONTEXT__ = TestContext;
+                Logger.info('🌐 [TestContext] Exportado para globalThis.__TEST_CONTEXT__');
+            }
+            // Fallback adicional para compatibilidade browser
+            if (typeof globalThis.window !== 'undefined' &&
+                !globalThis.window?.__TEST_CONTEXT__) {
+                ;
+                globalThis.window.__TEST_CONTEXT__ = TestContext;
+                Logger.info('🌐 [TestContext] Exportado para window.__TEST_CONTEXT__');
+            }
+            // Para Node.js
+            if (typeof global !== 'undefined' &&
+                !globalThis.global?.__TEST_CONTEXT__) {
+                ;
+                globalThis.global.__TEST_CONTEXT__ = TestContext;
+                Logger.info('🌐 [TestContext] Exportado para global.__TEST_CONTEXT__');
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [TestContext] Erro ao garantir disponibilidade global: ${error}`);
+        }
+    }
+    // ============================================
+    // 🔐 MÉTODOS DE AUTENTICAÇÃO E STORAGE STATE
+    // ============================================
+    /**
+     * 💾 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 TestContext.saveAuthState('./auth/admin-user.json')
+     */
+    static async saveAuthState(filePath) {
+        const page = TestContext.getPage();
+        return await AuthStateManager.saveState(page, filePath);
+    }
+    /**
+     * 🔄 Restaura o estado de autenticação salvo
+     * @param filePath Caminho do arquivo de estado
+     * @example
+     * // Antes de rodar testes
+     * await TestContext.restoreAuthState('./auth/admin-user.json')
+     */
+    static async restoreAuthState(filePath) {
+        const page = TestContext.getPage();
+        await AuthStateManager.restoreState(page, filePath);
+    }
+    /**
+     * 🧹 Limpa todo o estado de autenticação
+     * @example
+     * // Logout completo
+     * await TestContext.clearAuthState()
+     */
+    static async clearAuthState() {
+        const page = TestContext.getPage();
+        await AuthStateManager.clearState(page);
+    }
+    /**
+     * 📄 Verifica se existe um arquivo de estado salvo
+     * @param filePath Caminho do arquivo
+     */
+    static authStateExists(filePath) {
+        return AuthStateManager.stateExists(filePath);
+    }
+    /**
+     * 🔍 Lê o estado salvo sem aplicar
+     * @param filePath Caminho do arquivo
+     */
+    static readAuthState(filePath) {
+        return AuthStateManager.readState(filePath);
+    }
+    /**
+     * 🗑️ Remove um arquivo de estado
+     * @param filePath Caminho do arquivo
+     */
+    static deleteAuthState(filePath) {
+        return AuthStateManager.deleteState(filePath);
+    }
+    /**
+     * 📋 Lista todos os estados salvos
+     */
+    static listAuthStates() {
+        return AuthStateManager.listStates();
+    }
+}
+// ✅ Exportar TestContext globalmente para ES Modules
+;
+globalThis.__TEST_CONTEXT__ = TestContext;
+// 🆕 CRÍTICO: Garantir disponibilidade em diferentes contextos
+TestContext.ensureGlobalAvailability();
+// 🆕 Executar novamente após um delay para projetos que carregam depois
+setTimeout(() => {
+    TestContext.ensureGlobalAvailability();
+}, 100);

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

@@ -0,0 +1,7 @@
+import type { TestResult } from './UnifiedReportManager.js';
+export declare class UnifiedHtmlGenerator {
+    static generate(testes: TestResult[], inicio: Date, fim: Date, isIndividual?: boolean, tituloCustomizado?: string, projectName?: string, environment?: string, autocoreVersion?: string): Promise<Buffer>;
+    private static calcularEstatisticasPorTipo;
+    private static getCoresDosTipos;
+    private static getIconePorTipo;
+}