@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,23 @@
+/**
+ * 🎯 INTERCEPTAÇÃO MÁGICA REAL E FUNCIONAL
+ *
+ * Sistema que REALMENTE intercepta criação de classes Statements
+ * ESTRATÉGIA DIRETA: Interceptação manual via função específica
+ */
+/**
+ * 🌟 Ativar interceptação mágica global que FUNCIONA
+ */
+export declare function ativarInterceptacaoMagica(): void;
+/**
+ * 🛑 Desativar interceptação
+ */
+export declare function desativarInterceptacaoMagica(): void;
+/**
+ * 🔧 Função para interceptar classes específicas manualmente
+ */
+export declare function interceptarClasse<T extends new (...args: any[]) => any>(StatementsClass: T): T;
+/**
+ * 🎯 FUNÇÃO DIRETA PARA INTERCEPTAR UMA CLASSE STATEMENT
+ * Esta função deve ser chamada DIRETAMENTE quando uma classe Statement é definida
+ */
+export declare function interceptarStatementClasseDireta(StatementsClass: any, className?: string): Promise<any>;

package/dist/src/utils/InterceptacaoMagica.js

@@ -0,0 +1,365 @@
+/**
+ * 🎯 INTERCEPTAÇÃO MÁGICA REAL E FUNCIONAL
+ *
+ * Sistema que REALMENTE intercepta criação de classes Statements
+ * ESTRATÉGIA DIRETA: Interceptação manual via função específica
+ */
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { StatementLogger } from './StatementLogger.js';
+import { Logger } from './Logger.js';
+// Estado da interceptação
+let interceptacaoAtiva = false;
+const classesInterceptadas = new Set();
+/**
+ * 🌟 Ativar interceptação mágica global que FUNCIONA
+ */
+export function ativarInterceptacaoMagica() {
+    if (interceptacaoAtiva)
+        return;
+    StatementLogger.ativar();
+    interceptacaoAtiva = true;
+    // ✅ ESTRATÉGIA COMO API: Interceptação automática via polling das classes conhecidas
+    setupAutoStatementDetection();
+}
+/**
+ * 🎯 ESTRATÉGIA COMO API: Detectar automaticamente classes Statement disponíveis
+ * Similar a como ApiActions registra suas próprias ações automaticamente
+ */
+function setupAutoStatementDetection() {
+    // ✅ POLLING INTELIGENTE: Verificar periodicamente por novas classes Statement
+    const checkInterval = 2000; // Verificar a cada 2 segundos
+    let checkCount = 0;
+    const maxChecks = 30; // Máximo 60 segundos de verificação
+    const intervalId = setInterval(async () => {
+        checkCount++;
+        try {
+            await detectAndInterceptStatementClasses();
+            // Parar verificação após o limite
+            if (checkCount >= maxChecks) {
+                clearInterval(intervalId);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [AutoIntercept] Erro na verificação automática: ${error}`);
+        }
+    }, checkInterval);
+    // ✅ VERIFICAÇÃO INICIAL IMEDIATA
+    setTimeout(async () => {
+        try {
+            await detectAndInterceptStatementClasses();
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [AutoIntercept] Erro na verificação inicial: ${error}`);
+        }
+    }, 100);
+}
+/**
+ * � Detectar e interceptar classes Statement disponíveis globalmente
+ */
+async function detectAndInterceptStatementClasses() {
+    // ✅ ESTRATÉGIA 1: VERIFICAR CLASSES NO CONTEXTO GLOBAL
+    const globalObjects = [globalThis, global].filter(Boolean);
+    for (const globalObj of globalObjects) {
+        if (!globalObj)
+            continue;
+        // Procurar por todas as propriedades que podem ser classes Statement
+        const propertyNames = Object.getOwnPropertyNames(globalObj);
+        for (const propName of propertyNames) {
+            try {
+                const value = globalObj[propName];
+                // Verificar se é uma classe Statement válida
+                if (typeof value === 'function' &&
+                    value.prototype &&
+                    isStatementClassName(propName) &&
+                    !classesInterceptadas.has(propName)) {
+                    Logger.info(`🎯 [AutoIntercept] DETECTADA classe Statement global: ${propName}`);
+                    await interceptStatementClass(value, propName);
+                }
+            }
+            catch (error) {
+                // Ignorar erros de acesso a propriedades protegidas
+            }
+        }
+    }
+    // ✅ ESTRATÉGIA 2: VERIFICAR MÓDULOS REALMENTE CARREGADOS (CommonJS)
+    await scanLoadedModules();
+    // ✅ ESTRATÉGIA 3: DETECÇÃO ESM-NATIVE usando globalThis e import.meta
+    await scanESMStatements();
+    // ✅ ESTRATÉGIA 4: IMPORTAÇÃO DINÂMICA DE ARQUIVOS CONHECIDOS
+    await tryImportKnownStatementFiles();
+}
+/**
+ * 🔍 ESTRATÉGIA INTELIGENTE: Escanear apenas módulos realmente carregados pelo Node.js
+ * ✅ ESM COMPATIBLE: Verificação segura de require.cache
+ */
+async function scanLoadedModules() {
+    // ✅ ESM COMPATIBILITY: Verificar se require existe antes de usar
+    if (typeof require === 'undefined' || !require.cache) {
+        return;
+    }
+    const loadedModules = Object.keys(require.cache);
+    let foundCount = 0;
+    for (const modulePath of loadedModules) {
+        // Focar apenas em módulos que claramente contêm classes Statement
+        if (modulePath.toLowerCase().includes('statement') ||
+            modulePath.includes('/statements/') ||
+            modulePath.includes('\\statements\\')) {
+            try {
+                const module = require(modulePath);
+                if (module && typeof module === 'object') {
+                    await processModuleForStatements(module, `carregado:${modulePath.split(/[/\\]/).pop()}`);
+                    foundCount++;
+                }
+            }
+            catch (error) {
+                // Ignorar erros de módulos corrompidos
+            }
+        }
+    }
+    Logger.info(`🔍 [AutoIntercept] Escaneados ${foundCount} módulos Statement carregados`);
+}
+/**
+ * 🚀 ESTRATÉGIA ESM-NATIVE: Detectar classes Statement em ambiente ESM
+ * ✅ Usa globalThis, import.meta e módulos ESM nativos
+ */
+async function scanESMStatements() {
+    let foundCount = 0;
+    try {
+        // ✅ ESTRATÉGIA 1: Verificar globalThis para classes Statement
+        const globalKeys = Object.getOwnPropertyNames(globalThis);
+        for (const key of globalKeys) {
+            if (isStatementClassName(key) && !classesInterceptadas.has(key)) {
+                try {
+                    const StatementClass = globalThis[key];
+                    if (typeof StatementClass === 'function' &&
+                        StatementClass.prototype) {
+                        Logger.info(`🌍 [ESM] Detectada classe Statement global: ${key}`);
+                        await interceptStatementClass(StatementClass, key);
+                        foundCount++;
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros de acesso
+                }
+            }
+        }
+        // ✅ ESTRATÉGIA 2: Verificar window (se estiver em browser)
+        if (typeof globalThis !== 'undefined' && globalThis.window) {
+            const windowObj = globalThis.window;
+            const windowKeys = Object.getOwnPropertyNames(windowObj);
+            for (const key of windowKeys) {
+                if (isStatementClassName(key) && !classesInterceptadas.has(key)) {
+                    try {
+                        const StatementClass = windowObj[key];
+                        if (typeof StatementClass === 'function' &&
+                            StatementClass.prototype) {
+                            Logger.info(`🪟 [ESM] Detectada classe Statement no window: ${key}`);
+                            await interceptStatementClass(StatementClass, key);
+                            foundCount++;
+                        }
+                    }
+                    catch (error) {
+                        // Ignorar erros de acesso
+                    }
+                }
+            }
+        }
+        // ✅ ESTRATÉGIA 3: Verificar process.mainModule (Node.js ESM)
+        if (typeof process !== 'undefined' &&
+            process.mainModule &&
+            process.mainModule.exports) {
+            const moduleExports = process.mainModule.exports;
+            for (const [key, value] of Object.entries(moduleExports)) {
+                if (isStatementClassName(key) &&
+                    typeof value === 'function' &&
+                    value.prototype &&
+                    !classesInterceptadas.has(key)) {
+                    Logger.info(`📦 [ESM] Detectada classe Statement no mainModule: ${key}`);
+                    await interceptStatementClass(value, key);
+                    foundCount++;
+                }
+            }
+        }
+    }
+    catch (error) {
+        Logger.warning(`⚠️ [ESM] Erro na detecção ESM: ${error}`);
+    }
+}
+/**
+ * 📁 Detectar dinamicamente TODOS os arquivos Statement no projeto - 100% SEM LISTA FIXA
+ * ✅ ESM COMPATIBLE: Detecção segura sem dependência de require.cache
+ */
+async function tryImportKnownStatementFiles() {
+    // ✅ ESM COMPATIBILITY: Verificar se require existe antes de usar
+    if (typeof require === 'undefined') {
+        return;
+    }
+    // ✅ ÚNICA ESTRATÉGIA: Verificar APENAS módulos realmente carregados pelo Node.js
+    const loadedModules = Object.keys(require.cache || {});
+    let foundCount = 0;
+    for (const modulePath of loadedModules) {
+        // Detectar QUALQUER módulo que contenha "statement" (case-insensitive)
+        const pathLower = modulePath.toLowerCase();
+        if (pathLower.includes('statement')) {
+            try {
+                const module = require(modulePath);
+                await processModuleForStatements(module, `dynamic:${modulePath.split(/[/\\]/).pop()}`);
+                foundCount++;
+            }
+            catch (error) {
+                // Ignorar erros de módulos corrompidos
+            }
+        }
+    }
+    Logger.info(`🎯 [AutoIntercept] Detecção dinâmica: ${foundCount} módulos Statement processados`);
+    // ✅ DETECÇÃO ADICIONAL: Verificar objetos globais com padrão Statement*
+    if (typeof global !== 'undefined') {
+        const globalKeys = Object.getOwnPropertyNames(global);
+        for (const key of globalKeys) {
+            if (isStatementClassName(key) && !classesInterceptadas.has(key)) {
+                try {
+                    const StatementClass = global[key];
+                    if (typeof StatementClass === 'function' &&
+                        StatementClass.prototype) {
+                        Logger.info(`🌍 [AutoIntercept] Detectada classe Statement global: ${key}`);
+                        await interceptStatementClass(StatementClass, key);
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros de acesso
+                }
+            }
+        }
+    }
+}
+/**
+ * 🔍 Processar módulo em busca de classes Statement
+ */
+async function processModuleForStatements(module, source) {
+    if (!module)
+        return;
+    // Verificar todas as exportações do módulo
+    for (const [exportName, exportValue] of Object.entries(module)) {
+        if (typeof exportValue === 'function' &&
+            exportValue.prototype &&
+            isStatementClassName(exportName) &&
+            !classesInterceptadas.has(exportName)) {
+            Logger.info(`🎯 [AutoIntercept] DETECTADA classe Statement em módulo: ${exportName} (${source})`);
+            await interceptStatementClass(exportValue, exportName);
+        }
+    }
+}
+/**
+ * 🔍 Detectar se é nome de classe Statement
+ */
+function isStatementClassName(name) {
+    if (!name)
+        return false;
+    return ((name.startsWith('Statements') ||
+        (name.includes('Statement') && !name.includes('Tracker')) ||
+        name.endsWith('Statement')) &&
+        // 🚫 FILTRAR: Ignorar classes do sistema interno
+        !(name.includes('Tracker') ||
+            name.includes('Logger') ||
+            name.includes('Manager') ||
+            name.includes('Helper') ||
+            name.includes('Actions')));
+}
+/**
+ * 🎯 Interceptar classe Statement
+ */
+async function interceptStatementClass(StatementClass, className) {
+    if (classesInterceptadas.has(className))
+        return;
+    classesInterceptadas.add(className);
+    try {
+        Logger.info(`🔄 [InterceptacaoMagica] Interceptando ${className}...`);
+        // 🚫 REMOVIDO: NÃO criar testes automáticos
+        // O teste real já existe (ex: "CT01 - Consumo de Voz VC1")
+        // Apenas interceptamos os métodos para que sejam detectados como CTs
+        // Analisar métodos da classe
+        const methodNames = Object.getOwnPropertyNames(StatementClass.prototype).filter((name) => {
+            if (name === 'constructor')
+                return false;
+            if (name.startsWith('_'))
+                return false;
+            const descriptor = Object.getOwnPropertyDescriptor(StatementClass.prototype, name);
+            return descriptor && typeof descriptor.value === 'function';
+        });
+        Logger.info(`📋 [InterceptacaoMagica] ${className} tem ${methodNames.length} métodos: ${methodNames.join(', ')}`);
+        // Interceptar cada método DIRETAMENTE no prototype
+        for (const methodName of methodNames) {
+            const originalMethod = StatementClass.prototype[methodName];
+            if (typeof originalMethod === 'function') {
+                StatementClass.prototype[methodName] = async function (...args) {
+                    // 🎯 DETECTAR NOME REAL DO CT: Tentar extrair do contexto do teste
+                    let realCTName = `CT - ${className}.${methodName}`; // Nome padrão
+                    try {
+                        const testInfo = TestContext.getSafeTestInfo();
+                        if (testInfo?.title) {
+                            // 🎯 USAR NOME REAL DO TESTE: "CT01 - Consumo de Voz VC1"
+                            realCTName = testInfo.title;
+                            Logger.info(`🎯 [CT-REAL] Detectado nome real do CT: "${realCTName}"`);
+                        }
+                    }
+                    catch (error) {
+                        // Usar nome padrão se não conseguir detectar
+                        Logger.info(`⚠️ [CT-REAL] Usando nome padrão: "${realCTName}"`);
+                    }
+                    Logger.info(`🚀 [CT-INDIVIDUAL] Criando CT individual: ${realCTName}`);
+                    // Criar CT individual com nome real
+                    StatementTracker.startCT(realCTName);
+                    const startTime = Date.now();
+                    try {
+                        const result = await originalMethod.apply(this, args);
+                        const endTime = Date.now();
+                        const duration = endTime - startTime;
+                        // Finalizar CT com sucesso
+                        StatementTracker.endCT(realCTName, true);
+                        Logger.success(`✅ [CT-INDIVIDUAL] CT "${realCTName}" concluído com sucesso (${duration}ms)`);
+                        return result;
+                    }
+                    catch (error) {
+                        const endTime = Date.now();
+                        const duration = endTime - startTime;
+                        // Finalizar CT com erro
+                        StatementTracker.endCT(realCTName, false);
+                        Logger.info(`❌ [CT-INDIVIDUAL] CT "${realCTName}" falhou (${duration}ms): ${error}`);
+                        throw error;
+                    }
+                };
+            }
+        }
+        Logger.success(`✅ [InterceptacaoMagica] ${className} interceptado - ${methodNames.length} métodos podem criar CTs automaticamente`);
+    }
+    catch (error) {
+        Logger.warning(`⚠️ [InterceptacaoMagica] Erro ao interceptar ${className}: ${error}`);
+    }
+}
+/**
+ * 🛑 Desativar interceptação
+ */
+export function desativarInterceptacaoMagica() {
+    if (!interceptacaoAtiva)
+        return;
+    interceptacaoAtiva = false;
+    classesInterceptadas.clear();
+    Logger.info('🛑 Interceptação mágica desativada');
+}
+/**
+ * 🔧 Função para interceptar classes específicas manualmente
+ */
+export function interceptarClasse(StatementsClass) {
+    return StatementLogger.interceptClass(StatementsClass);
+}
+/**
+ * 🎯 FUNÇÃO DIRETA PARA INTERCEPTAR UMA CLASSE STATEMENT
+ * Esta função deve ser chamada DIRETAMENTE quando uma classe Statement é definida
+ */
+export async function interceptarStatementClasseDireta(StatementsClass, className) {
+    const nome = className || StatementsClass.name;
+    Logger.info(`🎯 [InterceptacaoMagica] INTERCEPTAÇÃO DIRETA: ${nome}`);
+    await interceptStatementClass(StatementsClass, nome);
+    return StatementsClass;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Sanitizador de dados sensíveis para uso em logs e outputs.
+ *
+ * Garante que tokens, senhas, API keys e outros segredos nunca
+ * sejam expostos em logs do framework.
+ *
+ * @module utils/LogSanitizer
+ */
+/**
+ * Verifica se uma chave parece conter dados sensíveis.
+ */
+export declare function isSensitiveKey(key: string): boolean;
+/**
+ * Verifica se um valor parece ser um segredo.
+ */
+export declare function isSensitiveValue(value: string): boolean;
+/**
+ * Mascara um valor sensível, mantendo início e fim para debug.
+ * Ex.: `abc123xyz` → `abc***xyz`
+ */
+export declare function maskValue(value: string): string;
+/**
+ * Sanitiza um objeto genérico, mascarando campos sensíveis.
+ * Funciona recursivamente em objetos aninhados.
+ */
+export declare function sanitize(data: unknown): unknown;
+/**
+ * Sanitiza uma string de log, mascarando padrões de segredo inline.
+ * Útil para mensagens de log que podem conter tokens concatenados.
+ */
+export declare function sanitizeLogMessage(message: string): string;
+/**
+ * Sanitiza headers HTTP, mascarando Authorization e outros campos sensíveis.
+ */
+export declare function sanitizeHeaders(headers: Record<string, string>): Record<string, string>;

package/dist/src/utils/LogSanitizer.js

@@ -0,0 +1,110 @@
+/**
+ * Sanitizador de dados sensíveis para uso em logs e outputs.
+ *
+ * Garante que tokens, senhas, API keys e outros segredos nunca
+ * sejam expostos em logs do framework.
+ *
+ * @module utils/LogSanitizer
+ */
+/** Padrões de chaves que devem ser mascarados (case-insensitive). */
+const SENSITIVE_KEY_PATTERNS = [
+    /password/i,
+    /passwd/i,
+    /secret/i,
+    /token/i,
+    /api[_-]?key/i,
+    /auth/i,
+    /bearer/i,
+    /credential/i,
+    /private[_-]?key/i,
+    /access[_-]?key/i,
+    /session[_-]?id/i,
+    /cookie/i,
+    /x-api-key/i,
+    /authorization/i,
+];
+/** Padrões de valores que parecem segredos (ex.: JWT, base64 longo). */
+const SENSITIVE_VALUE_PATTERNS = [
+    /^eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}/, // JWT
+    /^Bearer\s+.{10,}/i, // Bearer token
+    /^Basic\s+[A-Za-z0-9+/=]{10,}/i, // Basic auth
+    /^ghp_[A-Za-z0-9]{30,}/, // GitHub PAT
+    /^sk-[A-Za-z0-9]{30,}/, // OpenAI-style key
+];
+const MASK = '[REDACTED]';
+/**
+ * Verifica se uma chave parece conter dados sensíveis.
+ */
+export function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((p) => p.test(key));
+}
+/**
+ * Verifica se um valor parece ser um segredo.
+ */
+export function isSensitiveValue(value) {
+    return SENSITIVE_VALUE_PATTERNS.some((p) => p.test(value));
+}
+/**
+ * Mascara um valor sensível, mantendo início e fim para debug.
+ * Ex.: `abc123xyz` → `abc***xyz`
+ */
+export function maskValue(value) {
+    if (value.length <= 8)
+        return MASK;
+    return `${value.slice(0, 3)}***${value.slice(-3)}`;
+}
+/**
+ * Sanitiza um objeto genérico, mascarando campos sensíveis.
+ * Funciona recursivamente em objetos aninhados.
+ */
+export function sanitize(data) {
+    if (data === null || data === undefined)
+        return data;
+    if (typeof data === 'string') {
+        return isSensitiveValue(data) ? maskValue(data) : data;
+    }
+    if (Array.isArray(data)) {
+        return data.map((item) => sanitize(item));
+    }
+    if (typeof data === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (isSensitiveKey(key) && typeof value === 'string') {
+                result[key] = maskValue(value);
+            }
+            else {
+                result[key] = sanitize(value);
+            }
+        }
+        return result;
+    }
+    return data;
+}
+/**
+ * Sanitiza uma string de log, mascarando padrões de segredo inline.
+ * Útil para mensagens de log que podem conter tokens concatenados.
+ */
+export function sanitizeLogMessage(message) {
+    // Mascarar JWTs inline
+    let result = message.replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]*/g, MASK);
+    // Mascarar Bearer tokens
+    result = result.replace(/Bearer\s+[A-Za-z0-9_.-]{10,}/gi, `Bearer ${MASK}`);
+    // Mascarar password=... em query strings
+    result = result.replace(/(password|token|secret|api_key|apikey|access_key)=([^&\s]{4,})/gi, (_, key) => `${key}=${MASK}`);
+    return result;
+}
+/**
+ * Sanitiza headers HTTP, mascarando Authorization e outros campos sensíveis.
+ */
+export function sanitizeHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (isSensitiveKey(key)) {
+            result[key] = maskValue(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,65 @@
+import type { Page } from '@playwright/test';
+import type { IPage } from '../interfaces.js';
+type PageLike = Page | IPage | any;
+export declare class Logger {
+    static logLevel: string;
+    static logLevels: {
+        [key: string]: number;
+    };
+    /**
+     * Sanitiza uma mensagem antes de logar, mascarando segredos.
+     */
+    private static safe;
+    /**
+     * ATUALIZADO: Registra logs de sucesso e integra com UnifiedReportManager
+     */
+    static success(message: string): void;
+    /**
+     * ATUALIZADO: Registra logs informativos e integra com UnifiedReportManager
+     */
+    static info(message: string): void;
+    /**
+     * ATUALIZADO: Registra logs de aviso e integra com UnifiedReportManager
+     */
+    static warning(message: string): void;
+    /**
+     * ATUALIZADO: Registra logs de erro e integra com UnifiedReportManager
+     */
+    static error(message: string, error?: unknown): void;
+    /**
+     * ATUALIZADO: Captura screenshot integrado com UnifiedReportManager
+     */
+    static captureScreenshot(page: PageLike, nome?: string): Promise<void>;
+    static shouldLog(level: string): boolean;
+    static bloco(titulo: string): void;
+    static object(valor: any): void;
+    /**
+     * NOVO: Log específico para inicialização de teste
+     */
+    static testStart(testName: string, testType: string): void;
+    /**
+     * NOVO: Log específico para finalização de teste
+     */
+    static testEnd(testName: string, testType: string, duration: number, success: boolean): void;
+    /**
+     * NOVO: Log específico para ações de UI
+     */
+    static action(action: string, element?: string, description?: string): void;
+    /**
+     * NOVO: Log específico para validações
+     */
+    static validation(description: string, success: boolean, expected?: any, actual?: any): void;
+    /**
+     * NOVO: Log específico para métricas e performance
+     */
+    static metric(metricName: string, value: number, unit?: string, context?: string): void;
+    /**
+     * NOVO: Log para debug de desenvolvimento
+     */
+    static debug(message: string, data?: any): void;
+    /**
+     * NOVO: Log para separadores visuais
+     */
+    static separator(title?: string): void;
+}
+export {};