@silasfmartins/testhub 1.0.0

package/dist/src/testhub/DynamicConfigManager.d.ts

@@ -0,0 +1,121 @@
+/**
+ * DynamicConfigManager: Injeção automática de configurações do sistema selecionado
+ * URLs, credenciais, hosts são injetados automaticamente em ApiActions, playwright.config, SSHClient, BancoHelper
+ * Integrado com AutoCore Hub para buscar configurações centralizadas
+ */
+/**
+ * Gerenciador de configuração dinâmica
+ */
+export declare class DynamicConfigManager {
+    private static instance;
+    private systemsManager;
+    private hubClient;
+    private constructor();
+    /**
+     * Obtém instância singleton
+     */
+    static getInstance(): DynamicConfigManager;
+    /**
+     * 🔧 Obtém configuração injetável para API
+     * Usado por ApiActions para pegar base URL automaticamente
+     */
+    getApiConfig(): {
+        baseUrl: string;
+        headers?: Record<string, string>;
+    } | null;
+    /**
+     * 🔧 Obtém configuração injetável para Frontend/Playwright
+     * Usado para injetar baseURL no playwright.config.ts
+     */
+    getPlaywrightConfig(): {
+        baseURL: string;
+    } | null;
+    /**
+     * 🔧 Obtém configuração injetável para SSH
+     * Usado por SSHClient para pegar host, user, password
+     */
+    getSSHConfig(): {
+        host: string;
+        port: number;
+        username: string;
+        password?: string;
+        privateKey?: string;
+    } | null;
+    /**
+     * 🔧 Obtém configuração injetável para Banco de Dados
+     * Usado por BancoHelper para pegar host, service, user, password
+     */
+    getDatabaseConfig(): {
+        host: string;
+        port: number;
+        serviceName: string;
+        user: string;
+        password: string;
+    } | null;
+    /**
+     * 🔧 Injeta configurações em variáveis de ambiente (fallback)
+     * Usado quando o usuário já tem código que lê de process.env
+     *
+     * 🆕 IMPORTANTE: Agora injeta baseado no PROJECT_TYPE do projeto,
+     * não no tipo do ambiente (PROD, PREPROD, etc.)
+     *
+     * 📋 VARIÁVEIS INJETADAS:
+     *
+     * SEMPRE (qualquer tipo):
+     * - URL, USERNAME, PASSWORD → Para TestHubVars.get('URL'), etc.
+     * - BASE_URL, BASE_URL_API → Para ApiActions, Playwright
+     * - HUB_USERNAME, HUB_PASSWORD → Credenciais universais
+     *
+     * SSH (PROJECT_TYPE=SSH):
+     * - SSH_HOST → IP/hostname do servidor (vem do campo 'url' do Hub)
+     * - SSH_PORT → Porta SSH (default: 22)
+     * - SSH_USER → Usuário SSH
+     * - SSH_PASSWORD → Senha SSH
+     *
+     * BANCO (PROJECT_TYPE=BANCO):
+     * - DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_SERVICE_NAME
+     */
+    injectIntoEnvironment(): void;
+    /**
+     * 🔧 Obtém credenciais para uso em testes de autenticação
+     * Usado quando usuário precisa fazer login manualmente
+     */
+    getCredentials(): {
+        username: string;
+        password: string;
+    } | null;
+    /**
+     * 🔧 Valida se configuração do sistema é suficiente
+     */
+    validateConfig(requiredFields: string[]): {
+        valid: boolean;
+        missing: string[];
+    };
+    /**
+     * 🔧 Gera URL completa a partir de path relativo
+     * Ex: getFullUrl('/api/users') -> 'https://sistema.com/api/users'
+     */
+    getFullUrl(relativePath: string): string | null;
+    /**
+     * 🔧 Atualiza playwright.config.ts com baseURL automaticamente (em tempo de execução)
+     */
+    injectPlaywrightBaseUrl(): void;
+    /**
+     * 🔌 Testa conectividade com AutoCore Hub
+     */
+    testHubConnection(): Promise<boolean>;
+    /**
+     * 🔄 Recarrega configurações do AutoCore Hub
+     */
+    reloadFromHub(): Promise<void>;
+    /**
+     * 📊 Obtém estatísticas do AutoCore Hub
+     */
+    getHubStats(): Promise<{
+        totalSystems: number;
+        systemsLoaded: boolean;
+        hubConnected: boolean;
+        selectedSystem: string | null;
+    }>;
+}
+export default DynamicConfigManager;

