7069754431

Committed 02 Dec 2023 10:55AM UTC coverage: 95.167% (+0.001%) from 95.166%

Build # 7069754431

Build Type

Pull #2103

github

Committed by

web-flow

Commit Message

Merge b19e064ab into 87df64ce1

Pull Request Pull Request #2103: feat(serenity-bdd): Support for Serenity BDD 4

Run Details

3715 of 3852 branches covered (0.0%)

Branch coverage included in aggregate %.

168 of 171 new or added lines in 26 files covered. (98.25%)

14 existing lines in 1 file now uncovered.

32378 of 34074 relevant lines covered (95.02%)

940.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.41

/packages/webdriverio/src/screenplay/models/locators/WebdriverIOLocator.ts

import 'webdriverio';

import { f, LogicError } from '@serenity-js/core';
import type { PageElement, RootLocator, Selector } from '@serenity-js/web';
import { ByCss, ByCssContainingText, ByDeepCss, ById, ByTagName, ByXPath, Locator } from '@serenity-js/web';

import type { WebdriverIOErrorHandler } from '../WebdriverIOErrorHandler.js';
import { WebdriverIOPageElement } from '../WebdriverIOPageElement.js';
import type { WebdriverIORootLocator } from './WebdriverIORootLocator.js';

/**
 * WebdriverIO-specific implementation of {@apilink Locator}.
 *
 * @group Models
 */
export class WebdriverIOLocator extends Locator<WebdriverIO.Element, string> {

    constructor(
        parent: RootLocator<WebdriverIO.Element>,
        selector: Selector,
        private readonly errorHandler: WebdriverIOErrorHandler,
    ) {
        super(parent, selector);
    }

    // todo: refactor; replace with a map and some more generic lookup mechanism
    protected nativeSelector(): string {
        if (this.selector instanceof ByCss) {
            return this.selector.value;
        }

        if (this.selector instanceof ByDeepCss) {
            return `>>> ${ this.selector.value }`;
        }

        if (this.selector instanceof ByCssContainingText) {
            return `${ this.selector.value }*=${ this.selector.text }`;
        }

        if (this.selector instanceof ById) {
            return `#${ this.selector.value }`;
        }

        if (this.selector instanceof ByTagName) {
            return `<${ this.selector.value } />`;
        }

        if (this.selector instanceof ByXPath) {
            return this.selector.value;
        }

        throw new LogicError(f `${ this.selector } is not supported by ${ this.constructor.name }`);
    }

    async isPresent(): Promise<boolean> {
        try {
            const element = await this.resolveNativeElement();
            return Boolean(element);
        }
        catch {
            return false;
        }
    }

    async nativeElement(): Promise<WebdriverIO.Element> {
        try {
            return await this.resolveNativeElement();
        }
        catch (error) {
            return await this.errorHandler.executeIfHandled(error, () => this.resolveNativeElement());
        }
    }

    protected async resolveNativeElement(): Promise<WebdriverIO.Element> {
        const parent = await this.parent.nativeElement();

        if (parent.error) {
            throw parent.error;
        }

        const element = await parent.$(this.nativeSelector());

        if (element.error) {
            throw element.error;
        }

        return element;
    }

    async allNativeElements(): Promise<Array<WebdriverIO.Element>> {
        const parent = await this.parent.nativeElement();
        return parent.$$(this.nativeSelector());
    }

