@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,93 @@
+/**
+ * 🔐 AuthStateManager - Gerenciamento de Estado de Autenticação
+ * @description Sistema similar ao Playwright storageState para salvar e restaurar cookies, localStorage e sessionStorage
+ * @author TestHUB Team
+ * @version 1.0.0
+ *
+ * @note TypeScript global declaration for browser context in page.evaluate()
+ */
+/**
+ * @example
+ * // Salvar estado após login
+ * await AuthStateManager.saveState(page, './auth.json')
+ *
+ * // Restaurar estado em outro teste
+ * await AuthStateManager.restoreState(page, './auth.json')
+ *
+ * // Limpar estado
+ * await AuthStateManager.clearState(page)
+ */
+import type { BrowserContext, Page } from '@playwright/test';
+/**
+ * Interface para o estado de autenticação completo
+ */
+export interface AuthState {
+    cookies: Array<{
+        name: string;
+        value: string;
+        domain: string;
+        path: string;
+        expires?: number;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: 'Strict' | 'Lax' | 'None';
+    }>;
+    origins: Array<{
+        origin: string;
+        localStorage: Array<{
+            name: string;
+            value: string;
+        }>;
+        sessionStorage?: Array<{
+            name: string;
+            value: string;
+        }>;
+    }>;
+    timestamp: string;
+    url?: string;
+}
+export declare class AuthStateManager {
+    private static readonly DEFAULT_AUTH_DIR;
+    /**
+     * 💾 Salva o estado completo de autenticação (cookies + localStorage + sessionStorage)
+     * @param page Página do Playwright
+     * @param filePath Caminho do arquivo para salvar (padrão: ./test-results/auth/auth-state.json)
+     */
+    static saveState(page: Page, filePath?: string): Promise<string>;
+    /**
+     * 🔄 Restaura o estado de autenticação salvo
+     * @param page Página do Playwright
+     * @param filePath Caminho do arquivo de estado
+     */
+    static restoreState(page: Page, filePath?: string): Promise<void>;
+    /**
+     * 🧹 Limpa todo o estado de autenticação (cookies + localStorage + sessionStorage)
+     * @param page Página do Playwright
+     */
+    static clearState(page: Page): Promise<void>;
+    /**
+     * 📄 Verifica se um arquivo de estado existe
+     * @param filePath Caminho do arquivo
+     */
+    static stateExists(filePath?: string): boolean;
+    /**
+     * 🔍 Lê e retorna o estado sem aplicar
+     * @param filePath Caminho do arquivo
+     */
+    static readState(filePath?: string): AuthState | null;
+    /**
+     * 🗑️ Remove o arquivo de estado
+     * @param filePath Caminho do arquivo
+     */
+    static deleteState(filePath?: string): boolean;
+    /**
+     * 📋 Lista todos os arquivos de estado no diretório padrão
+     */
+    static listStates(): string[];
+    /**
+     * 🔐 Salva estado usando o contexto do Playwright diretamente (método alternativo)
+     * @param context Contexto do navegador
+     * @param filePath Caminho do arquivo
+     */
+    static saveContextState(context: BrowserContext, filePath?: string): Promise<string>;
+}

package/dist/src/testContext/AuthStateManager.js

