L'Objet Mock

L'objet mock est un objet qui représente une simulation réseau et contient des informations sur les requêtes correspondant à une url et des filterOptions donnés. Il peut être obtenu en utilisant la commande mock.

info

Notez que l'utilisation de la commande mock nécessite la prise en charge du protocole Chrome DevTools. Cette prise en charge est disponible si vous exécutez des tests localement dans un navigateur basé sur Chromium ou si vous utilisez Selenium Grid v4 ou supérieur. Cette commande ne peut pas être utilisée lors de l'exécution de tests automatisés dans le cloud. Pour en savoir plus, consultez la section Protocoles d'Automatisation.

Vous pouvez en savoir plus sur la simulation des requêtes et des réponses dans WebdriverIO dans notre guide Mocks et Spies.

Propriétés

Un objet mock contient les propriétés suivantes :

Nom	Type	Détails
url	String	L'URL passée à la commande mock
filterOptions	Object	Les options de filtrage des ressources passées à la commande mock
browser	Object	L'Objet Browser utilisé pour obtenir l'objet mock.
calls	Object[]	Informations sur les requêtes du navigateur correspondantes, contenant des propriétés telles que url, method, headers, initialPriority, referrerPolic, statusCode, responseHeaders et body

Méthodes

Les objets mock fournissent diverses commandes, listées dans la section mock, qui permettent aux utilisateurs de modifier le comportement de la requête ou de la réponse.

• abort
• abortOnce
• clear
• request
• requestOnce
• respond
• respondOnce
• restore
• waitForResponse

Événements

L'objet mock est un EventEmitter et plusieurs événements sont émis pour vos cas d'utilisation.

Voici une liste des événements.

request

Cet événement est émis lors du lancement d'une requête réseau qui correspond aux modèles mock. La requête est passée dans le callback de l'événement.

Interface de requête :

interface RequestEvent {
    requestId: number
    request: Matches
    responseStatusCode: number
    responseHeaders: Record<string, string>
}

overwrite

Cet événement est émis lorsque la réponse réseau est remplacée avec respond ou respondOnce. La réponse est passée dans le callback de l'événement.

Interface de réponse :

interface OverwriteEvent {
    requestId: number
    responseCode: number
    responseHeaders: Record<string, string>
    body?: string | Record<string, any>
}

fail

Cet événement est émis lorsqu'une requête réseau est interrompue avec abort ou abortOnce. L'échec est passé dans le callback de l'événement.

Interface d'échec :

interface FailEvent {
    requestId: number
    errorReason: Protocol.Network.ErrorReason
}

match

Cet événement est émis lorsqu'une nouvelle correspondance est ajoutée, avant continue ou overwrite. La correspondance est passée dans le callback de l'événement.

Interface de correspondance :

interface MatchEvent {
    url: string // URL de la requête (sans fragment).
    urlFragment?: string // Fragment de l'URL demandée commençant par un hash, si présent.
    method: string // Méthode de requête HTTP.
    headers: Record<string, string> // En-têtes de requête HTTP.
    postData?: string // Données de requête HTTP POST.
    hasPostData?: boolean // Vrai lorsque la requête a des données POST.
    mixedContentType?: MixedContentType // Le type d'export de contenu mixte de la requête.
    initialPriority: ResourcePriority // Priorité de la requête de ressource au moment où la requête est envoyée.
    referrerPolicy: ReferrerPolicy // La politique de référent de la requête, telle que définie dans https://www.w3.org/TR/referrer-policy/
    isLinkPreload?: boolean // Si elle est chargée via un préchargement de lien.
    body: string | Buffer | JsonCompatible // Corps de réponse de la ressource réelle.
    responseHeaders: Record<string, string> // En-têtes de réponse HTTP.
    statusCode: number // Code d'état de réponse HTTP.
    mockedResponse?: string | Buffer // Si le mock, émettant l'événement, a également modifié sa réponse.
}

continue

Cet événement est émis lorsque la réponse réseau n'a été ni remplacée ni interrompue, ou si la réponse a déjà été envoyée par un autre mock. requestId est passé dans le callback de l'événement.

Exemples

Obtenir le nombre de requêtes en attente :

let pendingRequests = 0
const mock = await browser.mock('**') // il est important de correspondre à toutes les requêtes, sinon, la valeur résultante peut être très déroutante.
mock.on('request', ({request}) => {
    pendingRequests++
    console.log(`requête correspondante pour ${request.url}, ${pendingRequests} requêtes en attente`)
})
mock.on('match', ({url}) => {
    pendingRequests--
    console.log(`requête résolue pour ${url}, ${pendingRequests} requêtes en attente`)
})

Générer une erreur en cas d'échec réseau 404 :

browser.addCommand('loadPageWithout404', (url, {selector, predicate}) => new Promise(async (resolve, reject) => {
    const mock = await this.mock('**')

    mock.on('match', ({url, statusCode}) => {
        if (statusCode === 404) {
            reject(new Error(`la requête vers ${url} a échoué avec "Not Found"`))
        }
    })

    await this.url(url).catch(reject)

    // attente ici, car certaines requêtes peuvent être encore en attente
    if (selector) {
        await this.$(selector).waitForExist().catch(reject)
    }

    if (predicate) {
        await this.waitUntil(predicate).catch(reject)
    }

    resolve()
}))

await browser.loadPageWithout404(browser, 'some/url', { selector: 'main' })

Déterminer si la valeur de réponse du mock a été utilisée :

const firstMock = await browser.mock('**/foo/**')
const secondMock = await browser.mock('**/foo/bar/**')

firstMock.respondOnce({id: 3, title: 'three'})
secondMock.respond({id: 4, title: 'four'})

firstMock.on('overwrite', () => {
    // se déclenche pour la première requête vers '**/foo/**'
}).on('continue', () => {
    // se déclenche pour le reste des requêtes vers '**/foo/**'
})

secondMock.on('continue', () => {
    // se déclenche pour la première requête vers '**/foo/bar/**'
}).on('overwrite', () => {
    // se déclenche pour le reste des requêtes vers '**/foo/bar/**'
})

Dans cet exemple, firstMock a été défini en premier et possède un appel respondOnce, donc la valeur de réponse de secondMock ne sera pas utilisée pour la première requête, mais sera utilisée pour les suivantes.