@serenity-js/playwright-test 3.31.17 → 3.32.0

package/src/reporter/PlaywrightEventBuffer.ts

@@ -0,0 +1,251 @@
+import path from 'node:path';
+
+import { type FullConfig } from '@playwright/test';
+import { type TestCase, type TestResult } from '@playwright/test/reporter';
+import { Duration, LogicError, Timestamp } from '@serenity-js/core';
+import {
+    type DomainEvent,
+    InteractionFinished,
+    RetryableSceneDetected,
+    SceneFinished,
+    SceneTagged
+} from '@serenity-js/core/lib/events';
+import { Path } from '@serenity-js/core/lib/io';
+import type {     CorrelationId,Outcome } from '@serenity-js/core/lib/model';
+import {
+    ArbitraryTag,
+    ExecutionFailedWithAssertionError,
+    ExecutionFailedWithError,
+    ExecutionIgnored,
+    ExecutionSkipped,
+    ExecutionSuccessful
+} from '@serenity-js/core/lib/model';
+import { type JSONObject } from 'tiny-types';
+
+import { WorkerEventStreamReader } from '../api/WorkerEventStreamReader';
+import { WorkerEventStreamWriter } from '../api/WorkerEventStreamWriter';
+import { EventFactory, PlaywrightSceneId } from '../events';
+import { PlaywrightErrorParser } from './PlaywrightErrorParser';
+
+export class PlaywrightEventBuffer {
+    private readonly errorParser = new PlaywrightErrorParser();
+    private readonly eventStreamReader = new WorkerEventStreamReader();
+
+    private eventFactory: EventFactory;
+    private readonly events = new Map<string, DomainEvent[]>();
+    private readonly deferredSceneFinishedEvents = new Map<string, {
+        event: SceneFinished;
+        outputDirectory: string;
+        workerIndex: number;
+    }>();
+
+    configure(config: Pick<FullConfig, 'rootDir'>): void {
+        this.eventFactory = new EventFactory(Path.from(config.rootDir));
+    }
+
+    appendTestStart(test: TestCase, result: TestResult): void {
+        this.events.set(
+            this.sceneId(test, result).value,
+            this.eventFactory.createSceneStartEvents(test, result),
+        );
+    }
+
+    appendRetryableSceneEvents(test: TestCase, result: TestResult): void {
+        const sceneId = this.sceneId(test, result);
+        const sceneEndTime = new Timestamp(result.startTime).plus(Duration.ofMilliseconds(result.duration));
+
+        this.events.get(sceneId.value).push(
+            new RetryableSceneDetected(sceneId, sceneEndTime),
+        );
+
+        if (result.retry > 0 || result.status !== 'passed') {
+            this.events.get(sceneId.value).push(
+                new SceneTagged(
+                    sceneId,
+                    new ArbitraryTag('retried'), // todo: replace with a dedicated tag
+                    sceneEndTime,
+                ),
+            );
+        }
+    }
+
+    deferAppendingSceneFinishedEvent(test: TestCase, result: TestResult): void {
+        const sceneId = this.sceneId(test, result);
+        const scenarioOutcome = this.outcomeFrom(test, result);
+
+        this.deferredSceneFinishedEvents.set(sceneId.value, {
+            event: this.eventFactory.createSceneFinishedEvent(test, result, scenarioOutcome),
+            outputDirectory: test.parent.project().outputDir,
+            workerIndex: result.workerIndex,
+        });
+    }
+
+    private determineScenarioOutcome(
+        worstInteractionOutcome: Outcome,
+        scenarioOutcome: Outcome,
+    ): Outcome {
+        if (worstInteractionOutcome instanceof ExecutionFailedWithAssertionError) {
+            return worstInteractionOutcome;
+        }
+
+        return worstInteractionOutcome.isWorseThan(scenarioOutcome)
+            ? worstInteractionOutcome
+            : scenarioOutcome;
+    }
+
+    appendCrashedWorkerEvents(test: TestCase, result: TestResult): void {
+        const workerStreamId = WorkerEventStreamWriter.workerStreamIdFor(result.workerIndex).value;
+        const sceneId = this.sceneId(test, result);
+
+        this.events.get(sceneId.value).push(
+            ...this.readEventStream(
+                test.parent.project().outputDir,
+                workerStreamId,
+                sceneId.value,
+            ),
+        );
+    }
+
+    appendSceneEvents(test: TestCase, result: TestResult): void {
+        const sceneId = this.sceneId(test, result);
+        this.events.get(sceneId.value).push(
+            ...this.readEventStream(test.parent.project().outputDir, sceneId.value),
+        );
+    }
+
+    private readEventStream(
+        outputDirectory: string,
+        streamId: string,
+        expectedSceneId: string = streamId,
+    ): DomainEvent[] {
+        const pathToEventStreamFile = path.join(outputDirectory, 'serenity', streamId, 'events.ndjson');
+
+        if (this.eventStreamReader.hasStream(pathToEventStreamFile)) {
+            return this.eventStreamReader.read(
+                pathToEventStreamFile,
+                (event: { type: string, value: JSONObject }) => {
+                    // re-attach events from orphaned beforeAll to the test case
+                    const hasSceneId = event.value['sceneId'] !== undefined;
+                    const isAttachedToScene = event.value['sceneId'] === expectedSceneId
+                    if(hasSceneId && ! isAttachedToScene) {
+                        event.value['sceneId'] = expectedSceneId;
+                    }
+                    return event;
+                }
+            );
+        }
+
+        return [];
+    }
+
+    appendSceneFinishedEvent(test: TestCase, result: TestResult): void {
+        const sceneId = this.sceneId(test, result);
+        const worstInteractionOutcome = this.determineWorstInteractionOutcome(this.events.get(sceneId.value));
+        const scenarioOutcome = this.determineScenarioOutcome(
+            worstInteractionOutcome,
+            this.outcomeFrom(test, result),
+        );
+
+        this.events.get(sceneId.value).push(
+            this.eventFactory.createSceneFinishedEvent(test, result, scenarioOutcome)
+        );
+    }
+
+    flush(test: TestCase, result: TestResult): DomainEvent[] {
+        const sceneId = this.sceneId(test, result);
+        const events = this.events.get(sceneId.value);
+
+        if (! events) {
+            throw new LogicError(`No events found for test: ${ sceneId.value }`);
+        }
+
+        this.events.delete(sceneId.value);
+
+        return events;
+    }
+
+    flushAllDeferred(): DomainEvent[] {
+        const allEvents = [];
+
+        for (const [ testId, events ] of this.events.entries()) {
+            const scenarioEvents = [];
+
+            scenarioEvents.push(...events);
+
+            if (this.deferredSceneFinishedEvents.has(testId)) {
+                const lastRecordedEvent = scenarioEvents.at(-1);
+                const deferredSceneFinished = this.deferredSceneFinishedEvents.get(testId);
+
+                const eventStream = this.readEventStream(
+                    deferredSceneFinished.outputDirectory,
+                    deferredSceneFinished.event.sceneId.value,
+                );
+
+                const firstEventSinceLastIndex = eventStream.findIndex(event => lastRecordedEvent.equals(event));
+                const eventsSinceLast = firstEventSinceLastIndex === -1
+                    ? eventStream
+                    : eventStream.slice(firstEventSinceLastIndex);
+
+                scenarioEvents.push(...eventsSinceLast);
+
+                const worstInteractionOutcome = this.determineWorstInteractionOutcome(scenarioEvents);
+
+                const sceneFinishedEvent = new SceneFinished(
+                    deferredSceneFinished.event.sceneId,
+                    deferredSceneFinished.event.details,
+                    this.determineScenarioOutcome(worstInteractionOutcome, deferredSceneFinished.event.outcome),
+                    deferredSceneFinished.event.timestamp,
+                )
+
+                scenarioEvents.push(sceneFinishedEvent);
+            }
+
+            allEvents.push(...scenarioEvents);
+        }
+
+        this.events.clear();
+        this.deferredSceneFinishedEvents.clear();
+
+        return allEvents;
+    }
+
+    private determineWorstInteractionOutcome(events: DomainEvent[]): Outcome {
+        let worstInteractionOutcome: Outcome = new ExecutionSuccessful();
+        for (const event of events) {
+            if (event instanceof InteractionFinished && event.outcome.isWorseThan(worstInteractionOutcome)) {
+                worstInteractionOutcome = event.outcome;
+            }
+        }
+        return worstInteractionOutcome;
+    }
+
+    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 sceneId(test: TestCase, result: TestResult): CorrelationId {
+        return PlaywrightSceneId.from(test.parent.project()?.name, test, result);
+    }
+}

