@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,468 @@
+/**
+ * @fileoverview Adaptador Appium para automação móvel seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+import { MobileDeviceSchema, SchemaValidator, SelectorSchema, TimeoutSchema, } from '../../domain/schemas/ValidationSchemas.js';
+import { IntegrationError } from '../../functions/errors/IntegrationError.js';
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+/**
+ * Adaptador que integra Appium com a arquitetura do AutoCore
+ * Implementa a interface IMobileDriver usando WebDriverIO
+ */
+export class AppiumAdapter {
+    driver;
+    deviceConfig;
+    constructor(driver, // WebDriverIO instance
+    deviceConfig) {
+        this.driver = driver;
+        this.deviceConfig = deviceConfig;
+        if (!driver) {
+            throw ValidationError.missingRequiredParameter('driver');
+        }
+        // Valida configuração do dispositivo
+        if (deviceConfig) {
+            SchemaValidator.validate(MobileDeviceSchema, deviceConfig);
+        }
+    }
+    /**
+     * Toca em um elemento
+     */
+    async tap(selector, options = {}) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed({ timeout });
+            await element.click();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('tap', `Falha ao tocar no elemento ${selector}`, err);
+        }
+    }
+    /**
+     * Duplo toque em um elemento
+     */
+    async doubleTap(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            await element.doubleClick();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('doubleTap', `Falha ao fazer duplo toque em ${selector}`, err);
+        }
+    }
+    /**
+     * Pressão longa em um elemento
+     */
+    async longPress(selector, duration = 1000) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            // WebDriverIO touch action
+            await this.driver.touchAction([
+                { action: 'press', element },
+                { action: 'wait', ms: duration },
+                { action: 'release' },
+            ]);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('longPress', `Falha ao fazer pressão longa em ${selector}`, err);
+        }
+    }
+    /**
+     * Desliza de um elemento para outro
+     */
+    async swipe(startSelector, endSelector) {
+        try {
+            const validStartSelector = SchemaValidator.validate(SelectorSchema, startSelector);
+            const validEndSelector = SchemaValidator.validate(SelectorSchema, endSelector);
+            const startElement = await this.driver.$(validStartSelector);
+            const endElement = await this.driver.$(validEndSelector);
+            await startElement.waitForDisplayed();
+            await endElement.waitForDisplayed();
+            const startLocation = await startElement.getLocation();
+            const endLocation = await endElement.getLocation();
+            await this.swipeByCoordinates(startLocation.x, startLocation.y, endLocation.x, endLocation.y);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('swipe', `Falha ao deslizar de ${startSelector} para ${endSelector}`, err);
+        }
+    }
+    /**
+     * Desliza por coordenadas
+     */
+    async swipeByCoordinates(startX, startY, endX, endY) {
+        try {
+            await this.driver.touchAction([
+                { action: 'press', x: startX, y: startY },
+                { action: 'wait', ms: 300 },
+                { action: 'moveTo', x: endX, y: endY },
+                { action: 'release' },
+            ]);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('swipeByCoordinates', `Falha ao deslizar de (${startX},${startY}) para (${endX},${endY})`, err);
+        }
+    }
+    /**
+     * Rola a tela em uma direção
+     */
+    async scroll(direction, distance = 500) {
+        try {
+            const windowSize = await this.driver.getWindowSize();
+            const centerX = windowSize.width / 2;
+            const centerY = windowSize.height / 2;
+            let startX = centerX, startY = centerY, endX = centerX, endY = centerY;
+            switch (direction) {
+                case 'up':
+                    startY = centerY + distance / 2;
+                    endY = centerY - distance / 2;
+                    break;
+                case 'down':
+                    startY = centerY - distance / 2;
+                    endY = centerY + distance / 2;
+                    break;
+                case 'left':
+                    startX = centerX + distance / 2;
+                    endX = centerX - distance / 2;
+                    break;
+                case 'right':
+                    startX = centerX - distance / 2;
+                    endX = centerX + distance / 2;
+                    break;
+            }
+            await this.swipeByCoordinates(startX, startY, endX, endY);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('scroll', `Falha ao rolar ${direction}`, err);
+        }
+    }
+    /**
+     * Envia texto para um elemento
+     */
+    async sendKeys(selector, text) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            if (!text && text !== '') {
+                throw ValidationError.missingRequiredParameter('text');
+            }
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            await element.setValue(text);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('sendKeys', `Falha ao enviar texto para ${selector}`, err);
+        }
+    }
+    /**
+     * Limpa texto de um elemento
+     */
+    async clearText(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            await element.clearValue();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('clearText', `Falha ao limpar texto de ${selector}`, err);
+        }
+    }
+    /**
+     * Esconde o teclado
+     */
+    async hideKeyboard() {
+        try {
+            await this.driver.hideKeyboard();
+        }
+        catch (error) {
+            // Ignorar erro se teclado não estiver visível
+            // Isso é normal em muitos casos
+        }
+    }
+    /**
+     * Obtém texto de um elemento
+     */
+    async getText(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            return await element.getText();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getText', `Falha ao obter texto de ${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 element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            return await element.getAttribute(attribute);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getAttribute', `Falha ao obter atributo ${attribute} de ${selector}`, err);
+        }
+    }
+    /**
+     * Verifica se elemento está visível
+     */
+    async isDisplayed(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            return await element.isDisplayed();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Verifica se elemento está habilitado
+     */
+    async isEnabled(selector) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            return await element.isEnabled();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Aguarda elemento ficar em condição específica
+     */
+    async waitForElement(selector, options = {}) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const timeout = options.timeout
+                ? SchemaValidator.validate(TimeoutSchema, options.timeout)
+                : 30_000;
+            const element = await this.driver.$(validSelector);
+            switch (options.condition || 'visible') {
+                case 'visible':
+                    await element.waitForDisplayed({ timeout });
+                    break;
+                case 'clickable':
+                    await element.waitForClickable({ timeout });
+                    break;
+                case 'exists':
+                    await element.waitForExist({ timeout });
+                    break;
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.timeoutError(`waitForElement ${selector}`, options.timeout || 30_000);
+        }
+    }
+    /**
+     * Gesto de pinça (reduzir)
+     */
+    async pinch(selector, scale) {
+        try {
+            const validSelector = SchemaValidator.validate(SelectorSchema, selector);
+            const element = await this.driver.$(validSelector);
+            await element.waitForDisplayed();
+            // WebDriverIO multi-touch para pinch
+            const location = await element.getLocation();
+            const size = await element.getSize();
+            const centerX = location.x + size.width / 2;
+            const centerY = location.y + size.height / 2;
+            const distance = Math.min(size.width, size.height) / 4;
+            await this.driver.multiTouchAction([
+                [
+                    { action: 'press', x: centerX - distance, y: centerY },
+                    { action: 'wait', ms: 300 },
+                    { action: 'moveTo', x: centerX - distance * scale, y: centerY },
+                    { action: 'release' },
+                ],
+                [
+                    { action: 'press', x: centerX + distance, y: centerY },
+                    { action: 'wait', ms: 300 },
+                    { action: 'moveTo', x: centerX + distance * scale, y: centerY },
+                    { action: 'release' },
+                ],
+            ]);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('pinch', `Falha ao fazer pinch em ${selector}`, err);
+        }
+    }
+    /**
+     * Gesto de zoom (ampliar)
+     */
+    async zoom(selector, scale) {
+        // Zoom é o inverso do pinch
+        await this.pinch(selector, 1 / scale);
+    }
+    /**
+     * Rotaciona dispositivo
+     */
+    async rotate(orientation) {
+        try {
+            await this.driver.setOrientation(orientation.toUpperCase());
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('rotate', `Falha ao rotacionar para ${orientation}`, err);
+        }
+    }
+    /**
+     * Muda para contexto WebView
+     */
+    async switchToWebView() {
+        try {
+            const contexts = await this.driver.getContexts();
+            const webviewContext = contexts.find((context) => context.includes('WEBVIEW'));
+            if (webviewContext) {
+                await this.driver.switchContext(webviewContext);
+            }
+            else {
+                throw new Error('WebView context não encontrado');
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('switchToWebView', 'Falha ao mudar para WebView', err);
+        }
+    }
+    /**
+     * Muda para contexto nativo
+     */
+    async switchToNativeApp() {
+        try {
+            await this.driver.switchContext('NATIVE_APP');
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('switchToNativeApp', 'Falha ao mudar para contexto nativo', err);
+        }
+    }
+    /**
+     * Obtém activity atual (Android)
+     */
+    async getCurrentActivity() {
+        try {
+            return await this.driver.getCurrentActivity();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getCurrentActivity', 'Falha ao obter activity atual', err);
+        }
+    }
+    /**
+     * Abre a aplicação
+     */
+    async launchApp() {
+        try {
+            await this.driver.launchApp();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('launchApp', 'Falha ao abrir aplicação', err);
+        }
+    }
+    /**
+     * Fecha a aplicação
+     */
+    async closeApp() {
+        try {
+            await this.driver.closeApp();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('closeApp', 'Falha ao fechar aplicação', err);
+        }
+    }
+    /**
+     * Reseta a aplicação
+     */
+    async resetApp() {
+        try {
+            await this.driver.reset();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('resetApp', 'Falha ao resetar aplicação', err);
+        }
+    }
+    /**
+     * Captura screenshot
+     */
+    async screenshot(path) {
+        try {
+            const screenshot = await this.driver.takeScreenshot();
+            const buffer = Buffer.from(screenshot, 'base64');
+            if (path) {
+                const fs = await import('fs/promises');
+                await fs.writeFile(path, buffer);
+            }
+            return buffer;
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('screenshot', 'Falha ao capturar screenshot', err);
+        }
+    }
+    /**
+     * Obtém código fonte da página
+     */
+    async getPageSource() {
+        try {
+            return await this.driver.getPageSource();
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('getPageSource', 'Falha ao obter código fonte', err);
+        }
+    }
+    /**
+     * Encerra o driver
+     */
+    async quit() {
+        try {
+            await this.driver.deleteSession();
+        }
+        catch {
+            // Best-effort: session may already be closed
+        }
+    }
+    /**
+     * Obtém a instância do WebDriverIO
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getDriver() {
+        return this.driver;
+    }
+    /**
+     * Obtém configuração do dispositivo
+     */
+    getDeviceConfig() {
+        return this.deviceConfig;
+    }
+}

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

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Adaptador Oracle para operações de banco de dados seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+/**
+ * Configuração de conexão com banco Oracle
+ */
+export interface OracleConfig {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+    connectionTimeout?: number;
+    queryTimeout?: number;
+    poolMin?: number;
+    poolMax?: number;
+}
+/**
+ * Resultado de consulta SQL
+ */
+export interface QueryResult {
+    rows: any[];
+    rowCount: number;
+    columns: string[];
+    executionTime: number;
+    query: string;
+    parameters?: any[];
+}
+/**
+ * Interface para clientes de banco de dados
+ */
+export interface IDatabaseClient {
+    connect(config: OracleConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(sql: string, parameters?: any[]): Promise<QueryResult>;
+    queryOne<T = any>(sql: string, parameters?: any[]): Promise<T | null>;
+    queryMany<T = any>(sql: string, parameters?: any[]): Promise<T[]>;
+    execute(sql: string, parameters?: any[]): Promise<{
+        affectedRows: number;
+        lastInsertId?: any;
+    }>;
+    executeBatch(sql: string, parametersArray: any[][]): Promise<{
+        affectedRows: number[];
+    }>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    testConnection(): Promise<boolean>;
+    getConnectionInfo(): OracleConfig | null;
+    executeScript(scriptPath: string): Promise<void>;
+    callProcedure(procedureName: string, parameters?: any[]): Promise<any>;
+    callFunction(functionName: string, parameters?: any[]): Promise<any>;
+}
+/**
+ * Adaptador que integra oracledb com a arquitetura do AutoCore
+ * Implementa a interface IDatabaseClient usando oracledb
+ */
+export declare class OracleAdapter implements IDatabaseClient {
+    private connection;
+    private pool;
+    private oracledb;
+    private connected;
+    private connectionConfig;
+    private inTransaction;
+    constructor();
+    /**
+     * Conecta ao banco Oracle
+     */
+    connect(config: OracleConfig): Promise<void>;
+    /**
+     * Desconecta do banco
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Verifica se está conectado
+     */
+    isConnected(): boolean;
+    /**
+     * Executa uma consulta SQL
+     */
+    query(sql: string, parameters?: any[]): Promise<QueryResult>;
+    /**
+     * Executa consulta e retorna um registro
+     */
+    queryOne<T = any>(sql: string, parameters?: any[]): Promise<T | null>;
+    /**
+     * Executa consulta e retorna múltiplos registros
+     */
+    queryMany<T = any>(sql: string, parameters?: any[]): Promise<T[]>;
+    /**
+     * Executa comando SQL (INSERT, UPDATE, DELETE)
+     */
+    execute(sql: string, parameters?: any[]): Promise<{
+        affectedRows: number;
+        lastInsertId?: any;
+    }>;
+    /**
+     * Executa múltiplos comandos em lote
+     */
+    executeBatch(sql: string, parametersArray: any[][]): Promise<{
+        affectedRows: number[];
+    }>;
+    /**
+     * Inicia transação
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Confirma transação
+     */
+    commit(): Promise<void>;
+    /**
+     * Desfaz transação
+     */
+    rollback(): Promise<void>;
+    /**
+     * Testa conexão com o banco
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * Obtém informações da conexão
+     */
+    getConnectionInfo(): OracleConfig | null;
+    /**
+     * Executa script SQL de arquivo
+     */
+    executeScript(scriptPath: string): Promise<void>;
+    /**
+     * Chama procedure armazenada
+     */
+    callProcedure(procedureName: string, parameters?: any[]): Promise<any>;
+    /**
+     * Chama função armazenada
+     */
+    callFunction(functionName: string, parameters?: any[]): Promise<any>;
+    /**
+     * Obtém a instância da conexão Oracle
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getConnection(): any;
+    /**
+     * Obtém o pool de conexões
+     */
+    getPool(): any;
+    /**
+     * Executa consulta com cursor (para grandes volumes)
+     */
+    queryWithCursor<T = any>(sql: string, parameters?: any[], batchSize?: number): AsyncGenerator<T[], void, unknown>;
+}