@serenity-js/playwright-test 3.31.17 → 3.32.1

package/src/api/test-api.ts

@@ -1,3 +1,7 @@
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
 import type {
     Expect,
     Fixtures,
@@ -7,52 +11,42 @@ import type {
     PlaywrightWorkerOptions,
     TestInfo,
     TestType,
+    WorkerInfo,
 } from '@playwright/test';
 import { test as playwrightBaseTest } from '@playwright/test';
-import { AnsiDiffFormatter, Cast, Duration, serenity as serenityInstance, TakeNotes } from '@serenity-js/core';
+import type { DiffFormatter } from '@serenity-js/core';
+import { AnsiDiffFormatter, Cast, Clock, Duration, Serenity, TakeNotes } from '@serenity-js/core';
 import { SceneFinishes, SceneTagged } from '@serenity-js/core/lib/events';
 import { BrowserTag, PlatformTag } from '@serenity-js/core/lib/model';
 import { BrowseTheWebWithPlaywright, SerenitySelectorEngines } from '@serenity-js/playwright';
 import { CallAnApi } from '@serenity-js/rest';
 import { Photographer, TakePhotosOfFailures } from '@serenity-js/web';
-import * as os from 'os';
-import type { JSONValue } from 'tiny-types';
 import { ensure, isFunction, property } from 'tiny-types';
 
-import {
-    DomainEventBuffer,
-    PlaywrightStepReporter,
-    SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE
-} from '../reporter';
+import { PlaywrightSceneId } from '../events';
+import { PlaywrightStepReporter, } from '../reporter';
+import { PlaywrightTestSceneIdFactory } from '../reporter/PlaywrightTestSceneIdFactory';
 import { PerformActivitiesAsPlaywrightSteps } from './PerformActivitiesAsPlaywrightSteps';
-import type { SerenityFixtures } from './SerenityFixtures';
-import type { SerenityOptions } from './SerenityOptions';
+import type { SerenityFixtures, SerenityWorkerFixtures } from './serenity-fixtures';
+import { WorkerEventStreamWriter } from './WorkerEventStreamWriter';
 
-const serenitySelectorEngines = new SerenitySelectorEngines();
+interface SerenityInternalFixtures {
+    configureScenarioInternal: void;
+}
 
-export const fixtures: Fixtures<Omit<SerenityOptions, 'actors'> & SerenityFixtures, object, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions> = {
-    actors: [
-        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-        async ({ contextOptions, baseURL, extraHTTPHeaders, page, proxy }, use): Promise<void> => {
-            await use(Cast.where(actor => actor.whoCan(
-                BrowseTheWebWithPlaywright.usingPage(page, contextOptions),
-                TakeNotes.usingAnEmptyNotepad(),
-                CallAnApi.using({
-                    baseURL: baseURL,
-                    headers: extraHTTPHeaders,
-                    proxy: proxy && proxy?.server
-                        ? asProxyConfig(proxy)
-                        : undefined,
-                }),
-            )));
-        },
-        { option: true },
-    ],
+interface SerenityInternalWorkerFixtures {
+    configureWorkerInternal: void;
+    sceneIdFactoryInternal: PlaywrightTestSceneIdFactory;
+    diffFormatterInternal: DiffFormatter;
+    eventStreamWriterInternal: WorkerEventStreamWriter;
+}
 
-    playwright: async ({ playwright }, use) => {
-        await serenitySelectorEngines.ensureRegisteredWith(playwright.selectors);
-        await use(playwright);
-    },
+export const fixtures: Fixtures<SerenityFixtures & SerenityInternalFixtures, SerenityWorkerFixtures & SerenityInternalWorkerFixtures, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions> = {
+
+    extraContextOptions: [
+        { defaultNavigationWaitUntil: 'load' },
+        { option: true }
+    ],
 
     defaultActorName: [
         'Serena',
@@ -70,14 +64,30 @@ export const fixtures: Fixtures<Omit<SerenityOptions, 'actors'> & SerenityFixtur
     ],
 
     crew: [
-        [
-            Photographer.whoWill(TakePhotosOfFailures)
-        ],
+        [ Photographer.whoWill(TakePhotosOfFailures) ],
+        { option: true },
+    ],
+
+    actors: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async ({ extraContextOptions, baseURL, extraHTTPHeaders, page, proxy }, use): Promise<void> => {
+            await use(Cast.where(actor => actor.whoCan(
+                BrowseTheWebWithPlaywright.usingPage(page, extraContextOptions),
+                TakeNotes.usingAnEmptyNotepad(),
+                CallAnApi.using({
+                    baseURL: baseURL,
+                    headers: extraHTTPHeaders,
+                    proxy: proxy && proxy?.server
+                        ? asProxyConfig(proxy)
+                        : undefined,
+                }),
+            )));
+        },
         { option: true },
     ],
 
-    // eslint-disable-next-line no-empty-pattern
-    platform: async ({}, use) => {
+    // eslint-disable-next-line no-empty-pattern,@typescript-eslint/explicit-module-boundary-types
+    platform: [ async ({}, use) => {
         const platform = os.platform();
 
         // https://nodejs.org/api/process.html#process_process_platform
@@ -86,75 +96,148 @@ export const fixtures: Fixtures<Omit<SerenityOptions, 'actors'> & SerenityFixtur
             : (platform === 'darwin' ? 'macOS' : 'Linux');
 
         await use({ name, version: os.release() });
-    },
+    }, { scope: 'worker' } ],
 
-    serenity: async ({ crew, cueTimeout, interactionTimeout, platform }, use, info: TestInfo) => {
+    diffFormatterInternal: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,no-empty-pattern
+        async ({}, use) => {
+            const diffFormatter = new AnsiDiffFormatter();
+            await use(diffFormatter);
+        },
+        { scope: 'worker', box: true }
+    ],
 
-        const domainEventBuffer = new DomainEventBuffer();
+    sceneIdFactoryInternal: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,no-empty-pattern
+        async ({ }, use) => {
+            await use(new PlaywrightTestSceneIdFactory());
+        },
+        { scope: 'worker', box: true },
+    ],
 
-        serenityInstance.configure({
-            diffFormatter: new AnsiDiffFormatter(),
-            cueTimeout: asDuration(cueTimeout),
-            interactionTimeout: asDuration(interactionTimeout),
-            crew: [
-                ...crew,
-                domainEventBuffer,
-                new PlaywrightStepReporter(info),
-            ],
-        });
+    serenity: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async ({ playwright, sceneIdFactoryInternal }, use, workerInfo) => {
+            const clock = new Clock();
+            const cwd = process.cwd();
+            const serenity = new Serenity(clock, cwd, sceneIdFactoryInternal);
 
-        serenityInstance.announce(new SceneTagged(
-            serenityInstance.currentSceneId(),
-            new PlatformTag(platform.name, platform.version),
-            serenityInstance.currentTime(),
-        ));
+            const serenitySelectorEngines = new SerenitySelectorEngines();
+            await serenitySelectorEngines.ensureRegisteredWith(playwright.selectors);
 
-        await use(serenityInstance);
+            await use(serenity);
+        },
+        { scope: 'worker', box: true }
+    ],
 
