Aller au contenu principal

Configuration

Basé sur le type de configuration (par exemple, utilisation des liaisons de protocole brutes, WebdriverIO en tant que package autonome ou le testrunner WDIO), il existe un ensemble différent d'options disponibles pour contrôler l'environnement.

Options WebDriver​

Les options suivantes sont définies lors de l'utilisation du package de protocole webdriver :

protocol​

Protocole à utiliser lors de la communication avec le serveur de pilote.

Type: String
Par défaut: http

hostname​

Hôte de votre serveur de pilote.

Type: String
Par défaut: 0.0.0.0

port​

Port sur lequel se trouve votre serveur de pilote.

Type: Number
Par défaut: undefined

path​

Chemin vers le point de terminaison du serveur de pilote.

Type: String
Par défaut: /

queryParams​

Paramètres de requête qui sont propagés au serveur de pilote.

Type: Object
Par défaut: undefined

user​

Votre nom d'utilisateur de service cloud (fonctionne uniquement pour les comptes Sauce Labs, Browserstack, TestingBot ou LambdaTest). Si défini, WebdriverIO définira automatiquement les options de connexion pour vous. Si vous n'utilisez pas de fournisseur cloud, cela peut être utilisé pour authentifier n'importe quel autre backend WebDriver.

Type: String
Par défaut: undefined

key​

Votre clé d'accès ou clé secrète du service cloud (fonctionne uniquement pour les comptes Sauce Labs, Browserstack, TestingBot ou LambdaTest). Si défini, WebdriverIO définira automatiquement les options de connexion pour vous. Si vous n'utilisez pas de fournisseur cloud, cela peut être utilisé pour authentifier n'importe quel autre backend WebDriver.

Type: String
Par défaut: undefined

capabilities​

Définit les capacités que vous souhaitez exécuter dans votre session WebDriver. Consultez le Protocole WebDriver pour plus de détails. Si vous exécutez un pilote plus ancien qui ne prend pas en charge le protocole WebDriver, vous devrez utiliser les capacités JSONWireProtocol pour exécuter avec succès une session.

En plus des capacités basées sur WebDriver, vous pouvez appliquer des options spécifiques au navigateur et au fournisseur qui permettent une configuration plus approfondie du navigateur ou de l'appareil distant. Celles-ci sont documentées dans les documents des fournisseurs correspondants, par exemple :

De plus, un utilitaire utile est le Configurateur de Test Automatisé de Sauce Labs, qui vous aide à créer cet objet en cliquant sur vos capacités souhaitées.

Type: Object
Par défaut: null

Exemple:

{
    browserName: 'chrome', // options: `chrome`, `edge`, `firefox`, `safari`
    browserVersion: '27.0', // version du navigateur
    platformName: 'Windows 10' // plateforme OS
}

Si vous exécutez des tests web ou natifs sur des appareils mobiles, capabilities diffère du protocole WebDriver. Consultez la Documentation d'Appium pour plus de détails.

logLevel​

Niveau de verbosité de la journalisation.

Type: String
Par défaut: info
Options: trace | debug | info | warn | error | silent

outputDir​

Répertoire pour stocker tous les fichiers journaux du testrunner (y compris les journaux de reporter et les journaux wdio). Si non défini, tous les journaux sont diffusés vers stdout. Étant donné que la plupart des reporters sont conçus pour journaliser vers stdout, il est recommandé de n'utiliser cette option que pour des reporters spécifiques où il est plus logique de pousser le rapport dans un fichier (comme le reporter junit, par exemple).

En mode autonome, le seul journal généré par WebdriverIO sera le journal wdio.

Type: String
Par défaut: null

connectionRetryTimeout​

Délai pour toute requête WebDriver vers un pilote ou une grille.

Type: Number
Par défaut: 120000

connectionRetryCount​

Nombre maximal de tentatives de requête vers le serveur Selenium.

Type: Number
Par défaut: 3

agent​

Vous permet d'utiliser un http/https/http2 agent personnalisé pour effectuer des requêtes.

Type: Object
Par défaut:

{
    http: new http.Agent({ keepAlive: true }),
    https: new https.Agent({ keepAlive: true })
}

headers​

Spécifiez des headers personnalisés à transmettre dans chaque requête WebDriver. Si votre grille Selenium nécessite une authentification de base, nous vous recommandons de passer un en-tête Authorization via cette option pour authentifier vos requêtes WebDriver, par exemple :