@@ -0,0 +1,256 @@
+/**
+ * 🔐 AuthStateManager - Gerenciamento de Estado de Autenticação
+ * @description Sistema similar ao Playwright storageState para salvar e restaurar cookies, localStorage e sessionStorage
+ * @author TestHUB Team
+ * @version 1.0.0
+ *
+ * @note TypeScript global declaration for browser context in page.evaluate()
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/Logger.js';
+export class AuthStateManager {
+    static DEFAULT_AUTH_DIR = './test-results/auth';
+    /**
+     * 💾 Salva o estado completo de autenticação (cookies + localStorage + sessionStorage)
+     * @param page Página do Playwright
+     * @param filePath Caminho do arquivo para salvar (padrão: ./test-results/auth/auth-state.json)
+     */
+    static async saveState(page, filePath) {
+        try {
+            const finalPath = filePath ||
+                path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+            // Garantir que o diretório existe
+            const dir = path.dirname(finalPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Coletar cookies do contexto
+            const context = page.context();
+            const cookies = await context.cookies();
+            // Coletar localStorage e sessionStorage da página
+            const storageData = await page.evaluate(() => {
+                const origins = [];
+                // Capturar origin atual
+                const origin = window.location.origin;
+                // Capturar localStorage
+                const localStorageItems = [];
+                for (let i = 0; i < window.localStorage.length; i++) {
+                    const key = window.localStorage.key(i);
+                    if (key) {
+                        localStorageItems.push({
+                            name: key,
+                            value: window.localStorage.getItem(key) || '',
+                        });
+                    }
+                }
+                // Capturar sessionStorage
+                const sessionStorageItems = [];
+                for (let i = 0; i < window.sessionStorage.length; i++) {
+                    const key = window.sessionStorage.key(i);
+                    if (key) {
+                        sessionStorageItems.push({
+                            name: key,
+                            value: window.sessionStorage.getItem(key) || '',
+                        });
+                    }
+                }
+                origins.push({
+                    origin,
+                    localStorage: localStorageItems,
+                    sessionStorage: sessionStorageItems,
+                });
+                return origins;
+            });
+            // Capturar URL atual para referência
+            const currentUrl = page.url();
+            // Criar objeto de estado
+            const authState = {
+                cookies: cookies.map((cookie) => ({
+                    name: cookie.name,
+                    value: cookie.value,
+                    domain: cookie.domain,
+                    path: cookie.path,
+                    expires: cookie.expires,
+                    httpOnly: cookie.httpOnly,
+                    secure: cookie.secure,
+                    sameSite: cookie.sameSite,
+                })),
+                origins: storageData,
+                timestamp: new Date().toISOString(),
+                url: currentUrl,
+            };
+            // Salvar no arquivo
+            fs.writeFileSync(finalPath, JSON.stringify(authState, null, 2), 'utf-8');
+            Logger.success(`✅ Estado de autenticação salvo: ${finalPath}`);
+            Logger.info(`   📊 ${cookies.length} cookies, ${storageData.length} origins`);
+            return finalPath;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao salvar estado de autenticação', error);
+            throw error;
+        }
+    }
+    /**
+     * 🔄 Restaura o estado de autenticação salvo
+     * @param page Página do Playwright
+     * @param filePath Caminho do arquivo de estado
+     */
+    static async restoreState(page, filePath) {
+        try {
+            const finalPath = filePath ||
+                path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+            if (!fs.existsSync(finalPath)) {
+                throw new Error(`Arquivo de estado não encontrado: ${finalPath}`);
+            }
+            // Ler estado do arquivo
+            const fileContent = fs.readFileSync(finalPath, 'utf-8');
+            const authState = JSON.parse(fileContent);
+            // Restaurar cookies no contexto
+            const context = page.context();
+            await context.addCookies(authState.cookies);
+            // Restaurar localStorage e sessionStorage
+            for (const originData of authState.origins) {
+                // Navegar para a origem se necessário
+                if (!page.url().startsWith(originData.origin)) {
+                    await page.goto(originData.origin);
+                }
+                // Restaurar localStorage
+                if (originData.localStorage && originData.localStorage.length > 0) {
+                    await page.evaluate((items) => {
+                        for (const item of items) {
+                            window.localStorage.setItem(item.name, item.value);
+                        }
+                    }, originData.localStorage);
+                }
+                // Restaurar sessionStorage
+                if (originData.sessionStorage && originData.sessionStorage.length > 0) {
+                    await page.evaluate((items) => {
+                        for (const item of items) {
+                            window.sessionStorage.setItem(item.name, item.value);
+                        }
+                    }, originData.sessionStorage);
+                }
+            }
+            Logger.success(`✅ Estado de autenticação restaurado: ${finalPath}`);
+            Logger.info(`   📊 ${authState.cookies.length} cookies, ${authState.origins.length} origins`);
+            Logger.info(`   🕐 Salvo em: ${authState.timestamp}`);
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao restaurar estado de autenticação', error);
+            throw error;
+        }
+    }
+    /**
+     * 🧹 Limpa todo o estado de autenticação (cookies + localStorage + sessionStorage)
+     * @param page Página do Playwright
+     */
+    static async clearState(page) {
+        try {
+            // Limpar cookies do contexto
+            const context = page.context();
+            await context.clearCookies();
+            // Limpar localStorage e sessionStorage
+            await page.evaluate(() => {
+                window.localStorage.clear();
+                window.sessionStorage.clear();
+            });
+            Logger.success('✅ Estado de autenticação limpo');
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao limpar estado de autenticação', error);
+            throw error;
+        }
+    }
+    /**
+     * 📄 Verifica se um arquivo de estado existe
+     * @param filePath Caminho do arquivo
+     */
+    static stateExists(filePath) {
+        const finalPath = filePath ||
+            path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+        return fs.existsSync(finalPath);
+    }
+    /**
+     * 🔍 Lê e retorna o estado sem aplicar
+     * @param filePath Caminho do arquivo
+     */
+    static readState(filePath) {
+        try {
+            const finalPath = filePath ||
+                path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+            if (!fs.existsSync(finalPath)) {
+                return null;
+            }
+            const fileContent = fs.readFileSync(finalPath, 'utf-8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao ler estado de autenticação', error);
+            return null;
+        }
+    }
+    /**
+     * 🗑️ Remove o arquivo de estado
+     * @param filePath Caminho do arquivo
+     */
+    static deleteState(filePath) {
+        try {
+            const finalPath = filePath ||
+                path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+            if (fs.existsSync(finalPath)) {
+                fs.unlinkSync(finalPath);
+                Logger.success(`✅ Arquivo de estado removido: ${finalPath}`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao remover estado de autenticação', error);
+            return false;
+        }
+    }
+    /**
+     * 📋 Lista todos os arquivos de estado no diretório padrão
+     */
+    static listStates() {
+        try {
+            const dir = AuthStateManager.DEFAULT_AUTH_DIR;
+            if (!fs.existsSync(dir)) {
+                return [];
+            }
+            const files = fs.readdirSync(dir);
+            return files
+                .filter((file) => file.endsWith('.json'))
+                .map((file) => path.join(dir, file));
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao listar estados', error);
+            return [];
+        }
+    }
+    /**
+     * 🔐 Salva estado usando o contexto do Playwright diretamente (método alternativo)
+     * @param context Contexto do navegador
+     * @param filePath Caminho do arquivo
+     */
+    static async saveContextState(context, filePath) {
+        try {
+            const finalPath = filePath ||
+                path.join(AuthStateManager.DEFAULT_AUTH_DIR, 'auth-state.json');
+            // Garantir que o diretório existe
+            const dir = path.dirname(finalPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Usar método nativo do Playwright
+            await context.storageState({ path: finalPath });
+            Logger.success(`✅ Estado de contexto salvo: ${finalPath}`);
+            return finalPath;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao salvar estado de contexto', error);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,198 @@
+/**
+ * 🤖 SISTEMA DE COVERAGE AUTOMÁTICO - AutoCore Framework
+ *
+ * ✅ FUNCIONAMENTO TRANSPARENTE:
+ * - Detecta automaticamente tipo de projeto (Playwright/Vitest/Mixed)
+ * - Hook automático em tests Vitest via globalSetup/globalTeardown
+ * - Hook automático em tests Playwright via beforeEach/afterEach
+ * - Usuário não precisa adicionar NENHUMA linha de código
+ * - Gera estrutura completa de coverage automaticamente
+ *
+ * 📁 ARQUIVOS GERADOS AUTOMATICAMENTE:
+ * - coverage/index.html (Dashboard visual)
+ * - coverage/coverage-final.json (Standard)
+ * - coverage/coverage-summary.json (Standard)
+ * - coverage/lcov.info (IDE integration)
+ * - coverage/autocore-coverage-report.json (Detalhado)
+ * - coverage/autocore-coverage-summary.json (Resumo)
+ */
+import type { IPage } from '../interfaces.js';
+export interface CoverageData {
+    frontend?: {
+        js?: any[];
+        css?: any[];
+        timestamp?: Date;
+    };
+    vitest?: {
+        lines?: {
+            total: number;
+            covered: number;
+            skipped: number;
+            pct: number;
+        };
+        functions?: {
+            total: number;
+            covered: number;
+            skipped: number;
+            pct: number;
+        };
+        statements?: {
+            total: number;
+            covered: number;
+            skipped: number;
+            pct: number;
+        };
+        branches?: {
+            total: number;
+            covered: number;
+            skipped: number;
+            pct: number;
+        };
+    };
+    summary?: {
+        totalCoverage: number;
+        frontendEnabled: boolean;
+        vitestEnabled: boolean;
+        projectType: 'playwright' | 'vitest' | 'mixed';
+        timestamp: Date;
+    };
+}
+export interface TestCoverageMetrics {
+    testName: string;
+    testType: 'Frontend' | 'API' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed';
+    coverage: CoverageData;
+    duration: number;
+    timestamp: Date;
+}
+/**
+ * 🤖 SISTEMA DE COVERAGE AUTOMÁTICO - AutoCore Framework
+ */
+export declare class CoverageManager {
+    private static instance;
+    private static coverageData;
+    private static globalCoverage;
+    private static outputDir;
+    private static isInitialized;
+    private static currentTestPage;
+    private static coverageWarningShown;
+    static getInstance(): CoverageManager;
+    /**
+     * 🤖 INICIALIZAÇÃO AUTOMÁTICA - Chamado pelo global-setup.ts
+     */
+    static autoInitialize(): Promise<void>;
+    /**
+     * ✅ NOVO: Limpa arquivos de coverage antigos para Playwright
+     */
+    private static cleanupOldCoverageFiles;
+    /**
+     * 🎯 Setup unificado para hooks
+     */
+    private static setupPlaywrightHooks;
+    private static setupVitestHooks;
+    private static setupProcessHooks;
+    /**
+     * 🔍 Tenta capturar coverage automaticamente sem interferir nos testes
+     */
+    private static tryAutoCapture;
+    /**
+     * 📸 Captura teste atual automaticamente
+     */
+    private static captureCurrentTest;
+    /**
+     * 🔍 Detecta nome do teste atual automaticamente
+     */
+    private static getCurrentTestName;
+    /**
+     * 🔗 Registra page automaticamente (chamado pelo framework)
+     * O usuário não chama isso - é automático via hooks internos
+     */
+    static registerPageAutomatically(page: IPage): void;
+    /**
+     * 🏁 Finalização automática - chamado pelos hooks
+     */
+    static autoFinalize(): Promise<void>;
+    /**
+     * 🔄 NOVO: Reset dados estáticos para nova execução
+     */
+    private static resetForNewExecution;
+    /**
+     * 🔍 Detecta o tipo de projeto automaticamente
+     */
+    static detectProjectType(): 'playwright' | 'vitest' | 'mixed';
+    /**
+     * 🔍 Verifica se existem testes Playwright (.spec.ts)
+     */
+    private static hasPlaywrightTests;
+    /**
+     * 🔍 Verifica se existe configuração Vitest
+     */
+    private static hasVitestConfig;
+    /**
+     * 🔍 Verifica se existem testes Vitest na pasta tests/unit
+     */
+    private static hasVitestTests;
+    /**
+     * 🔍 Busca arquivos recursivamente por padrão
+     */
+    private static findFilesRecursive;
+    /**
+     * ✅ NOVO: Inicia cobertura para teste Frontend
+     */
+    static startFrontendCoverage(page: IPage, testName: string): Promise<void>;
+    /**
+     * ✅ NOVO: Para cobertura Frontend e coleta dados
+     */
+    static stopFrontendCoverage(page: IPage, testName: string): Promise<CoverageData['frontend']>;
+    /**
+     * ✅ NOVO: Coleta cobertura do Vitest de forma inteligente
+     */
+    static collectVitestCoverage(): Promise<CoverageData['vitest']>;
+    /**
+     * ✅ NOVO: Registra cobertura completa de um teste
+     */
+    static registerTestCoverage(testName: string, testType: 'Frontend' | 'API' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed', page?: IPage, duration?: number): Promise<void>;
+    /**
+     * 🎭 NOVO: Gera métricas para testes Playwright puros
+     */
+    private static generatePlaywrightTestMetrics;
+    /**
+     * ✅ NOVO: Atualiza cobertura global
+     */
+    private static updateGlobalCoverage;
+    /**
+     * ✅ NOVO: Salva relatório de cobertura
+     */
+    static saveCoverageReport(): Promise<void>;
+    /**
+     * 📁 NOVO: Gera arquivos de cobertura padrão para projeto consumidor
+     */
+    private static generateStandardCoverageFiles;
+    /**
+     * 📄 Gera formato LCOV
+     */
+    private static generateLcovFormat;
+    /**
+     * 📄 Gera HTML básico para cobertura
+     */
+    private static generateCoverageHtml;
+    /**
+     * Obtém versão do framework
+     */
+    private static getFrameworkVersion;
+    /**
+     * ✅ PÚBLICO: Obtém cobertura global
+     */
+    static getGlobalCoverage(): CoverageData;
+    /**
+     * ✅ PÚBLICO: Obtém cobertura de um teste específico
+     */
+    static getTestCoverage(testName: string): TestCoverageMetrics | undefined;
+    /**
+     * ✅ PÚBLICO: Obtém todas as coberturas de teste
+     */
+    static getAllTestsCoverage(): TestCoverageMetrics[];
+    /**
+     * ✅ PÚBLICO: Reset para testes
+     */
+    static reset(): void;
+}