@silasfmartins/testhub 1.0.0

package/dist/src/infrastructure/adapters/PlaywrightAdapter.js

@@ -0,0 +1,382 @@
+/**
+ * @fileoverview Adaptador Playwright para automação web seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ *
+ * 🎯 OBJETIVO: Abstrai Playwright com interface padronizada IWebDriver
+ * - ✅ Facilita futuras migrações de tecnologia web (Playwright → outras)
+ * - ✅ Padroniza métodos entre diferentes drivers web
+ * - ✅ Adiciona validação automática com Zod
+ * - ✅ Integra automaticamente com sistema de evidências
+ * - ✅ Compatível 100% com WebActions atuais
+ *
+ * 🔄 DIFERENÇA DO SELENIUM/WebDriver:
+ * - Selenium: Protocolo W3C WebDriver padrão, mais lento, sem recursos modernos
+ * - Playwright: API nativa moderna, mais rápido, recursos avançados (auto-wait, interceptação)
+ *
+ * 🏗️ ARQUITETURA DDD:
+ * - Domain Layer: Interface IWebDriver (contrato independente de tecnologia)
+ * - Infrastructure Layer: PlaywrightAdapter (implementação específica)
+ * - Application Layer: WebActions (mantém compatibilidade com código atual)
+ *
+ * 💡 BENEFÍCIOS DESTA ABSTRAÇÃO:
+ * - Possibilita trocar Playwright por Selenium/Puppeteer sem quebrar código
+ * - Adiciona validação que Playwright puro não tem
+ * - Integra automaticamente com coverage/evidências do AutoCore
+ * - Permite DI (Dependency Injection) para testes unitários
+ * - Facilita mocking e debugging
+ *
+ * EXEMPLO USO DIRETO (DDD):
+ * ```typescript
+ * const webDriver: IWebDriver = new PlaywrightAdapter(page)
+ * await webDriver.click('#submit') // Validação automática + evidências
+ * ```
+ *
+ * EXEMPLO USO ATUAL (continua funcionando):
+ * ```typescript
+ * import { WebActions } from '@silasfmartins/testhub'
+ * await WebActions.click('#submit') // Usa PlaywrightAdapter internamente
+ * ```
+ */
+import { SchemaValidator, SelectorSchema, TimeoutSchema, UrlSchema, ViewportSchema, } from '../../domain/schemas/ValidationSchemas.js';
+import { IntegrationError } from '../../functions/errors/IntegrationError.js';
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+/**
+ * Adaptador que integra Playwright com a arquitetura do AutoCore
+ * Implementa a interface IWebDriver usando Playwright como infraestrutura
+ */
+export class PlaywrightAdapter {
+    page;
+    context;
+    constructor(page, context) {
+        this.page = page;
+        this.context = context;
+        if (!page) {
+            throw ValidationError.missingRequiredParameter('page');
+        }
+    }
+    /**
+     * Navega para uma URL
+     */
+    async navigate(url, options = {}) {
+        try {
+            // Validação usando Zod
+            const validUrl = SchemaValidator.validate(UrlSchema, url);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            await this.page.goto(validUrl, {
+                timeout,
+                waitUntil: 'domcontentloaded',
+            });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.networkError(url, err);
+        }
+    }
+    /**
+     * Clica em um elemento
+     */
+    async click(selector, options = {}) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            const locator = this.page.locator(validSelector);
+            await locator.click({ timeout });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('click', `Falha ao clicar no elemento ${selector}`, err);
+        }
+    }
+    /**
+     * Preenche um campo
+     */
+    async fill(selector, value, options = {}) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            if (!value && value !== '') {
+                throw ValidationError.missingRequiredParameter('value');
+            }
+            const locator = this.page.locator(validSelector);
+            await locator.fill(value, { timeout });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('fill', `Falha ao preencher campo ${selector}`, err);
+        }
+    }
+    /**
+     * Obtém texto de um elemento
+     */
+    async getText(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            const text = await locator.textContent();
+            return text || '';
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getText', `Falha ao obter texto do elemento ${selector}`, err);
+        }
+    }
+    /**
+     * Obtém atributo de um elemento
+     */
+    async getAttribute(selector, attribute) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            if (!attribute.trim()) {
+                throw ValidationError.missingRequiredParameter('attribute');
+            }
+            const locator = this.page.locator(validSelector);
+            return await locator.getAttribute(attribute);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getAttribute', `Falha ao obter atributo ${attribute} do elemento ${selector}`, err);
+        }
+    }
+    /**
+     * Verifica se elemento está visível
+     */
+    async isVisible(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            return await locator.isVisible();
+        }
+        catch (error) {
+            return false; // Retorna false se elemento não existir
+        }
+    }
+    /**
+     * Verifica se elemento está habilitado
+     */
+    async isEnabled(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            return await locator.isEnabled();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Aguarda elemento ficar em estado específico
+     */
+    async waitForElement(selector, options = {}) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            const locator = this.page.locator(validSelector);
+            await locator.waitFor({
+                state: options.state || 'visible',
+                timeout,
+            });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.timeoutError(`waitForElement ${selector}`, options.timeout || 30_000);
+        }
+    }
+    /**
+     * Seleciona opção em dropdown
+     */
+    async selectOption(selector, value) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            if (!value && value !== '') {
+                throw ValidationError.missingRequiredParameter('value');
+            }
+            const locator = this.page.locator(validSelector);
+            await locator.selectOption(value);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('selectOption', `Falha ao selecionar opção ${value} em ${selector}`, err);
+        }
+    }
+    /**
+     * Hover sobre elemento
+     */
+    async hover(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            await locator.hover();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('hover', `Falha ao fazer hover em ${selector}`, err);
+        }
+    }
+    /**
+     * Duplo clique
+     */
+    async doubleClick(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            await locator.dblclick();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('doubleClick', `Falha ao fazer duplo clique em ${selector}`, err);
+        }
+    }
+    /**
+     * Clique com botão direito
+     */
+    async rightClick(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const locator = this.page.locator(validSelector);
+            await locator.click({ button: 'right' });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('rightClick', `Falha ao fazer clique direito em ${selector}`, err);
+        }
+    }
+    /**
+     * Captura screenshot
+     */
+    async screenshot(options = {}) {
+        try {
+            return await this.page.screenshot({
+                path: options.path,
+                fullPage: options.fullPage !== false,
+            });
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('screenshot', 'Falha ao capturar screenshot', err);
+        }
+    }
+    /**
+     * Define tamanho do viewport
+     */
+    async setViewport(width, height) {
+        try {
+            const viewport = SchemaValidator.validate(ViewportSchema, {
+                width,
+                height,
+            });
+            await this.page.setViewportSize(viewport);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('setViewport', `Falha ao definir viewport ${width}x${height}`, err);
+        }
+    }
+    /**
+     * Executa JavaScript na página
+     */
+    async evaluateScript(script) {
+        try {
+            if (!script.trim()) {
+                throw ValidationError.missingRequiredParameter('script');
+            }
+            return await this.page.evaluate(script);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('evaluateScript', 'Falha ao executar JavaScript', err);
+        }
+    }
+    /**
+     * Voltar página
+     */
+    async goBack() {
+        try {
+            await this.page.goBack();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('goBack', 'Falha ao voltar página', err);
+        }
+    }
+    /**
+     * Avançar página
+     */
+    async goForward() {
+        try {
+            await this.page.goForward();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('goForward', 'Falha ao avançar página', err);
+        }
+    }
+    /**
+     * Recarregar página
+     */
+    async reload() {
+        try {
+            await this.page.reload();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('reload', 'Falha ao recarregar página', err);
+        }
+    }
+    /**
+     * Obtém URL atual
+     */
+    async getCurrentUrl() {
+        try {
+            return this.page.url();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getCurrentUrl', 'Falha ao obter URL atual', err);
+        }
+    }
+    /**
+     * Obtém título da página
+     */
+    async getTitle() {
+        try {
+            return await this.page.title();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getTitle', 'Falha ao obter título da página', err);
+        }
+    }
+    /**
+     * Fecha a página
+     */
+    async close() {
+        try {
+            await this.page.close();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('close', 'Falha ao fechar página', err);
+        }
+    }
+    /**
+     * Obtém a instância do Page do Playwright
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getPage() {
+        return this.page;
+    }
+    /**
+     * Obtém o contexto do browser
+     */
+    getContext() {
+        return this.context;
+    }
+}