import { Buffer } from 'buffer';
// Read the username and password from environment variables
const username = process.env.SELENIUM_GRID_USERNAME;
const password = process.env.SELENIUM_GRID_PASSWORD;

// Combine the username and password with a colon separator
const credentials = `${username}:${password}`;
// Encode the credentials using Base64
const encodedCredentials = Buffer.from(credentials).toString('base64');

export const config: WebdriverIO.Config = {
    // ...
    headers: {
        Authorization: `Basic ${encodedCredentials}`
    }
    // ...
}

Type: Object
Par défaut: {}

transformRequest​

Fonction interceptant les options de requête HTTP avant qu'une requête WebDriver ne soit effectuée

Type: (RequestOptions) => RequestOptions
Par défaut: aucun

transformResponse​

Fonction interceptant les objets de réponse HTTP après l'arrivée d'une réponse WebDriver. La fonction reçoit l'objet de réponse original comme premier argument et les RequestOptions correspondantes comme second argument.

Type: (Response, RequestOptions) => Response
Par défaut: aucun

strictSSL​

S'il n'exige pas que le certificat SSL soit valide. Il peut être défini via des variables d'environnement comme STRICT_SSL ou strict_ssl.

Type: Boolean
Par défaut: true

enableDirectConnect​

Activer ou non la fonctionnalité de connexion directe d'Appium. Cela ne fait rien si la réponse n'avait pas les clés appropriées lorsque le drapeau est activé.

Type: Boolean
Par défaut: true

cacheDir​

Le chemin vers la racine du répertoire de cache. Ce répertoire est utilisé pour stocker tous les pilotes qui sont téléchargés lors de la tentative de démarrage d'une session.

Type: String
Par défaut: process.env.WEBDRIVER_CACHE_DIR || os.tmpdir()

WebdriverIO​

Les options suivantes (y compris celles énumérées ci-dessus) peuvent être utilisées avec WebdriverIO en mode autonome :

automationProtocol​

Définissez le protocole que vous souhaitez utiliser pour votre automatisation de navigateur. Actuellement, seul webdriver est pris en charge, car c'est la principale technologie d'automatisation de navigateur utilisée par WebdriverIO.

Si vous souhaitez automatiser le navigateur à l'aide d'une technologie d'automatisation différente, assurez-vous de définir cette propriété sur un chemin qui mène à un module adhérant à l'interface suivante :

import type { Capabilities } from '@wdio/types';
import type { Client, AttachOptions } from 'webdriver';

export default class YourAutomationLibrary {
    /**
     * Start a automation session and return a WebdriverIO [monad](https://github.com/webdriverio/webdriverio/blob/940cd30939864bdbdacb2e94ee6e8ada9b1cc74c/packages/wdio-utils/src/monad.ts)
     * with respective automation commands. See the [webdriver](https://www.npmjs.com/package/webdriver) package
     * as a reference implementation
     *
     * @param {Capabilities.RemoteConfig} options WebdriverIO options
     * @param {Function} hook that allows to modify the client before it gets released from the function
     * @param {PropertyDescriptorMap} userPrototype allows user to add custom protocol commands
     * @param {Function} customCommandWrapper allows to modify the command execution
     * @returns a WebdriverIO compatible client instance
     */
    static newSession(
        options: Capabilities.RemoteConfig,
        modifier?: (...args: any[]) => any,
        userPrototype?: PropertyDescriptorMap,
        customCommandWrapper?: (...args: any[]) => any
    ): Promise<Client>;

    /**
     * allows user to attach to existing sessions
     * @optional
     */
    static attachToSession(
        options?: AttachOptions,
        modifier?: (...args: any[]) => any, userPrototype?: {},
        commandWrapper?: (...args: any[]) => any
    ): Client;

    /**
     * Changes The instance session id and browser capabilities for the new session
     * directly into the passed in browser object
     *
     * @optional
     * @param   {object} instance  the object we get from a new browser session.
     * @returns {string}           the new session id of the browser
     */
    static reloadSession(
        instance: Client,
        newCapabilities?: WebdriverIO.Capabilitie
    ): Promise<string>;
}

Type: String
Par défaut: webdriver

baseUrl​

