@silasfmartins/testhub 1.0.0

package/dist/src/playwright/fixtures.js

@@ -0,0 +1,718 @@
+import { test as base, expect as baseExpect } from '@playwright/test';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { TestContext } from '../testContext/TestContext.js';
+/**
+ * Classe para capturar e gerenciar logs de Network
+ */
+class NetworkLogger {
+    logs = [];
+    requestTimings = new Map();
+    currentPageUrl = '';
+    currentPageTitle = '';
+    /**
+     * Registra o início de uma requisição
+     */
+    logRequest(request) {
+        const timestamp = new Date().toISOString();
+        const requestId = `${request.method()}-${request.url()}-${timestamp}`;
+        this.requestTimings.set(request.url(), Date.now());
+        const entry = {
+            timestamp,
+            pageUrl: this.currentPageUrl,
+            pageTitle: this.currentPageTitle,
+            type: 'request',
+            method: request.method(),
+            url: request.url(),
+            resourceType: request.resourceType(),
+            headers: request.headers(),
+            postData: request.postData() || undefined,
+        };
+        this.logs.push(entry);
+    }
+    /**
+     * Registra a resposta de uma requisição
+     */
+    async logResponse(response) {
+        const timestamp = new Date().toISOString();
+        const startTime = this.requestTimings.get(response.url());
+        const duration = startTime ? Date.now() - startTime : undefined;
+        let size;
+        try {
+            const body = await response.body().catch(() => null);
+            size = body?.length;
+        }
+        catch {
+            size = undefined;
+        }
+        const entry = {
+            timestamp,
+            pageUrl: this.currentPageUrl,
+            pageTitle: this.currentPageTitle,
+            type: 'response',
+            method: response.request().method(),
+            url: response.url(),
+            status: response.status(),
+            statusText: response.statusText(),
+            resourceType: response.request().resourceType(),
+            duration,
+            size,
+            headers: response.headers(),
+            mimeType: response.headers()['content-type'],
+            fromServiceWorker: response.fromServiceWorker(),
+        };
+        this.logs.push(entry);
+    }
+    /**
+     * Registra requisição que falhou
+     */
+    logRequestFailed(request) {
+        const timestamp = new Date().toISOString();
+        const startTime = this.requestTimings.get(request.url());
+        const duration = startTime ? Date.now() - startTime : undefined;
+        const entry = {
+            timestamp,
+            pageUrl: this.currentPageUrl,
+            pageTitle: this.currentPageTitle,
+            type: 'failed',
+            method: request.method(),
+            url: request.url(),
+            resourceType: request.resourceType(),
+            duration,
+            errorText: request.failure()?.errorText,
+        };
+        this.logs.push(entry);
+    }
+    /**
+     * Atualiza informações da página atual
+     */
+    updatePageInfo(url, title) {
+        this.currentPageUrl = url;
+        this.currentPageTitle = title;
+    }
+    /**
+     * Retorna todos os logs
+     */
+    getLogs() {
+        return this.logs;
+    }
+    /**
+     * Gera relatório formatado em texto
+     */
+    generateTextReport() {
+        if (this.logs.length === 0) {
+            return '📡 [Network Logs] Nenhuma requisição capturada';
+        }
+        const lines = [
+            '═══════════════════════════════════════════════════════════════════════════════',
+            '📡 NETWORK LOGS - AutoCore',
+            `📊 Total de registros: ${this.logs.length}`,
+            `🕐 Capturado em: ${new Date().toISOString()}`,
+            '═══════════════════════════════════════════════════════════════════════════════',
+            '',
+        ];
+        // Agrupa por página
+        const byPage = new Map();
+        for (const log of this.logs) {
+            const pageKey = `${log.pageTitle || 'Sem título'} (${log.pageUrl || 'URL desconhecida'})`;
+            if (!byPage.has(pageKey)) {
+                byPage.set(pageKey, []);
+            }
+            byPage.get(pageKey).push(log);
+        }
+        for (const [pageKey, pageLogs] of byPage) {
+            lines.push(`\n📄 PÁGINA: ${pageKey}`);
+            lines.push('─'.repeat(79));
+            // Estatísticas da página
+            const requests = pageLogs.filter(l => l.type === 'request').length;
+            const responses = pageLogs.filter(l => l.type === 'response').length;
+            const failed = pageLogs.filter(l => l.type === 'failed').length;
+            const errors = pageLogs.filter(l => l.type === 'response' && l.status && l.status >= 400).length;
+            lines.push(`   📈 Requisições: ${requests} | Respostas: ${responses} | Falhas: ${failed} | Erros HTTP: ${errors}`);
+            lines.push('');
+            for (const log of pageLogs) {
+                const icon = log.type === 'request' ? '➡️' : log.type === 'response' ? (log.status && log.status >= 400 ? '❌' : '✅') : '💥';
+                const status = log.status ? ` [${log.status} ${log.statusText || ''}]` : '';
+                const duration = log.duration ? ` (${log.duration}ms)` : '';
+                const size = log.size ? ` ${this.formatBytes(log.size)}` : '';
+                const sw = log.fromServiceWorker ? ' [SW]' : '';
+                lines.push(`   ${icon} ${log.timestamp.split('T')[1].split('.')[0]} | ${log.method.padEnd(7)} | ${log.resourceType.padEnd(12)} |${status}${duration}${size}${sw}`);
+                lines.push(`      🔗 ${this.truncateUrl(log.url, 100)}`);
+                if (log.type === 'failed' && log.errorText) {
+                    lines.push(`      ⚠️ Erro: ${log.errorText}`);
+                }
+                if (log.postData) {
+                    lines.push(`      📤 Body: ${this.truncateString(log.postData, 200)}`);
+                }
+                lines.push('');
+            }
+        }
+        // Resumo final
+        lines.push('═══════════════════════════════════════════════════════════════════════════════');
+        lines.push('📊 RESUMO');
+        lines.push('─'.repeat(79));
+        const totalRequests = this.logs.filter(l => l.type === 'request').length;
+        const totalResponses = this.logs.filter(l => l.type === 'response').length;
+        const totalFailed = this.logs.filter(l => l.type === 'failed').length;
+        const totalErrors = this.logs.filter(l => l.type === 'response' && l.status && l.status >= 400).length;
+        const avgDuration = this.calculateAvgDuration();
+        const totalSize = this.calculateTotalSize();
+        lines.push(`   📤 Total Requisições: ${totalRequests}`);
+        lines.push(`   📥 Total Respostas: ${totalResponses}`);
+        lines.push(`   💥 Requisições Falhas: ${totalFailed}`);
+        lines.push(`   ❌ Erros HTTP (4xx/5xx): ${totalErrors}`);
+        lines.push(`   ⏱️ Tempo Médio: ${avgDuration}ms`);
+        lines.push(`   📦 Dados Transferidos: ${this.formatBytes(totalSize)}`);
+        lines.push('═══════════════════════════════════════════════════════════════════════════════');
+        return lines.join('\n');
+    }
+    /**
+     * Gera relatório em JSON
+     */
+    generateJsonReport() {
+        return JSON.stringify({
+            capturedAt: new Date().toISOString(),
+            totalLogs: this.logs.length,
+            summary: {
+                requests: this.logs.filter(l => l.type === 'request').length,
+                responses: this.logs.filter(l => l.type === 'response').length,
+                failed: this.logs.filter(l => l.type === 'failed').length,
+                httpErrors: this.logs.filter(l => l.type === 'response' && l.status && l.status >= 400).length,
+                avgDurationMs: this.calculateAvgDuration(),
+                totalBytes: this.calculateTotalSize(),
+            },
+            logs: this.logs,
+        }, null, 2);
+    }
+    truncateUrl(url, maxLength) {
+        if (url.length <= maxLength)
+            return url;
+        return url.substring(0, maxLength - 3) + '...';
+    }
+    truncateString(str, maxLength) {
+        if (str.length <= maxLength)
+            return str;
+        return str.substring(0, maxLength - 3) + '...';
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+    }
+    calculateAvgDuration() {
+        const durations = this.logs.filter(l => l.duration).map(l => l.duration);
+        if (durations.length === 0)
+            return 0;
+        return Math.round(durations.reduce((a, b) => a + b, 0) / durations.length);
+    }
+    calculateTotalSize() {
+        return this.logs.filter(l => l.size).reduce((acc, l) => acc + (l.size || 0), 0);
+    }
+    /**
+     * Limpa os logs
+     */
+    clear() {
+        this.logs = [];
+        this.requestTimings.clear();
+        this.currentPageUrl = '';
+        this.currentPageTitle = '';
+    }
+}
+/** Cache de resolução detectada (evita re-detectar a cada teste) */
+let _cachedResolution = null;
+/**
+ * Detecta resolução real da tela do SO (não do browser headless).
+ * Prioridade:
+ *   1) Env vars AUTOCORE_VIEWPORT_WIDTH / AUTOCORE_VIEWPORT_HEIGHT
+ *   2) Detecção via SO (Windows PowerShell, Linux xrandr/xdpyinfo)
+ *   3) Fallback 1920×1080
+ *
+ * Sempre clampeia entre 1024×768 (mínimo) e 3840×2160 (4K máximo)
+ * para evitar viewports absurdos.
+ */
+function detectScreenResolution() {
+    if (_cachedResolution)
+        return _cachedResolution;
+    const MIN_W = 1024, MIN_H = 768, MAX_W = 3840, MAX_H = 2160;
+    const FALLBACK = { width: 1920, height: 1080 };
+    const clamp = (w, h) => ({
+        width: Math.max(MIN_W, Math.min(MAX_W, w)),
+        height: Math.max(MIN_H, Math.min(MAX_H, h)),
+    });
+    // 1) Env vars (override manual)
+    const envW = Number(process.env.AUTOCORE_VIEWPORT_WIDTH);
+    const envH = Number(process.env.AUTOCORE_VIEWPORT_HEIGHT);
+    if (envW > 0 && envH > 0) {
+        _cachedResolution = clamp(envW, envH);
+        console.log(`📐 [AutoCore] Viewport via env: ${_cachedResolution.width}x${_cachedResolution.height}`);
+        return _cachedResolution;
+    }
+    // 2) Detecção por SO
+    try {
+        const platform = os.platform();
+        if (platform === 'win32') {
+            // PowerShell: lê resolução primária via WMI (sem GUI necessário)
+            const raw = execSync(`powershell -NoProfile -Command "Add-Type -AssemblyName System.Windows.Forms; $s=[System.Windows.Forms.Screen]::PrimaryScreen.Bounds; Write-Output ('{0}x{1}' -f $s.Width,$s.Height)"`, { timeout: 5000, encoding: 'utf-8', windowsHide: true }).trim();
+            const match = raw.match(/(\d+)x(\d+)/);
+            if (match) {
+                _cachedResolution = clamp(Number(match[1]), Number(match[2]));
+                console.log(`📐 [AutoCore] Viewport via Windows screen: ${_cachedResolution.width}x${_cachedResolution.height}`);
+                return _cachedResolution;
+            }
+        }
+        else if (platform === 'linux') {
+            // xdpyinfo ou xrandr para Linux com X11
+            try {
+                const raw = execSync('xdpyinfo 2>/dev/null | grep dimensions', { timeout: 3000, encoding: 'utf-8' }).trim();
+                const match = raw.match(/(\d+)x(\d+)/);
+                if (match) {
+                    _cachedResolution = clamp(Number(match[1]), Number(match[2]));
+                    console.log(`📐 [AutoCore] Viewport via xdpyinfo: ${_cachedResolution.width}x${_cachedResolution.height}`);
+                    return _cachedResolution;
+                }
+            }
+            catch {
+                // xdpyinfo indisponível, tentar xrandr
+                const raw = execSync('xrandr 2>/dev/null | grep "\\*" | head -1', { timeout: 3000, encoding: 'utf-8' }).trim();
+                const match = raw.match(/(\d+)x(\d+)/);
+                if (match) {
+                    _cachedResolution = clamp(Number(match[1]), Number(match[2]));
+                    console.log(`📐 [AutoCore] Viewport via xrandr: ${_cachedResolution.width}x${_cachedResolution.height}`);
+                    return _cachedResolution;
+                }
+            }
+        }
+        else if (platform === 'darwin') {
+            const raw = execSync('system_profiler SPDisplaysDataType 2>/dev/null | grep Resolution', { timeout: 3000, encoding: 'utf-8' }).trim();
+            const match = raw.match(/(\d+)\s*x\s*(\d+)/);
+            if (match) {
+                _cachedResolution = clamp(Number(match[1]), Number(match[2]));
+                console.log(`📐 [AutoCore] Viewport via macOS: ${_cachedResolution.width}x${_cachedResolution.height}`);
+                return _cachedResolution;
+            }
+        }
+    }
+    catch {
+        // Detecção falhou silenciosamente
+    }
+    // 3) Fallback
+    _cachedResolution = FALLBACK;
+    console.log(`📐 [AutoCore] Viewport fallback: ${FALLBACK.width}x${FALLBACK.height}`);
+    return _cachedResolution;
+}
+/**
+ * Configura viewport com resolução dinâmica da máquina.
+ * Usa detecção de SO com deviceScaleFactor=1 para evitar zoom.
+ * Injeta meta viewport tag para garantir zoom 100% no conteúdo.
+ */
+async function setupResponsiveViewport(page) {
+    try {
+        const { width, height } = detectScreenResolution();
+        await page.setViewportSize({ width, height });
+        // Garantir zoom 100% via meta tag
+        await page.addInitScript(() => {
+            const meta = document.querySelector('meta[name="viewport"]');
+            if (!meta) {
+                const m = document.createElement('meta');
+                m.name = 'viewport';
+                m.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0';
+                document.head?.appendChild(m);
+            }
+        });
+        console.log(`📐 [AutoCore-fixtures] Viewport final: ${width}x${height} (zoom 100%)`);
+    }
+    catch (err) {
+        console.warn('⚠️ Não foi possível ajustar viewport:', err);
+    }
+}
+/**
+ * Configura captura de logs de Network
+ */
+function setupNetworkLogging(page, networkLogger) {
+    // Atualiza info da página em cada navegação
+    page.on('framenavigated', async (frame) => {
+        if (frame === page.mainFrame()) {
+            try {
+                const url = page.url();
+                const title = await page.title().catch(() => '');
+                networkLogger.updatePageInfo(url, title);
+            }
+            catch {
+                // Ignora erros de página fechada
+            }
+        }
+    });
+    // Captura requisições
+    page.on('request', (request) => {
+        try {
+            networkLogger.logRequest(request);
+        }
+        catch {
+            // Ignora erros
+        }
+    });
+    // Captura respostas
+    page.on('response', async (response) => {
+        try {
+            await networkLogger.logResponse(response);
+        }
+        catch {
+            // Ignora erros
+        }
+    });
+    // Captura requisições que falharam
+    page.on('requestfailed', (request) => {
+        try {
+            networkLogger.logRequestFailed(request);
+        }
+        catch {
+            // Ignora erros
+        }
+    });
+    console.log('📡 [AutoCore] Network logging ativado');
+}
+/**
+ * Salva arquivos de network logs na pasta test-results/network-logs
+ *
+ * O Playwright NÃO limpa test-results/ automaticamente, então os arquivos são preservados.
+ * Para ter os arquivos dentro de playwright-report/, adicione NetworkLogsReporter ao seu playwright.config.ts:
+ *
+ * @example
+ * import { NetworkLogsReporter } from '@silasfmartins/testhub'
+ * export default defineConfig({
+ *   reporter: [['html'], NetworkLogsReporter],
+ * })
+ */
+function saveNetworkLogsToReport(testInfo, networkLogger) {
+    const logs = networkLogger.getLogs();
+    if (logs.length === 0)
+        return null;
+    try {
+        // 🔧 Usa test-results/network-logs que é preservado pelo Playwright
+        // O outputDir já é dentro de test-results, então usamos a raiz do projeto + test-results/network-logs
+        let projectRoot;
+        // outputDir é algo como: C:\...\test-sanity-frontend\test-results\chromium\...
+        // Queremos: C:\...\test-sanity-frontend
+        if (testInfo.outputDir) {
+            // Remove tudo a partir de 'test-results' (incluindo)
+            const testResultsIndex = testInfo.outputDir.indexOf('test-results');
+            if (testResultsIndex > 0) {
+                projectRoot = testInfo.outputDir.substring(0, testResultsIndex).replace(/[\\/]$/, '');
+            }
+            else {
+                projectRoot = testInfo.config?.rootDir || process.cwd();
+            }
+        }
+        else {
+            projectRoot = testInfo.config?.rootDir || process.cwd();
+        }
+        // 🔧 FIX ADICIONAL: Se rootDir termina com 'tests', remove para ir ao projeto raiz
+        if (projectRoot.endsWith('tests') || projectRoot.endsWith('tests/') || projectRoot.endsWith('tests\\')) {
+            projectRoot = path.dirname(projectRoot);
+        }
+        // 🔧 Salva em test-results/network-logs (pasta preservada pelo Playwright)
+        const reportDir = path.join(projectRoot, 'test-results', 'network-logs');
+        console.log(`📂 [AutoCore] Network logs directory:`);
+        console.log(`   📂 projectRoot: ${projectRoot}`);
+        console.log(`   📂 reportDir: ${reportDir}`);
+        // Cria a pasta se não existir
+        if (!fs.existsSync(reportDir)) {
+            fs.mkdirSync(reportDir, { recursive: true });
+            console.log(`📁 [AutoCore] Criada pasta: ${reportDir}`);
+        }
+        // Gera nome do arquivo baseado no teste (sanitizado)
+        const testName = testInfo.title.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 50);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const baseName = `${testName}_${timestamp}`;
+        // Salva arquivo TXT
+        const txtPath = path.join(reportDir, `${baseName}.txt`);
+        const textReport = networkLogger.generateTextReport();
+        fs.writeFileSync(txtPath, textReport, 'utf-8');
+        // Verifica se arquivo foi criado
+        if (fs.existsSync(txtPath)) {
+            console.log(`✅ [AutoCore] Arquivo TXT criado: ${txtPath}`);
+        }
+        else {
+            console.error(`❌ [AutoCore] FALHA ao criar arquivo TXT: ${txtPath}`);
+        }
+        // Salva arquivo JSON
+        const jsonPath = path.join(reportDir, `${baseName}.json`);
+        const jsonReport = networkLogger.generateJsonReport();
+        fs.writeFileSync(jsonPath, jsonReport, 'utf-8');
+        // Verifica se arquivo foi criado
+        if (fs.existsSync(jsonPath)) {
+            console.log(`✅ [AutoCore] Arquivo JSON criado: ${jsonPath}`);
+        }
+        else {
+            console.error(`❌ [AutoCore] FALHA ao criar arquivo JSON: ${jsonPath}`);
+        }
+        console.log(`📡 [AutoCore] Network logs salvos em: ${reportDir}`);
+        return { txtPath, jsonPath };
+    }
+    catch (err) {
+        console.error('❌ [AutoCore] Erro ao salvar network logs:', err);
+        console.error(`   📂 outputDir: ${testInfo.outputDir || '(não definido)'}`);
+        console.error(`   📂 config.rootDir: ${testInfo.config?.rootDir || '(não definido)'}`);
+        console.error(`   📂 cwd: ${process.cwd()}`);
+        return null;
+    }
+}
+/**
+ * Anexa logs de Network ao relatório do teste como Annotations
+ */
+async function attachNetworkLogs(testInfo, networkLogger) {
+    const logs = networkLogger.getLogs();
+    if (logs.length === 0) {
+        console.log('📡 [AutoCore] Nenhum log de network para anexar');
+        return;
+    }
+    try {
+        // 1. Salva arquivos na pasta playwright-report
+        const savedFiles = saveNetworkLogsToReport(testInfo, networkLogger);
+        // 2. Anexa relatório em texto (legível) ao teste
+        const textReport = networkLogger.generateTextReport();
+        await testInfo.attach('network-logs.txt', {
+            body: Buffer.from(textReport, 'utf-8'),
+            contentType: 'text/plain',
+        });
+        // 3. Anexa relatório em JSON (para processamento)
+        const jsonReport = networkLogger.generateJsonReport();
+        await testInfo.attach('network-logs.json', {
+            body: Buffer.from(jsonReport, 'utf-8'),
+            contentType: 'application/json',
+        });
+        // 4. Adiciona Annotations para aparecer no relatório HTML
+        const requests = logs.filter(l => l.type === 'request').length;
+        const responses = logs.filter(l => l.type === 'response').length;
+        const failed = logs.filter(l => l.type === 'failed').length;
+        const errors = logs.filter(l => l.type === 'response' && l.status && l.status >= 400).length;
+        const totalSize = logs.filter(l => l.size).reduce((acc, l) => acc + (l.size || 0), 0);
+        const avgDuration = logs.filter(l => l.duration).length > 0
+            ? Math.round(logs.filter(l => l.duration).reduce((acc, l) => acc + (l.duration || 0), 0) / logs.filter(l => l.duration).length)
+            : 0;
+        // Annotation com resumo de Network
+        testInfo.annotations.push({
+            type: '📡 Network Summary',
+            description: `Requests: ${requests} | Responses: ${responses} | Failed: ${failed} | HTTP Errors: ${errors}`,
+        });
+        testInfo.annotations.push({
+            type: '📊 Network Stats',
+            description: `Total Size: ${formatBytesStatic(totalSize)} | Avg Duration: ${avgDuration}ms`,
+        });
+        // Lista as URLs únicas visitadas
+        const uniquePages = [...new Set(logs.filter(l => l.pageUrl).map(l => l.pageUrl))];
+        if (uniquePages.length > 0) {
+            testInfo.annotations.push({
+                type: '🌐 Pages Visited',
+                description: uniquePages.slice(0, 5).join(' → ') + (uniquePages.length > 5 ? ` (+${uniquePages.length - 5} more)` : ''),
+            });
+        }
+        // Lista erros HTTP se houver
+        const httpErrors = logs.filter(l => l.type === 'response' && l.status && l.status >= 400);
+        if (httpErrors.length > 0) {
+            const errorSummary = httpErrors.slice(0, 3).map(e => `${e.status} ${e.method} ${e.url.substring(0, 50)}...`).join(' | ');
+            testInfo.annotations.push({
+                type: '❌ HTTP Errors',
+                description: errorSummary + (httpErrors.length > 3 ? ` (+${httpErrors.length - 3} more)` : ''),
+            });
+        }
+        // Lista requisições que falharam se houver
+        const failedRequests = logs.filter(l => l.type === 'failed');
+        if (failedRequests.length > 0) {
+            const failedSummary = failedRequests.slice(0, 3).map(f => `${f.method} ${f.url.substring(0, 50)}... (${f.errorText || 'unknown'})`).join(' | ');
+            testInfo.annotations.push({
+                type: '💥 Failed Requests',
+                description: failedSummary + (failedRequests.length > 3 ? ` (+${failedRequests.length - 3} more)` : ''),
+            });
+        }
+        // Adiciona link para os arquivos salvos
+        if (savedFiles) {
+            testInfo.annotations.push({
+                type: '📁 Network Logs Files',
+                description: `TXT: ${path.basename(savedFiles.txtPath)} | JSON: ${path.basename(savedFiles.jsonPath)}`,
+            });
+        }
+        // 5. Imprime resumo no terminal para visibilidade durante execução
+        console.log('');
+        console.log('═══════════════════════════════════════════════════════════════════');
+        console.log('📡 [AutoCore] NETWORK LOGS SUMMARY');
+        console.log('═══════════════════════════════════════════════════════════════════');
+        console.log(`   📊 Total: ${logs.length} logs capturados`);
+        console.log(`   ➡️  Requests: ${requests}`);
+        console.log(`   ✅ Responses: ${responses}`);
+        console.log(`   💥 Failed: ${failed}`);
+        console.log(`   ❌ HTTP Errors (4xx/5xx): ${errors}`);
+        console.log(`   📦 Total Size: ${formatBytesStatic(totalSize)}`);
+        console.log(`   ⏱️  Avg Duration: ${avgDuration}ms`);
+        if (uniquePages.length > 0) {
+            console.log(`   🌐 Pages Visited: ${uniquePages.length}`);
+            uniquePages.slice(0, 3).forEach((page, i) => {
+                console.log(`      ${i + 1}. ${page}`);
+            });
+            if (uniquePages.length > 3) {
+                console.log(`      ... +${uniquePages.length - 3} more`);
+            }
+        }
+        if (httpErrors.length > 0) {
+            console.log(`   ❌ HTTP Errors Details:`);
+            httpErrors.slice(0, 5).forEach(e => {
+                console.log(`      • ${e.status} ${e.method} ${e.url.substring(0, 80)}${e.url.length > 80 ? '...' : ''}`);
+            });
+            if (httpErrors.length > 5) {
+                console.log(`      ... +${httpErrors.length - 5} more errors`);
+            }
+        }
+        if (failedRequests.length > 0) {
+            console.log(`   💥 Failed Requests Details:`);
+            failedRequests.slice(0, 5).forEach(f => {
+                console.log(`      • ${f.method} ${f.url.substring(0, 60)}${f.url.length > 60 ? '...' : ''} (${f.errorText || 'unknown'})`);
+            });
+            if (failedRequests.length > 5) {
+                console.log(`      ... +${failedRequests.length - 5} more failures`);
+            }
+        }
+        if (savedFiles) {
+            console.log(`   📁 Files saved to: evidence/network-logs/`);
+            console.log(`      • ${path.basename(savedFiles.txtPath)}`);
+            console.log(`      • ${path.basename(savedFiles.jsonPath)}`);
+            console.log(`   ℹ️  Serão movidos para playwright-report/evidence/network-logs/`);
+        }
+        console.log('═══════════════════════════════════════════════════════════════════');
+        console.log('');
+    }
+    catch (err) {
+        console.warn('⚠️ [AutoCore] Erro ao anexar logs de network:', err);
+    }
+}
+/**
+ * Formata bytes em formato legível (helper estático)
+ */
+function formatBytesStatic(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+/**
+ * 🔧 TEST UNIVERSAL - FUNCIONA PARA WEB E PROJETOS SEM BROWSER
+ *
+ * O browser SÓ é lançado quando o teste usa:
+ *   - TestAnnotations.Frontend.testInfo = testInfo
+ *   - TestAnnotations.Mixed.testInfo = testInfo
+ *
+ * Para testes API, SSH, Banco, Mobile: NÃO lança browser.
+ *
+ * O mecanismo é lazy: o fixture armazena uma factory no TestContext.
+ * Quando o setter de Frontend/Mixed é chamado, dispara a criação assíncrona.
+ * O primeiro await subsequente (ex.: setSystem) aguarda a conclusão.
+ *
+ * 📡 NETWORK LOGS: Captura automaticamente todos os logs de rede (quando browser ativo).
+ *
+ * @example Web (com browser)
+ * ```typescript
+ * import { test, expect } from '@silasfmartins/testhub'
+ *
+ * test('Web test', async ({}, testInfo) => {
+ *   TestAnnotations.Frontend.testInfo = testInfo
+ *   await TestAnnotations.setSystem('MEU_SISTEMA')
+ *   await new MinhaPage().minhaAcao()
+ * })
+ * ```
+ *
+ * @example SSH/API/Banco (sem browser) - mesmo import!
+ * ```typescript
+ * import { test, expect, SSHActions } from '@silasfmartins/testhub'
+ *
+ * test('SSH test', async ({}, testInfo) => {
+ *   TestAnnotations.SSH.testInfo = testInfo
+ *   await SSHActions.connect({...})
+ * })
+ * ```
+ */
+// biome-ignore lint/suspicious/noConfusingVoidType: Playwright fixture pattern
+export const test = base.extend({
+    // 🔧 Network Logger - captura todos os logs de rede
+    networkLogs: [async ({}, use) => {
+            const logger = new NetworkLogger();
+            await use(logger);
+        }, { scope: 'test' }],
+    // 🔧 Auto-inject: armazena factory lazy ANTES do teste, limpa DEPOIS
+    autoInjectPage: [async ({ playwright, networkLogs }, use, testInfo) => {
+            let page;
+            let context;
+            let browser;
+            // Armazena factory lazy no TestContext — só executa quando Frontend/Mixed chamar requestBrowserCreation()
+            TestContext.setPageFactory(async () => {
+                if (page)
+                    return page;
+                // ⚠️ PROTEÇÃO: Se o tipo de teste foi definido como não-browser, não criar
+                if (TestContext.isNonBrowserTest()) {
+                    console.log(`🚫 [AutoCore] Teste ${TestContext.getTestType()} detectado - browser não será criado`);
+                    return null;
+                }
+                const browserName = testInfo.project?.use?.browserName || 'chromium';
+                console.log(`🌐 [AutoCore] Lançando browser lazy: ${browserName}`);
+                const browserType = playwright[browserName];
+                const resolution = detectScreenResolution();
+                browser = await browserType.launch();
+                context = await browser.newContext({
+                    viewport: { width: resolution.width, height: resolution.height },
+                    deviceScaleFactor: 1,
+                });
+                page = await context.newPage();
+                // Injeta no TestContext
+                TestContext.setPage(page);
+                console.log('🎭 [AutoCore] Page injetada automaticamente no TestContext (lazy)');
+                // Configura
+                setupNetworkLogging(page, networkLogs);
+                await setupResponsiveViewport(page);
+                return page;
+            });
+            // ---------- TEST BODY EXECUTA AQUI ----------
+            await use();
+            // ---------- CLEANUP (pós-teste) ----------
+            TestContext.setPageFactory(null);
+            if (page) {
+                // Anexa network logs ao relatório se browser foi usado
+                await attachNetworkLogs(testInfo, networkLogs);
+                await page.close().catch(() => { });
+                await context?.close().catch(() => { });
+                await browser?.close().catch(() => { });
+            }
+            else {
+                const testType = TestContext.getTestType() || 'desconhecido';
+                console.log(`🔧 [AutoCore] Teste "${testInfo.title}" executou sem browser (tipo: ${testType})`);
+                // ✅ NOVO: Anexar logs de API ao relatório mesmo sem browser
+                if (testType === 'API') {
+                    try {
+                        const { ApiActions } = await import('../api/ApiActions.js');
+                        if (ApiActions.hasLogsForTest(testInfo.title)) {
+                            const logs = ApiActions.getLogsForTest(testInfo.title);
+                            if (logs.length > 0) {
+                                await testInfo.attach('api-logs.txt', {
+                                    body: Buffer.from(logs.join('\n'), 'utf-8'),
+                                    contentType: 'text/plain',
+                                });
+                            }
+                        }
+                        // Anexar relatório final de API
+                        await ApiActions.anexarResumoDeLogs();
+                    }
+                    catch {
+                        // Silenciosamente ignorar se ApiActions não estiver disponível
+                    }
+                }
+            }
+            // Resetar tipo de teste para o próximo
+            TestContext.resetTestType();
+        }, { auto: true }],
+});
+export { NetworkLogger };
+export const expect = baseExpect;