@silasfmartins/testhub 1.0.0

package/dist/src/utils/testRecovery/autoFixCode.d.ts

@@ -0,0 +1,65 @@
+import { type ErrorType, type ActionType } from './TestRecoveryClient.js';
+/** Parâmetros para correção automática de código */
+export interface AutoFixCodeParams {
+    /** XPath antigo/quebrado */
+    xpath: string;
+    /** Novo XPath corrigido */
+    newXPath: string;
+    /** Tipo do erro que causou a falha */
+    errorType?: ErrorType;
+    /** Tipo de ação que falhou */
+    actionType?: ActionType;
+    /** Caminho absoluto do projeto Playwright */
+    projectRoot?: string;
+    /** Arquivo específico para corrigir (relativo a projectRoot) */
+    attributesFile?: string;
+    /** Nome da propriedade/getter a corrigir */
+    locatorProperty?: string;
+    /** Nome do sistema (para contexto) */
+    systemName?: string;
+    /** Se true, aplica correção automaticamente. Se false, retorna preview */
+    autoConfirm?: boolean;
+}
+/** Resultado da correção automática */
+export interface AutoFixCodeResult {
+    success: boolean;
+    fileUpdated: boolean;
+    filePath?: string;
+    changes?: {
+        oldXPath: string;
+        newXPath: string;
+        property?: string;
+        lineNumber?: number;
+    };
+}
+/**
+ * Corrige automaticamente um XPath quebrado no código-fonte
+ *
+ * @example
+ * ```typescript
+ * // Correção automática (aplica imediatamente)
+ * const success = await autoFixCode({
+ *   xpath: "//button[@id='btn-old']",
+ *   newXPath: "//button[@data-testid='btn-login']",
+ *   attributesFile: 'src/attributes/AttributesLogin.ts',
+ *   autoConfirm: true
+ * })
+ *
+ * // Preview sem aplicar (para revisão manual)
+ * const result = await autoFixCode({
+ *   xpath: "//button[@id='btn-old']",
+ *   newXPath: "//button[@data-testid='btn-login']",
+ *   autoConfirm: false
+ * })
+ * if (result.changes) {
+ *   console.log(`Linha ${result.changes.lineNumber}: ${result.changes.oldXPath} → ${result.changes.newXPath}`)
+ * }
+ * ```
+ *
+ * @param params Parâmetros da correção
+ * @returns true se a correção foi aplicada com sucesso
+ */
+export declare function autoFixCode(params: AutoFixCodeParams): Promise<boolean>;
+export declare function autoFixCode(params: AutoFixCodeParams & {
+    autoConfirm: false;
+}): Promise<AutoFixCodeResult>;

package/dist/src/utils/testRecovery/autoFixCode.js