    of(parent: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {
        return new WebdriverIOLocator(parent, this.selector, this.errorHandler);
    }

    closestTo(child: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {
        return new WebdriverIOParentElementLocator(this.parent, this.selector, child, this.errorHandler);
    }

    locate(child: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {
        return new WebdriverIOLocator(this, child.selector, this.errorHandler);
    }

    element(): PageElement<WebdriverIO.Element> {
        return new WebdriverIOPageElement(this);
    }

    async allElements(): Promise<Array<PageElement<WebdriverIO.Element>>> {
        const elements = await this.allNativeElements();

        return elements.map(childElement =>
            new WebdriverIOPageElement(
                new WebdriverIOExistingElementLocator(
                    this.parent as WebdriverIORootLocator,
                    this.selector,
                    this.errorHandler,
                    childElement
                )
            )
        );
    }
}

/**
 * @internal
 */
export class WebdriverIOExistingElementLocator extends WebdriverIOLocator {
    constructor(
        parentRoot: RootLocator<WebdriverIO.Element>,
        selector: Selector,
        errorHandler: WebdriverIOErrorHandler,
        private readonly existingNativeElement: WebdriverIO.Element,
    ) {
        super(parentRoot, selector, errorHandler);
    }

    async nativeElement(): Promise<WebdriverIO.Element> {
        return this.existingNativeElement;
    }

    async allNativeElements(): Promise<Array<WebdriverIO.Element>> {
        return [ this.existingNativeElement ];
    }
}

class WebdriverIOParentElementLocator extends WebdriverIOLocator {
    constructor(
        parentRoot: RootLocator<WebdriverIO.Element>,
        selector: Selector,
        private readonly child: WebdriverIOLocator,
        errorHandler: WebdriverIOErrorHandler
    ) {
        super(parentRoot, selector, errorHandler);
    }

    protected override async resolveNativeElement(): Promise<WebdriverIO.Element> {
        const cssSelector = this.asCssSelector(this.selector);
        const child = await this.child.nativeElement();

        if (child.error)  {
            throw child.error;
        }

        return child.$(
            /* c8 ignore next */
            new Function(`return this.closest(\`${ cssSelector.value }\`)`) as () => HTMLElement
        );
    }

    override async allNativeElements(): Promise<Array<WebdriverIO.Element>> {
        return [ await this.nativeElement() ];
    }
}

1	import 'webdriverio';	2✔
2		2✔
3	import { f, LogicError } from '@serenity-js/core';	2✔
4	import type { PageElement, RootLocator, Selector } from '@serenity-js/web';	2✔
5	import { ByCss, ByCssContainingText, ByDeepCss, ById, ByTagName, ByXPath, Locator } from '@serenity-js/web';	2✔
6		2✔
7	import type { WebdriverIOErrorHandler } from '../WebdriverIOErrorHandler.js';	2✔
8	import { WebdriverIOPageElement } from '../WebdriverIOPageElement.js';	2✔
9	import type { WebdriverIORootLocator } from './WebdriverIORootLocator.js';	2✔
10		2✔
11	/**	2✔
12	* WebdriverIO-specific implementation of {@apilink Locator}.	2✔
13	*	2✔
14	* @group Models	2✔
15	*/	2✔
16	export class WebdriverIOLocator extends Locator<WebdriverIO.Element, string> {	1!
17		×
18	constructor(	×
19	parent: RootLocator<WebdriverIO.Element>,	×
20	selector: Selector,	×
21	private readonly errorHandler: WebdriverIOErrorHandler,	×
22	) {	×
23	super(parent, selector);	×
24	}	×
25		×
26	// todo: refactor; replace with a map and some more generic lookup mechanism	×
27	protected nativeSelector(): string {	×
28	if (this.selector instanceof ByCss) {	×
29	return this.selector.value;	×
30	}	×
31		×
32	if (this.selector instanceof ByDeepCss) {	×
33	return `>>> ${ this.selector.value }`;	×
34	}	×
35		×
36	if (this.selector instanceof ByCssContainingText) {	×
37	return `${ this.selector.value }*=${ this.selector.text }`;	×
38	}	×
39		×
40	if (this.selector instanceof ById) {	×
41	return `#${ this.selector.value }`;	×
42	}	×
43		×
44	if (this.selector instanceof ByTagName) {	×
45	return `<${ this.selector.value } />`;	×
46	}	×
47		×
48	if (this.selector instanceof ByXPath) {	×
49	return this.selector.value;	×
50	}	×
51		×
52	throw new LogicError(f `${ this.selector } is not supported by ${ this.constructor.name }`);	×
53	}	×
54		×
55	async isPresent(): Promise<boolean> {	×
56	try {	×
57	const element = await this.resolveNativeElement();	×
58	return Boolean(element);	×
59	}	×
60	catch {	×
61	return false;	×
62	}	×
63	}	×
64		×
65	async nativeElement(): Promise<WebdriverIO.Element> {	×
66	try {	×
67	return await this.resolveNativeElement();	×
68	}	×
69	catch (error) {	×
70	return await this.errorHandler.executeIfHandled(error, () => this.resolveNativeElement());	×
71	}	×
72	}	×
73		×
74	protected async resolveNativeElement(): Promise<WebdriverIO.Element> {	×
75	const parent = await this.parent.nativeElement();	×
76		×
77	if (parent.error) {	×
78	throw parent.error;	×
79	}	×
80		×
81	const element = await parent.$(this.nativeSelector());	×
82		×
83	if (element.error) {	×
84	throw element.error;	×
85	}	×
86		×
87	return element;	×
88	}	×
89		×
90	async allNativeElements(): Promise<Array<WebdriverIO.Element>> {	×
91	const parent = await this.parent.nativeElement();	×
NEW 92	return parent.$$(this.nativeSelector());	×
93	}	×
94		×
95	of(parent: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {	×
96	return new WebdriverIOLocator(parent, this.selector, this.errorHandler);	×
97	}	×
98		×
99	closestTo(child: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {	×
100	return new WebdriverIOParentElementLocator(this.parent, this.selector, child, this.errorHandler);	×
101	}	×
102		×
103	locate(child: WebdriverIOLocator): Locator<WebdriverIO.Element, string> {	×
104	return new WebdriverIOLocator(this, child.selector, this.errorHandler);	×
105	}	×
106		×
107	element(): PageElement<WebdriverIO.Element> {	×
108	return new WebdriverIOPageElement(this);	×
109	}	×
110		×
111	async allElements(): Promise<Array<PageElement<WebdriverIO.Element>>> {	×
112	const elements = await this.allNativeElements();	×
113		×
114	return elements.map(childElement =>	×
115	new WebdriverIOPageElement(	×
116	new WebdriverIOExistingElementLocator(	×
117	this.parent as WebdriverIORootLocator,	×
118	this.selector,	×
119	this.errorHandler,	×
120	childElement	×
121	)	×
122	)	×
123	);	×
124	}	×
125	}	×
126		2✔
127	/**	2✔
128	* @internal	2✔
129	*/	2✔
130	export class WebdriverIOExistingElementLocator extends WebdriverIOLocator {	1!
131	constructor(	×
132	parentRoot: RootLocator<WebdriverIO.Element>,	×
133	selector: Selector,	×
134	errorHandler: WebdriverIOErrorHandler,	×
135	private readonly existingNativeElement: WebdriverIO.Element,	×
136	) {	×
137	super(parentRoot, selector, errorHandler);	×
138	}	×
139		×
140	async nativeElement(): Promise<WebdriverIO.Element> {	×
141	return this.existingNativeElement;	×
142	}	×
143		×
144	async allNativeElements(): Promise<Array<WebdriverIO.Element>> {	×
145	return [ this.existingNativeElement ];	×
146	}	×
147	}	×
148		2✔
149	class WebdriverIOParentElementLocator extends WebdriverIOLocator {	×
150	constructor(	×
151	parentRoot: RootLocator<WebdriverIO.Element>,	×
152	selector: Selector,	×
153	private readonly child: WebdriverIOLocator,	×
154	errorHandler: WebdriverIOErrorHandler	×
155	) {	×
156	super(parentRoot, selector, errorHandler);	×
157	}	×
158		×
159	protected override async resolveNativeElement(): Promise<WebdriverIO.Element> {	×
160	const cssSelector = this.asCssSelector(this.selector);	×
161	const child = await this.child.nativeElement();	×
162		×
163	if (child.error) {	×
164	throw child.error;	×
165	}	×
166		×
167	return child.$(	×
168	/* c8 ignore next */	2✔
169	new Function(`return this.closest(\`${ cssSelector.value }\`)`) as () => HTMLElement	2✔
170	);	×
171	}	×
172		×
173	override async allNativeElements(): Promise<Array<WebdriverIO.Element>> {	×
174	return [ await this.nativeElement() ];	×
175	}	×
176	}	×

serenity-js / serenity-js / 7069754431

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous