3056052985

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/serenity-js/serenity-js/commit/<a class=hub.com/serenity-js/serenity-js/commit/<a class="double-link" href="https://git"><a class=hub.com/serenity-js/serenity-js/commit/<a class="double-link" href="https://git"><a class=hub.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e7af">28f50c288<a href="https://github.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e7af">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/serenity-js/serenity-js/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/serenity-js/serenity-js/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e7af&quot;&gt;28f50c288&lt;/a&gt;&lt;a href=&quot;https://github.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e7af&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e&lt;/a&gt;1d62e7af&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/serenity-js/serenity-js/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/serenity-js/serenity-js/commit/<a class="double-link" href="https://github.com/serenity-js/serenity-js/commit/58629bc8efee9ec8592aa678d20463745386b46f">58629bc8e</a><a href="https://github.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e7af">&amp;quot;&amp;gt;58629bc8e&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;58629bc8e&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/serenity-js/serenity-js/commit/28f50c288a4c57c8a065bc263f14552e1d62e&lt;/a&gt;7af&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/serenity-js/serenity-js/commit/<a class="double-link" href="https://github.com/serenity-js/serenity-js/commit/c68f32248">c68f32248">c68f32248</a>

Pull Request Pull Request #1305: Support for Playwright Test

Run Details

1508 of 2037 branches covered (74.03%)

Branch coverage included in aggregate %.

100 of 100 new or added lines in 7 files covered. (100.0%)

5946 of 6410 relevant lines covered (92.76%)

601.2 hits per line

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

82.46

/packages/playwright-test/src/reporter/SerenityReporterForPlaywrightTest.ts

