@silasfmartins/testhub 1.0.0

package/dist/src/helpers/ParallelExecutionHelper.d.ts

@@ -0,0 +1,183 @@
+/**
+ * 🚀 ParallelExecutionHelper
+ *
+ * Helper para executar operações de diferentes contextos (Frontend, API, SSH, etc) em paralelo.
+ * Útil quando você precisa que uma ação API rode simultaneamente com uma ação Frontend.
+ *
+ * @example
+ * // Executar dashboard Frontend + API em paralelo
+ * await ParallelExecutionHelper.executeInParallel([
+ *   {
+ *     type: 'Frontend',
+ *     system: 'SALESFORCE_SANITY',
+ *     action: async () => {
+ *       await new PageDashboard().attDashboard()
+ *     }
+ *   },
+ *   {
+ *     type: 'Api',
+ *     system: 'API',
+ *     action: async () => {
+ *       await new StatementsAPI().sendData()
+ *     }
+ *   }
+ * ])
+ */
+import type { TestInfo } from "@playwright/test";
+export interface ParallelTask {
+    /** Tipo de contexto (Frontend, Api, Mobile, SSH, Banco) */
+    type: "Frontend" | "Api" | "Mobile" | "SSH" | "Banco";
+    /** Nome do sistema a ser usado */
+    system: string;
+    /** Ambiente (opcional, usa o padrão se não informado) */
+    environment?: string;
+    /** Função assíncrona a ser executada */
+    action: () => Promise<void>;
+    /** Descrição da task (para logs) */
+    description?: string;
+    /** Timeout opcional da task (ms). Se estourar, a task falha */
+    timeoutMs?: number;
+}
+export interface ParallelExecutionOptions {
+    /**
+     * Define qual contexto deve ficar ativo ao final.
+     * - frontend: prioriza task Frontend (default)
+     * - first: usa a primeira task informada
+     * - none: não altera contexto após o paralelo
+     */
+    restoreContext?: "frontend" | "first" | "none";
+}
+export declare class ParallelExecutionHelper {
+    private static applyTaskTestInfo;
+    private static runTaskAction;
+    /**
+     * Executa múltiplas tasks em paralelo, cada uma com seu próprio contexto.
+     *
+     * @param tasks Array de tasks a serem executadas em paralelo
+     * @param testInfo TestInfo do Playwright (obrigatório)
+     *
+     * @example
+     * test('CT001', async ({}, testInfo: TestInfo) => {
+     *   await ParallelExecutionHelper.executeInParallel([
+     *     {
+     *       type: 'Frontend',
+     *       system: 'SALESFORCE',
+     *       description: 'Atualizar Dashboard',
+     *       action: async () => {
+     *         await new PageDashboard().attDashboard()
+     *       }
+     *     },
+     *     {
+     *       type: 'Api',
+     *       system: 'API_BACKEND',
+     *       description: 'Enviar dados via API',
+     *       action: async () => {
+     *         await new StatementsAPI().sendData()
+     *       }
+     *     }
+     *   ], testInfo)
+     * })
+     */
+    static executeInParallel(tasks: ParallelTask[], testInfo: TestInfo, options?: ParallelExecutionOptions): Promise<void>;
+    /**
+     * 🔥 ATALHOS PARA COMBINAÇÕES COMUNS
+     */
+    /**
+     * Frontend + API em paralelo
+     */
+    static frontendWithApi(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, apiTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + Banco em paralelo
+     */
+    static frontendWithBanco(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + SSH em paralelo
+     */
+    static frontendWithSsh(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + Mobile em paralelo
+     */
+    static frontendWithMobile(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, mobileTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * API + Banco em paralelo
+     */
+    static apiWithBanco(testInfo: TestInfo, apiTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * API + SSH em paralelo
+     */
+    static apiWithSsh(testInfo: TestInfo, apiTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * API + Mobile em paralelo
+     */
+    static apiWithMobile(testInfo: TestInfo, apiTask: Omit<ParallelTask, "type">, mobileTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Mobile + Banco em paralelo
+     */
+    static mobileWithBanco(testInfo: TestInfo, mobileTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Mobile + SSH em paralelo
+     */
+    static mobileWithSsh(testInfo: TestInfo, mobileTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * SSH + Banco em paralelo
+     */
+    static sshWithBanco(testInfo: TestInfo, sshTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * 🎯 COMBINAÇÕES TRIPLAS
+     */
+    /**
+     * Frontend + API + Banco em paralelo
+     */
+    static frontendApiBanco(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, apiTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + API + SSH em paralelo
+     */
+    static frontendApiSsh(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, apiTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + API + Mobile em paralelo
+     */
+    static frontendApiMobile(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, apiTask: Omit<ParallelTask, "type">, mobileTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Frontend + Banco + SSH em paralelo
+     */
+    static frontendBancoSsh(testInfo: TestInfo, frontendTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * API + Banco + SSH em paralelo
+     */
+    static apiBancoSsh(testInfo: TestInfo, apiTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">, sshTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Mobile + API + Banco em paralelo
+     */
+    static mobileApiBanco(testInfo: TestInfo, mobileTask: Omit<ParallelTask, "type">, apiTask: Omit<ParallelTask, "type">, bancoTask: Omit<ParallelTask, "type">): Promise<void>;
+    /**
+     * Executa uma ação principal e aguarda um tempo antes de executar ações secundárias em paralelo.
+     * Útil quando você precisa que uma ação comece antes das outras.
+     *
+     * @example
+     * test('CT001', async ({}, testInfo: TestInfo) => {
+     *   await ParallelExecutionHelper.executeWithDelay(
+     *     testInfo,
+     *     {
+     *       type: 'Frontend',
+     *       system: 'SALESFORCE',
+     *       action: async () => {
+     *         await new PageLogin().login()
+     *         await new PageDashboard().openDashboard() // Começa primeiro
+     *       }
+     *     },
+     *     [
+     *       {
+     *         type: 'Api',
+     *         system: 'API',
+     *         action: async () => {
+     *           await new StatementsAPI().sendData() // Roda em paralelo após delay
+     *         }
+     *       }
+     *     ],
+     *     2000 // 2 segundos de delay
+     *   )
+     * })
+     */
+    static executeWithDelay(testInfo: TestInfo, primaryTask: ParallelTask, secondaryTasks: ParallelTask[], delayMs: number): Promise<void>;
+}
+export default ParallelExecutionHelper;

package/dist/src/helpers/ParallelExecutionHelper.js

@@ -0,0 +1,375 @@
+/**
+ * 🚀 ParallelExecutionHelper
+ *
+ * Helper para executar operações de diferentes contextos (Frontend, API, SSH, etc) em paralelo.
+ * Útil quando você precisa que uma ação API rode simultaneamente com uma ação Frontend.
+ *
+ * @example
+ * // Executar dashboard Frontend + API em paralelo
+ * await ParallelExecutionHelper.executeInParallel([
+ *   {
+ *     type: 'Frontend',
+ *     system: 'SALESFORCE_SANITY',
+ *     action: async () => {
+ *       await new PageDashboard().attDashboard()
+ *     }
+ *   },
+ *   {
+ *     type: 'Api',
+ *     system: 'API',
+ *     action: async () => {
+ *       await new StatementsAPI().sendData()
+ *     }
+ *   }
+ * ])
+ */
+import { TestAnnotations } from "../testContext/TestAnnotations.js";
+import { Logger } from "../utils/Logger.js";
+export class ParallelExecutionHelper {
+    static applyTaskTestInfo(taskType, testInfo) {
+        switch (taskType) {
+            case "Frontend":
+                TestAnnotations.Frontend.testInfo = testInfo;
+                break;
+            case "Api":
+                TestAnnotations.Api.testInfo = testInfo;
+                break;
+            case "Mobile":
+                TestAnnotations.Mobile.testInfo = testInfo;
+                break;
+            case "SSH":
+                TestAnnotations.SSH.testInfo = testInfo;
+                break;
+            case "Banco":
+                TestAnnotations.Banco.testInfo = testInfo;
+                break;
+        }
+    }
+    static async runTaskAction(task) {
+        if (!task.timeoutMs || task.timeoutMs <= 0) {
+            await task.action();
+            return;
+        }
+        await Promise.race([
+            task.action(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`Task excedeu timeout de ${task.timeoutMs}ms (${task.description || task.system})`));
+                }, task.timeoutMs);
+            }),
+        ]);
+    }
+    /**
+     * Executa múltiplas tasks em paralelo, cada uma com seu próprio contexto.
+     *
+     * @param tasks Array de tasks a serem executadas em paralelo
+     * @param testInfo TestInfo do Playwright (obrigatório)
+     *
+     * @example
+     * test('CT001', async ({}, testInfo: TestInfo) => {
+     *   await ParallelExecutionHelper.executeInParallel([
+     *     {
+     *       type: 'Frontend',
+     *       system: 'SALESFORCE',
+     *       description: 'Atualizar Dashboard',
+     *       action: async () => {
+     *         await new PageDashboard().attDashboard()
+     *       }
+     *     },
+     *     {
+     *       type: 'Api',
+     *       system: 'API_BACKEND',
+     *       description: 'Enviar dados via API',
+     *       action: async () => {
+     *         await new StatementsAPI().sendData()
+     *       }
+     *     }
+     *   ], testInfo)
+     * })
+     */
+    static async executeInParallel(tasks, testInfo, options) {
+        Logger.info(`\n🚀 Executando ${tasks.length} tasks em paralelo...`);
+        // Criar promises para cada task
+        const promises = tasks.map(async (task, index) => {
+            const taskName = task.description || `Task ${index + 1} (${task.type})`;
+            Logger.info(`\n📋 [${taskName}] Iniciando...`);
+            Logger.info(`   • Tipo: ${task.type}`);
+            Logger.info(`   • Sistema: ${task.system}`);
+            try {
+                // Configurar contexto específico para esta task
+                this.applyTaskTestInfo(task.type, testInfo);
+                // Configurar sistema
+                await TestAnnotations.setSystem(task.system, task.environment);
+                // Executar action
+                await this.runTaskAction(task);
+                Logger.success(`   ✅ [${taskName}] Concluída com sucesso`);
+            }
+            catch (error) {
+                Logger.error(`   ❌ [${taskName}] Erro`, error);
+                throw error;
+            }
+        });
+        // Aguardar todas as tasks em paralelo sem fail-fast
+        const settled = await Promise.allSettled(promises);
+        // Restaurar contexto para evitar que chamadas após o paralelo fiquem no sistema errado
+        const restoreMode = options?.restoreContext || "frontend";
+        const restoreTask = restoreMode === "none"
+            ? null
+            : restoreMode === "first"
+                ? tasks[0]
+                : tasks.find((task) => task.type === "Frontend") || tasks[0];
+        if (restoreTask) {
+            try {
+                this.applyTaskTestInfo(restoreTask.type, testInfo);
+                await TestAnnotations.setSystem(restoreTask.system, restoreTask.environment);
+                Logger.info(`🔁 Contexto restaurado após paralelo: ${restoreTask.type} (${restoreTask.system})`);
+            }
+            catch (restoreError) {
+                Logger.warning(`⚠️ Não foi possível restaurar contexto após paralelo: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`);
+            }
+        }
+        const failures = settled
+            .map((result, index) => ({ result, task: tasks[index] }))
+            .filter((item) => item.result.status === "rejected");
+        if (failures.length > 0) {
+            const summary = failures
+                .map((item, index) => {
+                const reason = item.result.reason;
+                const message = reason instanceof Error ? reason.message : String(reason);
+                return `${index + 1}) ${item.task.description || item.task.system}: ${message}`;
+            })
+                .join(" | ");
+            throw new Error(`Falha em ${failures.length}/${tasks.length} task(s) do paralelo. ${summary}`);
+        }
+        Logger.success(`\n✅ Todas as ${tasks.length} tasks foram concluídas em paralelo\n`);
+    }
+    /**
+     * 🔥 ATALHOS PARA COMBINAÇÕES COMUNS
+     */
+    /**
+     * Frontend + API em paralelo
+     */
+    static async frontendWithApi(testInfo, frontendTask, apiTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...apiTask, type: "Api" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + Banco em paralelo
+     */
+    static async frontendWithBanco(testInfo, frontendTask, bancoTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + SSH em paralelo
+     */
+    static async frontendWithSsh(testInfo, frontendTask, sshTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + Mobile em paralelo
+     */
+    static async frontendWithMobile(testInfo, frontendTask, mobileTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...mobileTask, type: "Mobile" },
+        ], testInfo);
+    }
+    /**
+     * API + Banco em paralelo
+     */
+    static async apiWithBanco(testInfo, apiTask, bancoTask) {
+        await this.executeInParallel([
+            { ...apiTask, type: "Api" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * API + SSH em paralelo
+     */
+    static async apiWithSsh(testInfo, apiTask, sshTask) {
+        await this.executeInParallel([
+            { ...apiTask, type: "Api" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * API + Mobile em paralelo
+     */
+    static async apiWithMobile(testInfo, apiTask, mobileTask) {
+        await this.executeInParallel([
+            { ...apiTask, type: "Api" },
+            { ...mobileTask, type: "Mobile" },
+        ], testInfo);
+    }
+    /**
+     * Mobile + Banco em paralelo
+     */
+    static async mobileWithBanco(testInfo, mobileTask, bancoTask) {
+        await this.executeInParallel([
+            { ...mobileTask, type: "Mobile" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * Mobile + SSH em paralelo
+     */
+    static async mobileWithSsh(testInfo, mobileTask, sshTask) {
+        await this.executeInParallel([
+            { ...mobileTask, type: "Mobile" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * SSH + Banco em paralelo
+     */
+    static async sshWithBanco(testInfo, sshTask, bancoTask) {
+        await this.executeInParallel([
+            { ...sshTask, type: "SSH" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * 🎯 COMBINAÇÕES TRIPLAS
+     */
+    /**
+     * Frontend + API + Banco em paralelo
+     */
+    static async frontendApiBanco(testInfo, frontendTask, apiTask, bancoTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...apiTask, type: "Api" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + API + SSH em paralelo
+     */
+    static async frontendApiSsh(testInfo, frontendTask, apiTask, sshTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...apiTask, type: "Api" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + API + Mobile em paralelo
+     */
+    static async frontendApiMobile(testInfo, frontendTask, apiTask, mobileTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...apiTask, type: "Api" },
+            { ...mobileTask, type: "Mobile" },
+        ], testInfo);
+    }
+    /**
+     * Frontend + Banco + SSH em paralelo
+     */
+    static async frontendBancoSsh(testInfo, frontendTask, bancoTask, sshTask) {
+        await this.executeInParallel([
+            { ...frontendTask, type: "Frontend" },
+            { ...bancoTask, type: "Banco" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * API + Banco + SSH em paralelo
+     */
+    static async apiBancoSsh(testInfo, apiTask, bancoTask, sshTask) {
+        await this.executeInParallel([
+            { ...apiTask, type: "Api" },
+            { ...bancoTask, type: "Banco" },
+            { ...sshTask, type: "SSH" },
+        ], testInfo);
+    }
+    /**
+     * Mobile + API + Banco em paralelo
+     */
+    static async mobileApiBanco(testInfo, mobileTask, apiTask, bancoTask) {
+        await this.executeInParallel([
+            { ...mobileTask, type: "Mobile" },
+            { ...apiTask, type: "Api" },
+            { ...bancoTask, type: "Banco" },
+        ], testInfo);
+    }
+    /**
+     * Executa uma ação principal e aguarda um tempo antes de executar ações secundárias em paralelo.
+     * Útil quando você precisa que uma ação comece antes das outras.
+     *
+     * @example
+     * test('CT001', async ({}, testInfo: TestInfo) => {
+     *   await ParallelExecutionHelper.executeWithDelay(
+     *     testInfo,
+     *     {
+     *       type: 'Frontend',
+     *       system: 'SALESFORCE',
+     *       action: async () => {
+     *         await new PageLogin().login()
+     *         await new PageDashboard().openDashboard() // Começa primeiro
+     *       }
+     *     },
+     *     [
+     *       {
+     *         type: 'Api',
+     *         system: 'API',
+     *         action: async () => {
+     *           await new StatementsAPI().sendData() // Roda em paralelo após delay
+     *         }
+     *       }
+     *     ],
+     *     2000 // 2 segundos de delay
+     *   )
+     * })
+     */
+    static async executeWithDelay(testInfo, primaryTask, secondaryTasks, delayMs) {
+        Logger.info(`\n🚀 Executando task principal com ${secondaryTasks.length} tasks secundárias (delay: ${delayMs}ms)...`);
+        // Iniciar task principal
+        const primaryPromise = (async () => {
+            const taskName = primaryTask.description || `Primary Task (${primaryTask.type})`;
+            Logger.info(`\n📋 [${taskName}] Iniciando...`);
+            try {
+                switch (primaryTask.type) {
+                    case "Frontend":
+                        TestAnnotations.Frontend.testInfo = testInfo;
+                        break;
+                    case "Api":
+                        TestAnnotations.Api.testInfo = testInfo;
+                        break;
+                    case "Mobile":
+                        TestAnnotations.Mobile.testInfo = testInfo;
+                        break;
+                    case "SSH":
+                        TestAnnotations.SSH.testInfo = testInfo;
+                        break;
+                    case "Banco":
+                        TestAnnotations.Banco.testInfo = testInfo;
+                        break;
+                }
+                await TestAnnotations.setSystem(primaryTask.system, primaryTask.environment);
+                await primaryTask.action();
+                Logger.success(`   ✅ [${taskName}] Concluída`);
+            }
+            catch (error) {
+                Logger.error(`   ❌ [${taskName}] Erro`, error);
+                throw error;
+            }
+        })();
+        // Aguardar delay antes de iniciar tasks secundárias
+        const secondaryPromises = (async () => {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            Logger.info(`\n⏰ Delay de ${delayMs}ms concluído, iniciando tasks secundárias...`);
+            await this.executeInParallel(secondaryTasks, testInfo);
+        })();
+        // Aguardar ambas em paralelo
+        await Promise.all([primaryPromise, secondaryPromises]);
+        Logger.success(`\n✅ Task principal e todas as tasks secundárias concluídas\n`);
+    }
+}
+export default ParallelExecutionHelper;

package/dist/src/helpers/SyncSignal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SyncSignal - simples sinalização em memória para sincronizar tasks paralelas
+ * Uso:
+ *  await SyncSignal.wait('api_done', 50000)
+ *  SyncSignal.signal('api_done')
+ *
+ * Nota: é in-memory e funciona quando as tasks rodam no mesmo processo/worker.
+ * Para sincronização entre processos/hosts use Redis ou outro mecanismo externo.
+ */
+export declare class SyncSignal {
+    static signal(name: string): void;
+    static reset(name: string): void;
+    static wait(name: string, timeoutMs?: number): Promise<void>;
+}
+export default SyncSignal;

package/dist/src/helpers/SyncSignal.js

@@ -0,0 +1,44 @@
+/**
+ * SyncSignal - simples sinalização em memória para sincronizar tasks paralelas
+ * Uso:
+ *  await SyncSignal.wait('api_done', 50000)
+ *  SyncSignal.signal('api_done')
+ *
+ * Nota: é in-memory e funciona quando as tasks rodam no mesmo processo/worker.
+ * Para sincronização entre processos/hosts use Redis ou outro mecanismo externo.
+ */
+const signals = {};
+export class SyncSignal {
+    static signal(name) {
+        if (!signals[name])
+            signals[name] = { resolved: true, resolvers: [] };
+        else {
+            signals[name].resolved = true;
+            for (const r of signals[name].resolvers)
+                r();
+            signals[name].resolvers = [];
+        }
+    }
+    static reset(name) {
+        signals[name] = { resolved: false, resolvers: [] };
+    }
+    static async wait(name, timeoutMs = 50000) {
+        if (!signals[name])
+            signals[name] = { resolved: false, resolvers: [] };
+        if (signals[name].resolved)
+            return;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                // remove resolver
+                signals[name].resolvers = signals[name].resolvers.filter(r => r !== resolve);
+                reject(new Error(`SyncSignal.wait timeout after ${timeoutMs}ms for '${name}'`));
+            }, timeoutMs);
+            const resolver = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            signals[name].resolvers.push(resolver);
+        });
+    }
+}
+export default SyncSignal;