@silasfmartins/testhub 1.0.0

package/dist/src/infrastructure/DependencyContainer.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Container de Injeção de Dependência para AutoCore
+ * @module Infrastructure/DI
+ */
+import type { BrowserContext, Page } from '@playwright/test';
+import { type IMobileDriver } from './adapters/AppiumAdapter.js';
+import { type IDatabaseClient } from './adapters/OracleAdapter.js';
+import { type IWebDriver } from './adapters/PlaywrightAdapter.js';
+import { type ISSHClient } from './adapters/SSHAdapter.js';
+/**
+ * Tipos de serviços disponíveis no container
+ */
+export type ServiceType = 'webDriver' | 'mobileDriver' | 'sshClient' | 'databaseClient' | 'testExecutionService' | 'reportGenerationService' | 'configurationService';
+/**
+ * Mapa de tipos para interfaces
+ */
+export interface ServiceMap {
+    webDriver: IWebDriver;
+    mobileDriver: IMobileDriver;
+    sshClient: ISSHClient;
+    databaseClient: IDatabaseClient;
+    testExecutionService: unknown;
+    reportGenerationService: unknown;
+    configurationService: unknown;
+}
+/**
+ * Factory function para criação de serviços
+ */
+export type ServiceFactory<T = unknown> = (container: DIContainer) => T | Promise<T>;
+/**
+ * Configuração de registro de serviço
+ */
+export interface ServiceRegistration<T = unknown> {
+    factory: ServiceFactory<T>;
+    singleton: boolean;
+    dependencies?: ServiceType[];
+}
+/**
+ * Container de Injeção de Dependência
+ * Implementa padrão Service Locator com injeção de dependência
+ */
+export declare class DIContainer {
+    private services;
+    private instances;
+    private resolving;
+    /**
+     * Registra um serviço no container
+     */
+    register<K extends ServiceType>(type: K, factory: ServiceFactory<ServiceMap[K]>, options?: {
+        singleton?: boolean;
+        dependencies?: ServiceType[];
+    }): void;
+    /**
+     * Registra uma instância já criada
+     */
+    registerInstance<K extends ServiceType>(type: K, instance: ServiceMap[K]): void;
+    /**
+     * Resolve um serviço do container
+     */
+    resolve<K extends ServiceType>(type: K): Promise<ServiceMap[K]>;
+    /**
+     * Verifica se um serviço está registrado
+     */
+    hasService(type: ServiceType): boolean;
+    /**
+     * Remove um serviço do container
+     */
+    unregister(type: ServiceType): void;
+    /**
+     * Limpa todas as instâncias (mantém registros)
+     */
+    clearInstances(): void;
+    /**
+     * Limpa todo o container
+     */
+    clear(): void;
+    /**
+     * Lista todos os serviços registrados
+     */
+    getRegisteredServices(): ServiceType[];
+    /**
+     * Cria um escopo filho do container
+     * Útil para isolar instâncias por teste ou contexto
+     */
+    createScope(): DIContainer;
+}
+/**
+ * Configurador de serviços padrão do AutoCore
+ */
+export declare class AutoCoreServiceConfigurator {
+    /**
+     * Configura todos os serviços padrão no container
+     */
+    static configure(container: DIContainer): void;
+    /**
+     * Configura container para testes web com Playwright
+     */
+    static configureForWeb(container: DIContainer, page: Page, context?: BrowserContext): void;
+    /**
+     * Configura container para testes móveis com Appium
+     */
+    static configureForMobile(container: DIContainer, driver: unknown, deviceConfig?: Record<string, unknown>): void;
+    /**
+     * Configura container para testes com SSH
+     */
+    static configureForSSH(container: DIContainer, credentials: {
+        host: string;
+        port: number;
+        username: string;
+        password?: string;
+        privateKey?: string;
+    }): Promise<void>;
+    /**
+     * Configura container para testes com Oracle
+     */
+    static configureForDatabase(container: DIContainer, config: {
+        host: string;
+        port: number;
+        database: string;
+        username: string;
+        password: string;
+    }): Promise<void>;
+}
+/**
+ * Container global padrão
+ * Pode ser usado para casos simples, mas recomenda-se criar instâncias específicas
+ */
+export declare const defaultContainer: DIContainer;
+/**
+ * Decorator para injeção de dependência em classes
+ */
+export declare function Injectable<T extends new (...args: any[]) => any>(dependencies?: ServiceType[]): (target: T) => T;
+/**
+ * Decorator para propriedades que devem ser injetadas
+ */
+export declare function Inject(serviceType: ServiceType): (target: any, propertyKey: string) => void;
+/**
+ * Utilitário para resolver dependências em funções
+ */
+export declare function resolveDependencies<T extends ServiceType[]>(container: DIContainer, ...serviceTypes: T): Promise<{
+    [K in keyof T]: ServiceMap[T[K]];
+}>;

