@serenity-js/playwright-test 3.31.17 → 3.32.1

package/src/reporter/SerenityReporterForPlaywrightTest.ts

@@ -1,49 +1,23 @@
 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.
  *
- * See [`SerenityOptions`](https://serenity-js.org/api/playwright-test/interface/SerenityOptions/) for usage examples.
+ * For usage examples, see:
+ * - [`SerenityFixtures`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/)
+ * - [`SerenityWorkerFixtures`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/)
  */
 export interface SerenityReporterForPlaywrightTestConfig {
     /**
@@ -52,7 +26,7 @@ export interface SerenityReporterForPlaywrightTestConfig {
      * Note that the `crew` can also be configured using [class descriptions](https://serenity-js.org/api/core/#ClassDescription).
      *
      * #### Learn more
-     * - [`SerenityOptions`](https://serenity-js.org/api/playwright-test/interface/SerenityOptions/)
+     * - [`SerenityFixtures`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/)
      * - [`SerenityConfig.crew`](https://serenity-js.org/api/core/class/SerenityConfig/#crew)
      */
     crew?: Array<StageCrewMember | StageCrewMemberBuilder | ClassDescription>;
@@ -74,113 +48,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 +151,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';

package/lib/api/SerenityFixtures.d.ts

@@ -1,130 +0,0 @@
-import type { Actor, Cast, Serenity } from '@serenity-js/core';
-/**
- * Serenity/JS-specific [Playwright Test fixtures](https://playwright.dev/docs/test-fixtures)
- * injected into your [test scenarios](https://serenity-js.org/api/playwright-test/function/it/).
- *
- * ## Example test scenario
- *
- * ```typescript
- * import { Ensure, equals } from '@serenity-js/assertions'
- * import { describe, it, test } from '@serenity-js/playwright-test'
- * import { Photographer, TakePhotosOfFailures } from '@serenity-js/web'
- *
- * describe(`Recording items`, () => {
- *
- *     test.use({
- *         defaultActorName: 'Serena',
- *         crew: [
- *             Photographer.whoWill(TakePhotosOfFailures),
- *         ],
- *     })
- *
- *     describe(`Todo List App`, () => {
- *
- *         it(`should allow me to add a todo item`, async ({ actor }) => {
- *             await actor.attemptsTo(
- *                 startWithAnEmptyList(),
- *
- *                 recordItem('Buy some milk'),
- *
- *                 Ensure.that(itemNames(), equals([
- *                     'Buy some milk',
- *                 ])),
- *             )
- *         })
- *     })
- * })
- * ```
- *
- * ## Learn more
- * - Declaring a Serenity/JS [test scenario](https://serenity-js.org/api/playwright-test/function/it/)
- * - [Grouping test scenarios](https://serenity-js.org/api/playwright-test/function/describe/)
- * - [Serenity/JS + Playwright Test project template](https://github.com/serenity-js/serenity-js-playwright-test-template/)
- */
-export interface SerenityFixtures {
-    /**
-     * Retrieves the root object of the Serenity/JS framework.
-     */
-    serenity: Serenity;
-    /**
-     * Name and version of the operating system that Playwright Test worker process runs on.
-     */
-    platform: {
-        name: string;
-        version: string;
-    };
-    /**
-     * A cast of Serenity/JS actors to be used instead of the default cast
-     * when instantiating [`actor`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actor)
-     * and invoking [`actorCalled`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actorCalled).
-     *
-     * #### Overriding the default cast of Serenity/JS actors
-     *
-     * ```typescript
-     * import { Cast, TakeNotes } from '@serenity-js/core'
-     * import { Ensure, equals } from '@serenity-js/assertions'
-     * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
-     * import { describe, it, test } from '@serenity-js/playwright-test'
-     *
-     * describe(`Recording items`, () => {
-     *
-     *     test.use({
-     *         defaultActorName: 'Serena',
-     *         actors: ({ browser, contextOptions }, use) => {
-     *             const cast = Cast.where(actor =>
-     *                 actor.whoCan(
-     *                     BrowseTheWebWithPlaywright.using(browser, contextOptions),
-     *                     TakeNotes.usingAnEmptyNotepad(),
-     *                 )
-     *             )
-     *
-     *             // Make sure to pass your custom cast to Playwright `use` callback
-     *             use(cast)
-     *         },
-     *     })
-     *
-     *     describe(`Todo List App`, () => {
-     *
-     *         it(`should allow me to add a todo item`, async ({ actor }) => {
-     *             await actor.attemptsTo(
-     *                 startWithAnEmptyList(),
-     *
-     *                 recordItem('Buy some milk'),
-     *
-     *                 Ensure.that(itemNames(), equals([
-     *                     'Buy some milk',
-     *                 ])),
-     *             )
-     *         })
-     *     })
-     * })
-     * ```
-     */
-    actors: Cast;
-    /**
-     * Uses the provided [cast](https://serenity-js.org/api/core/class/Cast/) of [`actors`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actors) to instantiate an [`Actor`](https://serenity-js.org/api/core/class/Actor/) called `name`
-     * and inject it into a [test scenario](https://serenity-js.org/api/playwright-test/function/it/).
-     *
-     * Retrieves an existing actor if one has already been instantiated.
-     *
-     * #### Learn more
-     * - Declaring a Serenity/JS [test scenario](https://serenity-js.org/api/playwright-test/function/it/)
-     * - [`SerenityOptions.actors`](https://serenity-js.org/api/playwright-test/interface/SerenityOptions/#actors)
-     * - [`SerenityFixtures.actors`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actors)
-     *
-     * @param name
-     */
-    actorCalled: (name: string) => Actor;
-    /**
-     * Default [`actor`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actor) injected into a [test scenario](https://serenity-js.org/api/playwright-test/function/it/).
-     *
-     * Using `actor` fixture is equivalent to invoking [`actorCalled`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actorCalled) with [`defaultActorName`](https://serenity-js.org/api/playwright-test/interface/SerenityOptions/#defaultActorName).
-     *
-     * #### Learn more
-     * - [`actorCalled`](https://serenity-js.org/api/playwright-test/interface/SerenityFixtures/#actorCalled)
-     * - [`SerenityOptions.defaultActorName`](https://serenity-js.org/api/playwright-test/interface/SerenityOptions/#defaultActorName)
-     * - Declaring a Serenity/JS [test scenario](https://serenity-js.org/api/playwright-test/function/it/)
-     */
-    actor: Actor;
-}
-//# sourceMappingURL=SerenityFixtures.d.ts.map

package/lib/api/SerenityFixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerenityFixtures.d.ts","sourceRoot":"","sources":["../../src/api/SerenityFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;OAEG;IACH,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,MAAM,EAAE,IAAI,CAAC;IAEb;;;;;;;;;;;;OAYG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;IAErC;;;;;;;;;OASG;IACH,KAAK,EAAE,KAAK,CAAC;CAChB"}

package/lib/api/SerenityFixtures.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=SerenityFixtures.js.map

package/lib/api/SerenityFixtures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerenityFixtures.js","sourceRoot":"","sources":["../../src/api/SerenityFixtures.ts"],"names":[],"mappings":""}