Archivo de Configuración
El archivo de configuración contiene toda la información necesaria para ejecutar tu suite de pruebas. Es un módulo de NodeJS que exporta un JSON.
Aquí hay un ejemplo de configuración con todas las propiedades soportadas e información adicional:
export const config = {
// ==================================
// Dónde deberían lanzarse tus pruebas
// ==================================
//
runner: 'local',
//
// =====================
// Configuraciones del Servidor
// =====================
// Dirección del host del servidor Selenium en ejecución. Esta información suele ser obsoleta, ya que
// WebdriverIO se conecta automáticamente a localhost. Además, si estás utilizando uno de los
// servicios en la nube compatibles como Sauce Labs, Browserstack, Testing Bot o TestMu AI (Formerly LambdaTest), tampoco
// necesitas definir la información de host y puerto (porque WebdriverIO puede averiguarlo
// a partir de tu información de usuario y clave). Sin embargo, si estás usando un backend Selenium
// privado, debes definir el `hostname`, `port` y `path` aquí.
//
hostname: 'localhost',
port: 4444,
path: '/',
// Protocol: http | https
// protocol: 'http',
//
// =================
// Proveedores de Servicios
// =================
// WebdriverIO admite Sauce Labs, Browserstack, Testing Bot y TestMu AI (Formerly LambdaTest). (Otros proveedores en la nube
// también deberían funcionar). Estos servicios definen valores específicos de `user` y `key` (o clave de acceso)
// que debes colocar aquí para conectarte a estos servicios.
//
user: 'webdriverio',
key: 'xxxxxxxxxxxxxxxx-xxxxxx-xxxxx-xxxxxxxxx',
// Si ejecutas tus pruebas en Sauce Labs, puedes especificar la región donde quieres ejecutar tus pruebas
// mediante la propiedad `region`. Los identificadores cortos disponibles para las regiones son `us` (predeterminado) y `eu`.
// Estas regiones se utilizan para la nube de VM de Sauce Labs y la Sauce Labs Real Device Cloud.
// Si no proporcionas la región, el valor predeterminado es `us`.
region: 'us',
//
// Sauce Labs proporciona una [oferta sin interfaz](https://saucelabs.com/products/web-testing/sauce-headless-testing)
// que te permite ejecutar pruebas de Chrome y Firefox sin interfaz.
//
headless: false,
//
// ==================
// Especificar Archivos de Prueba
// ==================
// Define qué especificaciones de prueba deben ejecutarse. El patrón es relativo al directorio
// del archivo de configuración que se está ejecutando.
//
// Las especificaciones se definen como un array de archivos de especificación (opcionalmente utilizando comodines
// que se expandirán). La prueba para cada archivo de especificación se ejecutará en un proceso
// de trabajo separado. Para tener un grupo de archivos de especificación ejecutándose en el mismo proceso
// de trabajo, enciérralos en un array dentro del array de specs.
//
// La ruta de los archivos de especificación se resolverá relativamente desde el directorio
// del archivo de configuración a menos que sea absoluta.
//
specs: [
'test/spec/**',
['group/spec/**']
],
// Patrones a excluir.
exclude: [
'test/spec/multibrowser/**',
'test/spec/mobile/**'
],
//
// ============
// Capacidades
// ============
// Define tus capacidades aquí. WebdriverIO puede ejecutar múltiples capacidades al mismo
// tiempo. Dependiendo del número de capacidades, WebdriverIO inicia varias sesiones
// de prueba. Dentro de tus `capabilities`, puedes sobrescribir las opciones `spec` y `exclude`
// para agrupar especificaciones específicas a una capacidad específica.
//
// Primero, puedes definir cuántas instancias deben iniciarse al mismo tiempo. Supongamos
// que tienes 3 capacidades diferentes (Chrome, Firefox y Safari) y has
// establecido `maxInstances` en 1. wdio generará 3 procesos.
//
// Por lo tanto, si tienes 10 archivos de especificación y estableces `maxInstances` en 10, todos los archivos de especificación
// se probarán al mismo tiempo y se generarán 30 procesos.
//
// La propiedad maneja cuántas capacidades de la misma prueba deben ejecutar pruebas.
//
maxInstances: 10,
//
// O establece un límite para ejecutar pruebas con una capacidad específica.
maxInstancesPerCapability: 10,
//
// Inserta los globales de WebdriverIO (por ejemplo, `browser`, `$` y `$$`) en el entorno global.
// Si lo estableces en `false`, debes importar desde `@wdio/globals`. Nota: WebdriverIO no
// maneja la inyección de globales específicos del marco de pruebas.
//
injectGlobals: true,
//
// Si tienes problemas para reunir todas las capacidades importantes, consulta el
// configurador de plataforma Sauce Labs - una gran herramienta para configurar tus capacidades:
// https://docs.saucelabs.com/basics/platform-configurator
//
capabilities: [{
browserName: 'chrome',
'goog:chromeOptions': {
// para ejecutar chrome sin interfaz se requieren las siguientes banderas
// (ver https://developers.google.com/web/updates/2017/04/headless-chrome)
// args: ['--headless', '--disable-gpu'],
}
//
// Parámetro para ignorar algunas o todas las banderas predeterminadas
// - si el valor es true: ignora todas las 'banderas predeterminadas' de DevTools y los 'argumentos predeterminados' de Puppeteer
// - si el valor es un array: DevTools filtra los argumentos predeterminados dados
// 'wdio:devtoolsOptions': {
// ignoreDefaultArgs: true,
// ignoreDefaultArgs: ['--disable-sync', '--disable-extensions'],
// }
}, {
// maxInstances puede sobrescribirse por capacidad. Por lo tanto, si tienes una grid Selenium interna
// con solo 5 instancias de firefox disponibles, puedes asegurarte de que no se inicien más de
// 5 instancias a la vez.
'wdio:maxInstances': 5,
browserName: 'firefox',
'wdio:specs': [
'test/ffOnly/*'
],
'moz:firefoxOptions': {
// bandera para activar el modo sin interfaz de Firefox (consulta https://github.com/mozilla/geckodriver/blob/master/README.md#firefox-capabilities para más detalles sobre moz:firefoxOptions)
// args: ['-headless']
},
// Si se proporciona outputDir, WebdriverIO puede capturar registros de sesión del controlador
// es posible configurar qué logTypes excluir.
excludeDriverLogs: ['bugreport', 'server'],
//
// Parámetro para ignorar algunos o todos los argumentos predeterminados de Puppeteer
// ignoreDefaultArgs: ['-foreground'], // establece el valor en true para ignorar todos los argumentos predeterminados
}],
//
// Lista adicional de argumentos de nodo para usar al iniciar procesos secundarios
execArgv: [],
//
// ===================
// Configuraciones de Prueba
// ===================
// Define todas las opciones relevantes para la instancia de WebdriverIO aquí
//
// Nivel de detalle de registro: trace | debug | info | warn | error | silent
logLevel: 'info',
//
// Establece niveles de registro específicos por registrador
// usa el nivel 'silent' para deshabilitar un registrador
logLevels: {
webdriver: 'info',
'@wdio/appium-service': 'info'
},
//
// Establece el directorio para almacenar todos los registros
outputDir: __dirname,
//
// Si solo quieres ejecutar tus pruebas hasta que una cantidad específica de pruebas hayan fallado, usa
// bail (el valor predeterminado es 0 - no detenerse, ejecutar todas las pruebas).
bail: 0,
//
// Establece una URL base para acortar las llamadas al comando `url()`. Si tu parámetro `url` comienza
// con `/`, se antepone la `baseUrl`, sin incluir la parte de la ruta de `baseUrl`.
//
// Si tu parámetro `url` comienza sin un esquema o `/` (como `some/path`), la `baseUrl`
// se antepone directamente.
baseUrl: 'http://localhost:8080',
//
// Tiempo de espera predeterminado para todos los comandos waitForXXX.
waitforTimeout: 1000,
//
// Agregar archivos para observar (por ejemplo, código de aplicación o objetos de página) cuando se ejecuta el comando `wdio`
// con la bandera `--watch`. Se admiten comodines.
filesToWatch: [
// por ejemplo, volver a ejecutar pruebas si cambio mi código de aplicación
// './app/**/*.js'
],
//
// Framework con el que quieres ejecutar tus especificaciones.
// Los siguientes son compatibles: 'mocha', 'jasmine', y 'cucumber'
// Consulta también: https://webdriver.io/docs/frameworks.html
//
// Asegúrate de tener instalado el paquete adaptador wdio para el framework específico antes de ejecutar cualquier prueba.
framework: 'mocha',
//
// El número de veces para volver a intentar todo el archivo de especificación cuando falla en su totalidad
specFileRetries: 1,
// Retraso en segundos entre los intentos de reintentar el archivo de especificación
specFileRetriesDelay: 0,
// Si los archivos de especificación reintentados deben reintentarse inmediatamente o diferirse al final de la cola
specFileRetriesDeferred: false,
//
// Reportero de pruebas para stdout.
// El único compatible por defecto es 'dot'
// Consulta también: https://webdriver.io/docs/dot-reporter.html , y haz clic en "Reporters" en la columna izquierda
reporters: [
'dot',
['allure', {
//
// Si estás usando el reportero "allure", debes definir el directorio donde
// WebdriverIO debe guardar todos los informes allure.
outputDir: './'
}]
],
//
// Opciones para pasar a Mocha.
// Consulta la lista completa en: http://mochajs.org
mochaOpts: {
ui: 'bdd'
},
//
// Opciones para pasar a Jasmine.
// Consulta también: https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-jasmine-framework#jasmineopts-options
jasmineOpts: {
//
// Tiempo de espera predeterminado de Jasmine
defaultTimeoutInterval: 5000,
//
// El framework Jasmine permite interceptar cada afirmación para registrar el estado de la aplicación
// o sitio web dependiendo del resultado. Por ejemplo, es muy útil tomar una captura de pantalla cada vez
// que falla una afirmación.
expectationResultHandler: function(passed, assertion) {
// haz algo
},
//
// Utiliza la funcionalidad grep específica de Jasmine
grep: null,
invertGrep: null
},
//
// Si estás usando Cucumber, debes especificar dónde se encuentran tus definiciones de pasos.
// Consulta también: https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-cucumber-framework#cucumberopts-options
cucumberOpts: {
require: [], // <string[]> (archivo/dir) requiere archivos antes de ejecutar características
backtrace: false, // <boolean> muestra el seguimiento completo de los errores
compiler: [], // <string[]> ("extensión:módulo") requiere archivos con la EXTENSION dada después de requerir el MÓDULO (repetible)
dryRun: false, // <boolean> invoca formateadores sin ejecutar pasos
failFast: false, // <boolean> aborta la ejecución en el primer fallo
snippets: true, // <boolean> oculta fragmentos de definición de pasos para pasos pendientes
source: true, // <boolean> oculta URIs de origen
strict: false, // <boolean> falla si hay pasos indefinidos o pendientes
tagExpression: '', // <string> (expresión) solo ejecuta las características o escenarios con etiquetas que coincidan con la expresión
timeout: 20000, // <number> tiempo de espera para definiciones de pasos
ignoreUndefinedDefinitions: false, // <boolean> Habilita esta configuración para tratar las definiciones indefinidas como advertencias.
scenarioLevelReporter: false // Habilita esto para hacer que webdriver.io se comporte como si los escenarios y no los pasos fueran las pruebas.
},
// Especifica una ruta de tsconfig personalizada - WDIO usa `tsx` para compilar archivos TypeScript
// Tu TSConfig se detecta automáticamente desde el directorio de trabajo actual
// pero puedes especificar una ruta personalizada aquí o configurando la variable de entorno TSX_TSCONFIG_PATH
// Consulta la documentación de `tsx`: https://tsx.is/dev-api/node-cli#custom-tsconfig-json-path
//
// Nota: Esta configuración será anulada por la variable de entorno TSX_TSCONFIG_PATH y/o el argumento de cli --tsConfigPath si se especifican.
// Esta configuración será ignorada si node no puede analizar tu archivo wdio.conf.ts sin la ayuda de tsx, por ejemplo, si tienes
// alias de ruta configurados en tsconfig.json y utilizas esos alias de ruta dentro de tu archivo wdio.config.ts.
// Usa esto solo si estás utilizando un archivo de configuración .js o si tu archivo de configuración .ts es JavaScript válido.
tsConfigPath: 'path/to/tsconfig.json',
//
// =====
// Hooks
// =====
// WebdriverIO proporciona varios hooks que puedes utilizar para interferir en el proceso de prueba con el fin de mejorarlo
// y construir servicios a su alrededor. Puedes aplicar una sola función o un array de
// métodos. Si uno de ellos devuelve una promesa, WebdriverIO esperará hasta que esa promesa se
// resuelva para continuar.
//
/**
* Se ejecuta una vez antes de que se inicien todos los trabajadores.
* @param {object} config objeto de configuración wdio
* @param {Array.<Object>} capabilities lista de detalles de capacidades
*/
onPrepare: function (config, capabilities) {
},
/**
* Se ejecuta antes de que se genere un proceso de trabajo y puede usarse para inicializar un servicio específico
* para ese trabajador, así como para modificar entornos de ejecución de manera asíncrona.
* @param {string} cid id de capacidad (por ejemplo, 0-0)
* @param {object} caps objeto que contiene capacidades para la sesión que se generará en el trabajador
* @param {object} specs especificaciones a ejecutar en el proceso de trabajo
* @param {object} args objeto que se fusionará con la configuración principal una vez que se inicialice el trabajador
* @param {object} execArgv lista de argumentos de cadena pasados al proceso de trabajo
*/
onWorkerStart: function (cid, caps, specs, args, execArgv) {
},
/**
* Se ejecuta después de que un proceso de trabajo haya finalizado.
* @param {string} cid id de capacidad (por ejemplo, 0-0)
* @param {number} exitCode 0 - éxito, 1 - fallo
* @param {object} specs especificaciones a ejecutar en el proceso de trabajo
* @param {number} retries número de reintentos utilizados
*/
onWorkerEnd: function (cid, exitCode, specs, retries) {
},
/**
* Se ejecuta antes de inicializar la sesión del navegador web y el framework de pruebas. Permite
* manipular configuraciones dependiendo de la capacidad o especificación.
* @param {object} config objeto de configuración wdio
* @param {Array.<Object>} capabilities lista de detalles de capacidades
* @param {Array.<String>} specs Lista de rutas de archivos de especificación que se ejecutarán
*/
beforeSession: function (config, capabilities, specs) {
},
/**
* Se ejecuta antes de que comience la ejecución de la prueba. En este punto puedes acceder a todas las variables
* globales como `browser`. Es el lugar perfecto para definir comandos personalizados.
* @param {Array.<Object>} capabilities lista de detalles de capacidades
* @param {Array.<String>} specs Lista de rutas de archivos de especificación que se ejecutarán
* @param {object} browser instancia de la sesión de navegador/dispositivo creada
*/
before: function (capabilities, specs, browser) {
},
/**
* Se ejecuta antes de que comience la suite (solo en Mocha/Jasmine).
* @param {object} suite detalles de la suite
*/
beforeSuite: function (suite) {
},
/**
* Este hook se ejecuta _antes_ de cada hook dentro de la suite.
* (Por ejemplo, esto se ejecuta antes de llamar a `before`, `beforeEach`, `after`, `afterEach` en Mocha). En Cucumber, `context` es el objeto World.
*/
beforeHook: function (test, context, hookName) {
},
/**
* Hook que se ejecuta _después_ de cada hook dentro de la suite.
* (Por ejemplo, esto se ejecuta después de llamar a `before`, `beforeEach`, `after`, `afterEach` en Mocha). En Cucumber, `context` es el objeto World.
*/
afterHook: function (test, context, { error, result, duration, passed, retries }, hookName) {
},
/**
* Función a ejecutar antes de una prueba (solo en Mocha/Jasmine)
* @param {object} test objeto de prueba
* @param {object} context objeto de alcance con el que se ejecutó la prueba
*/
beforeTest: function (test, context) {
},
/**
* Se ejecuta antes de ejecutar un comando WebdriverIO.
* @param {string} commandName nombre del comando hook
* @param {Array} args argumentos que recibiría el comando
*/
beforeCommand: function (commandName, args) {
},
/**
* Se ejecuta después de que se ejecuta un comando WebdriverIO
* @param {string} commandName nombre del comando hook
* @param {Array} args argumentos que recibiría el comando
* @param {*} result resultado del comando
* @param {Error} error objeto de error, si lo hay
*/
afterCommand: function (commandName, args, result, error) {
},
/**
* Función a ejecutar después de una prueba (solo en Mocha/Jasmine)
* @param {object} test objeto de prueba
* @param {object} context objeto de alcance con el que se ejecutó la prueba
* @param {Error} result.error objeto de error en caso de que la prueba falle, de lo contrario `undefined`
* @param {*} result.result objeto de retorno de la función de prueba
* @param {number} result.duration duración de la prueba
* @param {boolean} result.passed verdadero si la prueba ha pasado, falso en caso contrario
* @param {object} result.retries información sobre los reintentos relacionados con la especificación, por ejemplo, `{ attempts: 0, limit: 0 }`
*/
afterTest: function (test, context, { error, result, duration, passed, retries }) {
},
/**
* Hook que se ejecuta después de que la suite ha terminado (solo en Mocha/Jasmine).
* @param {object} suite detalles de la suite
*/
afterSuite: function (suite) {
},
/**
* Se ejecuta después de que todas las pruebas hayan terminado. Todavía tienes acceso a todas las variables globales de
* la prueba.
* @param {number} result 0 - prueba aprobada, 1 - prueba fallida
* @param {Array.<Object>} capabilities lista de detalles de capacidades
* @param {Array.<String>} specs Lista de rutas de archivos de especificación que se ejecutaron
*/
after: function (result, capabilities, specs) {
},
/**
* Se ejecuta justo después de terminar la sesión del navegador web.
* @param {object} config objeto de configuración wdio
* @param {Array.<Object>} capabilities lista de detalles de capacidades
* @param {Array.<String>} specs Lista de rutas de archivos de especificación que se ejecutaron
*/
afterSession: function (config, capabilities, specs) {
},
/**
* Se ejecuta después de que todos los trabajadores se hayan apagado y el proceso esté a punto de salir.
* Un error lanzado en el hook `onComplete` resultará en el fallo de la ejecución de la prueba.
* @param {object} exitCode 0 - éxito, 1 - fallo
* @param {object} config objeto de configuración wdio
* @param {Array.<Object>} capabilities lista de detalles de capacidades
* @param {<Object>} results objeto que contiene resultados de pruebas
*/
onComplete: function (exitCode, config, capabilities, results) {
},
/**
* Se ejecuta cuando ocurre una actualización.
* @param {string} oldSessionId ID de sesión de la sesión antigua
* @param {string} newSessionId ID de sesión de la nueva sesión
*/
onReload: function(oldSessionId, newSessionId) {
},
/**
* Hooks de Cucumber
*
* Se ejecuta antes de una Característica de Cucumber.
* @param {string} uri ruta al archivo de características
* @param {GherkinDocument.IFeature} feature objeto de característica de Cucumber
*/
beforeFeature: function (uri, feature) {
},
/**
*
* Se ejecuta antes de un Escenario de Cucumber.
* @param {ITestCaseHookParameter} world objeto world que contiene información sobre pickle y paso de prueba
* @param {object} context objeto Cucumber World
*/
beforeScenario: function (world, context) {
},
/**
*
* Se ejecuta antes de un Paso de Cucumber.
* @param {Pickle.IPickleStep} step datos del paso
* @param {IPickle} scenario pickle del escenario
* @param {object} context objeto Cucumber World
*/
beforeStep: function (step, scenario, context) {
},
/**
*
* Se ejecuta después de un Paso de Cucumber.
* @param {Pickle.IPickleStep} step datos del paso
* @param {IPickle} scenario pickle del escenario
* @param {object} result objeto de resultados que contiene resultados del escenario
* @param {boolean} result.passed verdadero si el escenario ha pasado
* @param {string} result.error pila de errores si el escenario falló
* @param {number} result.duration duración del escenario en milisegundos
* @param {object} context objeto Cucumber World
*/
afterStep: function (step, scenario, result, context) {
},
/**
*
* Se ejecuta después de un Escenario de Cucumber.
* @param {ITestCaseHookParameter} world objeto world que contiene información sobre pickle y paso de prueba
* @param {object} result objeto de resultados que contiene resultados del escenario `{passed: boolean, error: string, duration: number}`
* @param {boolean} result.passed verdadero si el escenario ha pasado
* @param {string} result.error pila de errores si el escenario falló
* @param {number} result.duration duración del escenario en milisegundos
* @param {object} context objeto Cucumber World
*/
afterScenario: function (world, result, context) {
},
/**
*
* Se ejecuta después de una Característica de Cucumber.
* @param {string} uri ruta al archivo de características
* @param {GherkinDocument.IFeature} feature objeto de característica de Cucumber
*/
afterFeature: function (uri, feature) {
},
/**
* Se ejecuta antes de que una biblioteca de aserciones de WebdriverIO haga una aserción.
* @param commandName nombre del comando
* @param args argumentos que recibiría el comando
*/
beforeAssertion: function (params) {
},
/**
* Se ejecuta después de que se ejecuta un comando WebdriverIO
* @param commandName nombre del comando
* @param args argumentos que recibiría el comando
* @param result resultado del comando
* @param error error en caso de que algo salga mal
*/
afterAssertion: function (params) {
}
}
También puedes encontrar un archivo con todas las opciones posibles y variaciones en la carpeta de ejemplos.