package/dist/src/testhub/DynamicConfigManager.js

@@ -0,0 +1,320 @@
+/**
+ * DynamicConfigManager: Injeção automática de configurações do sistema selecionado
+ * URLs, credenciais, hosts são injetados automaticamente em ApiActions, playwright.config, SSHClient, BancoHelper
+ * Integrado com AutoCore Hub para buscar configurações centralizadas
+ */
+import * as fs from 'fs';
+import { Logger } from '../utils/Logger.js';
+import { SystemsManager } from './SystemsManager.js';
+import { TestHubClient } from './TestHubClient.js';
+/**
+ * Gerenciador de configuração dinâmica
+ */
+export class DynamicConfigManager {
+    static instance;
+    systemsManager;
+    hubClient;
+    constructor() {
+        this.systemsManager = SystemsManager.getInstance();
+        this.hubClient = TestHubClient.getInstance();
+    }
+    /**
+     * Obtém instância singleton
+     */
+    static getInstance() {
+        if (!DynamicConfigManager.instance) {
+            DynamicConfigManager.instance = new DynamicConfigManager();
+        }
+        return DynamicConfigManager.instance;
+    }
+    /**
+     * 🔧 Obtém configuração injetável para API
+     * Usado por ApiActions para pegar base URL automaticamente
+     */
+    getApiConfig() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return null;
+        }
+        return {
+            baseUrl: systemConfig.baseUrl,
+            headers: {},
+        };
+    }
+    /**
+     * 🔧 Obtém configuração injetável para Frontend/Playwright
+     * Usado para injetar baseURL no playwright.config.ts
+     */
+    getPlaywrightConfig() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return null;
+        }
+        return {
+            baseURL: systemConfig.baseUrl,
+        };
+    }
+    /**
+     * 🔧 Obtém configuração injetável para SSH
+     * Usado por SSHClient para pegar host, user, password
+     */
+    getSSHConfig() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return null;
+        }
+        let privateKey;
+        if (systemConfig.privateKeyPath &&
+            fs.existsSync(systemConfig.privateKeyPath)) {
+            privateKey = fs.readFileSync(systemConfig.privateKeyPath, 'utf-8');
+        }
+        return {
+            host: systemConfig.host || '',
+            port: Number.parseInt(systemConfig.port || '22', 10),
+            username: systemConfig.username || '',
+            password: systemConfig.password,
+            privateKey,
+        };
+    }
+    /**
+     * 🔧 Obtém configuração injetável para Banco de Dados
+     * Usado por BancoHelper para pegar host, service, user, password
+     */
+    getDatabaseConfig() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return null;
+        }
+        return {
+            host: systemConfig.host || '',
+            port: Number.parseInt(systemConfig.port || '1521', 10),
+            serviceName: systemConfig.serviceName || '',
+            user: systemConfig.username || '',
+            password: systemConfig.password || '',
+        };
+    }
+    /**
+     * 🔧 Injeta configurações em variáveis de ambiente (fallback)
+     * Usado quando o usuário já tem código que lê de process.env
+     *
+     * 🆕 IMPORTANTE: Agora injeta baseado no PROJECT_TYPE do projeto,
+     * não no tipo do ambiente (PROD, PREPROD, etc.)
+     *
+     * 📋 VARIÁVEIS INJETADAS:
+     *
+     * SEMPRE (qualquer tipo):
+     * - URL, USERNAME, PASSWORD → Para TestHubVars.get('URL'), etc.
+     * - BASE_URL, BASE_URL_API → Para ApiActions, Playwright
+     * - HUB_USERNAME, HUB_PASSWORD → Credenciais universais
+     *
+     * SSH (PROJECT_TYPE=SSH):
+     * - SSH_HOST → IP/hostname do servidor (vem do campo 'url' do Hub)
+     * - SSH_PORT → Porta SSH (default: 22)
+     * - SSH_USER → Usuário SSH
+     * - SSH_PASSWORD → Senha SSH
+     *
+     * BANCO (PROJECT_TYPE=BANCO):
+     * - DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_SERVICE_NAME
+     */
+    injectIntoEnvironment() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return;
+        }
+        const selectedSystem = this.systemsManager.getSelectedSystem();
+        if (!selectedSystem) {
+            return;
+        }
+        // 🆕 Obter tipo de projeto da variável de ambiente
+        const projectType = process.env.PROJECT_TYPE?.toUpperCase();
+        // ═══════════════════════════════════════════════════════════════════
+        // 🌐 VARIÁVEIS UNIVERSAIS - Sempre injetadas (para TestHubVars)
+        // ═══════════════════════════════════════════════════════════════════
+        // URL: Para Frontend/API é a URL HTTP, para SSH é o host
+        if (systemConfig.baseUrl) {
+            process.env.URL = systemConfig.baseUrl;
+            process.env.BASE_URL = systemConfig.baseUrl;
+            process.env.BASE_URL_API = systemConfig.baseUrl;
+            process.env.AUTOCORE_HUB_SYSTEM_URL = systemConfig.baseUrl;
+        }
+        // USERNAME e PASSWORD: Universais para qualquer tipo
+        if (systemConfig.username) {
+            process.env.USERNAME = systemConfig.username;
+            process.env.HUB_USERNAME = systemConfig.username;
+        }
+        if (systemConfig.password) {
+            process.env.PASSWORD = systemConfig.password;
+            process.env.HUB_PASSWORD = systemConfig.password;
+        }
+        // PORT: Porta do serviço
+        if (systemConfig.port) {
+            process.env.PORT = systemConfig.port;
+        }
+        // ═══════════════════════════════════════════════════════════════════
+        // 🔌 SSH: Variáveis específicas quando o sistema contém informações de SSH
+        // Injectar mesmo que PROJECT_TYPE não seja 'SSH' quando o sistema tiver campos SSH
+        // ═══════════════════════════════════════════════════════════════════
+        const systemHasSshInfo = !!(systemConfig.privateKeyPath ||
+            systemConfig.username ||
+            systemConfig.password ||
+            (systemConfig.baseUrl && !systemConfig.baseUrl.startsWith('http')) ||
+            systemConfig.host);
+        if (projectType === 'SSH' || systemHasSshInfo) {
+            // Para SSH, o campo 'url' do Hub pode conter o HOST (IP ou hostname)
+            const sshHost = systemConfig.baseUrl?.replace(/^https?:\/\//, '').split('/')[0] || systemConfig.host;
+            if (sshHost) {
+                process.env.SSH_HOST = sshHost;
+            }
+            if (systemConfig.port) {
+                process.env.SSH_PORT = systemConfig.port;
+            }
+            else {
+                process.env.SSH_PORT = '22'; // Default SSH port
+            }
+            if (systemConfig.username) {
+                process.env.SSH_USER = systemConfig.username;
+            }
+            if (systemConfig.password) {
+                process.env.SSH_PASSWORD = systemConfig.password;
+            }
+            // Se o sistema tiver caminho para chave privada, expor caminho absoluto em SSH_KEY_PATH
+            if (systemConfig.privateKeyPath) {
+                const possiblePath = systemConfig.privateKeyPath;
+                // Se for relativo, resolver a partir do cwd
+                const absoluteKeyPath = require('path').isAbsolute(possiblePath)
+                    ? possiblePath
+                    : require('path').resolve(process.cwd(), possiblePath);
+                if (require('fs').existsSync(absoluteKeyPath)) {
+                    process.env.SSH_KEY_PATH = absoluteKeyPath;
+                    Logger.info(`🔑 SSH key path detected and injected: ${process.env.SSH_KEY_PATH}`);
+                }
+                else {
+                    Logger.warning(`⚠️ SSH key path configured in Hub not found on disk: ${absoluteKeyPath}`);
+                }
+            }
+        }
+        // ═══════════════════════════════════════════════════════════════════
+        // 🗄️ BANCO: Variáveis específicas quando PROJECT_TYPE=BANCO
+        // ═══════════════════════════════════════════════════════════════════
+        if (projectType === 'BANCO' || projectType === 'DATABASE') {
+            const dbHost = systemConfig.baseUrl?.replace(/^https?:\/\//, '').split('/')[0] || systemConfig.host;
+            if (dbHost) {
+                process.env.DB_HOST = dbHost;
+            }
+            if (systemConfig.port) {
+                process.env.DB_PORT = systemConfig.port;
+            }
+            else {
+                process.env.DB_PORT = '1521'; // Default Oracle port
+            }
+            if (systemConfig.serviceName) {
+                process.env.DB_SERVICE_NAME = systemConfig.serviceName;
+            }
+            if (systemConfig.username) {
+                process.env.DB_USER = systemConfig.username;
+            }
+            if (systemConfig.password) {
+                process.env.DB_PASSWORD = systemConfig.password;
+            }
+            Logger.info(`🗄️ [BANCO] Credenciais do Hub injetadas:`);
+            Logger.info(`   Host: ${process.env.DB_HOST}:${process.env.DB_PORT}`);
+            Logger.info(`   User: ${process.env.DB_USER}`);
+        }
+        // Configurações gerais do AutoCore Hub
+        process.env.AUTOCORE_HUB_SYSTEM_NAME = selectedSystem.name;
+        process.env.AUTOCORE_HUB_ENVIRONMENT = selectedSystem.environmentName;
+    }
+    /**
+     * 🔧 Obtém credenciais para uso em testes de autenticação
+     * Usado quando usuário precisa fazer login manualmente
+     */
+    getCredentials() {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!(systemConfig && systemConfig.username && systemConfig.password)) {
+            return null;
+        }
+        return {
+            username: systemConfig.username,
+            password: systemConfig.password,
+        };
+    }
+    /**
+     * 🔧 Valida se configuração do sistema é suficiente
+     */
+    validateConfig(requiredFields) {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return {
+                valid: false,
+                missing: ['Sistema não selecionado'],
+            };
+        }
+        const missing = [];
+        const configMap = systemConfig;
+        for (const field of requiredFields) {
+            if (!configMap[field]) {
+                missing.push(field);
+            }
+        }
+        return {
+            valid: missing.length === 0,
+            missing,
+        };
+    }
+    /**
+     * 🔧 Gera URL completa a partir de path relativo
+     * Ex: getFullUrl('/api/users') -> 'https://sistema.com/api/users'
+     */
+    getFullUrl(relativePath) {
+        const systemConfig = this.systemsManager.getSystemConfig();
+        if (!systemConfig) {
+            return null;
+        }
+        const baseUrl = systemConfig.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        const path = relativePath.startsWith('/')
+            ? relativePath
+            : `/${relativePath}`;
+        return `${baseUrl}${path}`;
+    }
+    /**
+     * 🔧 Atualiza playwright.config.ts com baseURL automaticamente (em tempo de execução)
+     */
+    injectPlaywrightBaseUrl() {
+        const playwrightConfig = this.getPlaywrightConfig();
+        if (!playwrightConfig) {
+            return;
+        }
+        // Injetar em process.env para playwright.config.ts pegar
+        process.env.AUTOCORE_BASE_URL = playwrightConfig.baseURL;
+        Logger.info(`🔧 baseURL injetado no Playwright via AutoCore Hub: ${playwrightConfig.baseURL}`);
+    }
+    /**
+     * 🔌 Testa conectividade com AutoCore Hub
+     */
+    async testHubConnection() {
+        Logger.info('🔌 Testando conectividade com AutoCore Hub...');
+        return await this.hubClient.testConnection();
+    }
+    /**
+     * 🔄 Recarrega configurações do AutoCore Hub
+     */
+    async reloadFromHub() {
+        Logger.info('🔄 Recarregando configurações do AutoCore Hub...');
+        await this.systemsManager.reload();
+    }
+    /**
+     * 📊 Obtém estatísticas do AutoCore Hub
+     */
+    async getHubStats() {
+        const systems = await this.systemsManager.listSystems();
+        const selectedSystem = this.systemsManager.getSelectedSystem();
+        const hubConnected = await this.hubClient.testConnection();
+        return {
+            totalSystems: systems.length,
+            systemsLoaded: systems.length > 0,
+            hubConnected,
+            selectedSystem: selectedSystem?.name || null,
+        };
+    }
+}
+export default DynamicConfigManager;

