@silasfmartins/testhub 1.0.0

package/dist/src/desktop/DesktopActions.js

@@ -0,0 +1,398 @@
+import { Logger } from '../utils/Logger.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { EvidenceCapture } from '../utils/EvidenceCapture.js';
+import DesktopConnection from './DesktopConnection.js';
+import { BaseError } from '../functions/errors/index.js';
+export class DesktopActions {
+    static ensureDriver() {
+        return DesktopConnection.getDriver();
+    }
+    static async executarComLog(nome, executar) {
+        const start = Date.now();
+        Logger.info(`DesktopActions: iniciando ${nome}`);
+        try {
+            const res = await executar();
+            const dur = Date.now() - start;
+            Logger.success(`DesktopActions: ${nome} concluído (${dur}ms)`);
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.title) {
+                UnifiedReportManager.adicionarLog(testInfo.title, `✅ ${nome} (${dur}ms)`);
+            }
+            return res;
+        }
+        catch (err) {
+            const dur = Date.now() - start;
+            Logger.error(`DesktopActions: erro em ${nome} (${dur}ms): ${String(err)}`);
+            const testInfo = TestContext.getSafeTestInfo();
+            // tentar capturar evidência
+            try {
+                const buff = await DesktopConnection.captureScreenshot(nome);
+                if (buff && testInfo?.title) {
+                    await EvidenceCapture.captureAction(testInfo.title, `Desktop: ${nome}`, `❌ erro (${dur}ms)`, { error: String(err) }, buff);
+                }
+            }
+            catch { }
+            throw err;
+        }
+    }
+    static async runSikuliIfNeeded(element, actionName, value) {
+        // Se o elemento for um objeto com imagePath, chamar Sikuli
+        if (element && typeof element === 'object' && element.imagePath) {
+            const script = element.sikuliScript || element.imagePath;
+            return DesktopConnection.runSikuliScript(script, [actionName, JSON.stringify(value || {})]);
+        }
+        return null;
+    }
+    static async click(element, description = '', getSnapshot = false) {
+        return this.executarComLog('click', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const el = await driver.$(element);
+                await el.waitForDisplayed({ timeout: 30000 });
+                await el.click();
+                return;
+            }
+            const sikuli = await this.runSikuliIfNeeded(element, 'click');
+            if (sikuli)
+                return sikuli;
+            throw new BaseError('Elemento não encontrado para click');
+        });
+    }
+    static async doubleClick(element, description = '', getSnapshot = false) {
+        return this.executarComLog('doubleClick', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const el = await driver.$(element);
+                await el.waitForDisplayed({ timeout: 30000 });
+                await el.doubleClick();
+                return;
+            }
+            const sik = await this.runSikuliIfNeeded(element, 'doubleClick');
+            if (sik)
+                return sik;
+            throw new BaseError('Elemento não encontrado para doubleClick');
+        });
+    }
+    static async setText(element, text, description = '', getSnapshot = false) {
+        return this.executarComLog('setText', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const el = await driver.$(element);
+                await el.waitForDisplayed({ timeout: 30000 });
+                await el.clearValue();
+                await el.setValue(text);
+                return;
+            }
+            const sik = await this.runSikuliIfNeeded(element, 'setText', text);
+            if (sik)
+                return sik;
+            throw new BaseError('Elemento não encontrado para setText');
+        });
+    }
+    static async selectInTableActiveRow(element, rowActivate, description = '', getSnapshot = false) {
+        return this.executarComLog('selectInTableActiveRow', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const row = await table.$(`tr:nth-child(${rowActivate})`);
+                await row.click();
+                return;
+            }
+            throw new BaseError('selectInTableActiveRow não suportado para esse elemento');
+        });
+    }
+    static async clickOptionInTable(element, item, description = '', getSnapshot = false) {
+        return this.executarComLog('clickOptionInTable', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const cell = await table.$(`//*[contains(., "${item}")]`);
+                await cell.click();
+                return;
+            }
+            throw new BaseError('clickOptionInTable não suportado para esse elemento');
+        });
+    }
+    static async clickOptionInTableRowAndHeader(element, row, header, description = '', getSnapshot = false) {
+        return this.executarComLog('clickOptionInTableRowAndHeader', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const headers = await table.$$('th');
+                let idx = -1;
+                for (let i = 0; i < (await headers.length); i++) {
+                    const txt = await headers[i].getText();
+                    if (txt.trim() === header) {
+                        idx = i + 1;
+                        break;
+                    }
+                }
+                if (idx === -1)
+                    throw new BaseError('Cabeçalho não encontrado');
+                const cell = await table.$(`tr:nth-child(${row}) td:nth-child(${idx})`);
+                await cell.click();
+                return;
+            }
+            throw new BaseError('clickOptionInTableRowAndHeader não suportado para esse elemento');
+        });
+    }
+    static async doubleClickOptionInTable(element, item, description = '', getSnapshot = false) {
+        return this.executarComLog('doubleClickOptionInTable', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const cell = await table.$(`//*[contains(., "${item}")]`);
+                await cell.doubleClick();
+                return;
+            }
+            throw new BaseError('doubleClickOptionInTable não suportado para esse elemento');
+        });
+    }
+    static async selectRowInTable(element, row, description = '', getSnapshot = false) {
+        return this.executarComLog('selectRowInTable', async () => {
+            return this.selectInTableActiveRow(element, row, description, getSnapshot);
+        });
+    }
+    static async selectRowOptionInTable(element, itens, description = '', getSnapshot = false) {
+        return this.executarComLog('selectRowOptionInTable', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const rows = await table.$$('tr');
+                for (const r of rows) {
+                    const txt = await r.getText();
+                    const hasAll = itens.every(it => txt.includes(it));
+                    if (hasAll) {
+                        await r.click();
+                        return;
+                    }
+                }
+                throw new BaseError('Linha não encontrada com todos os itens');
+            }
+            throw new BaseError('selectRowOptionInTable não suportado para esse elemento');
+        });
+    }
+    static async selectInTreeView(element, pathStr, description = '', getSnapshot = false) {
+        return this.executarComLog('selectInTreeView', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const parts = pathStr.split('/');
+                let context = await driver.$(element);
+                for (const p of parts) {
+                    const node = await context.$(`//*[text()="${p}"]`);
+                    await node.click();
+                    context = node;
+                }
+                return;
+            }
+            throw new BaseError('selectInTreeView não suportado para esse elemento');
+        });
+    }
+    static async selectInTabControl(element, item, description = '', getSnapshot = false) {
+        return this.executarComLog('selectInTabControl', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const tab = await driver.$(element);
+                await tab.waitForDisplayed({ timeout: 30000 });
+                const target = await tab.$(`//*[text()="${item}"]`);
+                await target.click();
+                return;
+            }
+            throw new BaseError('selectInTabControl não suportado para esse elemento');
+        });
+    }
+    static async setValueTable(element, value, row, column, description = '', getSnapshot = false) {
+        return this.executarComLog('setValueTable', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const table = await driver.$(element);
+                await table.waitForDisplayed({ timeout: 30000 });
+                const headers = await table.$$('th');
+                let idx = -1;
+                for (let i = 0; i < (await headers.length); i++) {
+                    const txt = await headers[i].getText();
+                    if (txt.trim() === column) {
+                        idx = i + 1;
+                        break;
+                    }
+                }
+                if (idx === -1)
+                    throw new BaseError('Coluna não encontrada');
+                const cell = await table.$(`tr:nth-child(${row}) td:nth-child(${idx})`);
+                const input = await cell.$('input');
+                await input.setValue(value);
+                return;
+            }
+            throw new BaseError('setValueTable não suportado para esse elemento');
+        });
+    }
+    static async setStateCheckBox(element, checked, description = '', getSnapshot = false) {
+        return this.executarComLog('setStateCheckBox', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const cb = await driver.$(element);
+                await cb.waitForDisplayed({ timeout: 30000 });
+                const isChecked = await cb.isSelected();
+                if (isChecked !== checked) {
+                    await cb.click();
+                }
+                return;
+            }
+            throw new BaseError('setStateCheckBox não suportado para esse elemento');
+        });
+    }
+    static async implicitWait(element, timeOrDesc, descriptionOrGet, getSnapshot) {
+        return this.executarComLog('implicitWait', async () => {
+            const driver = this.ensureDriver();
+            let time = 120;
+            if (typeof timeOrDesc === 'number')
+                time = timeOrDesc;
+            if (driver && typeof element === 'string') {
+                await driver.$(element).waitForExist({ timeout: time * 1000 });
+                return;
+            }
+            throw new BaseError('implicitWait não suportado para esse elemento');
+        });
+    }
+    static async selectInList(element, text, description = '', getSnapshot = false) {
+        return this.executarComLog('selectInList', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const list = await driver.$(element);
+                await list.waitForDisplayed({ timeout: 30000 });
+                const item = await list.$(`//*[text()="${text}"]`);
+                await item.click();
+                return;
+            }
+            throw new BaseError('selectInList não suportado para esse elemento');
+        });
+    }
+    static async validateObject(element, arg1, arg2, arg3) {
+        // Suporta várias assinaturas
+        return this.executarComLog('validateObject', async () => {
+            const driver = this.ensureDriver();
+            let timeout = 0;
+            let expected = true;
+            if (typeof arg1 === 'number') {
+                timeout = arg1;
+            }
+            else if (typeof arg1 === 'boolean') {
+                expected = arg1;
+            }
+            if (typeof arg2 === 'number')
+                timeout = arg2;
+            if (driver && typeof element === 'string') {
+                if (timeout > 0) {
+                    try {
+                        await driver.$(element).waitForDisplayed({ timeout: timeout * 1000 });
+                        return expected;
+                    }
+                    catch {
+                        return !expected;
+                    }
+                }
+                try {
+                    const exists = await driver.$(element).isExisting();
+                    return exists === expected;
+                }
+                catch {
+                    return !expected;
+                }
+            }
+            throw new BaseError('validateObject não suportado para esse elemento');
+        });
+    }
+    static async setTextTable(element, row, columnHeader, value, description = '', getSnapshot = false) {
+        return this.setValueTable(element, value, row, columnHeader, description, getSnapshot);
+    }
+    static async getText(element, description = '', getSnapshot = false) {
+        return this.executarComLog('getText', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof element === 'string') {
+                const el = await driver.$(element);
+                await el.waitForDisplayed({ timeout: 30000 });
+                return el.getText();
+            }
+            throw new BaseError('getText não suportado para esse elemento');
+        });
+    }
+    static async getTextEditor(element, description = '', getSnapshot = false) {
+        return this.getText(element, description, getSnapshot);
+    }
+    static async getAttachedText(element, description = '', getSnapshot = false) {
+        return this.getText(element, description, getSnapshot);
+    }
+    static async getLabel(element, description = '', getSnapshot = false) {
+        return this.getText(element, description, getSnapshot);
+    }
+    static async selectOptionMenu(element, description = '', getSnapshot = false) {
+        return this.click(element, description, getSnapshot);
+    }
+    static async selectOptionSubMenu(element, path, description = '', getSnapshot = false) {
+        return this.selectInTreeView(element, path, description, getSnapshot);
+    }
+    static async closeWindow(element, description = '') {
+        return this.executarComLog('closeWindow', async () => {
+            const driver = this.ensureDriver();
+            if (driver) {
+                await driver.closeWindow();
+                return;
+            }
+            throw new BaseError('closeWindow requires driver');
+        });
+    }
+    static async maximizeWindow(description = '', getSnapshot = false) {
+        return this.executarComLog('maximizeWindow', async () => {
+            const driver = this.ensureDriver();
+            if (driver) {
+                await driver.maximizeWindow();
+                return;
+            }
+            throw new BaseError('maximizeWindow requires driver');
+        });
+    }
+    static async pressKey(key, description = '') {
+        return this.executarComLog('pressKey', async () => {
+            const driver = this.ensureDriver();
+            if (driver) {
+                await driver.pressKeyCode?.(key) || await driver.keys?.([String.fromCharCode(key)]);
+                return;
+            }
+            throw new BaseError('pressKey requires driver');
+        });
+    }
+    static async releaseKey(key, description = '') {
+        return this.executarComLog('releaseKey', async () => {
+            // WebDriverIO usually doesn't have releaseKey; simulate with keyUp if available
+            const driver = this.ensureDriver();
+            if (driver) {
+                await driver.releaseActions?.() || undefined;
+                return;
+            }
+            throw new BaseError('releaseKey requires driver');
+        });
+    }
+    static async waitForElementJavaToDisappear(object, time = 60) {
+        return this.executarComLog('waitForElementJavaToDisappear', async () => {
+            const driver = this.ensureDriver();
+            if (driver && typeof object === 'string') {
+                try {
+                    await driver.$(object).waitForExist({ timeout: time * 1000, reverse: true });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+            // Se não houver driver, não é possível verificar
+            return false;
+        });
+    }
+}
+export default DesktopActions;

package/dist/src/desktop/DesktopConnection.d.ts

@@ -0,0 +1,32 @@
+import { ChildProcess } from 'node:child_process';
+/**
+ * Gerencia conexão com o driver desktop (WebDriverIO) e execução do SikuliX
+ */
+export declare class DesktopConnection {
+    private static driver;
+    private static appProcess;
+    static setDriver(driver: WebdriverIO.Browser): void;
+    static getDriver(): WebdriverIO.Browser | null;
+    /**
+     * Executa um script SikuliX externo. O comando `sikulix` ou `runsikulix` deve
+     * estar disponível no PATH ou passe full path via env SIKULIX_CMD.
+     */
+    static runSikuliScript(scriptPath: string, args?: string[]): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    /**
+     * Inicia a aplicação desktop informada pelo caminho `appPath`.
+     * Retorna o objeto ChildProcess iniciado.
+     */
+    static startApp(appPath: string, args?: string[]): Promise<ChildProcess>;
+    /**
+     * Fecha a aplicação iniciada por `startApp`, se existir.
+     */
+    static closeApp(): Promise<void>;
+    /**
+     * Captura screenshot do driver WebDriverIO
+     */
+    static captureScreenshot(name?: string): Promise<Buffer | null>;
+}
+export default DesktopConnection;

package/dist/src/desktop/DesktopConnection.js

@@ -0,0 +1,84 @@
+import { execFile, spawn } from 'node:child_process';
+/**
+ * Gerencia conexão com o driver desktop (WebDriverIO) e execução do SikuliX
+ */
+export class DesktopConnection {
+    static driver = null;
+    static appProcess = null;
+    static setDriver(driver) {
+        this.driver = driver;
+    }
+    static getDriver() {
+        return this.driver;
+    }
+    /**
+     * Executa um script SikuliX externo. O comando `sikulix` ou `runsikulix` deve
+     * estar disponível no PATH ou passe full path via env SIKULIX_CMD.
+     */
+    static async runSikuliScript(scriptPath, args = []) {
+        return new Promise((resolve, reject) => {
+            const cmd = process.env.SIKULIX_CMD || 'runsikulix';
+            const params = ['-r', scriptPath, ...args];
+            execFile(cmd, params, { cwd: process.cwd(), env: process.env }, (err, stdout, stderr) => {
+                if (err)
+                    return reject({ err, stdout, stderr });
+                resolve({ stdout: String(stdout), stderr: String(stderr) });
+            });
+        });
+    }
+    /**
+     * Inicia a aplicação desktop informada pelo caminho `appPath`.
+     * Retorna o objeto ChildProcess iniciado.
+     */
+    static async startApp(appPath, args = []) {
+        if (!appPath)
+            throw new Error('appPath é obrigatório para startApp');
+        // Se já existe processo, retorna
+        if (this.appProcess && !this.appProcess.killed)
+            return this.appProcess;
+        const child = spawn(appPath, args, {
+            cwd: process.cwd(),
+            env: process.env,
+            detached: false,
+            stdio: 'ignore',
+        });
+        this.appProcess = child;
+        // Registrar listeners para limpar referência quando encerrar
+        child.on('exit', () => {
+            this.appProcess = null;
+        });
+        return child;
+    }
+    /**
+     * Fecha a aplicação iniciada por `startApp`, se existir.
+     */
+    static async closeApp() {
+        try {
+            if (this.appProcess && !this.appProcess.killed) {
+                this.appProcess.kill();
+                this.appProcess = null;
+            }
+        }
+        catch (e) {
+            // ignorar
+        }
+    }
+    /**
+     * Captura screenshot do driver WebDriverIO
+     */
+    static async captureScreenshot(name = 'desktop') {
+        try {
+            if (!this.driver)
+                return null;
+            const base64 = await this.driver.saveScreenshot();
+            if (typeof base64 === 'string') {
+                return Buffer.from(base64, 'base64');
+            }
+            return base64;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+export default DesktopConnection;

package/dist/src/domain/entities/TestExecution.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Entidade de domínio para execução de testes
+ * @module Domain/Entities
+ */
+/**
+ * Tipos de teste suportados pelo framework
+ */
+export declare enum TestType {
+    API = "api",
+    WEB = "web",
+    MOBILE = "mobile",
+    SSH = "ssh",
+    DATABASE = "database"
+}
+/**
+ * Status de execução do teste
+ */
+export declare enum TestStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    PASSED = "passed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+/**
+ * Resultado de um teste executado
+ */
+export interface TestResult {
+    readonly status: TestStatus;
+    readonly message?: string;
+    readonly error?: Error;
+    readonly duration: number;
+    readonly timestamp: Date;
+    readonly metadata?: Record<string, any>;
+}
+/**
+ * Especificação de um teste a ser executado
+ */
+export interface TestSpecification {
+    readonly name: string;
+    readonly type: TestType;
+    readonly description?: string;
+    readonly timeout?: number;
+    readonly retries?: number;
+    readonly tags?: string[];
+    readonly parameters: Record<string, any>;
+}
+/**
+ * Entidade principal para execução de testes
+ * Contém a lógica de negócio para gerenciar o ciclo de vida de um teste
+ */
+export declare class TestExecution {
+    readonly id: string;
+    readonly specification: TestSpecification;
+    private _status;
+    private _startTime?;
+    private _endTime?;
+    private _result?;
+    private _steps;
+    constructor(id: string, specification: TestSpecification);
+    /**
+     * Inicia a execução do teste
+     */
+    start(): void;
+    /**
+     * Adiciona um passo de execução
+     */
+    addStep(step: TestStep): void;
+    /**
+     * Completa a execução do teste com sucesso
+     */
+    complete(message?: string, metadata?: Record<string, any>): void;
+    /**
+     * Marca o teste como falhou
+     */
+    fail(error: Error, metadata?: Record<string, any>): void;
+    /**
+     * Pula a execução do teste
+     */
+    skip(reason?: string): void;
+    /**
+     * Status atual do teste
+     */
+    get status(): TestStatus;
+    /**
+     * Resultado da execução (disponível após conclusão)
+     */
+    get result(): TestResult | undefined;
+    /**
+     * Duração da execução em milissegundos
+     */
+    get duration(): number;
+    /**
+     * Passos executados durante o teste
+     */
+    get steps(): readonly TestStep[];
+    /**
+     * Verifica se o teste está em execução
+     */
+    get isRunning(): boolean;
+    /**
+     * Verifica se o teste foi concluído (passou, falhou ou foi pulado)
+     */
+    get isCompleted(): boolean;
+}
+/**
+ * Representa um passo individual na execução de um teste
+ */
+export interface TestStep {
+    readonly id: string;
+    readonly description: string;
+    readonly timestamp: Date;
+    readonly duration?: number;
+    readonly status: TestStatus;
+    readonly data?: any;
+    readonly error?: Error;
+}