Skip to content

Commit 62a200b

Browse files
dprevost-LMIdprevost-LMI
committed
Add coverage
1 parent f89d340 commit 62a200b

3 files changed

Lines changed: 169 additions & 145 deletions

File tree

‎src/util/elementsUtil.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -53,5 +53,3 @@ export const map = async <T>(
5353
return await Promise.all(results)
5454
}
5555

56-
export const toArray = <T>(value: T | T[]): T[] => (Array.isArray(value) ? value : [value])
57-

‎test/util/elementsUtil.test.ts‎

Lines changed: 168 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
1-
import { vi, test, describe, expect } from 'vitest'
1+
import { vi, test, describe, expect, beforeEach } from 'vitest'
22
import { $, $$ } from '@wdio/globals'
33

4-
import { wrapExpectedWithArray } from '../../src/util/elementsUtil.js'
4+
import { awaitElements, wrapExpectedWithArray, map } from '../../src/util/elementsUtil.js'
5+
import { elementFactory } from '../__mocks__/@wdio/globals.js'
56

67
vi.mock('@wdio/globals')
78

89
describe('elementsUtil', () => {
9-
describe('wrapExpectedWithArray', () => {
10+
describe(wrapExpectedWithArray, () => {
1011
test('is not array ', async () => {
1112
const el = (await $('sel')) as unknown as WebdriverIO.Element
1213
const actual = wrapExpectedWithArray(el, 'Test Actual', 'Test Expected')
@@ -19,4 +20,168 @@ describe('elementsUtil', () => {
1920
expect(actual).toEqual(['Test Expected'])
2021
})
2122
})
23+
24+
describe(awaitElements, () => {
25+
26+
describe('given single element', () => {
27+
28+
let element: WebdriverIO.Element
29+
let chainableElement: ChainablePromiseElement
30+
31+
beforeEach(() => {
32+
element = elementFactory('element1')
33+
chainableElement = $('element1')
34+
})
35+
36+
test('should return undefined when received is undefined', async () => {
37+
const { elements, isSingleElement } = await awaitElements(undefined)
38+
39+
expect(elements).toBeUndefined()
40+
expect(isSingleElement).toBe(false)
41+
})
42+
43+
test('should return undefined when received is Promise of undefined (typing not supported)', async () => {
44+
const { elements, isSingleElement } = await awaitElements(Promise.resolve(undefined) as any)
45+
46+
expect(elements).toBeUndefined()
47+
expect(isSingleElement).toBe(false)
48+
})
49+
50+
test('should return single element when received is a non-awaited ChainableElement', async () => {
51+
const { elements, isSingleElement } = await awaitElements(chainableElement)
52+
53+
expect(elements).toHaveLength(1)
54+
expect(elements?.[0].selector).toEqual(element.selector)
55+
expect(isSingleElement).toBe(true)
56+
})
57+
58+
test('should return single element when received is an awaited ChainableElement', async () => {
59+
const { elements, isSingleElement } = await awaitElements(await chainableElement)
60+
61+
expect(elements).toHaveLength(1)
62+
expect(elements?.[0].selector).toEqual(element.selector)
63+
expect(isSingleElement).toBe(true)
64+
})
65+
66+
test('should return single element when received is getElement of non awaited ChainableElement (typing not supported)', async () => {
67+
const { elements, isSingleElement } = await awaitElements(chainableElement.getElement() as any)
68+
69+
expect(elements).toHaveLength(1)
70+
expect(elements?.[0].selector).toEqual(element.selector)
71+
expect(isSingleElement).toBe(true)
72+
})
73+
74+
test('should return single element when received is getElement of an awaited ChainableElement', async () => {
75+
const { elements, isSingleElement } = await awaitElements(await chainableElement.getElement())
76+
77+
expect(elements).toHaveLength(1)
78+
expect(elements?.[0].selector).toEqual(element.selector)
79+
expect(isSingleElement).toBe(true)
80+
})
81+
82+
test('should return single element when received is WebdriverIO.Element', async () => {
83+
const { elements, isSingleElement } = await awaitElements(element)
84+
85+
expect(elements).toHaveLength(1)
86+
expect(elements?.[0].selector).toEqual(element.selector)
87+
expect(isSingleElement).toBe(true)
88+
})
89+
})
90+
91+
describe('given multiple elements', () => {
92+
93+
let element1: WebdriverIO.Element
94+
let element2: WebdriverIO.Element
95+
let elementArray: WebdriverIO.Element[]
96+
let chainableElementArray: ChainablePromiseArray
97+
98+
beforeEach(() => {
99+
element1 = elementFactory('element1')
100+
element2 = elementFactory('element2')
101+
elementArray = [element1, element2]
102+
chainableElementArray = $$('element1')
103+
})
104+
105+
test('should return multiple elements when received is a non-awaited ChainableElementArray', async () => {
106+
const { elements, isSingleElement } = await awaitElements(chainableElementArray)
107+
108+
expect(elements).toHaveLength(2)
109+
expect(elements).toEqual(expect.objectContaining([
110+
expect.objectContaining({ selector: element1.selector }),
111+
expect.objectContaining({ selector: element1.selector })
112+
]))
113+
expect(isSingleElement).toBe(false)
114+
})
115+
116+
test('should return multiple elements when received is an awaited ChainableElementArray', async () => {
117+
const { elements, isSingleElement } = await awaitElements(await chainableElementArray)
118+
119+
expect(elements).toHaveLength(2)
120+
expect(elements).toEqual(expect.objectContaining([
121+
expect.objectContaining({ selector: element1.selector }),
122+
expect.objectContaining({ selector: element1.selector })
123+
]))
124+
expect(isSingleElement).toBe(false)
125+
})
126+
127+
test('should return multiple elements when received is getElements of non awaited ChainableElement (typing not supported)', async () => {
128+
const { elements, isSingleElement } = await awaitElements(chainableElementArray.getElements() as any)
129+
130+
expect(elements).toHaveLength(2)
131+
expect(elements).toEqual(expect.objectContaining([
132+
expect.objectContaining({ selector: element1.selector }),
133+
expect.objectContaining({ selector: element1.selector })
134+
]))
135+
expect(isSingleElement).toBe(false)
136+
})
137+
138+
test('should return multiple elements when received is getElements of an awaited ChainableElementArray', async () => {
139+
const { elements, isSingleElement } = await awaitElements(await chainableElementArray.getElements())
140+
141+
expect(elements).toHaveLength(2)
142+
expect(elements).toEqual(expect.objectContaining([
143+
expect.objectContaining({ selector: element1.selector }),
144+
expect.objectContaining({ selector: element1.selector })
145+
]))
146+
expect(isSingleElement).toBe(false)
147+
})
148+
149+
test('should return multiple elements when received is WebdriverIO.Element[]', async () => {
150+
const { elements, isSingleElement } = await awaitElements(elementArray)
151+
152+
expect(elements).toHaveLength(2)
153+
expect(elements).toEqual(expect.objectContaining([
154+
expect.objectContaining({ selector: element1.selector }),
155+
expect.objectContaining({ selector: element2.selector })
156+
]))
157+
expect(isSingleElement).toBe(false)
158+
})
159+
})
160+
161+
})
162+
163+
describe(map, () => {
164+
test('should map elements of type Element[]', async () => {
165+
const elements: WebdriverIO.Element[] = [elementFactory('el1'), elementFactory('el2')]
166+
const command = vi.fn().mockResolvedValue('mapped')
167+
168+
const result = await map(elements, command)
169+
170+
expect(result).toEqual(['mapped', 'mapped'])
171+
expect(command).toHaveBeenCalledTimes(2)
172+
expect(command).toHaveBeenCalledWith(elements[0])
173+
expect(command).toHaveBeenCalledWith(elements[1])
174+
})
175+
test('should map elements of type ElementArray', async () => {
176+
const elements: WebdriverIO.ElementArray = await $$('elements').getElements()
177+
const command = vi.fn().mockResolvedValue('mapped')
178+
179+
const result = await map(elements, command)
180+
181+
expect(result).toEqual(['mapped', 'mapped'])
182+
expect(command).toHaveBeenCalledTimes(2)
183+
expect(command).toHaveBeenCalledWith(elements[0])
184+
expect(command).toHaveBeenCalledWith(elements[1])
185+
})
186+
})
22187
})

‎test/utils.test.ts‎

Lines changed: 1 addition & 140 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ import { enhanceErrorBe } from '../src/util/formatMessage.js'
66
import type { CommandOptions } from 'expect-webdriverio'
77
import { elementFactory } from './__mocks__/@wdio/globals.js'
88
import { executeCommandWithArray } from '../src/util/executeCommand.js'
9-
import { $, $$ } from '@wdio/globals'
9+
import { $ } from '@wdio/globals'
1010

1111
vi.mock('../src/util/executeCommand.js', async (importOriginal) => {
1212
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
@@ -350,143 +350,4 @@ Received: "not displayed"`)
350350
})
351351
})
352352

353-
describe(awaitElements, () => {
354-
355-
describe('given single element', () => {
356-
357-
let element: WebdriverIO.Element
358-
let chainableElement: ChainablePromiseElement
359-
360-
beforeEach(() => {
361-
element = elementFactory('element1')
362-
chainableElement = $('element1')
363-
})
364-
365-
test('should return undefined when received is undefined', async () => {
366-
const { elements, isSingleElement } = await awaitElements(undefined)
367-
368-
expect(elements).toBeUndefined()
369-
expect(isSingleElement).toBe(false)
370-
})
371-
372-
test('should return undefined when received is Promise of undefined (typing not supported)', async () => {
373-
const { elements, isSingleElement } = await awaitElements(Promise.resolve(undefined) as any)
374-
375-
expect(elements).toBeUndefined()
376-
expect(isSingleElement).toBe(false)
377-
})
378-
379-
test('should return single element when received is a non-awaited ChainableElement', async () => {
380-
const { elements, isSingleElement } = await awaitElements(chainableElement)
381-
382-
expect(elements).toHaveLength(1)
383-
expect(elements?.[0].selector).toEqual(element.selector)
384-
expect(isSingleElement).toBe(true)
385-
})
386-
387-
test('should return single element when received is an awaited ChainableElement', async () => {
388-
const { elements, isSingleElement } = await awaitElements(await chainableElement)
389-
390-
expect(elements).toHaveLength(1)
391-
expect(elements?.[0].selector).toEqual(element.selector)
392-
expect(isSingleElement).toBe(true)
393-
})
394-
395-
test('should return single element when received is getElement of non awaited ChainableElement (typing not supported)', async () => {
396-
const { elements, isSingleElement } = await awaitElements(chainableElement.getElement() as any)
397-
398-
expect(elements).toHaveLength(1)
399-
expect(elements?.[0].selector).toEqual(element.selector)
400-
expect(isSingleElement).toBe(true)
401-
})
402-
403-
test('should return single element when received is getElement of an awaited ChainableElement', async () => {
404-
const { elements, isSingleElement } = await awaitElements(await chainableElement.getElement())
405-
406-
expect(elements).toHaveLength(1)
407-
expect(elements?.[0].selector).toEqual(element.selector)
408-
expect(isSingleElement).toBe(true)
409-
})
410-
411-
test('should return single element when received is WebdriverIO.Element', async () => {
412-
const { elements, isSingleElement } = await awaitElements(element)
413-
414-
expect(elements).toHaveLength(1)
415-
expect(elements?.[0].selector).toEqual(element.selector)
416-
expect(isSingleElement).toBe(true)
417-
})
418-
})
419-
420-
describe('given multiple elements', () => {
421-
422-
let element1: WebdriverIO.Element
423-
let element2: WebdriverIO.Element
424-
let elementArray: WebdriverIO.Element[]
425-
let chainableElementArray: ChainablePromiseArray
426-
427-
beforeEach(() => {
428-
element1 = elementFactory('element1')
429-
element2 = elementFactory('element2')
430-
elementArray = [element1, element2]
431-
chainableElementArray = $$('element1')
432-
})
433-
434-
test('should return multiple elements when received is a non-awaited ChainableElementArray', async () => {
435-
const { elements, isSingleElement } = await awaitElements(chainableElementArray)
436-
437-
expect(elements).toHaveLength(2)
438-
expect(elements).toEqual(expect.objectContaining([
439-
expect.objectContaining({ selector: element1.selector }),
440-
expect.objectContaining({ selector: element1.selector })
441-
]))
442-
expect(isSingleElement).toBe(false)
443-
})
444-
445-
test('should return multiple elements when received is an awaited ChainableElementArray', async () => {
446-
const { elements, isSingleElement } = await awaitElements(await chainableElementArray)
447-
448-
expect(elements).toHaveLength(2)
449-
expect(elements).toEqual(expect.objectContaining([
450-
expect.objectContaining({ selector: element1.selector }),
451-
expect.objectContaining({ selector: element1.selector })
452-
]))
453-
expect(isSingleElement).toBe(false)
454-
})
455-
456-
test('should return multiple elements when received is getElements of non awaited ChainableElement (typing not supported)', async () => {
457-
const { elements, isSingleElement } = await awaitElements(chainableElementArray.getElements() as any)
458-
459-
expect(elements).toHaveLength(2)
460-
expect(elements).toEqual(expect.objectContaining([
461-
expect.objectContaining({ selector: element1.selector }),
462-
expect.objectContaining({ selector: element1.selector })
463-
]))
464-
expect(isSingleElement).toBe(false)
465-
})
466-
467-
test('should return multiple elements when received is getElements of an awaited ChainableElementArray', async () => {
468-
const { elements, isSingleElement } = await awaitElements(await chainableElementArray.getElements())
469-
470-
expect(elements).toHaveLength(2)
471-
expect(elements).toEqual(expect.objectContaining([
472-
expect.objectContaining({ selector: element1.selector }),
473-
expect.objectContaining({ selector: element1.selector })
474-
]))
475-
expect(isSingleElement).toBe(false)
476-
})
477-
478-
test('should return multiple elements when received is WebdriverIO.Element[]', async () => {
479-
const { elements, isSingleElement } = await awaitElements(elementArray)
480-
481-
expect(elements).toHaveLength(2)
482-
expect(elements).toEqual(expect.objectContaining([
483-
expect.objectContaining({ selector: element1.selector }),
484-
expect.objectContaining({ selector: element2.selector })
485-
]))
486-
expect(isSingleElement).toBe(false)
487-
})
488-
})
489-
490-
})
491-
492353
})

0 commit comments

Comments
 (0)