@silasfmartins/testhub 1.0.0

package/dist/src/octane/OctaneReporter.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import https from 'node:https';
+import { fileURLToPath } from 'node:url';
+import fetch from 'node-fetch';
+import path from 'path';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const report = { features: [] };
+export function addScenarioToReport(featureName, scenarioName, octaneTag, steps, status) {
+    let feature = report.features.find((f) => f.name === featureName);
+    if (!feature) {
+        feature = { name: featureName, scenarios: [] };
+        report.features.push(feature);
+    }
+    feature.scenarios.push({
+        scenario: scenarioName,
+        status,
+        octane_tag: octaneTag,
+        steps,
+    });
+}
+export function saveReport() {
+    const outputPath = path.join(__dirname, '..', 'octane-report.json');
+    fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+}
+/**
+ * Envia o relatório octane-report.json para o endpoint do Octane/ALM
+ * Ignora validação SSL (inseguro, apenas para ambientes controlados)
+ */
+export async function sendReportToOctane(octaneUrl, clientId, clientSecret) {
+    const outputPath = path.join(__dirname, '..', 'octane-report.json');
+    if (!fs.existsSync(outputPath)) {
+        throw new Error('Relatório octane-report.json não encontrado');
+    }
+    const reportData = fs.readFileSync(outputPath, 'utf-8');
+    // Ignora validação SSL
+    let agent = new https.Agent({
+        rejectUnauthorized: false,
+    });
+    if (process.env.USE_PROXY === 'true') {
+        const proxyUrl = `http://${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
+        agent = new HttpsProxyAgent(proxyUrl);
+        agent.options.rejectUnauthorized = false;
+    }
+    const auth = Buffer.from(`${clientId}:${clientSecret}`, 'utf-8').toString('base64');
+    const fetchOptions = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Basic ${auth}`,
+        },
+        body: reportData,
+        agent,
+    };
+    const response = await fetch(octaneUrl, fetchOptions);
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Falha ao enviar relatório para Octane: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+}

package/dist/src/playwright/CryptoActions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CryptoActions: encrypt/decrypt files using OpenPGP (PGP/GPG compatible)
+ * - Uses openpgp v5 API
+ */
+export declare class CryptoActions {
+    /**
+     * Encrypt a file using a public key (armored). If `armor` is false, output will be binary.
+     */
+    static encryptFile(inputPath: string, outputPath: string, publicKeyArmored: string, armor?: boolean): Promise<void>;
+    /**
+     * Decrypt a file using a private key (armored). If private key is encrypted, passphrase is required.
+     */
+    static decryptFile(inputPath: string, outputPath: string, privateKeyArmored: string, passphrase?: string): Promise<void>;
+    /**
+     * Convenience wrappers for GPG compatibility — same OpenPGP format
+     */
+    static encryptFileGPG(inputPath: string, outputPath: string, publicKeyArmored: string, armor?: boolean): Promise<void>;
+    static decryptFileGPG(inputPath: string, outputPath: string, privateKeyArmored: string, passphrase?: string): Promise<void>;
+}
+export default CryptoActions;

package/dist/src/playwright/CryptoActions.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import * as openpgp from 'openpgp';
+import { Logger } from '../utils/Logger.js';
+/**
+ * CryptoActions: encrypt/decrypt files using OpenPGP (PGP/GPG compatible)
+ * - Uses openpgp v5 API
+ */
+export class CryptoActions {
+    /**
+     * Encrypt a file using a public key (armored). If `armor` is false, output will be binary.
+     */
+    static async encryptFile(inputPath, outputPath, publicKeyArmored, armor = true) {
+        Logger.info(`CryptoActions.encryptFile ${inputPath} => ${outputPath}`);
+        const data = fs.readFileSync(inputPath);
+        const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+        const message = await openpgp.createMessage({ binary: data });
+        const encrypted = await openpgp.encrypt({
+            message,
+            encryptionKeys: publicKey,
+            format: armor ? 'armored' : 'binary',
+        });
+        if (armor && typeof encrypted === 'string') {
+            fs.writeFileSync(outputPath, encrypted, 'utf8');
+        }
+        else if (!armor && encrypted instanceof Uint8Array) {
+            fs.writeFileSync(outputPath, Buffer.from(encrypted));
+        }
+        else if (typeof encrypted === 'string') {
+            // fallback
+            fs.writeFileSync(outputPath, encrypted, 'utf8');
+        }
+        else {
+            fs.writeFileSync(outputPath, Buffer.from(encrypted));
+        }
+    }
+    /**
+     * Decrypt a file using a private key (armored). If private key is encrypted, passphrase is required.
+     */
+    static async decryptFile(inputPath, outputPath, privateKeyArmored, passphrase) {
+        Logger.info(`CryptoActions.decryptFile ${inputPath} => ${outputPath}`);
+        const data = fs.readFileSync(inputPath);
+        // Determine if armored
+        const asString = data.toString('utf8');
+        const isArmored = asString.includes('-----BEGIN PGP');
+        let message;
+        if (isArmored) {
+            message = await openpgp.readMessage({ armoredMessage: asString });
+        }
+        else {
+            message = await openpgp.readMessage({ binaryMessage: new Uint8Array(data) });
+        }
+        let privKey = await openpgp.readPrivateKey({ armoredKey: privateKeyArmored });
+        if (passphrase) {
+            privKey = await openpgp.decryptKey({ privateKey: privKey, passphrase });
+        }
+        const decrypted = await openpgp.decrypt({ message, decryptionKeys: privKey });
+        const out = decrypted.data;
+        if (typeof out === 'string') {
+            fs.writeFileSync(outputPath, out, 'utf8');
+        }
+        else {
+            fs.writeFileSync(outputPath, Buffer.from(out));
+        }
+    }
+    /**
+     * Convenience wrappers for GPG compatibility — same OpenPGP format
+     */
+    static async encryptFileGPG(inputPath, outputPath, publicKeyArmored, armor = true) {
+        return this.encryptFile(inputPath, outputPath, publicKeyArmored, armor);
+    }
+    static async decryptFileGPG(inputPath, outputPath, privateKeyArmored, passphrase) {
+        return this.decryptFile(inputPath, outputPath, privateKeyArmored, passphrase);
+    }
+}
+export default CryptoActions;