@@ -0,0 +1,32 @@
+import { fixInCode } from './TestRecoveryClient.js';
+export async function autoFixCode(params) {
+    const projectRoot = params.projectRoot || process.env.AUTOCORE_PROJECT_ROOT || process.cwd();
+    const payload = {
+        url: undefined,
+        failedXPath: params.xpath,
+        newXPath: params.newXPath,
+        errorType: params.errorType,
+        actionType: params.actionType,
+        projectRoot,
+        attributesFile: params.attributesFile,
+        locatorProperty: params.locatorProperty,
+        systemName: params.systemName,
+        autoConfirm: params.autoConfirm ?? true,
+    };
+    const result = await fixInCode(payload);
+    if (!result) {
+        return params.autoConfirm === false
+            ? { success: false, fileUpdated: false }
+            : false;
+    }
+    // Se autoConfirm=false, retorna resultado completo para revisão
+    if (params.autoConfirm === false) {
+        return {
+            success: result.success,
+            fileUpdated: result.fileUpdated,
+            filePath: result.filePath,
+            changes: result.changes,
+        };
+    }
+    return result.success && result.fileUpdated;
+}

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,59 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        // ✅ IMPORTANTE: globals: false evita conflitos com Jest/Playwright
+        // Use imports explícitos: import { describe, it, expect } from 'vitest'
+        globals: false,
+        environment: 'node',
+        // 🔧 NOVO: Variáveis de ambiente para testes
+        env: {
+            DISABLE_DEVICEFARM_AUTOOPEN: 'true', // Desabilitar abertura automática do DeviceFarmViewer durante testes
+        },
+        setupFiles: [
+            '@silasfmartins/testhub/setup', // ✅ AutoCore Jest-Safe Setup
+            './tests/setup.ts', // ✅ Setup específico do projeto
+        ],
+        // 🔧 NOVO: Incluir tanto .test.ts quanto .spec.ts
+        include: [
+            'tests/**/*.test.ts',
+            'tests/**/*.spec.ts',
+            '**/*.test.ts',
+            '**/*.spec.ts',
+        ],
+        // 🔧 NOVO: Excluir arquivos que podem causar conflito
+        exclude: [
+            'node_modules/**',
+            'dist/**',
+            '.git/**',
+            'coverage/**',
+            'playwright-report/**',
+            'test-results/**',
+        ],
+        // 🔧 Configurações de isolamento melhoradas
+        isolate: true, // Isolar cada arquivo de teste
+        pool: 'forks', // Usar forks em vez de threads para evitar conflitos
+        // 🔧 NOVO: Configurações para evitar conflitos Jest/Vitest
+        sequence: {
+            concurrent: false, // Executar sequencialmente
+            shuffle: false, // Não embaralhar ordem dos testes
+        },
+        // 🔧 NOVO: Configurações de retry e timeout
+        retry: 0, // Não retry em caso de falha
+        testTimeout: 30_000, // 30 segundos timeout
+        hookTimeout: 10_000, // 10 segundos para hooks
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'html', 'lcov'],
+            include: ['src/**/*.ts'],
+            exclude: [
+                'tests/**',
+                'src/**/*.d.ts',
+                'src/**/*.test.ts',
+                'src/**/*.spec.ts',
+            ],
+        },
+    },
+    esbuild: {
+        target: 'node18', // Target específico para melhor compatibilidade
+    },
+});

package/dist/wdio.conf.d.ts

@@ -0,0 +1 @@
+export declare const config: WebdriverIO.Config;

package/dist/wdio.conf.js