package/dist/src/infrastructure/DependencyContainer.js

@@ -0,0 +1,250 @@
+/**
+ * @fileoverview Container de Injeção de Dependência para AutoCore
+ * @module Infrastructure/DI
+ */
+import { ValidationError } from '../functions/errors/ValidationError.js';
+import { AppiumAdapter } from './adapters/AppiumAdapter.js';
+import { OracleAdapter, } from './adapters/OracleAdapter.js';
+import { PlaywrightAdapter, } from './adapters/PlaywrightAdapter.js';
+import { SSHAdapter } from './adapters/SSHAdapter.js';
+/**
+ * Container de Injeção de Dependência
+ * Implementa padrão Service Locator com injeção de dependência
+ */
+export class DIContainer {
+    services = new Map();
+    instances = new Map();
+    resolving = new Set();
+    /**
+     * Registra um serviço no container
+     */
+    register(type, factory, options = {}) {
+        const registration = {
+            factory,
+            singleton: options.singleton !== false, // Default para singleton
+            dependencies: options.dependencies || [],
+        };
+        this.services.set(type, registration);
+    }
+    /**
+     * Registra uma instância já criada
+     */
+    registerInstance(type, instance) {
+        this.instances.set(type, instance);
+        this.register(type, () => instance, { singleton: true });
+    }
+    /**
+     * Resolve um serviço do container
+     */
+    async resolve(type) {
+        // Verificar dependência circular
+        if (this.resolving.has(type)) {
+            throw ValidationError.invalidConfiguration('dependency', `Dependência circular detectada para serviço: ${type}`);
+        }
+        // Retornar instância singleton se existir
+        if (this.instances.has(type)) {
+            return this.instances.get(type);
+        }
+        // Verificar se serviço está registrado
+        const registration = this.services.get(type);
+        if (!registration) {
+            throw ValidationError.invalidConfiguration('service', `Serviço não registrado: ${type}`);
+        }
+        this.resolving.add(type);
+        try {
+            // Resolver dependências primeiro
+            const dependencies = [];
+            if (registration.dependencies) {
+                for (const depType of registration.dependencies) {
+                    const dependency = await this.resolve(depType);
+                    dependencies.push(dependency);
+                }
+            }
+            // Criar instância
+            const instance = await registration.factory(this);
+            // Armazenar se for singleton
+            if (registration.singleton) {
+                this.instances.set(type, instance);
+            }
+            return instance;
+        }
+        finally {
+            this.resolving.delete(type);
+        }
+    }
+    /**
+     * Verifica se um serviço está registrado
+     */
+    hasService(type) {
+        return this.services.has(type);
+    }
+    /**
+     * Remove um serviço do container
+     */
+    unregister(type) {
+        this.services.delete(type);
+        this.instances.delete(type);
+    }
+    /**
+     * Limpa todas as instâncias (mantém registros)
+     */
+    clearInstances() {
+        this.instances.clear();
+    }
+    /**
+     * Limpa todo o container
+     */
+    clear() {
+        this.services.clear();
+        this.instances.clear();
+        this.resolving.clear();
+    }
+    /**
+     * Lista todos os serviços registrados
+     */
+    getRegisteredServices() {
+        return Array.from(this.services.keys());
+    }
+    /**
+     * Cria um escopo filho do container
+     * Útil para isolar instâncias por teste ou contexto
+     */
+    createScope() {
+        const scope = new DIContainer();
+        // Copiar registros (mas não instâncias)
+        for (const [type, registration] of this.services) {
+            scope.services.set(type, registration);
+        }
+        return scope;
+    }
+}
+/**
+ * Configurador de serviços padrão do AutoCore
+ */
+export class AutoCoreServiceConfigurator {
+    /**
+     * Configura todos os serviços padrão no container
+     */
+    static configure(container) {
+        // Registrar adaptadores de infraestrutura
+        container.register('webDriver', () => {
+            throw ValidationError.invalidConfiguration('webDriver', 'WebDriver deve ser configurado com instância específica');
+        }, { singleton: true });
+        container.register('mobileDriver', () => {
+            throw ValidationError.invalidConfiguration('mobileDriver', 'MobileDriver deve ser configurado com instância específica');
+        }, { singleton: true });
+        container.register('sshClient', () => new SSHAdapter(), { singleton: true });
+        container.register('databaseClient', () => new OracleAdapter(), {
+            singleton: true,
+        });
+        // Registrar serviços de aplicação (placeholders até implementarmos)
+        container.register('testExecutionService', async (c) => {
+            const webDriver = await c.resolve('webDriver');
+            const mobileDriver = await c.resolve('mobileDriver');
+            // Placeholder - será implementado na próxima etapa
+            return {
+                webDriver,
+                mobileDriver,
+                execute: async (_testConfig) => {
+                    // placeholder
+                },
+            };
+        }, {
+            singleton: false, // Novo serviço por execução
+            dependencies: ['webDriver', 'mobileDriver'],
+        });
+        container.register('reportGenerationService', async (_c) => {
+            // Placeholder - será implementado na próxima etapa
+            return {
+                generateReport: async (_results) => {
+                    // placeholder
+                },
+            };
+        }, { singleton: true });
+        container.register('configurationService', () => {
+            // Placeholder - será implementado na próxima etapa
+            return {
+                getConfig: (_key) => {
+                    return null;
+                },
+            };
+        }, { singleton: true });
+    }
+    /**
+     * Configura container para testes web com Playwright
+     */
+    static configureForWeb(container, page, context) {
+        const webDriver = new PlaywrightAdapter(page, context);
+        container.registerInstance('webDriver', webDriver);
+    }
+    /**
+     * Configura container para testes móveis com Appium
+     */
+    static configureForMobile(container, driver, deviceConfig) {
+        const mobileDriver = new AppiumAdapter(driver, deviceConfig);
+        container.registerInstance('mobileDriver', mobileDriver);
+    }
+    /**
+     * Configura container para testes com SSH
+     */
+    static async configureForSSH(container, credentials) {
+        const sshClient = new SSHAdapter();
+        await sshClient.connect(credentials);
+        container.registerInstance('sshClient', sshClient);
+    }
+    /**
+     * Configura container para testes com Oracle
+     */
+    static async configureForDatabase(container, config) {
+        const databaseClient = new OracleAdapter();
+        await databaseClient.connect(config);
+        container.registerInstance('databaseClient', databaseClient);
+    }
+}
+/**
+ * Container global padrão
+ * Pode ser usado para casos simples, mas recomenda-se criar instâncias específicas
+ */
+export const defaultContainer = new DIContainer();
+// Configurar serviços padrão
+AutoCoreServiceConfigurator.configure(defaultContainer);
+/**
+ * Decorator para injeção de dependência em classes
+ */
+export function Injectable(dependencies = []) {
+    return (target) => class extends target {
+        constructor(...args) {
+            super(...args);
+            // Adicionar metadados de dependências
+            Object.defineProperty(this, '__dependencies', {
+                value: dependencies,
+                writable: false,
+                enumerable: false,
+            });
+        }
+    };
+}
+/**
+ * Decorator para propriedades que devem ser injetadas
+ */
+export function Inject(serviceType) {
+    return (target, propertyKey) => {
+        Object.defineProperty(target, propertyKey, {
+            get() {
+                if (!this.__container) {
+                    throw ValidationError.invalidConfiguration('injection', `Container não configurado para classe ${target.constructor.name}`);
+                }
+                return this.__container.resolve(serviceType);
+            },
+            enumerable: true,
+            configurable: false,
+        });
+    };
+}
+/**
+ * Utilitário para resolver dependências em funções
+ */
+export async function resolveDependencies(container, ...serviceTypes) {
+    const resolved = await Promise.all(serviceTypes.map((type) => container.resolve(type)));
+    return resolved;
+}

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

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview Adaptador Appium para automação móvel seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+/**
+ * Interface para drivers móveis
+ */
+export interface IMobileDriver {
+    tap(selector: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    doubleTap(selector: string): Promise<void>;
+    longPress(selector: string, duration?: number): Promise<void>;
+    swipe(startSelector: string, endSelector: string): Promise<void>;
+    swipeByCoordinates(startX: number, startY: number, endX: number, endY: number): Promise<void>;
+    scroll(direction: 'up' | 'down' | 'left' | 'right', distance?: number): Promise<void>;
+    sendKeys(selector: string, text: string): Promise<void>;
+    clearText(selector: string): Promise<void>;
+    hideKeyboard(): Promise<void>;
+    getText(selector: string): Promise<string>;
+    getAttribute(selector: string, attribute: string): Promise<string | null>;
+    isDisplayed(selector: string): Promise<boolean>;
+    isEnabled(selector: string): Promise<boolean>;
+    waitForElement(selector: string, options?: {
+        timeout?: number;
+        condition?: 'visible' | 'clickable' | 'exists';
+    }): Promise<void>;
+    pinch(selector: string, scale: number): Promise<void>;
+    zoom(selector: string, scale: number): Promise<void>;
+    rotate(orientation: 'portrait' | 'landscape'): Promise<void>;
+    switchToWebView(): Promise<void>;
+    switchToNativeApp(): Promise<void>;
+    getCurrentActivity(): Promise<string>;
+    launchApp(): Promise<void>;
+    closeApp(): Promise<void>;
+    resetApp(): Promise<void>;
+    screenshot(path?: string): Promise<Buffer>;
+    getPageSource(): Promise<string>;
+    quit(): Promise<void>;
+}
+/**
+ * Adaptador que integra Appium com a arquitetura do AutoCore
+ * Implementa a interface IMobileDriver usando WebDriverIO
+ */
+export declare class AppiumAdapter implements IMobileDriver {
+    private driver;
+    private deviceConfig;
+    constructor(driver: any, // WebDriverIO instance
+    deviceConfig: any);
+    /**
+     * Toca em um elemento
+     */
+    tap(selector: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Duplo toque em um elemento
+     */
+    doubleTap(selector: string): Promise<void>;
+    /**
+     * Pressão longa em um elemento
+     */
+    longPress(selector: string, duration?: number): Promise<void>;
+    /**
+     * Desliza de um elemento para outro
+     */
+    swipe(startSelector: string, endSelector: string): Promise<void>;
+    /**
+     * Desliza por coordenadas
+     */
+    swipeByCoordinates(startX: number, startY: number, endX: number, endY: number): Promise<void>;
+    /**
+     * Rola a tela em uma direção
+     */
+    scroll(direction: 'up' | 'down' | 'left' | 'right', distance?: number): Promise<void>;
+    /**
+     * Envia texto para um elemento
+     */
+    sendKeys(selector: string, text: string): Promise<void>;
+    /**
+     * Limpa texto de um elemento
+     */
+    clearText(selector: string): Promise<void>;
+    /**
+     * Esconde o teclado
+     */
+    hideKeyboard(): Promise<void>;
+    /**
+     * Obtém texto de um elemento
+     */
+    getText(selector: string): Promise<string>;
+    /**
+     * Obtém atributo de um elemento
+     */
+    getAttribute(selector: string, attribute: string): Promise<string | null>;
+    /**
+     * Verifica se elemento está visível
+     */
+    isDisplayed(selector: string): Promise<boolean>;
+    /**
+     * Verifica se elemento está habilitado
+     */
+    isEnabled(selector: string): Promise<boolean>;
+    /**
+     * Aguarda elemento ficar em condição específica
+     */
+    waitForElement(selector: string, options?: {
+        timeout?: number;
+        condition?: 'visible' | 'clickable' | 'exists';
+    }): Promise<void>;
+    /**
+     * Gesto de pinça (reduzir)
+     */
+    pinch(selector: string, scale: number): Promise<void>;
+    /**
+     * Gesto de zoom (ampliar)
+     */
+    zoom(selector: string, scale: number): Promise<void>;
+    /**
+     * Rotaciona dispositivo
+     */
+    rotate(orientation: 'portrait' | 'landscape'): Promise<void>;
+    /**
+     * Muda para contexto WebView
+     */
+    switchToWebView(): Promise<void>;
+    /**
+     * Muda para contexto nativo
+     */
+    switchToNativeApp(): Promise<void>;
+    /**
+     * Obtém activity atual (Android)
+     */
+    getCurrentActivity(): Promise<string>;
+    /**
+     * Abre a aplicação
+     */
+    launchApp(): Promise<void>;
+    /**
+     * Fecha a aplicação
+     */
+    closeApp(): Promise<void>;
+    /**
+     * Reseta a aplicação
+     */
+    resetApp(): Promise<void>;
+    /**
+     * Captura screenshot
+     */
+    screenshot(path?: string): Promise<Buffer>;
+    /**
+     * Obtém código fonte da página
+     */
+    getPageSource(): Promise<string>;
+    /**
+     * Encerra o driver
+     */
+    quit(): Promise<void>;
+    /**
+     * Obtém a instância do WebDriverIO
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getDriver(): any;
+    /**
+     * Obtém configuração do dispositivo
+     */
+    getDeviceConfig(): any;
+}