package/src/reporter/PlaywrightTestSceneIdFactory.ts

@@ -0,0 +1,14 @@
+import type { CorrelationIdFactory } from '@serenity-js/core/lib/model';
+import { CorrelationId } from '@serenity-js/core/lib/model';
+
+export class PlaywrightTestSceneIdFactory implements CorrelationIdFactory {
+    private testId: CorrelationId;
+
+    setTestId(testId: string): void {
+        this.testId = new CorrelationId(testId);
+    }
+
+    create(): CorrelationId {
+        return this.testId;
+    }
+}

package/src/reporter/SerenityReporterForPlaywrightTest.ts

@@ -1,44 +1,16 @@
 import type { FullConfig } from '@playwright/test';
-import type { Reporter, Suite, TestCase, TestError, TestResult, } from '@playwright/test/reporter';
-import type {
-    ClassDescription,
-    Serenity,
-    StageCrewMember,
-    StageCrewMemberBuilder,
-    Timestamp,
-} from '@serenity-js/core';
-import { LogicError, serenity as reporterSerenityInstance, } from '@serenity-js/core';
+import type { FullResult, Reporter, Suite, TestCase, TestError, TestResult, } from '@playwright/test/reporter';
+import type { ClassDescription, StageCrewMember, StageCrewMemberBuilder } from '@serenity-js/core';
+import { Clock, Duration, Serenity, Timestamp } from '@serenity-js/core';
 import type { OutputStream } from '@serenity-js/core/lib/adapter';