-        const serialisedEvents: Array<{ type: string, value: JSONValue }> = [];
+    eventStreamWriterInternal: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,no-empty-pattern
+        async ({ }, use, workerInfo) => {
 
-        for (const event of domainEventBuffer.flush()) {
-            serialisedEvents.push({
-                type: event.constructor.name,
-                value: event.toJSON(),
-            });
+            const serenityOutputDirectory = path.join(workerInfo.project.outputDir, 'serenity');
 
-            if (event instanceof SceneTagged) {
-                test.info().annotations.push({ type: event.tag.type, description: event.tag.name });
-            }
-        }
+            const eventStreamWriter = new WorkerEventStreamWriter(
+                serenityOutputDirectory,
+                workerInfo,
+            );
 
-        info.attach('serenity-js-events.json', {
-            contentType: SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE,
-            body: Buffer.from(JSON.stringify(serialisedEvents), 'utf8'),
-        });
-    },
+            await use(eventStreamWriter);
+        },
+        { scope: 'worker', box: true },
+    ],
 
-    actorCalled: async ({ serenity, actors, browser, browserName, contextOptions }, use) => {
+    configureWorkerInternal: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async ({ diffFormatterInternal, eventStreamWriterInternal, sceneIdFactoryInternal, serenity, browser }, use, info: WorkerInfo) => {
+
+            serenity.configure({
+                actors: Cast.where(actor => actor.whoCan(
+                    BrowseTheWebWithPlaywright.using(browser),
+                    TakeNotes.usingAnEmptyNotepad(),
+                    // todo: consider making `axios` a fixture and injecting an ability to CallAnApi
+                )),
+                crew: [
+                    eventStreamWriterInternal,
+                ],
+                diffFormatter: diffFormatterInternal,
+            });
 
-        const sceneId = serenity.currentSceneId();
+            sceneIdFactoryInternal.setTestId(`worker-${ info.workerIndex }`);
+            const workerBeforeAllSceneId = serenity.assignNewSceneId();
 
-        serenity.engage(asCast(actors));
+            await use(void 0);
+
+            await eventStreamWriterInternal.persistAll(workerBeforeAllSceneId);
+        },
+        { scope: 'worker', auto: true, box: true },
+    ],
 