package/dist/src/infrastructure/adapters/SSHAdapter.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview Adaptador SSH para execução remota seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+/**
+ * Credenciais SSH validadas pelo Zod
+ */
+export interface SSHCredentials {
+    host: string;
+    port: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+}
+/**
+ * Resultado de execução de comando SSH
+ */
+export interface SSHResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    command: string;
+    timestamp: Date;
+}
+/**
+ * Interface para clientes SSH
+ */
+export interface ISSHClient {
+    connect(credentials: SSHCredentials): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    executeCommand(command: string, options?: {
+        timeout?: number;
+        cwd?: string;
+    }): Promise<SSHResult>;
+    uploadFile(localPath: string, remotePath: string): Promise<void>;
+    downloadFile(remotePath: string, localPath: string): Promise<void>;
+    createDirectory(remotePath: string, recursive?: boolean): Promise<void>;
+    removeFile(remotePath: string): Promise<void>;
+    removeDirectory(remotePath: string, recursive?: boolean): Promise<void>;
+    fileExists(remotePath: string): Promise<boolean>;
+    getFileInfo(remotePath: string): Promise<{
+        size: number;
+        modified: Date;
+        isDirectory: boolean;
+    }>;
+    listDirectory(remotePath: string): Promise<string[]>;
+}
+/**
+ * Adaptador que integra node-ssh com a arquitetura do AutoCore
+ * Implementa a interface ISSHClient usando node-ssh
+ */
+export declare class SSHAdapter implements ISSHClient {
+    private ssh;
+    private connected;
+    private connectionInfo;
+    constructor();
+    /**
+     * Conecta ao servidor SSH
+     */
+    connect(credentials: SSHCredentials): Promise<void>;
+    /**
+     * Desconecta do servidor SSH
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Verifica se está conectado
+     */
+    isConnected(): boolean;
+    /**
+     * Executa comando no servidor remoto
+     */
+    executeCommand(command: string, options?: {
+        timeout?: number;
+        cwd?: string;
+    }): Promise<SSHResult>;
+    /**
+     * Faz upload de arquivo para o servidor
+     */
+    uploadFile(localPath: string, remotePath: string): Promise<void>;
+    /**
+     * Faz download de arquivo do servidor
+     */
+    downloadFile(remotePath: string, localPath: string): Promise<void>;
+    /**
+     * Cria diretório no servidor
+     */
+    createDirectory(remotePath: string, recursive?: boolean): Promise<void>;
+    /**
+     * Remove arquivo do servidor
+     */
+    removeFile(remotePath: string): Promise<void>;
+    /**
+     * Remove diretório do servidor
+     */
+    removeDirectory(remotePath: string, recursive?: boolean): Promise<void>;
+    /**
+     * Verifica se arquivo existe no servidor
+     */
+    fileExists(remotePath: string): Promise<boolean>;
+    /**
+     * Obtém informações de arquivo/diretório
+     */
+    getFileInfo(remotePath: string): Promise<{
+        size: number;
+        modified: Date;
+        isDirectory: boolean;
+    }>;
+    /**
+     * Lista conteúdo de diretório
+     */
+    listDirectory(remotePath: string): Promise<string[]>;
+    /**
+     * Obtém informações da conexão atual
+     */
+    getConnectionInfo(): SSHCredentials | null;
+    /**
+     * Obtém a instância do NodeSSH
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getSSHClient(): any;
+    /**
+     * Executa múltiplos comandos em sequência
+     */
+    executeCommandSequence(commands: string[], options?: {
+        stopOnError?: boolean;
+        timeout?: number;
+        cwd?: string;
+    }): Promise<SSHResult[]>;
+    /**
+     * Executa script local no servidor remoto
+     */
+    executeScript(scriptContent: string, options?: {
+        interpreter?: string;
+        args?: string[];
+        timeout?: number;
+        cwd?: string;
+    }): Promise<SSHResult>;
+}