Raccourcissez les appels de commande url en définissant une URL de base.

  • Si votre paramètre url commence par /, alors baseUrl est ajouté au début (sauf le chemin baseUrl, s'il en a un).
  • Si votre paramètre url commence sans schéma ou / (comme some/path), alors le baseUrl complet est ajouté directement au début.

Type: String
Par défaut: null

waitforTimeout​

Délai par défaut pour toutes les commandes waitFor*. (Notez le 'f' minuscule dans le nom de l'option.) Ce délai affecte uniquement les commandes commençant par waitFor* et leur temps d'attente par défaut.

Pour augmenter le délai d'un test, veuillez consulter la documentation du framework.

Type: Number
Par défaut: 5000

waitforInterval​

Intervalle par défaut pour toutes les commandes waitFor* pour vérifier si un état attendu (par exemple, la visibilité) a été modifié.

Type: Number
Par défaut: 100

region​

Si vous exécutez sur Sauce Labs, vous pouvez choisir d'exécuter des tests entre différents centres de données : US ou EU. Pour changer votre région en EU, ajoutez region: 'eu' à votre configuration.

Remarque : Cela n'a d'effet que si vous fournissez des options user et key qui sont connectées à votre compte Sauce Labs.

Type: String
Par défaut: us

(uniquement pour vm et/ou em/simulateurs)

Options du Testrunner​

Les options suivantes (y compris celles énumérées ci-dessus) sont définies uniquement pour l'exécution de WebdriverIO avec le testrunner WDIO :

specs​

Définissez les spécifications pour l'exécution des tests. Vous pouvez soit spécifier un modèle glob pour faire correspondre plusieurs fichiers à la fois, soit envelopper un glob ou un ensemble de chemins dans un tableau pour les exécuter dans un seul processus de travail. Tous les chemins sont considérés comme relatifs au chemin du fichier de configuration.

Type: (String | String[])[]
Par défaut: []

exclude​

Excluez les spécifications de l'exécution des tests. Tous les chemins sont considérés comme relatifs au chemin du fichier de configuration.

Type: String[]
Par défaut: []

suites​

Un objet décrivant diverses suites, que vous pouvez ensuite spécifier avec l'option --suite sur l'interface de ligne de commande wdio.

Type: Object
Par défaut: {}

capabilities​

La même chose que la section capabilities décrite ci-dessus, à l'exception de l'option de spécifier soit un objet multiremote, soit plusieurs sessions WebDriver dans un tableau pour une exécution parallèle.

Vous pouvez appliquer les mêmes capacités spécifiques au fournisseur et au navigateur que celles définies ci-dessus.

Type: Object|Object[]
Par défaut: [{ 'wdio:maxInstances': 5, browserName: 'firefox' }]

maxInstances​

Nombre maximum total de travailleurs parallèles en cours d'exécution.

Remarque : qu'il peut s'agir d'un nombre aussi élevé que 100, lorsque les tests sont effectués sur des fournisseurs externes tels que les machines de Sauce Labs. Là, les tests ne sont pas testés sur une seule machine, mais plutôt sur plusieurs machines virtuelles. Si les tests doivent être exécutés sur une machine de développement locale, utilisez un nombre plus raisonnable, comme 3, 4 ou 5. Essentiellement, c'est le nombre de navigateurs qui seront démarrés simultanément et qui exécuteront vos tests en même temps, donc cela dépend de la quantité de RAM disponible sur votre machine et du nombre d'autres applications en cours d'exécution sur votre machine.

Vous pouvez également appliquer maxInstances dans vos objets de capacité en utilisant la capacité wdio:maxInstances. Cela limitera le nombre de sessions parallèles pour cette capacité particulière.

Type: Number
Par défaut: 100

maxInstancesPerCapability​

Nombre maximum total de travailleurs parallèles en cours d'exécution par capacité.

Type: Number
Par défaut: 100

injectGlobals​

Insère les éléments globaux de WebdriverIO (par exemple, browser, $ et $$) dans l'environnement global. Si vous définissez à false, vous devriez importer depuis @wdio/globals, par exemple :

import { browser, $, $$, expect } from '@wdio/globals'

Remarque : WebdriverIO ne gère pas l'injection de globales spécifiques au framework de test.

Type: Boolean
Par défaut: true

bail​

Si vous souhaitez que l'exécution de votre test s'arrête après un nombre spécifique d'échecs de test, utilisez bail. (Par défaut, c'est 0, ce qui exécute tous les tests quoi qu'il arrive.) Remarque : Un test dans ce contexte sont tous les tests dans un seul fichier de spécification (lors de l'utilisation de Mocha ou Jasmine) ou toutes les étapes dans un fichier de fonctionnalité (lors de l'utilisation de Cucumber). Si vous souhaitez contrôler le comportement du bail dans les tests d'un seul fichier de test, jetez un coup d'œil aux options de framework disponibles.

Type: Number
Par défaut: 0 (ne pas s'arrêter ; exécuter tous les tests)

specFileRetries​

Le nombre de fois pour réessayer un fichier de spécification entier lorsqu'il échoue dans son ensemble.

Type: Number
Par défaut: 0

specFileRetriesDelay​

Délai en secondes entre les tentatives de réessai du fichier de spécification

Type: Number
Par défaut: 0

specFileRetriesDeferred​

Si les fichiers de spécification réessayés doivent être réessayés immédiatement ou différés à la fin de la file d'attente.

Type: Boolean
Par défaut: true

groupLogsByTestSpec​

Choisissez la vue de sortie du journal.

Si défini sur false, les journaux de différents fichiers de test seront imprimés en temps réel. Veuillez noter que cela peut entraîner le mélange des sorties de journal de différents fichiers lors de l'exécution en parallèle.

Si défini sur true, les sorties de journal seront regroupées par spécification de test et imprimées uniquement lorsque la spécification de test est terminée.

Par défaut, il est défini sur false, donc les journaux sont imprimés en temps réel.

Type: Boolean
Par défaut: false

services​

Les services prennent en charge un travail spécifique dont vous ne voulez pas vous occuper. Ils améliorent votre configuration de test sans presque aucun effort.

Type: String[]|Object[]
Par défaut: []

framework​

Définit le framework de test à utiliser par le testrunner WDIO.

Type: String
Par défaut: mocha
Options: mocha | jasmine

mochaOpts, jasmineOpts et cucumberOpts​

Options spécifiques au framework. Consultez la documentation de l'adaptateur de framework pour connaître les options disponibles. Pour en savoir plus à ce sujet, consultez Frameworks.

Type: Object
Par défaut: { timeout: 10000 }

cucumberFeaturesWithLineNumbers​

Liste des fonctionnalités cucumber avec numéros de ligne (lorsque vous utilisez le framework cucumber).

Type: String[] Par défaut: []

reporters​

Liste des reporters à utiliser. Un reporter peut être soit une chaîne, soit un tableau de ['reporterName', { /* reporter options */}] où le premier élément est une chaîne avec le nom du reporter et le second élément un objet avec les options du reporter.

Type: String[]|Object[]
Par défaut: []

Exemple:

reporters: [
    'dot',
    'spec'
    ['junit', {
        outputDir: `${__dirname}/reports`,
        otherOption: 'foobar'
    }]
]

reporterSyncInterval​

Détermine à quel intervalle le reporter doit vérifier s'ils sont synchronisés s'ils rapportent leurs journaux de manière asynchrone (par exemple, si les journaux sont diffusés vers un fournisseur tiers).

Type: Number
Par défaut: 100 (ms)

reporterSyncTimeout​

Détermine le temps maximum dont disposent les reporters pour terminer le téléchargement de tous leurs journaux jusqu'à ce qu'une erreur soit générée par le testrunner.

Type: Number
Par défaut: 5000 (ms)

execArgv​

Arguments Node à spécifier lors du lancement des processus enfants.

Type: String[]
Par défaut: null

filesToWatch​

Une liste de modèles de chaînes prenant en charge glob qui indiquent au testrunner de surveiller d'autres fichiers, par exemple des fichiers d'application, lors de son exécution avec le flag --watch. Par défaut, le testrunner surveille déjà tous les fichiers de spécification.

Type: String[]
Par défaut: []

updateSnapshots​

Définissez sur true si vous souhaitez mettre à jour vos instantanés. Idéalement utilisé dans le cadre d'un paramètre CLI, par exemple wdio run wdio.conf.js --s.

Type: 'new' | 'all' | 'none'
Par défaut: none si non fourni et que les tests sont exécutés dans CI, new si non fourni, sinon ce qui a été fourni

resolveSnapshotPath​

Remplace le chemin d'instantané par défaut. Par exemple, pour stocker des instantanés à côté des fichiers de test.

wdio.conf.ts
export const config: WebdriverIO.Config = {
    resolveSnapshotPath: (testPath, snapExtension) => testPath + snapExtension,
}

Type: (testPath: string, snapExtension: string) => string
Par défaut: stocke les fichiers d'instantanés dans le répertoire __snapshots__ à côté du fichier de test

tsConfigPath​

WDIO utilise tsx pour compiler les fichiers TypeScript. Votre TSConfig est automatiquement détecté à partir du répertoire de travail actuel, mais vous pouvez spécifier un chemin personnalisé ici ou en définissant la variable d'environnement TSX_TSCONFIG_PATH.

Voir la documentation de tsx : https://tsx.is/dev-api/node-cli#custom-tsconfig-json-path

Type: String
Par défaut: null

Hooks​

Le testrunner WDIO vous permet de définir des hooks à déclencher à des moments spécifiques du cycle de vie du test. Cela permet des actions personnalisées (par exemple, prendre une capture d'écran si un test échoue).

Chaque hook a comme paramètre des informations spécifiques sur le cycle de vie (par exemple, des informations sur la suite de tests ou le test). Pour en savoir plus sur toutes les propriétés des hooks, consultez notre exemple de configuration.

Remarque : Certains hooks (onPrepare, onWorkerStart, onWorkerEnd et onComplete) sont exécutés dans un processus différent et ne peuvent donc pas partager de données globales avec les autres hooks qui vivent dans le processus de travail.

onPrepare​

S'exécute une fois avant que tous les travailleurs ne soient lancés.

Paramètres :

  • config (object) : objet de configuration WebdriverIO
  • param (object[]) : liste des détails des capacités

onWorkerStart​

S'exécute avant qu'un processus de travail ne soit généré et peut être utilisé pour initialiser un service spécifique pour ce travailleur ainsi que pour modifier les environnements d'exécution de manière asynchrone.

Paramètres :

  • cid (string) : id de capacité (par exemple 0-0)
  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • specs (string[]) : spécifications à exécuter dans le processus de travail
  • args (object) : objet qui sera fusionné avec la configuration principale une fois le travailleur initialisé
  • execArgv (string[]) : liste d'arguments de chaîne transmis au processus de travail

onWorkerEnd​

S'exécute juste après qu'un processus de travail a quitté.

Paramètres :

  • cid (string) : id de capacité (par exemple 0-0)
  • exitCode (number) : 0 - succès, 1 - échec
  • specs (string[]) : spécifications à exécuter dans le processus de travail
  • retries (number) : nombre de tentatives au niveau de la spécification utilisées comme défini dans "Ajouter des tentatives sur la base d'un fichier de spécification"

beforeSession​

S'exécute juste avant l'initialisation de la session webdriver et du framework de test. Il vous permet de manipuler les configurations en fonction de la capacité ou de la spécification.

Paramètres :

  • config (object) : objet de configuration WebdriverIO
  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • specs (string[]) : spécifications à exécuter dans le processus de travail

before​

S'exécute avant le début de l'exécution du test. À ce stade, vous pouvez accéder à toutes les variables globales comme browser. C'est l'endroit idéal pour définir des commandes personnalisées.

Paramètres :

  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • specs (string[]) : spécifications à exécuter dans le processus de travail
  • browser (object) : instance de la session de navigateur/appareil créée

beforeSuite​

Hook qui s'exécute avant le début de la suite (uniquement dans Mocha/Jasmine)

Paramètres :

  • suite (object) : détails de la suite

beforeHook​

Hook qui s'exécute avant un hook dans la suite démarre (par exemple, s'exécute avant d'appeler beforeEach dans Mocha)

Paramètres :

  • test (object) : détails du test
  • context (object) : contexte de test (représente l'objet World dans Cucumber)

afterHook​

Hook qui s'exécute après la fin d'un hook dans la suite (par exemple, s'exécute après avoir appelé afterEach dans Mocha)

Paramètres :

  • test (object) : détails du test
  • context (object) : contexte de test (représente l'objet World dans Cucumber)
  • result (object) : résultat du hook (contient les propriétés error, result, duration, passed, retries)

beforeTest​

Fonction à exécuter avant un test (uniquement dans Mocha/Jasmine).

Paramètres :

  • test (object) : détails du test
  • context (object) : objet de portée avec lequel le test a été exécuté

beforeCommand​

S'exécute avant l'exécution d'une commande WebdriverIO.

Paramètres :

  • commandName (string) : nom de la commande
  • args (*) : arguments que la commande recevrait

afterCommand​

S'exécute après l'exécution d'une commande WebdriverIO.

Paramètres :

  • commandName (string) : nom de la commande
  • args (*) : arguments que la commande recevrait
  • result (number) : 0 - succès de la commande, 1 - erreur de la commande
  • error (Error) : objet d'erreur le cas échéant

afterTest​

Fonction à exécuter après la fin d'un test (dans Mocha/Jasmine).

Paramètres :

  • test (object) : détails du test
  • context (object) : objet de portée avec lequel le test a été exécuté
  • result.error (Error) : objet d'erreur en cas d'échec du test, sinon undefined
  • result.result (Any) : objet de retour de la fonction de test
  • result.duration (Number) : durée du test
  • result.passed (Boolean) : vrai si le test a réussi, sinon faux
  • result.retries (Object) : informations sur les tentatives liées à un seul test comme défini pour Mocha et Jasmine ainsi que Cucumber, par exemple { attempts: 0, limit: 0 }, voir
  • result (object) : résultat du hook (contient les propriétés error, result, duration, passed, retries)

afterSuite​

Hook qui s'exécute après la fin de la suite (uniquement dans Mocha/Jasmine)

Paramètres :

  • suite (object) : détails de la suite

after​

S'exécute après que tous les tests sont terminés. Vous avez toujours accès à toutes les variables globales du test.

Paramètres :

  • result (number) : 0 - test réussi, 1 - test échoué
  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • specs (string[]) : spécifications à exécuter dans le processus de travail

afterSession​

S'exécute juste après la fin de la session webdriver.

Paramètres :

  • config (object) : objet de configuration WebdriverIO
  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • specs (string[]) : spécifications à exécuter dans le processus de travail

onComplete​

S'exécute après que tous les travailleurs ont été arrêtés et que le processus est sur le point de se terminer. Une erreur lancée dans le hook onComplete entraînera l'échec de l'exécution du test.

Paramètres :

  • exitCode (number) : 0 - succès, 1 - échec
  • config (object) : objet de configuration WebdriverIO
  • caps (object) : contenant les capacités pour la session qui sera générée dans le travailleur
  • result (object) : objet de résultats contenant les résultats des tests

onReload​

S'exécute lors d'une actualisation.

Paramètres :

  • oldSessionId (string) : ID de session de l'ancienne session
  • newSessionId (string) : ID de session de la nouvelle session

beforeFeature​

S'exécute avant une fonctionnalité Cucumber.

Paramètres :

  • uri (string) : chemin vers le fichier de fonctionnalité
  • feature (GherkinDocument.IFeature) : objet de fonctionnalité Cucumber

afterFeature​

S'exécute après une fonctionnalité Cucumber.

Paramètres :

  • uri (string) : chemin vers le fichier de fonctionnalité
  • feature (GherkinDocument.IFeature) : objet de fonctionnalité Cucumber

beforeScenario​

S'exécute avant un scénario Cucumber.

Paramètres :

  • world (ITestCaseHookParameter) : objet world contenant des informations sur pickle et l'étape de test
  • context (object) : objet World Cucumber

afterScenario​

S'exécute après un scénario Cucumber.

Paramètres :

  • world (ITestCaseHookParameter) : objet world contenant des informations sur pickle et l'étape de test
  • result (object) : objet de résultats contenant les résultats du scénario
  • result.passed (boolean) : vrai si le scénario a réussi
  • result.error (string) : pile d'erreurs si le scénario a échoué
  • result.duration (number) : durée du scénario en millisecondes
  • context (object) : objet World Cucumber

beforeStep​

S'exécute avant une étape Cucumber.

Paramètres :

  • step (Pickle.IPickleStep) : objet d'étape Cucumber
  • scenario (IPickle) : objet de scénario Cucumber
  • context (object) : objet World Cucumber

afterStep​

S'exécute après une étape Cucumber.

Paramètres :

  • step (Pickle.IPickleStep) : objet d'étape Cucumber
  • scenario (IPickle) : objet de scénario Cucumber
  • result: (object) : objet de résultats contenant les résultats de l'étape
  • result.passed (boolean) : vrai si le scénario a réussi
  • result.error (string) : pile d'erreurs si le scénario a échoué
  • result.duration (number) : durée du scénario en millisecondes
  • context (object) : objet World Cucumber

beforeAssertion​

Hook qui s'exécute avant qu'une assertion WebdriverIO ne se produise.

Paramètres :

  • params: informations d'assertion
  • params.matcherName (string) : nom du matcher (par exemple toHaveTitle)
  • params.expectedValue: valeur passée dans le matcher
  • params.options: options d'assertion

afterAssertion​

Hook qui s'exécute après qu'une assertion WebdriverIO s'est produite.

Paramètres :

  • params: informations d'assertion
  • params.matcherName (string) : nom du matcher (par exemple toHaveTitle)
  • params.expectedValue: valeur passée dans le matcher
  • params.options: options d'assertion
  • params.result: résultats de l'assertion

Welcome! How can I help?

WebdriverIO AI Copilot