-import type { DomainEvent } from '@serenity-js/core/lib/events';
-import * as events from '@serenity-js/core/lib/events';
-import {
-    InteractionFinished,
-    RetryableSceneDetected,
-    SceneFinished,
-    SceneStarts,
-    SceneTagged,
-    TestRunFinished,
-    TestRunFinishes,
-    TestRunnerDetected,
-    TestRunStarts
-} from '@serenity-js/core/lib/events';
-import { FileSystem, FileSystemLocation, Path, RequirementsHierarchy, } from '@serenity-js/core/lib/io';
-import type { CorrelationId, Outcome, Tag } from '@serenity-js/core/lib/model';
-import {
-    ArbitraryTag,
-    Category,
-    ExecutionFailedWithAssertionError,
-    ExecutionFailedWithError,
-    ExecutionIgnored,
-    ExecutionRetriedTag,
-    ExecutionSkipped,
-    ExecutionSuccessful,
-    Name,
-    ScenarioDetails,
-    Tags,
-} from '@serenity-js/core/lib/model';
-
-import { SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE } from './PlaywrightAttachments';
+import { TestRunFinished, TestRunFinishes, TestRunStarts } from '@serenity-js/core/lib/events';
+import { ExecutionFailedWithError, ExecutionSuccessful, } from '@serenity-js/core/lib/model';
+
+import { PlaywrightErrorParser } from './PlaywrightErrorParser';
+import { PlaywrightEventBuffer } from './PlaywrightEventBuffer';
+import { PlaywrightTestSceneIdFactory } from './PlaywrightTestSceneIdFactory';
+
+type HookType = 'beforeAll' | 'afterAll' | 'beforeEach' | 'afterEach';
 
 /**
  * Configuration object accepted by `@serenity-js/playwright-test` reporter.
@@ -74,113 +46,101 @@ export interface SerenityReporterForPlaywrightTestConfig {
  * Serenity/JS [stage crew members](https://serenity-js.org/api/core/interface/StageCrewMember/).
  */
 export class SerenityReporterForPlaywrightTest implements Reporter {
-    private errorParser = new PlaywrightErrorParser();
-    private sceneIds: Map<string, CorrelationId> = new Map();
+    private readonly errorParser = new PlaywrightErrorParser();
+
+    private readonly sceneIdFactory: PlaywrightTestSceneIdFactory;
+    private readonly serenity: Serenity;
     private unhandledError?: Error;
 
+    private readonly eventBuffer: PlaywrightEventBuffer = new PlaywrightEventBuffer();
+    private readonly suiteTestCounts = new Map<Suite, number>();
+
     /**
      * @param config
-     * @param serenity
-     *  Instance of [`Serenity`](https://serenity-js.org/api/core/class/Serenity/), specific to the Node process running this Serenity reporter.
-     *  Note that Playwright runs test workers and reporters in separate processes.
-     * @param requirementsHierarchy
-     *  Root directory of the requirements hierarchy, used to determine capabilities and themes.
      */
-    constructor(
-        config: SerenityReporterForPlaywrightTestConfig,
-        private readonly serenity: Serenity = reporterSerenityInstance,
-        private requirementsHierarchy: RequirementsHierarchy = new RequirementsHierarchy(
-            new FileSystem(Path.from(process.cwd())),
-        ),
-    ) {
+    constructor(config: SerenityReporterForPlaywrightTestConfig) {
+        this.sceneIdFactory = new PlaywrightTestSceneIdFactory();
+
+        this.serenity = new Serenity(
+            new Clock(),
+            process.cwd(),
+            this.sceneIdFactory,
+        )
         this.serenity.configure(config);
     }
 
     onBegin(config: FullConfig, suite: Suite): void {
-        this.requirementsHierarchy = new RequirementsHierarchy(
-            new FileSystem(Path.from(config.rootDir)),
-        );
+        this.eventBuffer.configure(config);
+        this.serenity.announce(new TestRunStarts(this.serenity.currentTime()));
 
-        this.serenity.announce(new TestRunStarts(this.now()));
+        this.countTestsPerSuite(suite);
     }
 
-    onTestBegin(test: TestCase): void {
-        const currentSceneId = this.serenity.assignNewSceneId();
-
-        this.sceneIds.set(test.id, currentSceneId);
-
-        const { scenarioDetails, scenarioTags } = this.scenarioDetailsFrom(test);
-
-        const tags: Tag[] = [
-            ... scenarioTags,
-            ... test.tags.flatMap(tag => Tags.from(tag)),
-        ];
-
-        this.emit(
-            new SceneStarts(currentSceneId, scenarioDetails, this.serenity.currentTime()),
+    private countTestsPerSuite(suite: Suite): void {
+        suite.allTests().forEach(test => {
+            let currentSuite: Suite | undefined = test.parent;
+            while (currentSuite) {
+                const count = this.suiteTestCounts.get(currentSuite) ?? 0;
+                this.suiteTestCounts.set(currentSuite, count + 1);
 
-            ...this.requirementsHierarchy
-                .requirementTagsFor(scenarioDetails.location.path, scenarioDetails.category.value)
-                .map(tag => new SceneTagged(currentSceneId, tag, this.serenity.currentTime())),
-
-            new TestRunnerDetected(
-                currentSceneId,
-                new Name('Playwright'),
-                this.serenity.currentTime(),
-            ),
+                currentSuite = currentSuite.parent;
+            }
+        });
+    }
 
-            ...tags.map(tag => new SceneTagged(currentSceneId, tag, this.serenity.currentTime())),
-        );
+    onTestBegin(test: TestCase, result: TestResult): void {
+        this.eventBuffer.appendTestStart(test, result);
     }
 
     // TODO might be nice to support that by emitting TestStepStarted / Finished
     // onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void {
     //     // console.log('>> onStepBegin');
     // }
+    // todo: add stdout -> Log https://github.com/microsoft/playwright/blob/main/packages/playwright/src/reporters/list.ts#L67
 
     // onStepEnd(test: TestCase, _result: TestResult, step: TestStep): void {
     //     // console.log('>> onStepEnd');
     // }
 
     onTestEnd(test: TestCase, result: TestResult): void {
-        this.announceRetryIfNeeded(test, result);
 
-        const currentSceneId = this.sceneIds.get(test.id);
+        const pendingAfterAllHooks = this.countPendingAfterAllHooks(test);
 
-        let worstInteractionOutcome: Outcome = new ExecutionSuccessful();
+        if (test.retries > 0) {
+            this.eventBuffer.appendRetryableSceneEvents(test, result);
+        }
 
-        for (const attachment of result.attachments) {
-            if (! (attachment.contentType === SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE && attachment.body)) {
-                continue;
-            }
+        this.eventBuffer.appendCrashedWorkerEvents(test, result);
+        this.eventBuffer.appendSceneEvents(test, result);
 
-            const messages = JSON.parse(attachment.body.toString());
+        if (pendingAfterAllHooks === 0) {
+            this.eventBuffer.appendSceneFinishedEvent(test, result)
 
-            for (const message of messages) {
-                if (message.value.sceneId === 'unknown') {
-                    message.value.sceneId = currentSceneId.value;
-                }
+            const events = this.eventBuffer.flush(test, result);
+
+            this.serenity.announce(...events);
+        }
+        else {
+            this.eventBuffer.deferAppendingSceneFinishedEvent(test, result);
+        }
+    }
 
-                const event = events[message.type].fromJSON(message.value);
+    private countPendingAfterAllHooks(test: TestCase): number {
+        let currentSuite: Suite | undefined = test.parent;
+        const pendingAfterAllHooks: Suite[] = [];
 
-                this.serenity.announce(event);
+        while (currentSuite) {
+            const remainingSuites = (this.suiteTestCounts.get(currentSuite) || 0) - 1;
+            this.suiteTestCounts.set(currentSuite, remainingSuites);
 
-                if (event instanceof InteractionFinished && event.outcome.isWorseThan(worstInteractionOutcome)) {
-                    worstInteractionOutcome = event.outcome;
-                }
+            if (remainingSuites === 0 && currentSuite['_hooks'].some((hook: { type: HookType }) => hook.type === 'afterAll')) {
+                pendingAfterAllHooks.push(currentSuite);
             }
-        }
 
-        const scenarioOutcome = this.outcomeFrom(test, result);
+            currentSuite = currentSuite.parent;
+        }
 
-        this.serenity.announce(
-            new SceneFinished(
-                currentSceneId,
-                this.scenarioDetailsFrom(test).scenarioDetails,
-                this.determineScenarioOutcome(worstInteractionOutcome, scenarioOutcome),
-                this.now(),
-            ),
-        );
+        return pendingAfterAllHooks.length;
     }
 
     onError(error: TestError): void {
@@ -189,173 +149,50 @@ export class SerenityReporterForPlaywrightTest implements Reporter {
         }
     }
 
-    private determineScenarioOutcome(
-        worstInteractionOutcome: Outcome,
-        scenarioOutcome: Outcome,
-    ): Outcome {
-        if (worstInteractionOutcome instanceof ExecutionFailedWithAssertionError) {
-            return worstInteractionOutcome;
-        }
-
-        return worstInteractionOutcome.isWorseThan(scenarioOutcome)
-            ? worstInteractionOutcome
-            : scenarioOutcome;
-    }
-
-    private outcomeFrom(test: TestCase, result: TestResult): Outcome {
-        const outcome = test.outcome();
-
-        if (outcome === 'skipped') {
-            return new ExecutionSkipped();
-        }
+    async onEnd(fullResult: FullResult): Promise<void> {
 
-        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),
-            );
-        }
+        const deferredEvents = this.eventBuffer.flushAllDeferred();
 
-        return new ExecutionSuccessful();
-    }
+        this.serenity.announce(
+            ...deferredEvents,
+        );
 
-    private scenarioDetailsFrom(test: TestCase): { scenarioDetails: ScenarioDetails, scenarioTags: Tag[] } {
-        const [
-            root_,
-            browserName_,
-            fileName,
-            describeOrItBlockTitle,
-            ...nestedTitles
-        ] = test.titlePath();
-
-        const path = new Path(test.location.file);
-        const scenarioName = nestedTitles.join(' ').trim();
-
-        const name = scenarioName || describeOrItBlockTitle;
-        const featureName = scenarioName ? describeOrItBlockTitle : fileName;
-
-        return {
-            scenarioDetails: new ScenarioDetails(
-                new Name(Tags.stripFrom(name)),
-                new Category(Tags.stripFrom(featureName)),
-                new FileSystemLocation(path, test.location.line, test.location.column),
-            ),
-            scenarioTags: Tags.from(`${ featureName } ${ name }`),
-        };
-    }
+        const fullDuration = Duration.ofMilliseconds(Math.round(fullResult.duration));
+        const endTime = new Timestamp(fullResult.startTime).plus(fullDuration);
 
-    async onEnd(): Promise<void> {
-        this.serenity.announce(new TestRunFinishes(this.serenity.currentTime()));
+        this.serenity.announce(new TestRunFinishes(endTime));
 
         try {
             await this.serenity.waitForNextCue();
 
-            const outcome = this.unhandledError ?
-                new ExecutionFailedWithError(this.unhandledError)
+            const outcome = this.unhandledError
+                ? new ExecutionFailedWithError(this.unhandledError)
                 : new ExecutionSuccessful();
 
             this.serenity.announce(
                 new TestRunFinished(
                     outcome,
-                    this.serenity.currentTime(),
+                    endTime,
                 ),
             );
-        } catch (error) {
+        }
+        catch (error) {
             this.serenity.announce(
                 new TestRunFinished(
                     new ExecutionFailedWithError(error),
-                    this.serenity.currentTime(),
+                    endTime,
                 ),
             );
+
             throw error;
         }
     }
 
-    // TODO emit a text artifact with stdout?
+    // 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;
-        }
-
-        const currentSceneId = this.sceneIds.get(test.id);
-
-        this.emit(
-            new RetryableSceneDetected(currentSceneId, this.now()),
-            new SceneTagged(
-                currentSceneId,
-                new ArbitraryTag('retried'), // todo: replace with a dedicated tag
-                this.now(),
-            ),
-        );
-
-        if (result.retry > 0) {
-            this.emit(
-                new SceneTagged(
-                    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);
-        }
-
-        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, '');
-    }
-}

package/src/reporter/index.ts

@@ -1,4 +1,2 @@
-export * from './DomainEventBuffer';
-export * from './PlaywrightAttachments';
 export * from './PlaywrightStepReporter';
 export * from './SerenityReporterForPlaywrightTest';