Mock-objektet

Mock-objektet är ett objekt som representerar en nätverksmock och innehåller information om förfrågningar som matchade given url och filterOptions. Det kan erhållas med hjälp av kommandot mock.

info

Observera att användning av mock-kommandot kräver stöd för Chrome DevTools-protokollet. Detta stöd ges om du kör tester lokalt i Chromium-baserade webbläsare eller om du använder Selenium Grid v4 eller högre. Detta kommando kan inte användas när du kör automatiserade tester i molnet. Läs mer i avsnittet Automation Protocols.

Du kan läsa mer om att mocka förfrågningar och svar i WebdriverIO i vår guide Mocks and Spies.

Egenskaper

Ett mock-objekt innehåller följande egenskaper:

Namn	Typ	Detaljer
url	String	URL:en som skickades in i mock-kommandot
filterOptions	Object	Resursfiltreringsalternativen som skickades in i mock-kommandot
browser	Object	Browser Object som användes för att få mock-objektet.
calls	Object[]	Information om matchande webbläsarförfrågningar, innehållande egenskaper som url, method, headers, initialPriority, referrerPolic, statusCode, responseHeaders och body

Metoder

Mock-objekt tillhandahåller olika kommandon, listade i avsnittet mock, som låter användare modifiera beteendet för förfrågan eller svaret.

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

Händelser

Mock-objektet är en EventEmitter och ett antal händelser emitteras för dina användningsfall.

Här är en lista över händelser.

request

Denna händelse emitteras när en nätverksförfrågan som matchar mock-mönster görs. Förfrågan skickas i händelsecallback.

Request-gränssnitt:

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

overwrite

Denna händelse emitteras när nätverkssvar skrivs över med respond eller respondOnce. Svaret skickas i händelsecallback.

Response-gränssnitt:

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

fail

Denna händelse emitteras när nätverksförfrågan avbryts med abort eller abortOnce. Felet skickas i händelsecallback.

Fail-gränssnitt:

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

match

Denna händelse emitteras när en ny matchning läggs till, före continue eller overwrite. Matchningen skickas i händelsecallback.

Match-gränssnitt:

interface MatchEvent {
    url: string // Request URL (without fragment).
    urlFragment?: string // Fragment of the requested URL starting with hash, if present.
    method: string // HTTP request method.
    headers: Record<string, string> // HTTP request headers.
    postData?: string // HTTP POST request data.
    hasPostData?: boolean // True when the request has POST data.
    mixedContentType?: MixedContentType // The mixed content export type of the request.
    initialPriority: ResourcePriority // Priority of the resource request at the time request is sent.
    referrerPolicy: ReferrerPolicy // The referrer policy of the request, as defined in https://www.w3.org/TR/referrer-policy/
    isLinkPreload?: boolean // Whether is loaded via link preload.
    body: string | Buffer | JsonCompatible // Body response of actual resource.
    responseHeaders: Record<string, string> // HTTP response headers.
    statusCode: number // HTTP response status code.
    mockedResponse?: string | Buffer // If mock, emitting the event, also modified it's response.
}

continue

Denna händelse emitteras när nätverkssvaret varken har skrivits över eller avbrutits, eller om svaret redan har skickats av en annan mock. requestId skickas i händelsecallback.

Exempel

Att få antal väntande förfrågningar:

let pendingRequests = 0
const mock = await browser.mock('**') // it is important to match all requests otherwise, the resulting value can be very confusing.
mock.on('request', ({request}) => {
    pendingRequests++
    console.log(`matched request to ${request.url}, pending ${pendingRequests} requests`)
})
mock.on('match', ({url}) => {
    pendingRequests--
    console.log(`resolved request to ${url}, pending ${pendingRequests} requests`)
})

Att kasta ett fel vid 404-nätverksfel:

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(`request to ${url} failed with "Not Found"`))
        }
    })

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

    // waiting here, because some requests can still be pending
    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' })

Att avgöra om mock respond-värdet användes:

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', () => {
    // triggers for first request to '**/foo/**'
}).on('continue', () => {
    // triggers for rest requests to '**/foo/**'
})

secondMock.on('continue', () => {
    // triggers for first request to '**/foo/bar/**'
}).on('overwrite', () => {
    // triggers for rest requests to '**/foo/bar/**'
})

I detta exempel definierades firstMock först och har ett respondOnce-anrop, så secondMock-svarsvärdet kommer inte att användas för den första förfrågan, men kommer att användas för resten av dem.