import { FullConfig, TestError } from '@playwright/test';
import { Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
import { LogicError, Serenity, serenity as reporterSerenityInstance, StageCrewMember, StageCrewMemberBuilder, Timestamp } from '@serenity-js/core';
import { OutputStream } from '@serenity-js/core/lib/adapter';
import * as events from '@serenity-js/core/lib/events';
import { DomainEvent, InteractionFinished, RetryableSceneDetected, SceneFinished, SceneStarts, SceneTagged, TestRunFinished, TestRunFinishes, TestRunnerDetected, TestRunStarts } from '@serenity-js/core/lib/events';
import { FileSystemLocation, Path } from '@serenity-js/core/lib/io';
import { ArbitraryTag, Category, CorrelationId, ExecutionFailedWithError, ExecutionIgnored, ExecutionRetriedTag, ExecutionSkipped, ExecutionSuccessful, FeatureTag, Name, Outcome, ScenarioDetails } from '@serenity-js/core/lib/model';

import { SERENITY_JS_DOMAIN_EVENT_ATTACHMENT_CONTENT_TYPE } from './PlaywrightAttachments';

// TODO Split SerenityConfig into ActorsConfig and SerenityReportingConfig
export class SerenityReporterForPlaywrightTestConfig {
    /**
     * A list of {@apilink StageCrewMemberBuilder|StageCrewMemberBuilders} or {@apilink StageCrewMember|StageCrewMembers}
     * to be notified of {@apilink DomainEvent|DomainEvents} that occur during the scenario execution.
     */
    crew?: Array<StageCrewMember | StageCrewMemberBuilder>;

    /**
     * An output stream to be injected into {@apilink StageCrewMemberBuilder|StageCrewMemberBuilders}
     *
     * Defaults to [`process.stdout`](https://nodejs.org/api/process.html#process_process_stdout).
     */
    outputStream?: OutputStream;
}

/**
 * Receives notifications from Playwright Test and translates them to Serenity/JS
 * {@apilink DomainEvent|domain events}, so that they can be used with Serenity/JS reporters.
 */
export class SerenityReporterForPlaywrightTest implements Reporter {
    // config!: FullConfig;
    // suite!: Suite;

    private errorParser = new PlaywrightErrorParser();

    private currentSceneId: CorrelationId;

    // TODO use({ actors: ({ context, page, ... }) => Cast)
    //  so that people can override it

    /**
     * 
     * @param config 
     * @param serenity 
     *  Instance of {@apilink Serenity}, specific to the Node process running this Serenity reporter. 
     *  Note that Playwright runs test workers and reporters in separate processes.
     */
    constructor(
        config: SerenityReporterForPlaywrightTestConfig,
        private readonly serenity: Serenity = reporterSerenityInstance,
    ) {
        // TODO register Console Reporter and SerenityBDD reporter, or StreamReporter, and ArtifactArchiver
        this.serenity.configure(config);

        // TODO use context to set up actors
        //  it.use({ actors: new Actors() })    // how do I inject a browser here?
    }

    onBegin(config: FullConfig, suite: Suite): void {
        this.serenity.announce(new TestRunStarts(this.now()));
    }

    onTestBegin(test: TestCase): void {

        this.currentSceneId = this.serenity.assignNewSceneId()

        const scenario = this.scenarioDetailsFrom(test);

        this.emit(
            new SceneStarts(this.currentSceneId, scenario, this.serenity.currentTime()),
            new SceneTagged(this.currentSceneId, new FeatureTag(scenario.category.value), this.serenity.currentTime()),
            new TestRunnerDetected(this.currentSceneId, new Name('Playwright'), this.serenity.currentTime()),
        );
    }

    // TODO might be nice to support that by emitting TestStepStarted / Finished
    // onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void {
    //     // console.log('>> onStepBegin');
    // }
    
    // onStepEnd(test: TestCase, _result: TestResult, step: TestStep): void {
    //     // console.log('>> onStepEnd');
    // }
            
    onTestEnd(test: TestCase, result: TestResult): void {

        this.announceRetryIfNeeded(test, result);

        let worstOutcome: Outcome;

        for (const attachment of result.attachments) {
            if (! (attachment.contentType === SERENITY_JS_DOMAIN_EVENT_ATTACHMENT_CONTENT_TYPE && attachment.body)) {
                continue;
            }

            const message = JSON.parse(attachment.body.toString());

            if (message.value.sceneId === 'unknown') {
                message.value.sceneId = this.currentSceneId.value;
            }

            const event = events[message.type].fromJSON(message.value);

            this.serenity.announce(event);

            if (event instanceof InteractionFinished && (! worstOutcome || event.outcome.isWorseThan(worstOutcome))) {
                worstOutcome = event.outcome;
            }
        }

        this.serenity.announce(
            new SceneFinished(
                this.currentSceneId,
                this.scenarioDetailsFrom(test),
                worstOutcome || this.outcomeFrom(test, result), // Playwright serialisation loses error details. Use Serenity/JS outcomes if possible.
                this.now(),
            )
        );
    }

    private outcomeFrom(test: TestCase, result: TestResult): Outcome {
        
        const outcome = test.outcome();

        if (outcome === 'skipped') {
            return new ExecutionSkipped();
        }
        
        if (outcome === 'unexpected' && result.status === 'passed') {
            return new ExecutionFailedWithError(new LogicError(`Scenario expected to fail, but ${ result.status }`));
        }

        if (['failed', 'interrupted', 'timedOut'].includes(result.status)) {
            
            if (test.retries > result.retry) {
                return new ExecutionIgnored(this.errorParser.errorFrom(result.error));    
            }

            return new ExecutionFailedWithError(this.errorParser.errorFrom(result.error));    
        }

        return new ExecutionSuccessful();
    }

    private scenarioDetailsFrom(test: TestCase) {
        const [ root_, browserName_, fileName_, featureName, ...scenarioTitle] = test.titlePath();

        return new ScenarioDetails(
            new Name(scenarioTitle.join(' ')),
            new Category(featureName),
            new FileSystemLocation(
                new Path(test.location.file),
                test.location.line,
                test.location.column,
            ),
        );
    }

    async onEnd(): Promise<void> {
        this.serenity.announce(new TestRunFinishes(this.serenity.currentTime()));
        
        await this.serenity.waitForNextCue();
        
        this.serenity.announce(new TestRunFinished(this.serenity.currentTime()));
    }

    // TODO emit a text artifact with stdout?
    // reporter.onStdErr(chunk, test, result)
    // reporter.onStdOut(chunk, test, result)

    private emit(...events: DomainEvent[]): void {
        events.forEach(event => {
            this.serenity.announce(event)
        });
    }

    private announceRetryIfNeeded(test: TestCase, result: TestResult): void {
        if (test.retries === 0) {
            return;
        }

        this.emit(
            new RetryableSceneDetected(
                this.currentSceneId,
                this.now(),
            ),
            new SceneTagged(
                this.currentSceneId,
                new ArbitraryTag('retried'),        // todo: replace with a dedicated tag
                this.now(),
            ),
        );

        if (result.retry > 0) {
            this.emit(
                new SceneTagged(
                    this.currentSceneId,
                    new ExecutionRetriedTag(result.retry),
                    this.serenity.currentTime(),
                ),
            );
        }
    }

    private now(): Timestamp {
        return this.serenity.currentTime();
    }

    printsToStdio(): boolean {
        return true;
    }
}

class PlaywrightErrorParser {
    private static ascii = new RegExp(
        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', // eslint-disable-line no-control-regex
        'g',
    );
    
    public errorFrom(testError: TestError): Error {

        const message = testError.message && PlaywrightErrorParser.stripAsciiFrom(testError.message);
        let stack = testError.stack && PlaywrightErrorParser.stripAsciiFrom(testError.stack);
        
        // TODO: Do I need to process it?
        // const value     = testError.value;
        
        const prologue = `Error: ${message}`;
        if (stack && message && stack.startsWith(prologue)) {
            stack = stack.slice(prologue.length);
        }

        const error = new Error(message);
        error.stack = stack;

        return error;
    }

    private static stripAsciiFrom(text: string): string {
        return text.replace(this.ascii, '');
    }
}

1	import { FullConfig, TestError } from '@playwright/test';
2	import { Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
3	import { LogicError, Serenity, serenity as reporterSerenityInstance, StageCrewMember, StageCrewMemberBuilder, Timestamp } from '@serenity-js/core';	30✔
4	import { OutputStream } from '@serenity-js/core/lib/adapter';
5	import * as events from '@serenity-js/core/lib/events';	30✔
6	import { DomainEvent, InteractionFinished, RetryableSceneDetected, SceneFinished, SceneStarts, SceneTagged, TestRunFinished, TestRunFinishes, TestRunnerDetected, TestRunStarts } from '@serenity-js/core/lib/events';	30✔
7	import { FileSystemLocation, Path } from '@serenity-js/core/lib/io';	30✔
8	import { ArbitraryTag, Category, CorrelationId, ExecutionFailedWithError, ExecutionIgnored, ExecutionRetriedTag, ExecutionSkipped, ExecutionSuccessful, FeatureTag, Name, Outcome, ScenarioDetails } from '@serenity-js/core/lib/model';	30✔
9
10	import { SERENITY_JS_DOMAIN_EVENT_ATTACHMENT_CONTENT_TYPE } from './PlaywrightAttachments';	30✔
11
12	// TODO Split SerenityConfig into ActorsConfig and SerenityReportingConfig
13	export class SerenityReporterForPlaywrightTestConfig {	30✔
14	/**
15	* A list of {@apilink StageCrewMemberBuilder\|StageCrewMemberBuilders} or {@apilink StageCrewMember\|StageCrewMembers}
16	* to be notified of {@apilink DomainEvent\|DomainEvents} that occur during the scenario execution.
17	*/
18	crew?: Array<StageCrewMember \| StageCrewMemberBuilder>;
19
20	/**
21	* An output stream to be injected into {@apilink StageCrewMemberBuilder\|StageCrewMemberBuilders}
22	*
23	* Defaults to [`process.stdout`](https://nodejs.org/api/process.html#process_process_stdout).
24	*/
25	outputStream?: OutputStream;
26	}
27
28	/**
29	* Receives notifications from Playwright Test and translates them to Serenity/JS
30	* {@apilink DomainEvent\|domain events}, so that they can be used with Serenity/JS reporters.
31	*/
32	export class SerenityReporterForPlaywrightTest implements Reporter {	30✔
33	// config!: FullConfig;
34	// suite!: Suite;
35
36	private errorParser = new PlaywrightErrorParser();	14✔
37
38	private currentSceneId: CorrelationId;
39
40	// TODO use({ actors: ({ context, page, ... }) => Cast)
41	// so that people can override it
42
43	/**
44	*
45	* @param config
46	* @param serenity
47	* Instance of {@apilink Serenity}, specific to the Node process running this Serenity reporter.
48	* Note that Playwright runs test workers and reporters in separate processes.
49	*/
50	constructor(
51	config: SerenityReporterForPlaywrightTestConfig,
52	private readonly serenity: Serenity = reporterSerenityInstance,	14✔
53	) {
54	// TODO register Console Reporter and SerenityBDD reporter, or StreamReporter, and ArtifactArchiver
55	this.serenity.configure(config);	14✔
56
57	// TODO use context to set up actors
58	// it.use({ actors: new Actors() }) // how do I inject a browser here?
59	}
60
61	onBegin(config: FullConfig, suite: Suite): void {
62	this.serenity.announce(new TestRunStarts(this.now()));	14✔
63	}
64
65	onTestBegin(test: TestCase): void {
66
67	this.currentSceneId = this.serenity.assignNewSceneId()	16✔
68
69	const scenario = this.scenarioDetailsFrom(test);	16✔
70
71	this.emit(	16✔
72	new SceneStarts(this.currentSceneId, scenario, this.serenity.currentTime()),
73	new SceneTagged(this.currentSceneId, new FeatureTag(scenario.category.value), this.serenity.currentTime()),
74	new TestRunnerDetected(this.currentSceneId, new Name('Playwright'), this.serenity.currentTime()),
75	);
76	}
77
78	// TODO might be nice to support that by emitting TestStepStarted / Finished
79	// onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void {
80	// // console.log('>> onStepBegin');
81	// }
82
83	// onStepEnd(test: TestCase, _result: TestResult, step: TestStep): void {
84	// // console.log('>> onStepEnd');
85	// }
86
87	onTestEnd(test: TestCase, result: TestResult): void {
88
89	this.announceRetryIfNeeded(test, result);	16✔
90
91	let worstOutcome: Outcome;
92
93	for (const attachment of result.attachments) {	16✔
94	if (! (attachment.contentType === SERENITY_JS_DOMAIN_EVENT_ATTACHMENT_CONTENT_TYPE && attachment.body)) {	14!
95	continue;	×
96	}
97
98	const message = JSON.parse(attachment.body.toString());	14✔
99
100	if (message.value.sceneId === 'unknown') {	14✔
101	message.value.sceneId = this.currentSceneId.value;	10✔
102	}
103
104	const event = events[message.type].fromJSON(message.value);	14✔
105
106	this.serenity.announce(event);	14✔
107
108	if (event instanceof InteractionFinished && (! worstOutcome \|\| event.outcome.isWorseThan(worstOutcome))) {	14!
109	worstOutcome = event.outcome;	2✔
110	}
111	}
112
113	this.serenity.announce(	16✔
114	new SceneFinished(
115	this.currentSceneId,
116	this.scenarioDetailsFrom(test),
117	worstOutcome \|\| this.outcomeFrom(test, result), // Playwright serialisation loses error details. Use Serenity/JS outcomes if possible.	30!
118	this.now(),
119	)
120	);
121	}
122
123	private outcomeFrom(test: TestCase, result: TestResult): Outcome {
124
125	const outcome = test.outcome();	14✔
126
127	if (outcome === 'skipped') {	14✔
128	return new ExecutionSkipped();	5✔
129	}
130
131	if (outcome === 'unexpected' && result.status === 'passed') {	9!
132	return new ExecutionFailedWithError(new LogicError(`Scenario expected to fail, but ${ result.status }`));	1✔
133	}
134
135	if (['failed', 'interrupted', 'timedOut'].includes(result.status)) {	8✔
136
137	if (test.retries > result.retry) {	5✔
138	return new ExecutionIgnored(this.errorParser.errorFrom(result.error));	2✔
139	}
140
141	return new ExecutionFailedWithError(this.errorParser.errorFrom(result.error));	3✔
142	}
143
144	return new ExecutionSuccessful();	3✔
145	}
146
147	private scenarioDetailsFrom(test: TestCase) {
148	const [ root_, browserName_, fileName_, featureName, ...scenarioTitle] = test.titlePath();	32✔
149
150	return new ScenarioDetails(	32✔
151	new Name(scenarioTitle.join(' ')),
152	new Category(featureName),
153	new FileSystemLocation(
154	new Path(test.location.file),
155	test.location.line,
156	test.location.column,
157	),
158	);
159	}
160
161	async onEnd(): Promise<void> {
162	this.serenity.announce(new TestRunFinishes(this.serenity.currentTime()));	14✔
163
164	await this.serenity.waitForNextCue();	14✔
165
166	this.serenity.announce(new TestRunFinished(this.serenity.currentTime()));	14✔
167	}
168
169	// TODO emit a text artifact with stdout?
170	// reporter.onStdErr(chunk, test, result)
171	// reporter.onStdOut(chunk, test, result)
172
173	private emit(...events: DomainEvent[]): void {
174	events.forEach(event => {	21✔
175	this.serenity.announce(event)	56✔
176	});
177	}
178
179	private announceRetryIfNeeded(test: TestCase, result: TestResult): void {
180	if (test.retries === 0) {	16✔
181	return;	13✔
182	}
183
184	this.emit(	3✔
185	new RetryableSceneDetected(
186	this.currentSceneId,
187	this.now(),
188	),
189	new SceneTagged(
190	this.currentSceneId,
191	new ArbitraryTag('retried'), // todo: replace with a dedicated tag
192	this.now(),
193	),
194	);
195
196	if (result.retry > 0) {	3✔
197	this.emit(	2✔
198	new SceneTagged(
199	this.currentSceneId,
200	new ExecutionRetriedTag(result.retry),
201	this.serenity.currentTime(),
202	),
203	);
204	}
205	}
206
207	private now(): Timestamp {
208	return this.serenity.currentTime();	36✔
209	}
210
211	printsToStdio(): boolean {
212	return true;	×
213	}
214	}
215
216	class PlaywrightErrorParser {
217	private static ascii = new RegExp(	30✔
218	'[\\u001B\\u009B][[\\]()#;?](?:(?:(?:[a-zA-Z\\d](?:;[-a-zA-Z\\d\\/#&.:=?%@~_]))?\\u0007)\|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', // eslint-disable-line no-control-regex
219	'g',
220	);
221
222	public errorFrom(testError: TestError): Error {
223
224	const message = testError.message && PlaywrightErrorParser.stripAsciiFrom(testError.message);	5!
225	let stack = testError.stack && PlaywrightErrorParser.stripAsciiFrom(testError.stack);	5!
226
227	// TODO: Do I need to process it?
228	// const value = testError.value;
229
230	const prologue = `Error: ${message}`;	5✔
231	if (stack && message && stack.startsWith(prologue)) {	5!
232	stack = stack.slice(prologue.length);	4✔
233	}
234
235	const error = new Error(message);	5✔
236	error.stack = stack;	5✔
237
238	return error;	5✔
239	}
240
241	private static stripAsciiFrom(text: string): string {
242	return text.replace(this.ascii, '');	10✔
243	}
244	}

serenity-js / serenity-js / 3056052985

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