package/dist/src/testhub/SystemsManager.d.ts

@@ -0,0 +1,119 @@
+/**
+ * SystemsManager: Gerenciador de sistemas com IntelliSense dinâmico
+ * Busca sistemas do backend e cria enum dinâmico para autocomplete
+ */
+import { type TestHubEnvironment, type TestHubSystem } from './TestHubClient.js';
+/**
+ * Sistema selecionado pelo usuário
+ */
+export interface SelectedSystem {
+    name: string;
+    system: TestHubSystem;
+    environment: TestHubEnvironment;
+    environmentName: string;
+}
+/**
+ * Gerenciador de sistemas com suporte a IntelliSense
+ */
+export declare class SystemsManager {
+    private static instance;
+    private client;
+    private selectedSystem;
+    private systemsLoaded;
+    private systems;
+    private constructor();
+    /**
+     * Obtém instância singleton
+     */
+    static getInstance(): SystemsManager;
+    /**
+     * 🚀 Inicializa o gerenciador e busca sistemas do backend
+     */
+    initialize(): Promise<void>;
+    /**
+     * 📝 Gera arquivo TypeScript com enum Systems para IntelliSense
+     *
+     * ESTRATÉGIA: Salva enum em .rbqa/SystemsEnum.ts no projeto consumidor
+     * para que possa ser importado sem modificar source files do framework
+     */
+    private generateSystemsEnum; /**
+     * Gera conteúdo do enum TypeScript
+     */
+    private generateEnumContent;
+    /**
+     * Sanitiza nome do sistema para usar como chave de enum
+     * IMPORTANTE: Preserva o formato original se já for válido (ex: AUTENTICA_IN_HML)
+     */
+    private sanitizeEnumKey;
+    /**
+     * 🎯 Seleciona um sistema para uso nos testes
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'preprod', 'esteira1')
+     * @param projectType Tipo de projeto (API, Frontend, etc) para filtrar ambientes
+     */
+    selectSystem(systemName: string, environmentName?: string, projectType?: TestHubEnvironment['type']): Promise<SelectedSystem>;
+    /**
+     * Obtém sistema selecionado atual
+     */
+    getSelectedSystem(): SelectedSystem | null;
+    /**
+     * Verifica se um sistema foi selecionado
+     */
+    hasSystemSelected(): boolean;
+    /**
+     * Valida se sistema foi selecionado (lança erro se não)
+     */
+    validateSystemSelected(): void;
+    /**
+     * Lista todos os sistemas disponíveis
+     */
+    listSystems(): Promise<TestHubSystem[]>;
+    /**
+     * Lista sistemas por tipo
+     */
+    listSystemsByType(type: TestHubEnvironment['type']): Promise<TestHubSystem[]>;
+    /**
+     * Limpa seleção atual
+     */
+    clearSelection(): void;
+    /**
+     * Recarrega sistemas do backend (força atualização)
+     */
+    reload(): Promise<void>;
+    /**
+     * Obtém configuração do sistema selecionado (para injeção automática)
+     */
+    getSystemConfig(): {
+        baseUrl: string;
+        username?: string;
+        password?: string;
+        host?: string;
+        port?: string;
+        serviceName?: string;
+        privateKeyPath?: string;
+    } | null;
+}
+/**
+ * 🌐 Enum Systems com Lazy Loading
+ *
+ * Este enum é populado dinamicamente quando você usa TestAnnotations.setSystem()
+ * pela primeira vez. Ele carrega os sistemas do AutoCore Hub automaticamente.
+ *
+ * ✅ USO RECOMENDADO:
+ *
+ * import { TestAnnotations, Systems } from "@silasfmartins/testhub"
+ *
+ * test("Meu teste", async ({}, testInfo) => {
+ *   TestAnnotations.Api.testInfo = testInfo
+ *
+ *   // Opção 1: String direta (sempre funciona)
+ *   await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+ *
+ *   // Opção 2: Enum (após primeira execução)
+ *   await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)
+ * })
+ *
+ * 💡 O enum Systems é populado automaticamente na primeira chamada de setSystem()
+ */
+export declare const Systems: Record<string, string>;
+export default SystemsManager;