206 | }
207 | }
208 |
209 | /**
210 | * Extending types
211 | */
212 | declare module '@japa/runner/core' {
213 | export interface TestContext {
214 | /**
215 | * Playwright browser
216 | */
217 | browser: PlayWrightBrowser
218 |
219 | /**
220 | * Playwright browser context
221 | */
222 | browserContext: BrowserContext
223 |
224 | /**
225 | * Opens a new page and visit the URL
226 | */
227 | visit: BrowserContext['visit']
228 | }
229 | }
230 |
--------------------------------------------------------------------------------
/src/decorators/assertions.ts:
--------------------------------------------------------------------------------
1 | /*
2 | * @japa/browser-client
3 | *
4 | * (c) Japa.dev
5 | *
6 | * For the full copyright and license information, please view the LICENSE
7 | * file that was distributed with this source code.
8 | */
9 |
10 | import qs from '@poppinss/qs'
11 | import { inspect } from 'node:util'
12 | import { AssertionError } from 'node:assert'
13 | import type { Locator, Page } from 'playwright'
14 | import type { Decorator } from '../types/main.js'
15 | import { isSubsetOf, retryTest } from '../helpers.js'
16 | import { DEFAULT_ASSERTIONS_CONFIG } from '../plugin/normalize_config.js'
17 |
18 | /**
19 | * Returns locator for a selector
20 | */
21 | function getLocator(selector: string | Locator, page: Page): Locator {
22 | return typeof selector === 'string' ? page.locator(selector) : selector
23 | }
24 |
25 | /**
26 | * Decorates the page object with custom assertions
27 | */
28 | export const addAssertions = {
29 | page(page, _context, config) {
30 | const retrySettings = { ...DEFAULT_ASSERTIONS_CONFIG, ...config?.assertions }
31 |
32 | page.assertExists = function assertExists(selector) {
33 | return retryTest(retrySettings, async () => {
34 | const matchingCount = await getLocator(selector, this).count()
35 |
36 | if (matchingCount <= 0) {
37 | throw new AssertionError({
38 | message: `expected ${inspect(selector)} element to exist`,
39 | stackStartFn: assertExists,
40 | })
41 | }
42 | })
43 | }
44 |
45 | page.assertNotExists = function assertNotExists(selector) {
46 | return retryTest(retrySettings, async () => {
47 | const matchingCount = await getLocator(selector, this).count()
48 |
49 | if (matchingCount !== 0) {
50 | throw new AssertionError({
51 | message: `expected ${inspect(selector)} element to not exist`,
52 | stackStartFn: assertNotExists,
53 | })
54 | }
55 | })
56 | }
57 |
58 | page.assertElementsCount = function assertElementsCount(selector, expectedCount) {
59 | return retryTest(retrySettings, async () => {
60 | const matchingCount = await getLocator(selector, this).count()
61 |
62 | if (matchingCount !== expectedCount) {
63 | throw new AssertionError({
64 | message: `expected ${inspect(selector)} to have '${expectedCount}' elements`,
65 | stackStartFn: assertElementsCount,
66 | actual: matchingCount,
67 | expected: expectedCount,
68 | })
69 | }
70 | })
71 | }
72 |
73 | page.assertVisible = function assertVisible(selector) {
74 | return retryTest(retrySettings, async () => {
75 | const isVisible = await getLocator(selector, this).isVisible()
76 |
77 | if (!isVisible) {
78 | throw new AssertionError({
79 | message: `expected ${inspect(selector)} element to be visible`,
80 | stackStartFn: assertVisible,
81 | })
82 | }
83 | })
84 | }
85 |
86 | page.assertNotVisible = function assertNotVisible(selector) {
87 | return retryTest(retrySettings, async () => {
88 | const isVisible = await getLocator(selector, this).isVisible()
89 |
90 | if (isVisible) {
91 | throw new AssertionError({
92 | message: `expected ${inspect(selector)} element to be not visible`,
93 | stackStartFn: assertNotVisible,
94 | })
95 | }
96 | })
97 | }
98 |
99 | page.assertTitle = function assertTitle(expectedTitle) {
100 | return retryTest(retrySettings, async () => {
101 | const title = await this.title()
102 |
103 | if (title !== expectedTitle) {
104 | throw new AssertionError({
105 | message: `expected page title '${title}' to equal '${expectedTitle}'`,
106 | stackStartFn: assertTitle,
107 | actual: title,
108 | expected: expectedTitle,
109 | })
110 | }
111 | })
112 | }
113 |
114 | page.assertTitleContains = function assertTitleContains(expectedSubstring) {
115 | return retryTest(retrySettings, async () => {
116 | const pageTitle = await this.title()
117 |
118 | if (!pageTitle.includes(expectedSubstring)) {
119 | throw new AssertionError({
120 | message: `expected page title '${pageTitle}' to include '${expectedSubstring}'`,
121 | stackStartFn: assertTitleContains,
122 | })
123 | }
124 | })
125 | }
126 |
127 | page.assertUrl = function assertUrl(expectedUrl) {
128 | return retryTest(retrySettings, async () => {
129 | const url = this.url()
130 |
131 | if (url !== expectedUrl) {
132 | throw new AssertionError({
133 | message: `expected page URL '${url}' to equal '${expectedUrl}'`,
134 | stackStartFn: assertUrl,
135 | actual: url,
136 | expected: expectedUrl,
137 | })
138 | }
139 | })
140 | }
141 |
142 | page.assertUrlContains = function assertUrlContains(expectedSubstring) {
143 | return retryTest(retrySettings, async () => {
144 | const pageUrl = this.url()
145 |
146 | if (!pageUrl.includes(expectedSubstring)) {
147 | throw new AssertionError({
148 | message: `expected page URL '${pageUrl}' to include '${expectedSubstring}'`,
149 | stackStartFn: assertUrlContains,
150 | })
151 | }
152 | })
153 | }
154 |
155 | page.assertUrlMatches = function assertUrlMatches(regex) {
156 | return retryTest(retrySettings, async () => {
157 | const url = this.url()
158 |
159 | if (!regex.test(url)) {
160 | throw new AssertionError({
161 | message: `expected page URL '${url}' to match '${regex}'`,
162 | stackStartFn: assertUrlMatches,
163 | actual: url,
164 | expected: regex,
165 | })
166 | }
167 | })
168 | }
169 |
170 | page.assertPath = function assertPath(expectedPathName) {
171 | return retryTest(retrySettings, async () => {
172 | const { pathname } = new URL(this.url())
173 |
174 | if (pathname !== expectedPathName) {
175 | throw new AssertionError({
176 | message: `expected page pathname '${pathname}' to equal '${expectedPathName}'`,
177 | stackStartFn: assertPath,
178 | actual: pathname,
179 | expected: expectedPathName,
180 | })
181 | }
182 | })
183 | }
184 |
185 | page.assertPathContains = function assertPathContains(expectedSubstring) {
186 | return retryTest(retrySettings, async () => {
187 | const { pathname } = new URL(this.url())
188 |
189 | if (!pathname.includes(expectedSubstring)) {
190 | throw new AssertionError({
191 | message: `expected page pathname '${pathname}' to include '${expectedSubstring}'`,
192 | stackStartFn: assertPathContains,
193 | })
194 | }
195 | })
196 | }
197 |
198 | page.assertPathMatches = function assertPathMatches(regex) {
199 | return retryTest(retrySettings, async () => {
200 | const { pathname } = new URL(this.url())
201 |
202 | if (!regex.test(pathname)) {
203 | throw new AssertionError({
204 | message: `expected page pathname '${pathname}' to match '${regex}'`,
205 | stackStartFn: assertPathMatches,
206 | })
207 | }
208 | })
209 | }
210 |
211 | page.assertQueryString = function assertQueryString(expectedSubset) {
212 | return retryTest(retrySettings, async () => {
213 | const pageURL = new URL(this.url())
214 | const queryString = qs.parse(pageURL.search, { ignoreQueryPrefix: true })
215 |
216 | if (!isSubsetOf(queryString, expectedSubset)) {
217 | throw new AssertionError({
218 | message: `expected '${inspect(queryString)}' to contain '${inspect(expectedSubset)}'`,
219 | stackStartFn: assertQueryString,
220 | actual: queryString,
221 | expected: expectedSubset,
222 | })
223 | }
224 | })
225 | }
226 |
227 | page.assertCookie = function assertCookie(cookieName, value?) {
228 | return retryTest(retrySettings, async () => {
229 | const pageCookies = await this.context().cookies()
230 | const matchingCookie = pageCookies.find(({ name }) => name === cookieName)
231 |
232 | if (!matchingCookie) {
233 | throw new AssertionError({
234 | message: `expected '${cookieName}' cookie to exist`,
235 | stackStartFn: assertCookie,
236 | })
237 | }
238 |
239 | if (value && matchingCookie.value !== value) {
240 | throw new AssertionError({
241 | message: `expected '${cookieName}' cookie value to equal '${value}'`,
242 | stackStartFn: assertCookie,
243 | actual: matchingCookie.value,
244 | expected: value,
245 | })
246 | }
247 | })
248 | }
249 |
250 | page.assertCookieMissing = function assertCookieMissing(cookieName) {
251 | return retryTest(retrySettings, async () => {
252 | const pageCookies = await this.context().cookies()
253 | const matchingCookie = pageCookies.find(({ name }) => name === cookieName)
254 |
255 | if (matchingCookie) {
256 | throw new AssertionError({
257 | message: `expected '${cookieName}' cookie to not exist`,
258 | stackStartFn: assertCookieMissing,
259 | })
260 | }
261 | })
262 | }
263 |
264 | page.assertText = function assertText(selector, expectedValue) {
265 | return retryTest(retrySettings, async () => {
266 | const actual = await getLocator(selector, this).innerText({ timeout: 2000 })
267 | if (actual !== expectedValue) {
268 | throw new AssertionError({
269 | message: `expected ${inspect(selector)} inner text to equal '${expectedValue}'`,
270 | stackStartFn: assertText,
271 | actual: actual,
272 | expected: expectedValue,
273 | })
274 | }
275 | })
276 | }
277 |
278 | page.assertElementsText = function assertElementsText(selector, expectedValues) {
279 | return retryTest(retrySettings, async () => {
280 | const innertTexts = await getLocator(selector, this).allInnerTexts()
281 |
282 | innertTexts.forEach((text, index) => {
283 | if (text !== expectedValues[index]) {
284 | throw new AssertionError({
285 | message: `expected ${inspect(selector)} value to deeply equal ${inspect(
286 | expectedValues
287 | )} in same order`,
288 | stackStartFn: assertElementsText,
289 | actual: innertTexts,
290 | expected: expectedValues,
291 | })
292 | }
293 | })
294 | })
295 | }
296 |
297 | page.assertTextContains = function assertTextContains(selector, expectedSubstring) {
298 | return retryTest(retrySettings, async () => {
299 | const actual = await getLocator(selector, this).innerText({ timeout: 2000 })
300 |
301 | if (!actual.includes(expectedSubstring)) {
302 | throw new AssertionError({
303 | message: `expected ${inspect(selector)} inner text to include '${expectedSubstring}'`,
304 | stackStartFn: assertTextContains,
305 | })
306 | }
307 | })
308 | }
309 |
310 | page.assertChecked = function assertChecked(selector) {
311 | return retryTest(retrySettings, async () => {
312 | let isChecked: boolean | undefined
313 |
314 | try {
315 | isChecked = await getLocator(selector, this).isChecked({ timeout: 2000 })
316 | } catch (error) {
317 | if (error.message.includes('Not a checkbox')) {
318 | throw new AssertionError({
319 | message: `expected ${inspect(selector)} to be a checkbox`,
320 | stackStartFn: assertChecked,
321 | })
322 | }
323 |
324 | throw error
325 | }
326 |
327 | /**
328 | * Assert only when we are able to locate the checkbox
329 | */
330 | if (isChecked === false) {
331 | throw new AssertionError({
332 | message: `expected ${inspect(selector)} checkbox to be checked`,
333 | stackStartFn: assertChecked,
334 | })
335 | }
336 | })
337 | }
338 |
339 | page.assertNotChecked = function assertNotChecked(selector) {
340 | return retryTest(retrySettings, async () => {
341 | let isChecked: boolean | undefined
342 |
343 | try {
344 | isChecked = await getLocator(selector, this).isChecked({ timeout: 2000 })
345 | } catch (error) {
346 | if (error.message.includes('Not a checkbox')) {
347 | throw new AssertionError({
348 | message: `expected ${inspect(selector)} to be a checkbox`,
349 | stackStartFn: assertNotChecked,
350 | })
351 | }
352 |
353 | throw error
354 | }
355 |
356 | /**
357 | * Assert only when we are able to locate the checkbox
358 | */
359 | if (isChecked === true) {
360 | throw new AssertionError({
361 | message: `expected ${inspect(selector)} checkbox to be not checked`,
362 | stackStartFn: assertNotChecked,
363 | })
364 | }
365 | })
366 | }
367 |
368 | page.assertDisabled = function assertDisabled(selector) {
369 | return retryTest(retrySettings, async () => {
370 | const isDisabled = await getLocator(selector, this).isDisabled({ timeout: 2000 })
371 |
372 | if (!isDisabled) {
373 | throw new AssertionError({
374 | message: `expected ${inspect(selector)} element to be disabled`,
375 | stackStartFn: assertDisabled,
376 | })
377 | }
378 | })
379 | }
380 |
381 | page.assertNotDisabled = function assertNotDisabled(selector) {
382 | return retryTest(retrySettings, async () => {
383 | const isDisabled = await getLocator(selector, this).isDisabled({ timeout: 2000 })
384 |
385 | if (isDisabled) {
386 | throw new AssertionError({
387 | message: `expected ${inspect(selector)} element to be not disabled`,
388 | stackStartFn: assertNotDisabled,
389 | })
390 | }
391 | })
392 | }
393 |
394 | page.assertInputValue = function assertInputValue(selector, expectedValue) {
395 | return retryTest(retrySettings, async () => {
396 | let inputValue: string | undefined
397 |
398 | try {
399 | inputValue = await getLocator(selector, this).inputValue({ timeout: 2000 })
400 | } catch (error) {
401 | if (error.message.includes('Node is not')) {
402 | throw new AssertionError({
403 | message: `expected ${inspect(selector)} element to be an input, select or a textarea`,
404 | stackStartFn: assertInputValue,
405 | })
406 | }
407 |
408 | throw error
409 | }
410 |
411 | if (inputValue !== expectedValue) {
412 | throw new AssertionError({
413 | message: `expected ${inspect(selector)} value to equal '${expectedValue}'`,
414 | stackStartFn: assertInputValue,
415 | actual: inputValue,
416 | expected: expectedValue,
417 | })
418 | }
419 | })
420 | }
421 |
422 | page.assertSelectedOptions = function assertSelectedOptions(selector, expectedValues) {
423 | return retryTest(retrySettings, async () => {
424 | const element = await this.$eval(selector, (node) => {
425 | /* c8 ignore start */
426 | if (node.nodeName === 'SELECT') {
427 | const options = [...node.options]
428 | return {
429 | multiple: node.multiple,
430 | selected: options
431 | .filter((option: any) => option.selected)
432 | .map((option: any) => option.value),
433 | }
434 | }
435 | /* c8 ignore end */
436 | })
437 |
438 | /**
439 | * Not a select box
440 | */
441 | if (!element) {
442 | throw new AssertionError({
443 | message: `expected ${inspect(selector)} element to be a select box`,
444 | stackStartFn: assertSelectedOptions,
445 | })
446 | }
447 |
448 | /**
449 | * Using different assertions for multiple and single
450 | * select boxes
451 | */
452 | if (element.multiple) {
453 | element.selected.forEach((elem) => {
454 | if (!expectedValues.includes(elem)) {
455 | throw new AssertionError({
456 | message: `expected ${inspect(selector)} value to deeply equal ${inspect(
457 | expectedValues
458 | )}`,
459 | stackStartFn: assertSelectedOptions,
460 | actual: element.selected,
461 | expected: expectedValues,
462 | })
463 | }
464 | })
465 | } else {
466 | if (element.selected[0] !== expectedValues[0]) {
467 | throw new AssertionError({
468 | message: `expected ${inspect(selector)} value to equal ${inspect(expectedValues)}`,
469 | stackStartFn: assertSelectedOptions,
470 | actual: element.selected[0],
471 | expected: expectedValues[0],
472 | })
473 | }
474 | }
475 | })
476 | }
477 | },
478 | } satisfies Decorator
479 |
--------------------------------------------------------------------------------
/tests/page/assertions.spec.ts:
--------------------------------------------------------------------------------
1 | /*
2 | * @japa/browser-client
3 | *
4 | * (c) Japa.dev
5 | *
6 | * For the full copyright and license information, please view the LICENSE
7 | * file that was distributed with this source code.
8 | */
9 |
10 | import { test } from '@japa/runner'
11 | import { chromium } from 'playwright'
12 |
13 | import { decorateBrowser } from '../../index.js'
14 | import { ServerFactory } from '../../factories/server.js'
15 | import { addAssertions } from '../../src/decorators/assertions.js'
16 | import type { PluginConfig } from '../../src/types/main.js'
17 | import { basicDocument } from '../helpers.js'
18 |
19 | test.group('Assertions', () => {
20 | // Use short timeout for expect in order to speed up tests for failing assertions
21 | const pluginConfig: PluginConfig = {
22 | assertions: {
23 | timeout: 200,
24 | },
25 | }
26 |
27 | test('assert element to exist', async ({ assert, cleanup }) => {
28 | const server = new ServerFactory()
29 | await server.create((_, res) => {
30 | res.setHeader('content-type', 'text/html')
31 | res.write(
32 | basicDocument({
33 | body: `
34 | Hello world
35 | Title
36 | `,
37 | })
38 | )
39 | res.end()
40 | })
41 |
42 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
43 | cleanup(async () => {
44 | await server.close()
45 | await browser.close()
46 | })
47 |
48 | const page = await browser.newPage()
49 |
50 | await page.goto(server.url)
51 | await page.assertExists('p')
52 | await page.assertExists('h1')
53 | await assert.rejects(() => page.assertExists('span'), /expected 'span' element to exist/)
54 |
55 | await page.evaluate(() => {
56 | setTimeout(() => {
57 | // @ts-expect-error
58 | document.body.appendChild(document.createElement('h2'))
59 | }, 50)
60 | })
61 | await page.assertExists(page.locator('h2'))
62 | })
63 |
64 | test('assert elements to have expected count', async ({ assert, cleanup }) => {
65 | const server = new ServerFactory()
66 | await server.create((_, res) => {
67 | res.setHeader('content-type', 'text/html')
68 | res.write(
69 | basicDocument({
70 | body: `
71 | Hello world
72 | Hi world
73 |
74 | Title
75 |
76 |
77 | - Hello world
78 | - Hi world
79 | - Bye world
80 |
81 | `,
82 | })
83 | )
84 | res.end()
85 | })
86 |
87 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
88 | cleanup(async () => {
89 | await server.close()
90 | await browser.close()
91 | })
92 |
93 | const page = await browser.newPage()
94 |
95 | await page.goto(server.url)
96 | await page.assertElementsCount('p', 2)
97 | await page.assertElementsCount('h1', 1)
98 | await page.assertElementsCount('ul > li ', 3)
99 | await assert.rejects(
100 | () => page.assertElementsCount('span', 1),
101 | /expected 'span' to have '1' elements/
102 | )
103 |
104 | await page.evaluate(() => {
105 | setTimeout(() => {
106 | // @ts-expect-error
107 | document.querySelector('ul').appendChild(document.createElement('li'))
108 | }, 50)
109 | })
110 | await page.assertElementsCount('ul > li ', 4)
111 | })
112 |
113 | test('assert element to not exist', async ({ assert, cleanup }) => {
114 | const server = new ServerFactory()
115 | await server.create((_, res) => {
116 | res.setHeader('content-type', 'text/html')
117 | res.write(basicDocument({ body: ` Title
` }))
118 | res.end()
119 | })
120 |
121 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
122 | cleanup(async () => {
123 | await server.close()
124 | await browser.close()
125 | })
126 |
127 | const page = await browser.newPage()
128 |
129 | await page.goto(server.url)
130 | await page.assertNotExists('p')
131 | await page.assertNotExists('span')
132 | await assert.rejects(() => page.assertNotExists('h1'), /expected 'h1' element to not exist/)
133 |
134 | await page.evaluate(() => {
135 | setTimeout(() => {
136 | // @ts-expect-error
137 | document.querySelector('h1').remove()
138 | }, 50)
139 | })
140 | await page.assertNotExists('h1')
141 | })
142 |
143 | test('assert element to be visible', async ({ assert, cleanup }) => {
144 | const server = new ServerFactory()
145 | await server.create((_, res) => {
146 | res.setHeader('content-type', 'text/html')
147 | res.write(
148 | basicDocument({
149 | body: `
150 | Hello world
151 | Title
152 | `,
153 | })
154 | )
155 | res.end()
156 | })
157 |
158 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
159 | cleanup(async () => {
160 | await server.close()
161 | await browser.close()
162 | })
163 |
164 | const page = await browser.newPage()
165 |
166 | await page.goto(server.url)
167 | await page.assertVisible('p')
168 | await assert.rejects(() => page.assertVisible('h1'), /expected 'h1' element to be visible/)
169 | await assert.rejects(() => page.assertVisible('span'), /expected 'span' element to be visible/)
170 |
171 | await page.evaluate(() => {
172 | setTimeout(() => {
173 | // @ts-expect-error
174 | document.querySelector('h1').style.display = ''
175 | }, 50)
176 | })
177 | await page.assertVisible('h1')
178 | })
179 |
180 | test('assert element to be not visible', async ({ assert, cleanup }) => {
181 | const server = new ServerFactory()
182 | await server.create((_, res) => {
183 | res.setHeader('content-type', 'text/html')
184 | res.write(
185 | basicDocument({
186 | body: `
187 | Hello world
188 | Title
189 | `,
190 | })
191 | )
192 | res.end()
193 | })
194 |
195 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
196 | cleanup(async () => {
197 | await server.close()
198 | await browser.close()
199 | })
200 |
201 | const page = await browser.newPage()
202 |
203 | await page.goto(server.url)
204 | await page.assertNotVisible('h1')
205 | await page.assertNotVisible('span')
206 | await assert.rejects(() => page.assertNotVisible('p'), /expected 'p' element to be not visible/)
207 |
208 | await page.evaluate(() => {
209 | setTimeout(() => {
210 | // @ts-expect-error
211 | document.querySelector('p').style.display = 'none'
212 | }, 50)
213 | })
214 | await page.assertNotVisible('p')
215 | })
216 |
217 | test('assert page title', async ({ assert, cleanup }) => {
218 | const server = new ServerFactory()
219 | await server.create((_, res) => {
220 | res.setHeader('content-type', 'text/html')
221 | res.write(basicDocument({ title: 'Hello world' }))
222 | res.end()
223 | })
224 |
225 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
226 | cleanup(async () => {
227 | await server.close()
228 | await browser.close()
229 | })
230 |
231 | const page = await browser.newPage()
232 |
233 | await page.goto(server.url)
234 | await page.assertTitle('Hello world')
235 | await assert.rejects(
236 | () => page.assertTitle('Foo'),
237 | /expected page title 'Hello world' to equal 'Foo'/
238 | )
239 |
240 | await page.evaluate(() => {
241 | setTimeout(() => {
242 | // @ts-expect-error
243 | document.title = 'New title'
244 | }, 50)
245 | })
246 | await page.assertTitle('New title')
247 | })
248 |
249 | test('assert page title to include a substr', async ({ assert, cleanup }) => {
250 | const server = new ServerFactory()
251 | await server.create((_, res) => {
252 | res.setHeader('content-type', 'text/html')
253 | res.write(basicDocument({ title: 'Hello world' }))
254 | res.end()
255 | })
256 |
257 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
258 | cleanup(async () => {
259 | await server.close()
260 | await browser.close()
261 | })
262 |
263 | const page = await browser.newPage()
264 |
265 | await page.goto(server.url)
266 | await page.assertTitleContains('world')
267 | await assert.rejects(
268 | () => page.assertTitleContains('Foo'),
269 | /expected page title 'Hello world' to include 'Foo'/
270 | )
271 |
272 | await page.evaluate(() => {
273 | setTimeout(() => {
274 | // @ts-expect-error
275 | document.title = 'New title'
276 | }, 50)
277 | })
278 | await page.assertTitleContains('New ')
279 | })
280 |
281 | test('assert page URL', async ({ assert, cleanup }) => {
282 | assert.plan(1)
283 |
284 | const server = new ServerFactory()
285 | await server.create((_, res) => {
286 | res.setHeader('content-type', 'text/html')
287 | res.write(basicDocument())
288 | res.end()
289 | })
290 |
291 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
292 | cleanup(async () => {
293 | await server.close()
294 | await browser.close()
295 | })
296 |
297 | const page = await browser.newPage()
298 |
299 | await page.goto(`${server.url}/foo/bar`)
300 | await page.assertUrl(`${server.url}/foo/bar`)
301 | await assert.rejects(
302 | () => page.assertUrl('Foo'),
303 | new RegExp("expected page URL 'http://localhost:3000/foo/bar' to equal 'Foo'")
304 | )
305 |
306 | await page.evaluate(() => {
307 | setTimeout(() => {
308 | // @ts-expect-error
309 | location.href = '/bar/foo'
310 | }, 50)
311 | })
312 | await page.assertUrl(`${server.url}/bar/foo`)
313 | })
314 |
315 | test('assert page URL with query string', async ({ assert, cleanup }) => {
316 | assert.plan(1)
317 |
318 | const server = new ServerFactory()
319 | await server.create((_, res) => {
320 | res.setHeader('content-type', 'text/html')
321 | res.write(`
322 |
323 | Hello world
324 |
325 |
326 |
327 | `)
328 | res.end()
329 | })
330 |
331 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
332 | cleanup(async () => {
333 | await server.close()
334 | await browser.close()
335 | })
336 |
337 | const page = await browser.newPage()
338 |
339 | await page.goto(`${server.url}/foo/bar?sort=id`)
340 | await page.assertUrl(`${server.url}/foo/bar?sort=id`)
341 | await assert.rejects(
342 | () => page.assertUrl('Foo?sort=id'),
343 | new RegExp(
344 | "expected page URL 'http://localhost:3000/foo/bar\\?sort=id' to equal 'Foo\\?sort=id'"
345 | )
346 | )
347 | })
348 |
349 | test('assert page URL to include a substring', async ({ assert, cleanup }) => {
350 | assert.plan(1)
351 |
352 | const server = new ServerFactory()
353 | await server.create((_, res) => {
354 | res.setHeader('content-type', 'text/html')
355 | res.write(basicDocument())
356 | res.end()
357 | })
358 |
359 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
360 | cleanup(async () => {
361 | await server.close()
362 | await browser.close()
363 | })
364 |
365 | const page = await browser.newPage()
366 |
367 | await page.goto(`${server.url}/foo/bar?sort=id`)
368 | await page.assertUrlContains(`${server.url}/foo/bar`)
369 | await assert.rejects(
370 | () => page.assertUrlContains('baz'),
371 | new RegExp("expected page URL 'http://localhost:3000/foo/bar\\?sort=id' to include 'baz'")
372 | )
373 |
374 | await page.evaluate(() => {
375 | setTimeout(() => {
376 | // @ts-expect-error
377 | location.href = '/bar/foo'
378 | }, 50)
379 | })
380 | await page.assertUrlContains('ar/fo')
381 | })
382 |
383 | test('assert page URL to match regex', async ({ assert, cleanup }) => {
384 | const server = new ServerFactory()
385 | await server.create((_, res) => {
386 | res.setHeader('content-type', 'text/html')
387 | res.write(basicDocument())
388 | res.end()
389 | })
390 |
391 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
392 | cleanup(async () => {
393 | await server.close()
394 | await browser.close()
395 | })
396 |
397 | const page = await browser.newPage()
398 |
399 | await page.goto(`${server.url}/foo/bar?sort=id`)
400 | await page.assertUrlMatches(/foo/)
401 | await assert.rejects(
402 | () => page.assertUrlMatches(/baz/),
403 | new RegExp("expected page URL 'http://localhost:3000/foo/bar\\?sort=id' to match '/baz/'")
404 | )
405 |
406 | await page.evaluate(() => {
407 | setTimeout(() => {
408 | // @ts-expect-error
409 | location.href = '/bar/foo'
410 | }, 50)
411 | })
412 | await page.assertUrlMatches(/ar\/fo/)
413 | })
414 |
415 | test('assert page path', async ({ assert, cleanup }) => {
416 | const server = new ServerFactory()
417 | await server.create((_, res) => {
418 | res.setHeader('content-type', 'text/html')
419 | res.write(basicDocument())
420 | res.end()
421 | })
422 |
423 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
424 | cleanup(async () => {
425 | await server.close()
426 | await browser.close()
427 | })
428 |
429 | const page = await browser.newPage()
430 |
431 | await page.goto(`${server.url}/foo/bar`)
432 | await page.assertPath('/foo/bar')
433 | await assert.rejects(
434 | () => page.assertPath('baz'),
435 | new RegExp("expected page pathname '/foo/bar' to equal 'baz'")
436 | )
437 |
438 | await page.evaluate(() => {
439 | setTimeout(() => {
440 | // @ts-expect-error
441 | location.href = '/bar/foo'
442 | }, 50)
443 | })
444 | await page.assertPath('/bar/foo')
445 | })
446 |
447 | test('assert page path to contain a substring', async ({ assert, cleanup }) => {
448 | const server = new ServerFactory()
449 | await server.create((_, res) => {
450 | res.setHeader('content-type', 'text/html')
451 | res.write(basicDocument())
452 | res.end()
453 | })
454 |
455 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
456 | cleanup(async () => {
457 | await server.close()
458 | await browser.close()
459 | })
460 |
461 | const page = await browser.newPage()
462 |
463 | await page.goto(`${server.url}/foo/bar`)
464 | await page.assertPathContains('foo')
465 | await assert.rejects(
466 | () => page.assertPathContains('baz'),
467 | new RegExp("expected page pathname '/foo/bar' to include 'baz'")
468 | )
469 |
470 | await page.evaluate(() => {
471 | setTimeout(() => {
472 | // @ts-expect-error
473 | location.href = '/bar/foo'
474 | }, 50)
475 | })
476 | await page.assertPathContains('ar/fo')
477 | })
478 |
479 | test('assert page path to match regex', async ({ assert, cleanup }) => {
480 | const server = new ServerFactory()
481 | await server.create((_, res) => {
482 | res.setHeader('content-type', 'text/html')
483 | res.write(basicDocument())
484 | res.end()
485 | })
486 |
487 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
488 | cleanup(async () => {
489 | await server.close()
490 | await browser.close()
491 | })
492 |
493 | const page = await browser.newPage()
494 |
495 | await page.goto(`${server.url}/foo/bar`)
496 | await page.assertPathMatches(/foo/)
497 | await assert.rejects(
498 | () => page.assertPathMatches(/baz/),
499 | new RegExp("expected page pathname '/foo/bar' to match '/baz/'")
500 | )
501 |
502 | await page.evaluate(() => {
503 | setTimeout(() => {
504 | // @ts-expect-error
505 | location.href = '/bar/foo'
506 | }, 50)
507 | })
508 | await page.assertPathMatches(/ar\/fo/)
509 | })
510 |
511 | test('assert page path with query string', async ({ assert, cleanup }) => {
512 | const server = new ServerFactory()
513 | await server.create((_, res) => {
514 | res.setHeader('content-type', 'text/html')
515 | res.write(basicDocument())
516 | res.end()
517 | })
518 |
519 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
520 | cleanup(async () => {
521 | await server.close()
522 | await browser.close()
523 | })
524 |
525 | const page = await browser.newPage()
526 |
527 | await page.goto(`${server.url}/foo/bar?sort=id`)
528 | await page.assertPath('/foo/bar')
529 | await assert.rejects(
530 | () => page.assertPath('baz'),
531 | /expected page pathname '\/foo\/bar' to equal 'baz'/
532 | )
533 | })
534 |
535 | test('assert page query string', async ({ assert, cleanup }) => {
536 | const server = new ServerFactory()
537 | await server.create((_, res) => {
538 | res.setHeader('content-type', 'text/html')
539 | res.write(basicDocument())
540 | res.end()
541 | })
542 |
543 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
544 | cleanup(async () => {
545 | await server.close()
546 | await browser.close()
547 | })
548 |
549 | const page = await browser.newPage()
550 |
551 | await page.goto(`${server.url}/foo/bar?sort=id&sortDir=asc`)
552 | await page.assertQueryString({ sort: 'id' })
553 | await page.assertQueryString({ sortDir: 'asc' })
554 | await assert.rejects(
555 | () => page.assertQueryString({ orderBy: 'id' }),
556 | /expected '\{ sort: 'id', sortDir: 'asc' \}' to contain '\{ orderBy: 'id' \}'/
557 | )
558 |
559 | await page.evaluate(() => {
560 | setTimeout(() => {
561 | // @ts-expect-error
562 | location.href = '/foo/bar?sort=id&sortDir=desc'
563 | }, 50)
564 | })
565 | await page.assertQueryString({ sortDir: 'desc' })
566 | })
567 |
568 | test('assert page to have a cookie', async ({ assert, cleanup }) => {
569 | const server = new ServerFactory()
570 | await server.create((req, res) => {
571 | if (req.url === '/set_cookie') {
572 | res.setHeader('set-cookie', 'cart_items=3')
573 | }
574 |
575 | if (req.url === '/set_other_cookie') {
576 | res.setHeader('set-cookie', 'cart_items=4')
577 | }
578 |
579 | res.setHeader('content-type', 'text/html')
580 | res.write(basicDocument())
581 | res.end()
582 | })
583 |
584 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
585 | cleanup(async () => {
586 | await server.close()
587 | await browser.close()
588 | })
589 |
590 | const page = await browser.newPage()
591 |
592 | await page.goto(server.url)
593 | await assert.rejects(
594 | () => page.assertCookie('cart_items'),
595 | /expected 'cart_items' cookie to exist/
596 | )
597 |
598 | await page.goto(`${server.url}/set_cookie`)
599 | await page.assertCookie('cart_items')
600 |
601 | await page.goto(`${server.url}/set_cookie`)
602 | await assert.rejects(
603 | () => page.assertCookie('cart_items', '2'),
604 | /expected 'cart_items' cookie value to equal '2'/
605 | )
606 |
607 | await page.goto(`${server.url}/set_cookie`)
608 | await page.assertCookie('cart_items', '3')
609 |
610 | await page.evaluate(() => {
611 | setTimeout(() => {
612 | // @ts-expect-error
613 | location.href = '/set_other_cookie'
614 | }, 50)
615 | })
616 | await page.assertCookie('cart_items', '4')
617 | })
618 |
619 | test('assert cookie to be missing', async ({ assert, cleanup }) => {
620 | const server = new ServerFactory()
621 | await server.create((req, res) => {
622 | if (req.url === '/set_cookie') {
623 | res.setHeader('set-cookie', 'cart_items=3')
624 | }
625 |
626 | res.setHeader('content-type', 'text/html')
627 | res.write(basicDocument())
628 | res.end()
629 | })
630 |
631 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
632 | cleanup(async () => {
633 | await server.close()
634 | await browser.close()
635 | })
636 |
637 | const page = await browser.newPage()
638 |
639 | await page.goto(server.url)
640 | await page.assertCookieMissing('cart_items')
641 |
642 | await page.goto(`${server.url}/set_cookie`)
643 | await assert.rejects(
644 | () => page.assertCookieMissing('cart_items'),
645 | /expected 'cart_items' cookie to not exist/
646 | )
647 |
648 | await page.evaluate(() => {
649 | setTimeout(() => {
650 | // @ts-expect-error
651 | document.cookie =
652 | 'cart_items=; Max-Age=0; path=/; domain=localhost;expires=Thu, 01 Jan 1970 00:00:01 GMT'
653 | }, 50)
654 | })
655 | await page.assertCookieMissing('cart_items')
656 | })
657 |
658 | test('assert element innerText', async ({ assert, cleanup }) => {
659 | const server = new ServerFactory()
660 | await server.create((_, res) => {
661 | res.setHeader('content-type', 'text/html')
662 | res.write(
663 | basicDocument({
664 | body: `
665 | It works!
666 | Hello world
667 | `,
668 | })
669 | )
670 | res.end()
671 | })
672 |
673 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
674 | cleanup(async () => {
675 | await server.close()
676 | await browser.close()
677 | })
678 |
679 | const page = await browser.newPage()
680 |
681 | await page.goto(server.url)
682 | await page.assertText('body', ['It works!', '', 'Hello world'].join('\n'))
683 | await page.assertText('h1', 'It works!')
684 | await page.assertText('p', 'Hello world')
685 |
686 | await assert.rejects(
687 | () => page.assertText('p', 'Aloha'),
688 | /expected 'p' inner text to equal 'Aloha'/
689 | )
690 |
691 | await page.evaluate(() => {
692 | setTimeout(() => {
693 | // @ts-expect-error
694 | document.querySelector('p').innerText = 'Aloha'
695 | }, 50)
696 | })
697 | await page.assertText('p', 'Aloha')
698 | })
699 |
700 | test('assert elementsText', async ({ assert, cleanup }) => {
701 | const server = new ServerFactory()
702 | await server.create((_, res) => {
703 | res.setHeader('content-type', 'text/html')
704 | res.write(
705 | basicDocument({
706 | body: `
707 |
708 | - Hello world
709 | - Hi world
710 | - Bye world
711 |
712 | `,
713 | })
714 | )
715 | res.end()
716 | })
717 |
718 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
719 | cleanup(async () => {
720 | await server.close()
721 | await browser.close()
722 | })
723 |
724 | const page = await browser.newPage()
725 |
726 | await page.goto(server.url)
727 | await page.assertElementsText('ul > li', ['Hello world', 'Hi world', 'Bye world'])
728 |
729 | await assert.rejects(
730 | () => page.assertElementsText('ul > li', ['Hello world', 'Hi world', 'Goodbye world']),
731 | /expected 'ul > li' value to deeply equal \[ 'Hello world', 'Hi world', 'Goodbye world' \] in same order/
732 | )
733 |
734 | await page.evaluate(() => {
735 | setTimeout(() => {
736 | // @ts-expect-error
737 | document.querySelector('li:last-child').innerText = 'Goodbye world'
738 | }, 50)
739 | })
740 | await page.assertElementsText('ul > li', ['Hello world', 'Hi world', 'Goodbye world'])
741 | })
742 |
743 | test('assert element innerText to include substring', async ({ assert, cleanup }) => {
744 | const server = new ServerFactory()
745 | await server.create((_, res) => {
746 | res.setHeader('content-type', 'text/html')
747 | res.write(
748 | basicDocument({
749 | body: `
750 | It works!
751 | Hello world
752 | `,
753 | })
754 | )
755 | res.end()
756 | })
757 |
758 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
759 | cleanup(async () => {
760 | await server.close()
761 | await browser.close()
762 | })
763 |
764 | const page = await browser.newPage()
765 |
766 | await page.goto(server.url)
767 |
768 | await page.assertTextContains('body', 'Hello world')
769 | await page.assertTextContains('h1', 'works')
770 | await page.assertTextContains('p', 'world')
771 | await assert.rejects(
772 | () => page.assertTextContains('p', 'Aloha'),
773 | /expected 'p' inner text to include 'Aloha'/
774 | )
775 |
776 | await page.evaluate(() => {
777 | setTimeout(() => {
778 | // @ts-expect-error
779 | document.querySelector('p').innerText = 'Aloha world'
780 | }, 50)
781 | })
782 | await page.assertTextContains('p', 'Aloha')
783 | })
784 |
785 | test('assert a checkbox is checked', async ({ assert, cleanup }) => {
786 | const server = new ServerFactory()
787 | await server.create((_, res) => {
788 | res.setHeader('content-type', 'text/html')
789 | res.write(
790 | basicDocument({
791 | body: `
792 |
793 | Terms and conditions
794 | Subscribe to newsletter
795 |
796 |
797 | `,
798 | })
799 | )
800 | res.end()
801 | })
802 |
803 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
804 | cleanup(async () => {
805 | await server.close()
806 | await browser.close()
807 | })
808 |
809 | const page = await browser.newPage()
810 |
811 | await page.goto(server.url)
812 |
813 | await page.assertChecked('input[name="terms"]')
814 | await assert.rejects(
815 | () => page.assertChecked('input[name="newsletter"]'),
816 | /expected 'input\[name="newsletter"\]' checkbox to be checked/
817 | )
818 |
819 | await assert.rejects(
820 | () => page.assertChecked('input[name="foo"]'),
821 | /expected 'input\[name="foo"\]' to be a checkbox/
822 | )
823 |
824 | await page.evaluate(() => {
825 | setTimeout(() => {
826 | // @ts-expect-error
827 | document.querySelector('input[name="newsletter"]').checked = true
828 | }, 50)
829 | })
830 | await page.assertChecked('input[name="newsletter"]')
831 | })
832 |
833 | test('assert a checkbox is not checked', async ({ assert, cleanup }) => {
834 | const server = new ServerFactory()
835 | await server.create((_, res) => {
836 | res.setHeader('content-type', 'text/html')
837 | res.write(
838 | basicDocument({
839 | body: `
840 |
841 | Terms and conditions
842 | Subscribe to newsletter
843 |
844 |
845 | `,
846 | })
847 | )
848 | res.end()
849 | })
850 |
851 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
852 | cleanup(async () => {
853 | await server.close()
854 | await browser.close()
855 | })
856 |
857 | const page = await browser.newPage()
858 |
859 | await page.goto(server.url)
860 |
861 | await page.assertNotChecked('input[name="newsletter"]')
862 | await assert.rejects(
863 | () => page.assertNotChecked('input[name="terms"]'),
864 | /expected 'input\[name="terms"\]' checkbox to be not checked/
865 | )
866 |
867 | await assert.rejects(
868 | () => page.assertNotChecked('input[name="foo"]'),
869 | /expected 'input\[name="foo"\]' to be a checkbox/
870 | )
871 |
872 | await page.evaluate(() => {
873 | setTimeout(() => {
874 | // @ts-expect-error
875 | document.querySelector('input[name="terms"]').checked = false
876 | }, 50)
877 | })
878 | await page.assertNotChecked('input[name="terms"]')
879 | })
880 |
881 | test('assert element is disabled', async ({ assert, cleanup }) => {
882 | const server = new ServerFactory()
883 | await server.create((_, res) => {
884 | res.setHeader('content-type', 'text/html')
885 | res.write(
886 | basicDocument({
887 | body: `
888 | Terms and conditions
889 | Subscribe to newsletter
890 |
891 | `,
892 | })
893 | )
894 | res.end()
895 | })
896 |
897 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
898 | cleanup(async () => {
899 | await server.close()
900 | await browser.close()
901 | })
902 |
903 | const page = await browser.newPage()
904 |
905 | await page.goto(server.url)
906 |
907 | await page.assertDisabled('input[name="terms"]')
908 | await assert.rejects(
909 | () => page.assertDisabled('input[name="newsletter"]'),
910 | /expected 'input\[name="newsletter"\]' element to be disabled/
911 | )
912 | await assert.rejects(
913 | () => page.assertDisabled('#foo'),
914 | /expected '#foo' element to be disabled/
915 | )
916 |
917 | await page.evaluate(() => {
918 | setTimeout(() => {
919 | // @ts-expect-error
920 | document.querySelector('input[name="newsletter"]').toggleAttribute('disabled', true)
921 | }, 50)
922 | })
923 | await page.assertDisabled('input[name="newsletter"]')
924 | })
925 |
926 | test('assert element is not disabled', async ({ assert, cleanup }) => {
927 | const server = new ServerFactory()
928 | await server.create((_, res) => {
929 | res.setHeader('content-type', 'text/html')
930 | res.write(
931 | basicDocument({
932 | body: `
933 | Terms and conditions
934 | Subscribe to newsletter
935 |
936 | `,
937 | })
938 | )
939 | res.end()
940 | })
941 |
942 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
943 | cleanup(async () => {
944 | await server.close()
945 | await browser.close()
946 | })
947 |
948 | const page = await browser.newPage()
949 |
950 | await page.goto(server.url)
951 |
952 | await page.assertNotDisabled('input[name="newsletter"]')
953 | await page.assertNotDisabled('#foo')
954 | await assert.rejects(
955 | () => page.assertNotDisabled('input[name="terms"]'),
956 | /expected 'input\[name="terms"\]' element to be not disabled/
957 | )
958 |
959 | await page.evaluate(() => {
960 | setTimeout(() => {
961 | // @ts-expect-error
962 | document.querySelector('input[name="terms"]').toggleAttribute('disabled', false)
963 | }, 50)
964 | })
965 | await page.assertNotDisabled('input[name="terms"]')
966 | })
967 |
968 | test('assert input value', async ({ assert, cleanup }) => {
969 | const server = new ServerFactory()
970 | await server.create((_, res) => {
971 | res.setHeader('content-type', 'text/html')
972 | res.write(
973 | basicDocument({
974 | body: `
975 |
976 |
977 |
982 |
983 | `,
984 | })
985 | )
986 | res.end()
987 | })
988 |
989 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
990 | cleanup(async () => {
991 | await server.close()
992 | await browser.close()
993 | })
994 |
995 | const page = await browser.newPage()
996 |
997 | await page.goto(server.url)
998 |
999 | await page.fill('input[name="fullname"]', 'virk')
1000 | await page.assertInputValue('input[name="fullname"]', 'virk')
1001 |
1002 | await page.selectOption('select[name="country"]', 'IND')
1003 | await page.assertInputValue('select[name="country"]', 'IND')
1004 |
1005 | await page.fill('input[name="age"]', '32')
1006 | await page.assertInputValue('input[name="age"]', '32')
1007 |
1008 | await assert.rejects(
1009 | () => page.assertInputValue('#foo', 'IND'),
1010 | /expected '#foo' element to be an input, select or a textarea/
1011 | )
1012 | await assert.rejects(
1013 | () => page.assertInputValue('input[name="fullname"]', 'john doe'),
1014 | /expected 'input\[name="fullname"\]' value to equal 'john doe'/
1015 | )
1016 |
1017 | await page.evaluate(() => {
1018 | setTimeout(() => {
1019 | // @ts-expect-error
1020 | document.querySelector('input[name="fullname"]').value = 'john doe'
1021 | }, 50)
1022 | })
1023 | await page.assertInputValue('input[name="fullname"]', 'john doe')
1024 | })
1025 |
1026 | test('assert select options', async ({ assert, cleanup }) => {
1027 | const server = new ServerFactory()
1028 | await server.create((_, res) => {
1029 | res.setHeader('content-type', 'text/html')
1030 | res.write(
1031 | basicDocument({
1032 | body: `
1033 |
1038 |
1039 |
1046 |
1047 |
1048 | `,
1049 | })
1050 | )
1051 | res.end()
1052 | })
1053 |
1054 | const browser = decorateBrowser(await chromium.launch(), [addAssertions], pluginConfig)
1055 | cleanup(async () => {
1056 | await server.close()
1057 | await browser.close()
1058 | })
1059 |
1060 | const page = await browser.newPage()
1061 |
1062 | await page.goto(server.url)
1063 |
1064 | await page.selectOption('select[name="country"]', 'IND')
1065 | await page.assertSelectedOptions('select[name="country"]', ['IND'])
1066 |
1067 | await page.selectOption('select[name="tags"]', ['js', 'css'])
1068 | await page.assertSelectedOptions('select[name="tags"]', ['css', 'js'])
1069 |
1070 | await assert.rejects(
1071 | () => page.assertSelectedOptions('#foo', []),
1072 | /expected '#foo' element to be a select box/
1073 | )
1074 | await assert.rejects(
1075 | () => page.assertSelectedOptions('select[name="country"]', ['FR']),
1076 | /expected 'select\[name="country"\]' value to equal \[ 'FR' \]/
1077 | )
1078 |
1079 | await page.evaluate(() => {
1080 | setTimeout(() => {
1081 | // @ts-expect-error
1082 | document.querySelector('select[name="country"]').value = 'FR'
1083 | }, 50)
1084 | })
1085 | await page.assertSelectedOptions('select[name="country"]', ['FR'])
1086 | })
1087 | })
1088 |
--------------------------------------------------------------------------------