-        const actorCalled = (name: string) => {
-            const actor = serenity.theActorCalled(name);
-            return actor.whoCan(new PerformActivitiesAsPlaywrightSteps(actor, serenity, it));
-        };
+    configureScenarioInternal: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async ({ actors, browser, browserName, crew, cueTimeout, diffFormatterInternal, eventStreamWriterInternal, interactionTimeout, platform, sceneIdFactoryInternal, serenity }, use, info: TestInfo) => {
+
+            serenity.configure({
+                actors: asCast(actors),
+                diffFormatter: diffFormatterInternal,
+                cueTimeout: asDuration(cueTimeout),
+                interactionTimeout: asDuration(interactionTimeout),
+                crew: [
+                    ...crew,
+                    new PlaywrightStepReporter(info),
+                ],
+            });
 
-        serenity.announce(new SceneTagged(
-            sceneId,
-            new BrowserTag(browserName, browser.version()),
-            serenity.currentTime(),
-        ));
+            const playwrightSceneId = PlaywrightSceneId.from(
+                info.project.name,
+                { id: info.testId, repeatEachIndex: info.repeatEachIndex },
+                { retry: info.retry }
+            );
+
+            sceneIdFactoryInternal.setTestId(playwrightSceneId.value);
+            const sceneId = serenity.assignNewSceneId();
+
+            serenity.announce(
+                new SceneTagged(
+                    sceneId,
+                    new PlatformTag(platform.name, platform.version),
+                    serenity.currentTime(),
+                ),
+                new SceneTagged(
+                    sceneId,
+                    new BrowserTag(browserName, browser.version()),
+                    serenity.currentTime(),
+                )
+            );
+
+            await use(void 0);
+
+            try {
+                serenity.announce(
+                    new SceneFinishes(sceneId, serenity.currentTime()),
+                );
+
+                await serenity.waitForNextCue();
+            }
+            finally {
+                await eventStreamWriterInternal.persist(playwrightSceneId.value);
+            }
+        },
+        { auto: true, box: true, }
+    ],
 
