@serenity-js/playwright-test/esm/events/EventFactory.js

Serenity/JS test runner adapter for Playwright Test, combining Playwright's developer experience with the advanced reporting and automation capabilities of Serenity/JS

import { Duration, Timestamp } from '@serenity-js/core';
import { SceneFinished, SceneParametersDetected, SceneSequenceDetected, SceneStarts, SceneTagged, SceneTemplateDetected, TestRunnerDetected } from '@serenity-js/core/events';
import { FileSystem, FileSystemLocation, Path, RequirementsHierarchy } from '@serenity-js/core/io';
import { Category, Description, Name, ProjectTag, ScenarioDetails, ScenarioParameters, Tags } from '@serenity-js/core/model';
import { PlaywrightSceneId } from './PlaywrightSceneId.js';
export class EventFactory {
    requirementsHierarchy;
    constructor(rootDirectory) {
        this.requirementsHierarchy = new RequirementsHierarchy(new FileSystem(rootDirectory));
    }
    createSceneStartEvents(test, result) {
        const sceneId = PlaywrightSceneId.from(test.parent.project()?.name, test, result);
        const startTime = new Timestamp(result.startTime);
        const project = 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 = [];
        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;
    }
    createSceneSequenceEvents(sceneId, startTime, scenarioDetails, test, result) {
        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, result, scenarioOutcome) {
        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);
    }
    uniqueTags(...tags) {
        const uniqueTags = {};
        for (const tag of tags) {
            const { name, type } = tag.toJSON();
            const key = `${name} ${type}`;
            uniqueTags[key] = tag;
        }
        return Object.values(uniqueTags);
    }
    scenarioDetailsFrom(test) {
        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));
    }
    scenarioMetadataFrom(test) {
        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,
        };
    }
    tagsFrom(scenarioDetails, extraTagValues) {
        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)
        ];
    }
}
//# sourceMappingURL=EventFactory.js.map