package/dist/src/playwright/EnhancedWebActions.d.ts

@@ -0,0 +1,7 @@
+import { Page } from '@playwright/test';
+export declare class EnhancedWebActions {
+    private page;
+    constructor(page: Page);
+    waitForSelectorWithRecovery(selector: string, context: string, timeout?: number): Promise<boolean>;
+    private callTestRecoveryAPI;
+}

package/dist/src/playwright/EnhancedWebActions.js

@@ -0,0 +1,65 @@
+import { Logger } from '../utils/Logger.js';
+export class EnhancedWebActions {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    async waitForSelectorWithRecovery(selector, context, timeout = 120000) {
+        Logger.info(`🔄 [EnhancedWebActions] Aguardando seletor: ${selector}`);
+        try {
+            await this.page.locator(selector).waitFor({ state: 'visible', timeout });
+            Logger.success(`✅ [EnhancedWebActions] Seletor encontrado: ${selector}`);
+            return true;
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [EnhancedWebActions] Falha ao encontrar seletor: ${selector}. Tentando recuperação...`);
+            const newSelector = await this.callTestRecoveryAPI(selector, context);
+            if (newSelector) {
+                Logger.info(`🔄 [EnhancedWebActions] Tentando novo seletor sugerido: ${newSelector}`);
+                try {
+                    await this.page.locator(newSelector).waitFor({ state: 'visible', timeout });
+                    Logger.success(`✅ [EnhancedWebActions] Novo seletor encontrado: ${newSelector}`);
+                    return true;
+                }
+                catch (recoveryError) {
+                    Logger.error(`❌ [EnhancedWebActions] Falha ao usar novo seletor: ${newSelector}`, recoveryError);
+                }
+            }
+            else {
+                Logger.error('❌ [EnhancedWebActions] Nenhum novo seletor sugerido pela API de Test Recovery.');
+            }
+            Logger.error('❌ [EnhancedWebActions] Erro final ao aguardar seletor', error);
+            return false;
+        }
+    }
+    async callTestRecoveryAPI(failedSelector, context) {
+        Logger.info(`🔄 [EnhancedWebActions] Chamando API de Test Recovery para seletor: ${failedSelector}`);
+        try {
+            const response = await this.page.request.post('http://api.test-recovery.local/analyze-failure', {
+                data: {
+                    selector: failedSelector,
+                    context,
+                },
+            });
+            if (response.ok()) {
+                const result = await response.json();
+                const newSelector = result.newSelector;
+                const confidence = result.confidence;
+                Logger.success(`✅ [EnhancedWebActions] Novo seletor sugerido: ${newSelector} (confiança: ${confidence})`);
+                if (confidence >= 0.7) {
+                    return newSelector;
+                }
+                else {
+                    Logger.warning('⚠️ [EnhancedWebActions] Confiança baixa no novo seletor. Revisão manual recomendada.');
+                }
+            }
+            else {
+                Logger.error(`❌ [EnhancedWebActions] Falha ao chamar API de Test Recovery: ${response.status()}`);
+            }
+        }
+        catch (error) {
+            Logger.error('❌ [EnhancedWebActions] Erro ao tentar chamar API de Test Recovery', error);
+        }
+        return null;
+    }
+}