-        await use(actorCalled);
+    actorCalled: [
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async ({ serenity }, use) => {
 
-        serenity.announce(
-            new SceneFinishes(sceneId, serenity.currentTime()),
-        );
+            const actorCalled = (name: string) => {
+                const actor = serenity.theActorCalled(name);
+                return actor.whoCan(new PerformActivitiesAsPlaywrightSteps(actor, serenity, it));
+            };
 
-        await serenityInstance.waitForNextCue();
-    },
+            await use(actorCalled);
+        },
+        { scope: 'worker' },
+    ],
 
     actor: async ({ actorCalled, defaultActorName }, use) => {
         await use(actorCalled(defaultActorName));
@@ -191,14 +274,17 @@ export type TestApi<TestArgs extends Record<string, any>, WorkerArgs extends Rec
          *
          * Shorthand for [`useBase`](https://serenity-js.org/api/playwright-test/function/useBase/)
          */
-        useFixtures: <T extends Record<string, any>, W extends Record<string, any> = object>(customFixtures: Fixtures<T, W, TestArgs, WorkerArgs>) => TestApi<TestArgs & T, WorkerArgs & W>,
+        useFixtures: <T extends Record<string, any>, W extends Record<string, any> = object>(
+            customFixtures: Fixtures<T, W, TestArgs, WorkerArgs>
+        ) => TestApi<TestArgs & T, WorkerArgs & W>,
+
         it: TestType<TestArgs, WorkerArgs>,
         test: TestType<TestArgs, WorkerArgs>,
     }
 
-function createTestApi<TestArgs extends Record<string, any>, WorkerArgs extends Record<string, any> = object>(baseTest: TestType<TestArgs, WorkerArgs>): TestApi<TestArgs, WorkerArgs> {
+function createTestApi<BaseTestFixtures extends (PlaywrightTestArgs & PlaywrightTestOptions), BaseWorkerFixtures extends (PlaywrightWorkerArgs & PlaywrightWorkerOptions)>(baseTest: TestType<BaseTestFixtures, BaseWorkerFixtures>): TestApi<BaseTestFixtures, BaseWorkerFixtures> {
     return {
-        useFixtures<T extends Record<string, any>, W extends Record<string, any> = object>(customFixtures: Fixtures<T, W, TestArgs, WorkerArgs>): TestApi<TestArgs & T, WorkerArgs & W> {
+        useFixtures<T extends Record<string, any>, W extends Record<string, any> = object>(customFixtures: Fixtures<T, W, BaseTestFixtures, BaseWorkerFixtures>): TestApi<BaseTestFixtures & T, BaseWorkerFixtures & W> {
             return createTestApi(baseTest.extend(customFixtures));
         },
         beforeAll: baseTest.beforeAll,
@@ -212,7 +298,7 @@ function createTestApi<TestArgs extends Record<string, any>, WorkerArgs extends
     };
 }
 
-const api = createTestApi(playwrightBaseTest).useFixtures(fixtures);
+const api = createTestApi(playwrightBaseTest).useFixtures<SerenityFixtures, SerenityWorkerFixtures>(fixtures);
 
 /**
  * Declares a single test scenario.
@@ -478,11 +564,13 @@ export const useFixtures = api.useFixtures;
  *
  * @param baseTest
  */
-export function useBase<TestArgs extends Record<string, any>, WorkerArgs extends Record<string, any> = object>(
-    baseTest: TestType<TestArgs, WorkerArgs>
-): TestApi<Omit<SerenityOptions, 'actors'> & SerenityFixtures & TestArgs, WorkerArgs> {
-    return createTestApi(baseTest)
-        .useFixtures<TestArgs & Omit<SerenityOptions, 'actors'> & SerenityFixtures, WorkerArgs>(fixtures);
+export function useBase<
+    BaseTestFixtures extends (PlaywrightTestArgs & PlaywrightTestOptions),
+    BaseWorkerFixtures extends (PlaywrightWorkerArgs & PlaywrightWorkerOptions)
+> (baseTest: TestType<BaseTestFixtures, BaseWorkerFixtures>): TestApi<BaseTestFixtures & SerenityFixtures, BaseWorkerFixtures & SerenityWorkerFixtures> {
+    return createTestApi<BaseTestFixtures, BaseWorkerFixtures>(baseTest).useFixtures(
+        fixtures as Fixtures<SerenityFixtures, SerenityWorkerFixtures, BaseTestFixtures, BaseWorkerFixtures>
+    );
 }
 
 /**

package/src/events/EventFactory.ts

@@ -0,0 +1,204 @@
+import type { FullProject } from '@playwright/test/reporter';
+import { type TestCase, type TestResult } from '@playwright/test/reporter';
+import { Duration, Timestamp } from '@serenity-js/core';
+import {
+    type DomainEvent,
+    SceneFinished,
+    SceneParametersDetected,
+    SceneSequenceDetected,
+    SceneStarts,
+    SceneTagged,
+    SceneTemplateDetected,
+    TestRunnerDetected
+} from '@serenity-js/core/lib/events';
+import { FileSystem, FileSystemLocation, Path, RequirementsHierarchy } from '@serenity-js/core/lib/io';
+import type { Outcome, Tag } from '@serenity-js/core/lib/model';
+import {
+    Category,
+    Description,
+    Name,
+    ProjectTag,
+    ScenarioDetails,
+    ScenarioParameters,
+    Tags
+} from '@serenity-js/core/lib/model';
+
+import { PlaywrightSceneId } from './PlaywrightSceneId';
+
+export class EventFactory {
+    private requirementsHierarchy: RequirementsHierarchy;
+
+    constructor(rootDirectory: Path) {
+        this.requirementsHierarchy = new RequirementsHierarchy(
+            new FileSystem(rootDirectory),
+        );
+    }
+
+    createSceneStartEvents(test: TestCase, result: TestResult): DomainEvent[] {
+        const sceneId = PlaywrightSceneId.from(test.parent.project()?.name, test, result);
+        const startTime = new Timestamp(result.startTime);
+
+        const project: FullProject | undefined = test.parent.project();
+        const projectName = project?.name ?? '';
+
+        const scenarioDetails = this.scenarioDetailsFrom(test);
+
+        const allTags = this.tagsFrom(
+            scenarioDetails,
+            test.tags,
+        );
+
+        if (projectName) {
+            allTags.push(new ProjectTag(projectName));
+        }
+
+        const events: DomainEvent[] = [];
+
+        if (test.retries > 0) {
+            events.push(
+                ...this.createSceneSequenceEvents(
+                    sceneId,
+                    startTime,
+                    scenarioDetails,
+                    test,
+                    result
+                )
+            );
+        }
+
+        events.push(
+            new SceneStarts(sceneId,
+                scenarioDetails,
+                startTime
+            ),
+            new TestRunnerDetected(sceneId, new Name('Playwright'), startTime),
+            ...allTags.map(tag => new SceneTagged(sceneId, tag, startTime))
+        )
+
+        return events;
+    }
+
+    private createSceneSequenceEvents(
+        sceneId: PlaywrightSceneId,
+        startTime: Timestamp,
+        scenarioDetails: ScenarioDetails,
+        test: TestCase,
+        result: TestResult
+    ): DomainEvent[] {
+
+        const attempt = result.retry + 1;
+        const parameters = {
+            Retries: `Attempt #${ attempt }`
+        };
+
+        return [
+            new SceneSequenceDetected(sceneId, scenarioDetails, startTime),
+            new SceneTemplateDetected(
+                sceneId,
+                new Description(''),
+                startTime,
+            ),
+            new SceneParametersDetected(
+                sceneId,
+                scenarioDetails,
+                new ScenarioParameters(
+                    new Name(''),
+                    new Description(`Max retries: ${ test.retries }`),
+                    parameters,
+                )
+            ),
+        ];
+    }
+
+    createSceneFinishedEvent(test: TestCase, result: TestResult, scenarioOutcome: Outcome): SceneFinished {
+        const sceneId = PlaywrightSceneId.from(test.parent.project()?.name, test, result);
+        const duration = Duration.ofMilliseconds(result.duration);
+        const sceneEndTime = new Timestamp(result.startTime).plus(duration);
+
+        const scenarioDetails = this.scenarioDetailsFrom(test);
+
+        return new SceneFinished(
+            sceneId,
+            scenarioDetails,
+            scenarioOutcome,
+            sceneEndTime,
+        );
+    }
+
+    private uniqueTags(...tags: Tag[]) {
+        const uniqueTags: Record<string, Tag> = { };
+
+        for (const tag of tags) {
+            const { name, type } = tag.toJSON();
+            const key = `${ name } ${ type }`;
+            uniqueTags[key] = tag;
+        }
+
+        return Object.values(uniqueTags);
+    }
+
+    private scenarioDetailsFrom(test: Pick<TestCase, 'titlePath' | 'location' | 'parent' | 'repeatEachIndex'>): ScenarioDetails {
+
+        const { featureName, name } = this.scenarioMetadataFrom(test);
+        const { file, line, column } = test.location;
+
+        const nameWithoutTags = Tags.stripFrom(name);
+
+        const repetitionSuffix = test.repeatEachIndex
+            ? ` - Repetition ${ test.repeatEachIndex }`
+            : '';
+
+        const scenarioName = `${ nameWithoutTags }${ repetitionSuffix }`;
+
+        return new ScenarioDetails(
+            new Name(scenarioName),
+            new Category(Tags.stripFrom(featureName)),
+            new FileSystemLocation(Path.from(file), line, column),
+        );
+    }
+
+    private scenarioMetadataFrom(test: Pick<TestCase, 'titlePath' | 'location'>): { featureName: string, name: string } {
+        const [
+            root_,
+            browserName_,
+            fileName,
+            describeOrItBlockTitle,
+            ...nestedTitles
+        ] = test.titlePath();
+
+        const scenarioName = nestedTitles.join(' ').trim();
+
+        const name = scenarioName || describeOrItBlockTitle;
+        const featureName = scenarioName ? describeOrItBlockTitle : fileName;
+
+        return {
+            featureName,
+            name,
+        };
+    }
+
+    private tagsFrom(scenarioDetails: ScenarioDetails, extraTagValues: string[]): Tag[] {
+
+        const tagsFromRequirementsHierarchy  = this.requirementsHierarchy.requirementTagsFor(
+            scenarioDetails.location.path,
+            scenarioDetails.category.value,
+        );
+
+        const tagsFromTitle = Tags.from([
+            scenarioDetails.category.value,
+            scenarioDetails.name.value,
+        ].join(' '));
+
+        const extraTags = extraTagValues
+            .filter(Boolean)
+            .flatMap(tagValue => Tags.from(tagValue));
+
+        return [
+            ...tagsFromRequirementsHierarchy,
+            ...this.uniqueTags(
+                ...tagsFromTitle,
+                ...extraTags,
+            )
+        ]
+    }
+}

package/src/events/PlaywrightSceneId.ts

@@ -0,0 +1,20 @@
+import { createHash } from 'node:crypto';
+
+import type { FullProject, TestCase, TestResult } from '@playwright/test/reporter';
+import { CorrelationId } from '@serenity-js/core/lib/model';
+
+export class PlaywrightSceneId extends CorrelationId {
+
+    static override fromJSON(v: string): CorrelationId {
+        return new PlaywrightSceneId(v);
+    }
+
+    static from(projectName: FullProject['name'], test: Pick<TestCase, 'id' | 'repeatEachIndex'>, result: Pick<TestResult, 'retry'>): CorrelationId {
+        const projectId = createHash('sha1')
+            .update(projectName)
+            .digest('hex')
+            .slice(0, 10);
+
+        return new PlaywrightSceneId(`${ test.id }-${ projectId }-${ test.repeatEachIndex }-${ result.retry }`);
+    }
+}

package/src/events/index.ts

@@ -0,0 +1,2 @@
+export * from './EventFactory';
+export * from './PlaywrightSceneId';

package/src/reporter/PlaywrightErrorParser.ts

@@ -0,0 +1,35 @@
+import type { TestError } from '@playwright/test/reporter';
+
+export 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);
+        }
+
+        if (testError.cause) {
+            stack += `\nCaused by: ${ this.errorFrom(testError.cause).stack }`;
+        }
+
+        const error = new Error(message);
+        error.stack = stack;
+
+        return error;
+    }
+
+    private static stripAsciiFrom(text: string): string {
+        return text.replace(this.ascii, '');
+    }
+}