@@ -0,0 +1,420 @@
+/// <reference types="@wdio/types" />
+import { Agent } from 'node:https';
+// 🔧 CONFIGURAÇÃO OTIMIZADA PARA DEVICEFARM
+const isDeviceFarm = process.env.DEVICEFARM_HOST || process.env.DEVICEFARM_API_KEY;
+const deviceFarmHost = process.env.DEVICEFARM_HOST || 'devicefarm-qa.com.br';
+const deviceFarmPort = Number(process.env.DEVICEFARM_PORT) || 443;
+const deviceFarmPath = process.env.DEVICEFARM_PATH || '/api/mobile/wd/hub';
+export const config = {
+    //
+    // ====================
+    // Runner Configuration
+    // ====================
+    runner: 'local',
+    tsConfigPath: './tsconfig.e2e.json',
+    // 🌐 CONFIGURAÇÃO DEVICEFARM
+    ...(isDeviceFarm
+        ? {
+            protocol: 'https',
+            hostname: deviceFarmHost,
+            port: deviceFarmPort,
+            path: deviceFarmPath,
+        }
+        : {
+            port: 4723,
+        }),
+    //
+    // ==================
+    // Specify Test Files
+    // ==================
+    // Define which test specs should run. The pattern is relative to the directory
+    // of the configuration file being run.
+    //
+    // The specs are defined as an array of spec files (optionally using wildcards
+    // that will be expanded). The test for each spec file will be run in a separate
+    // worker process. In order to have a group of spec files run in the same worker
+    // process simply enclose them in an array within the specs array.
+    //
+    // The path of the spec files will be resolved relative from the directory of
+    // of the config file unless it's absolute.
+    //
+    specs: [
+        // ToDo: define location for spec files here
+        'tests/**/*.spec.ts',
+    ],
+    // Patterns to exclude.
+    exclude: [
+    // 'path/to/excluded/files'
+    ],
+    //
+    // ============
+    // Capabilities
+    // ============
+    // Define your capabilities here. WebdriverIO can run multiple capabilities at the same
+    // time. Depending on the number of capabilities, WebdriverIO launches several test
+    // sessions. Within your capabilities you can overwrite the spec and exclude options in
+    // order to group specific specs to a specific capability.
+    //
+    // First, you can define how many instances should be started at the same time. Let's
+    // say you have 3 different capabilities (Chrome, Firefox, and Safari) and you have
+    // set maxInstances to 1; wdio will spawn 3 processes. Therefore, if you have 10 spec
+    // files and you set maxInstances to 10, all spec files will get tested at the same time
+    // and 30 processes will get spawned. The property handles how many capabilities
+    // from the same test should run tests.
+    //
+    maxInstances: 10,
+    //
+    // If you have trouble getting all important capabilities together, check out the
+    // Sauce Labs platform configurator - a great tool to configure your capabilities:
+    // https://saucelabs.com/platform/platform-configurator
+    //
+    capabilities: [
+        {
+            // 🔧 CAPABILITIES DINÂMICAS PARA DEVICEFARM iOS/Android
+            ...(isDeviceFarm
+                ? {
+                    // 📱 CONFIGURAÇÃO UNIVERSAL DEVICEFARM (iOS/Android)
+                    'appium:apiKey': process.env.DEVICEFARM_API_KEY ||
+                        '75ec082d-f22c-4b17-b872-1a0d4791fa40',
+                    'appium:deviceId': process.env.DEVICEFARM_DEVICE_ID ||
+                        process.env.MOBILE_DEVICE_ID ||
+                        'device-001',
+                    // 🍎 iOS quando especificado
+                    ...(process.env.MOBILE_PLATFORM === 'iOS' ||
+                        process.env.IOS_BUNDLE_ID
+                        ? {
+                            platformName: 'iOS',
+                            'appium:automationName': 'XCUITest',
+                            'appium:bundleId': process.env.IOS_BUNDLE_ID || 'com.apple.Preferences',
+                            'appium:autoAcceptAlerts': true,
+                            'appium:autoDismissAlerts': false,
+                            'appium:shouldUseSingletonTestManager': false,
+                            'appium:shouldUseTestManagerForVisibilityDetection': false,
+                            'appium:maxTypingFrequency': 60,
+                            'appium:simpleIsVisibleCheck': true,
+                            'appium:wdaLocalPort': 8100,
+                            'appium:mjpegServerPort': 9100,
+                            'appium:webkitDebugProxyPort': 27_753,
+                            'appium:useNewWDA': false,
+                            'appium:clearSystemFiles': false,
+                            'appium:preventWDAAttachments': true,
+                            'appium:connectHardwareKeyboard': false,
+                            'appium:calendarAccessAuthorized': true,
+                            'appium:isHeadless': false,
+                        }
+                        : {
+                            // 🤖 Android quando especificado ou padrão
+                            platformName: 'Android',
+                            'appium:automationName': 'UiAutomator2',
+                            'appium:appPackage': process.env.ANDROID_APP_PACKAGE || 'com.android.settings',
+                            'appium:appActivity': process.env.ANDROID_APP_ACTIVITY || '.Settings',
+                            'appium:autoGrantPermissions': true,
+                            'appium:disableWindowAnimation': true,
+                            'appium:skipServerInstallation': true,
+                            'appium:skipDeviceInitialization': false,
+                        }),
+                    // 🔒 CONFIGURAÇÕES SSL UNIVERSAIS PARA DEVICEFARM
+                    'appium:acceptSslCerts': true,
+                    'appium:acceptInsecureCerts': true,
+                    'appium:ignoreSSLErrors': true,
+                    'appium:acceptSslCertificates': true,
+                    // 🎯 CONFIGURAÇÕES DE PERFORMANCE UNIVERSAIS
+                    'appium:newCommandTimeout': 600,
+                    'appium:commandTimeouts': {
+                        default: 60_000,
+                    },
+                    'appium:noReset': true,
+                    'appium:fullReset': false,
+                }
+                : {
+                    // 🏠 CONFIGURAÇÃO LOCAL (Android padrão)
+                    platformName: 'Android',
+                    browserName: 'Chrome',
+                    'appium:deviceName': 'Android GoogleAPI Emulator',
+                    'appium:platformVersion': '12.0',
+                    'appium:automationName': 'UiAutomator2',
+                }),
+        },
+    ],
+    //
+    // ===================
+    // Test Configurations
+    // ===================
+    // Define all options that are relevant for the WebdriverIO instance here
+    //
+    // Level of logging verbosity: trace | debug | info | warn | error | silent
+    logLevel: 'info',
+    // 🔒 CONFIGURAÇÕES SSL PARA WEBDRIVERIO
+    ...(isDeviceFarm
+        ? {
+            agent: new Agent({
+                rejectUnauthorized: false,
+                keepAlive: true,
+                maxSockets: 50,
+            }),
+        }
+        : {}),
+    //
+    // Set specific log levels per logger
+    // loggers:
+    // - webdriver, webdriverio
+    // - @wdio/browserstack-service, @wdio/lighthouse-service, @wdio/sauce-service
+    // - @wdio/mocha-framework, @wdio/jasmine-framework
+    // - @wdio/local-runner
+    // - @wdio/sumologic-reporter
+    // - @wdio/cli, @wdio/config, @wdio/utils
+    // Level of logging verbosity: trace | debug | info | warn | error | silent
+    // logLevels: {
+    //     webdriver: 'info',
+    //     '@wdio/appium-service': 'info'
+    // },
+    //
+    // If you only want to run your tests until a specific amount of tests have failed use
+    // bail (default is 0 - don't bail, run all tests).
+    bail: 0,
+    //
+    // Set a base URL in order to shorten url command calls. If your `url` parameter starts
+    // with `/`, the base url gets prepended, not including the path portion of your baseUrl.
+    // If your `url` parameter starts without a scheme or `/` (like `some/path`), the base url
+    // gets prepended directly.
+    // baseUrl: 'http://localhost:8080',
+    //
+    // Default timeout for all waitFor* commands.
+    waitforTimeout: isDeviceFarm ? 30_000 : 10_000, // DeviceFarm precisa de mais tempo
+    //
+    // Default timeout in milliseconds for request
+    // if browser driver or grid doesn't send response
+    connectionRetryTimeout: isDeviceFarm ? 180_000 : 120_000, // 3 min para DeviceFarm
+    //
+    // Default request retries count
+    connectionRetryCount: isDeviceFarm ? 5 : 3, // Mais tentativas para DeviceFarm
+    //
+    // Test runner services
+    // Services take over a specific job you don't want to take care of. They enhance
+    // your test setup with almost no effort. Unlike plugins, they don't add new
+    // commands. Instead, they hook themselves up into the test process.
+    services: ['appium'],
+    // Framework you want to run your specs with.
+    // The following are supported: Mocha, Jasmine, and Cucumber
+    // see also: https://webdriver.io/docs/frameworks
+    //
+    // Make sure you have the wdio adapter package for the specific framework installed
+    // before running any tests.
+    framework: 'mocha',
+    //
+    // The number of times to retry the entire specfile when it fails as a whole
+    // specFileRetries: 1,
+    //
+    // Delay in seconds between the spec file retry attempts
+    // specFileRetriesDelay: 0,
+    //
+    // Whether or not retried spec files should be retried immediately or deferred to the end of the queue
+    // specFileRetriesDeferred: false,
+    //
+    // Test reporter for stdout.
+    // The only one supported by default is 'dot'
+    // see also: https://webdriver.io/docs/dot-reporter
+    reporters: ['spec'],
+    // Options to be passed to Mocha.
+    // See the full list at http://mochajs.org/
+    mochaOpts: {
+        ui: 'bdd',
+        timeout: isDeviceFarm ? 120_000 : 60_000, // DeviceFarm precisa de mais tempo
+    },
+    //
+    // =====
+    // Hooks DeviceFarm
+    // =====
+    /**
+     * 🔧 DEVICEFARM: Hook executado antes da sessão iniciar
+     */
+    beforeSession(config, capabilities, specs, cid) {
+        if (isDeviceFarm) {
+            console.log('🔧 Preparando sessão DeviceFarm...');
+            // Configurar SSL permissivo
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            // Configurações adicionais de SSL
+            process.env.HTTPS_PROXY_REJECT_UNAUTHORIZED = '0';
+            process.env.REJECT_UNAUTHORIZED = '0';
+        }
+    },
+    /**
+     * 🔧 DEVICEFARM: Hook executado antes dos testes iniciarem
+     */
+    before(capabilities, specs) {
+        if (isDeviceFarm) {
+            console.log('🍎 Sessão DeviceFarm iniciada com sucesso!');
+            console.log(`📱 Device: ${capabilities['appium:deviceId'] || 'N/A'}`);
+            console.log(`🎯 Platform: ${capabilities.platformName || 'N/A'}`);
+        }
+    },
+    /**
+     * 🔧 DEVICEFARM: Hook executado após cada teste
+     */
+    afterTest(test, context, { error, result, duration, passed, retries }) {
+        if (isDeviceFarm) {
+            const status = passed ? '✅' : '❌';
+            console.log(`${status} ${test.title}: ${duration}ms`);
+            if (error) {
+                console.log(`💥 Erro: ${error.message}`);
+            }
+        }
+    },
+    //
+    // =====
+    // Hooks
+    // =====
+    // WebdriverIO provides several hooks you can use to interfere with the test process in order to enhance
+    // it and to build services around it. You can either apply a single function or an array of
+    // methods to it. If one of them returns with a promise, WebdriverIO will wait until that promise got
+    // resolved to continue.
+    /**
+     * Gets executed once before all workers get launched.
+     * @param {object} config wdio configuration object
+     * @param {Array.<Object>} capabilities list of capabilities details
+     */
+    // onPrepare: function (config, capabilities) {
+    // },
+    /**
+     * Gets executed before a worker process is spawned and can be used to initialize specific service
+     * for that worker as well as modify runtime environments in an async fashion.
+     * @param  {string} cid      capability id (e.g 0-0)
+     * @param  {object} caps     object containing capabilities for session that will be spawn in the worker
+     * @param  {object} specs    specs to be run in the worker process
+     * @param  {object} args     object that will be merged with the main configuration once worker is initialized
+     * @param  {object} execArgv list of string arguments passed to the worker process
+     */
+    // onWorkerStart: function (cid, caps, specs, args, execArgv) {
+    // },
+    /**
+     * Gets executed just after a worker process has exited.
+     * @param  {string} cid      capability id (e.g 0-0)
+     * @param  {number} exitCode 0 - success, 1 - fail
+     * @param  {object} specs    specs to be run in the worker process
+     * @param  {number} retries  number of retries used
+     */
+    // onWorkerEnd: function (cid, exitCode, specs, retries) {
+    // },
+    /**
+     * Gets executed just before initialising the webdriver session and test framework. It allows you
+     * to manipulate configurations depending on the capability or spec.
+     * @param {object} config wdio configuration object
+     * @param {Array.<Object>} capabilities list of capabilities details
+     * @param {Array.<String>} specs List of spec file paths that are to be run
+     * @param {string} cid worker id (e.g. 0-0)
+     */
+    // beforeSession: function (config, capabilities, specs, cid) {
+    // },
+    /**
+     * Gets executed before test execution begins. At this point you can access to all global
+     * variables like `browser`. It is the perfect place to define custom commands.
+     * @param {Array.<Object>} capabilities list of capabilities details
+     * @param {Array.<String>} specs        List of spec file paths that are to be run
+     * @param {object}         browser      instance of created browser/device session
+     */
+    // before: function (capabilities, specs) {
+    // },
+    /**
+     * Runs before a WebdriverIO command gets executed.
+     * @param {string} commandName hook command name
+     * @param {Array} args arguments that command would receive
+     */
+    // beforeCommand: function (commandName, args) {
+    // },
+    /**
+     * Hook that gets executed before the suite starts
+     * @param {object} suite suite details
+     */
+    // beforeSuite: function (suite) {
+    // },
+    /**
+     * Function to be executed before a test (in Mocha/Jasmine) starts.
+     */
+    // beforeTest: function (test, context) {
+    // },
+    /**
+     * Hook that gets executed _before_ a hook within the suite starts (e.g. runs before calling
+     * beforeEach in Mocha)
+     */
+    // beforeHook: function (test, context, hookName) {
+    // },
+    /**
+     * Hook that gets executed _after_ a hook within the suite starts (e.g. runs after calling
+     * afterEach in Mocha)
+     */
+    // afterHook: function (test, context, { error, result, duration, passed, retries }, hookName) {
+    // },
+    /**
+     * Function to be executed after a test (in Mocha/Jasmine only)
+     * @param {object}  test             test object
+     * @param {object}  context          scope object the test was executed with
+     * @param {Error}   result.error     error object in case the test fails, otherwise `undefined`
+     * @param {*}       result.result    return object of test function
+     * @param {number}  result.duration  duration of test
+     * @param {boolean} result.passed    true if test has passed, otherwise false
+     * @param {object}  result.retries   information about spec related retries, e.g. `{ attempts: 0, limit: 0 }`
+     */
+    // afterTest: function(test, context, { error, result, duration, passed, retries }) {
+    // },
+    /**
+     * Hook that gets executed after the suite has ended
+     * @param {object} suite suite details
+     */
+    // afterSuite: function (suite) {
+    // },
+    /**
+     * Runs after a WebdriverIO command gets executed
+     * @param {string} commandName hook command name
+     * @param {Array} args arguments that command would receive
+     * @param {number} result 0 - command success, 1 - command error
+     * @param {object} error error object if any
+     */
+    // afterCommand: function (commandName, args, result, error) {
+    // },
+    /**
+     * Gets executed after all tests are done. You still have access to all global variables from
+     * the test.
+     * @param {number} result 0 - test pass, 1 - test fail
+     * @param {Array.<Object>} capabilities list of capabilities details
+     * @param {Array.<String>} specs List of spec file paths that ran
+     */
+    // after: function (result, capabilities, specs) {
+    // },
+    /**
+     * Gets executed right after terminating the webdriver session.
+     * @param {object} config wdio configuration object
+     * @param {Array.<Object>} capabilities list of capabilities details
+     * @param {Array.<String>} specs List of spec file paths that ran
+     */
+    // afterSession: function (config, capabilities, specs) {
+    // },
+    /**
+     * Gets executed after all workers got shut down and the process is about to exit. An error
+     * thrown in the onComplete hook will result in the test run failing.
+     * @param {object} exitCode 0 - success, 1 - fail
+     * @param {object} config wdio configuration object
+     * @param {Array.<Object>} capabilities list of capabilities details
+     * @param {<Object>} results object containing test results
+     */
+    // onComplete: function(exitCode, config, capabilities, results) {
+    // },
+    /**
+     * Gets executed when a refresh happens.
+     * @param {string} oldSessionId session ID of the old session
+     * @param {string} newSessionId session ID of the new session
+     */
+    // onReload: function(oldSessionId, newSessionId) {
+    // }
+    /**
+     * Hook that gets executed before a WebdriverIO assertion happens.
+     * @param {object} params information about the assertion to be executed
+     */
+    // beforeAssertion: function(params) {
+    // }
+    /**
+     * Hook that gets executed after a WebdriverIO assertion happened.
+     * @param {object} params information about the assertion that was executed, including its results
+     */
+    // afterAssertion: function(params) {
+    // }
+};