@uuv/playwright 1.3.0

package/dist/cucumber/preprocessor/gen/generate.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PWFile = void 0;
+const formatter = __importStar(require("./formatter"));
+const i18n_1 = require("./i18n");
+class PWFile {
+    doc;
+    pickles;
+    lines = [];
+    keywordsMap;
+    constructor(doc, pickles) {
+        this.doc = doc;
+        this.pickles = pickles;
+    }
+    get content() {
+        return this.lines.join("\n");
+    }
+    get language() {
+        return this.doc.feature?.language || "en";
+    }
+    build() {
+        this.loadI18nKeywords();
+        this.lines = [...formatter.fileHeader(this.doc.uri), ...this.getRootSuite()];
+        return this;
+    }
+    loadI18nKeywords() {
+        if (this.language !== "en") {
+            this.keywordsMap = (0, i18n_1.getKeywordsMap)(this.language);
+        }
+    }
+    getRootSuite() {
+        if (!this.doc.feature) {
+            throw new Error("Document without feature.");
+        }
+        return this.getSuite(this.doc.feature);
+    }
+    getSuite({ name, children }) {
+        const lines = [];
+        children.forEach((child) => lines.push(...this.getSuiteChild(child)));
+        return formatter.suite(name, lines);
+    }
+    getSuiteChild(child) {
+        if ("rule" in child && child.rule) {
+            return this.getSuite(child.rule);
+        }
+        const { background, scenario } = child;
+        if (background) {
+            return this.getBeforeEach(background);
+        }
+        if (scenario) {
+            return this.getScenarioLines(scenario);
+        }
+        throw new Error(`Empty child: ${JSON.stringify(child)}`);
+    }
+    getScenarioLines(scenario) {
+        return isOutline(scenario) ? this.getOutlineSuite(scenario) : this.getTest(scenario);
+    }
+    getBeforeEach(bg) {
+        const { keywords, lines } = this.getSteps(bg);
+        return formatter.beforeEach(keywords, lines);
+    }
+    getOutlineSuite(scenario) {
+        const suiteLines = [];
+        let exampleIndex = 0;
+        scenario.examples.forEach((example) => {
+            example.tableBody.forEach((exampleRow) => {
+                const title = `Example #${++exampleIndex}`;
+                const { keywords, lines } = this.getSteps(scenario, exampleRow.id);
+                const testLines = formatter.test(title, keywords, lines);
+                suiteLines.push(...testLines);
+            });
+        });
+        return formatter.suite(scenario.name, suiteLines);
+    }
+    getTest(scenario) {
+        const { keywords, lines } = this.getSteps(scenario);
+        return formatter.test(scenario.name, keywords, lines);
+    }
+    getSteps(scenario, outlineExampleRowId) {
+        const keywords = new Set();
+        const lines = scenario.steps.map((step) => {
+            const pickleStep = this.getPickleStep(step, outlineExampleRowId);
+            const { keyword, line } = this.getStep(step, pickleStep);
+            keywords.add(keyword);
+            return line;
+        });
+        return { keywords, lines };
+    }
+    getStep(step, { text, argument }) {
+        const keyword = this.getKeyword(step);
+        const line = formatter.step(keyword, text, argument);
+        return { keyword, line };
+    }
+    getPickleStep(step, outlineExampleRowId) {
+        for (const pickle of this.pickles) {
+            const pickleStep = pickle.steps.find(({ astNodeIds }) => {
+                const hasStepId = astNodeIds.includes(step.id);
+                const hasRowId = !outlineExampleRowId || astNodeIds.includes(outlineExampleRowId);
+                return hasStepId && hasRowId;
+            });
+            if (pickleStep) {
+                return pickleStep;
+            }
+        }
+        throw new Error(`Pickle step not found for step: ${step.text}`);
+    }
+    getKeyword(step) {
+        const origKeyword = step.keyword.trim();
+        if (origKeyword === "*") {
+            return "And";
+        }
+        if (!this.keywordsMap) {
+            return origKeyword;
+        }
+        const enKeyword = this.keywordsMap.get(origKeyword);
+        if (!enKeyword) {
+            throw new Error(`Keyword not found: ${origKeyword}`);
+        }
+        return enKeyword;
+    }
+}
+exports.PWFile = PWFile;
+function isOutline(scenario) {
+    return scenario.keyword === "Scenario Outline";
+}

package/dist/cucumber/preprocessor/gen/i18n.d.ts

@@ -0,0 +1,2 @@
+export type KeywordsMap = Map<string, string>;
+export declare function getKeywordsMap(language: string): KeywordsMap;

package/dist/cucumber/preprocessor/gen/i18n.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeywordsMap = void 0;
+/**
+ * Get i18n keywords.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/cli/i18n.ts
+ */
+const gherkin_1 = require("@cucumber/gherkin");
+function getKeywordsMap(language) {
+    const origMap = gherkin_1.dialects[language];
+    if (!origMap) {
+        throw new Error(`Language not found: ${language}`);
+    }
+    const targetMap = new Map();
+    const enKeywords = Object.keys(origMap);
+    enKeywords.forEach((enKeyword) => handleKeyword(enKeyword, origMap, targetMap));
+    return targetMap;
+}
+exports.getKeywordsMap = getKeywordsMap;
+function handleKeyword(enKeyword, origMap, targetMap) {
+    const nativeKeywords = origMap[enKeyword];
+    // Array.isArray converts to any[]
+    if (typeof nativeKeywords === "string") {
+        return;
+    }
+    nativeKeywords.forEach((nativeKeyword) => {
+        nativeKeyword = nativeKeyword.trim();
+        if (!nativeKeyword || nativeKeyword === "*") {
+            return;
+        }
+        targetMap.set(nativeKeyword, capitalizeFirstLetter(enKeyword));
+    });
+}
+function capitalizeFirstLetter(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/dist/cucumber/preprocessor/gen/index.d.ts

@@ -0,0 +1,7 @@
+import { GherkinDocument } from "@cucumber/messages";
+export type GenOptions = {
+    outputDir?: string;
+    cucumberConfig?: string;
+    cwd?: string;
+};
+export declare function generateTestFiles(inputOptions?: GenOptions): Promise<Map<string, GherkinDocument>>;

package/dist/cucumber/preprocessor/gen/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestFiles = void 0;
+/**
+ * Generate playwright tests from Gherkin documents.
+ */
+const node_path_1 = __importDefault(require("node:path"));
+const api_1 = require("@cucumber/cucumber/api");
+const load_sources_1 = require("./load_sources");
+const generate_1 = require("./generate");
+const save_1 = require("./save");
+const defaults = {
+    outputDir: ".features-gen",
+    cwd: process.cwd(),
+};
+async function generateTestFiles(inputOptions) {
+    const { outputDir, cwd, cucumberConfig } = Object.assign({}, defaults, inputOptions);
+    const features = await loadFeatures({ file: cucumberConfig }, { cwd });
+    const files = buildFiles(features);
+    const paths = (0, save_1.saveFiles)(files, node_path_1.default.join(cwd, outputDir));
+    const mapOfFile = new Map();
+    paths.forEach((path, index) => mapOfFile.set(path, Array.from(features.keys())[index]));
+    return mapOfFile;
+}
+exports.generateTestFiles = generateTestFiles;
+async function loadFeatures(options, environment) {
+    const { runConfiguration } = await (0, api_1.loadConfiguration)(options, environment);
+    const { filteredPickles, parseErrors } = await (0, load_sources_1.loadSources)(runConfiguration.sources, environment);
+    handleParseErrors(parseErrors);
+    return groupByDocument(filteredPickles);
+}
+function buildFiles(features) {
+    const files = [];
+    features.forEach((pickles, doc) => files.push(new generate_1.PWFile(doc, pickles).build()));
+    return files;
+}
+function groupByDocument(filteredPickles) {
+    const features = new Map();
+    filteredPickles.forEach(({ pickle, gherkinDocument }) => {
+        let pickles = features.get(gherkinDocument);
+        if (!pickles) {
+            pickles = [];
+            features.set(gherkinDocument, pickles);
+        }
+        pickles.push(pickle);
+    });
+    return features;
+}
+function handleParseErrors(parseErrors) {
+    if (parseErrors.length) {
+        parseErrors.forEach((parseError) => {
+            // eslint-disable-next-line no-console
+            console.error(`Parse error in "${parseError.source.uri}" ${parseError.message}`);
+        });
+        process.exit(1);
+    }
+}

package/dist/cucumber/preprocessor/gen/load_sources.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copied from original load_sources, but returns full Pickles.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/load_sources.ts
+ */
+/// <reference types="packages/runner-playwright/src/cucumber/preprocessor/gen/gherkin" />
+import { IRunEnvironment, ISourcesCoordinates } from "@cucumber/cucumber/lib/api/types";
+/**
+ * Load and parse features, produce a filtered and ordered test plan and/or parse errors.
+ *
+ * @public
+ * @param coordinates - Coordinates required to find features
+ * @param environment - Project environment.
+ */
+export declare function loadSources(coordinates: ISourcesCoordinates, environment?: IRunEnvironment): Promise<{
+    filteredPickles: import("@cucumber/cucumber/lib/api/gherkin").PickleWithDocument[];
+    parseErrors: import("@cucumber/messages").ParseError[];
+}>;

package/dist/cucumber/preprocessor/gen/load_sources.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Copied from original load_sources, but returns full Pickles.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/load_sources.ts
+ */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./gherkin.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSources = void 0;
+const paths_1 = require("@cucumber/cucumber/lib/api/paths");
+const messages_1 = require("@cucumber/messages");
+const environment_1 = require("@cucumber/cucumber/lib/api/environment");
+const gherkin_1 = require("@cucumber/cucumber/lib/api/gherkin");
+const console_logger_1 = require("@cucumber/cucumber/lib/api/console_logger");
+/**
+ * Load and parse features, produce a filtered and ordered test plan and/or parse errors.
+ *
+ * @public
+ * @param coordinates - Coordinates required to find features
+ * @param environment - Project environment.
+ */
+async function loadSources(coordinates, environment = {}) {
+    const { cwd, stderr, debug } = (0, environment_1.mergeEnvironment)(environment);
+    const logger = new console_logger_1.ConsoleLogger(stderr, debug);
+    const newId = messages_1.IdGenerator.uuid();
+    const { unexpandedFeaturePaths, featurePaths } = await (0, paths_1.resolvePaths)(logger, cwd, coordinates);
+    if (featurePaths.length === 0) {
+        return {
+            filteredPickles: [],
+            parseErrors: [],
+        };
+    }
+    const { filteredPickles, parseErrors } = await (0, gherkin_1.getFilteredPicklesAndErrors)({
+        newId,
+        cwd,
+        logger,
+        unexpandedFeaturePaths,
+        featurePaths,
+        coordinates,
+    });
+    return {
+        filteredPickles,
+        parseErrors,
+    };
+}
+exports.loadSources = loadSources;

package/dist/cucumber/preprocessor/gen/save.d.ts

@@ -0,0 +1,2 @@
+import { PWFile } from "./generate";
+export declare function saveFiles(files: PWFile[], outputDir: string): string[];

package/dist/cucumber/preprocessor/gen/save.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveFiles = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function saveFiles(files, outputDir) {
+    clearDir(outputDir);
+    const paths = files.map((file) => {
+        const filePath = node_path_1.default.join(outputDir, `${file.doc.uri}.spec.js`);
+        const dir = node_path_1.default.dirname(filePath);
+        if (!node_fs_1.default.existsSync(dir)) {
+            node_fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        node_fs_1.default.writeFileSync(filePath, file.content);
+        return filePath;
+    });
+    return paths;
+}
+exports.saveFiles = saveFiles;
+function clearDir(dir) {
+    if (node_fs_1.default.existsSync(dir)) {
+        node_fs_1.default.rmSync(dir, { recursive: true });
+    }
+}

package/dist/cucumber/preprocessor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./run/fixtures";
+export * from "./run/world";

package/dist/cucumber/preprocessor/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./run/fixtures"), exports);
+__exportStar(require("./run/world"), exports);

package/dist/cucumber/preprocessor/run/fixtures.d.ts

@@ -0,0 +1,3 @@
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    [key: string]: any;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/dist/cucumber/preprocessor/run/fixtures.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const test_1 = require("@playwright/test");
+const support_1 = require("./support");
+const invoke_1 = require("./invoke");
+exports.test = test_1.test.extend({
+    world: async ({ page, context, browser, browserName, request }, use, testInfo) => {
+        const { runConfiguration, supportCodeLibrary } = await (0, support_1.loadCucumber)();
+        const World = (0, support_1.getWorldConstructor)(supportCodeLibrary);
+        const world = new World({
+            page,
+            context,
+            browser,
+            browserName,
+            request,
+            testInfo,
+            parameters: runConfiguration.runtime.worldParameters || {},
+            log: () => { },
+            attach: async () => { }, // eslint-disable-line @typescript-eslint/no-empty-function
+        });
+        await world.init();
+        await use(world);
+        await world.destroy();
+    },
+    invokeStep: ({ world }, use) => use(invoke_1.invokeStep.bind(null, world)),
+    Given: ({ invokeStep }, use) => use(invokeStep),
+    When: ({ invokeStep }, use) => use(invokeStep),
+    Then: ({ invokeStep }, use) => use(invokeStep),
+    And: ({ invokeStep }, use) => use(invokeStep),
+    But: ({ invokeStep }, use) => use(invokeStep),
+});

package/dist/cucumber/preprocessor/run/invoke.d.ts

@@ -0,0 +1,2 @@
+import { World } from "./world";
+export declare function invokeStep(world: World, text: string, argument?: unknown): Promise<any>;

package/dist/cucumber/preprocessor/run/invoke.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeStep = void 0;
+const support_1 = require("./support");
+async function invokeStep(world, text, argument) {
+    const stepDefinition = await findStepDefinition(text);
+    const { parameters } = await stepDefinition.getInvocationParameters({
+        hookParameter: {},
+        step: { text, argument },
+        world,
+    });
+    return stepDefinition.code.apply(world, parameters);
+}
+exports.invokeStep = invokeStep;
+async function findStepDefinition(stepText) {
+    const { supportCodeLibrary } = await (0, support_1.loadCucumber)();
+    const stepDefinitions = supportCodeLibrary.stepDefinitions.filter((step) => {
+        return step.matchesStepName(stepText);
+    });
+    if (!stepDefinitions.length) {
+        throw new Error(`Unknown step: ${stepText}`);
+    }
+    if (stepDefinitions.length > 1) {
+        throw new Error([`Several steps found for text: ${stepText}`, ...stepDefinitions.map((s) => `- ${s.pattern}`)].join("\n"));
+    }
+    // todo: check stepDefinition.keyword with PickleStepType
+    return stepDefinitions[0];
+}

package/dist/cucumber/preprocessor/run/support.d.ts

@@ -0,0 +1,9 @@
+import { IRunConfiguration } from "@cucumber/cucumber/api";
+import { ISupportCodeLibrary } from "@cucumber/cucumber/lib/support_code_library_builder/types";
+import { World } from "./world";
+export type LoadedCucumber = {
+    runConfiguration: IRunConfiguration;
+    supportCodeLibrary: ISupportCodeLibrary;
+};
+export declare function loadCucumber(): Promise<LoadedCucumber>;
+export declare function getWorldConstructor(supportCodeLibrary: ISupportCodeLibrary): typeof World;

package/dist/cucumber/preprocessor/run/support.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorldConstructor = exports.loadCucumber = void 0;
+const api_1 = require("@cucumber/cucumber/api");
+const cucumber_1 = require("@cucumber/cucumber");
+const world_1 = require("./world");
+let loadedCucumber;
+async function loadCucumber() {
+    if (!loadedCucumber) {
+        const { runConfiguration } = await (0, api_1.loadConfiguration)();
+        const supportCodeLibrary = await (0, api_1.loadSupport)(runConfiguration);
+        loadedCucumber = { runConfiguration, supportCodeLibrary };
+    }
+    return loadedCucumber;
+}
+exports.loadCucumber = loadCucumber;
+function getWorldConstructor(supportCodeLibrary) {
+    // setWorldConstructor was not called
+    if (supportCodeLibrary.World === cucumber_1.World) {
+        return world_1.World;
+    }
+    if (!Object.prototype.isPrototypeOf.call(world_1.World, supportCodeLibrary.World)) {
+        throw new Error("CustomWorld should inherit from playwright-bdd World");
+    }
+    return supportCodeLibrary.World;
+}
+exports.getWorldConstructor = getWorldConstructor;

package/dist/cucumber/preprocessor/run/world.d.ts

@@ -0,0 +1,22 @@
+import { APIRequestContext, Browser, BrowserContext, Page, TestInfo } from "@playwright/test";
+import { World as CucumberWorld, IWorldOptions } from "@cucumber/cucumber";
+export type WorldOptions<ParametersType = any> = IWorldOptions<ParametersType> & {
+    page: Page;
+    context: BrowserContext;
+    browser: Browser;
+    browserName: string;
+    request: APIRequestContext;
+    testInfo: TestInfo;
+};
+export declare class World<ParametersType = any> extends CucumberWorld<ParametersType> {
+    protected options: WorldOptions<ParametersType>;
+    constructor(options: WorldOptions<ParametersType>);
+    get page(): Page;
+    get context(): BrowserContext;
+    get browser(): Browser;
+    get browserName(): string;
+    get request(): APIRequestContext;
+    get testInfo(): TestInfo;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/cucumber/preprocessor/run/world.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.World = void 0;
+const cucumber_1 = require("@cucumber/cucumber");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class World extends cucumber_1.World {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    get page() {
+        return this.options.page;
+    }
+    get context() {
+        return this.options.context;
+    }
+    get browser() {
+        return this.options.browser;
+    }
+    get browserName() {
+        return this.options.browserName;
+    }
+    get request() {
+        return this.options.request;
+    }
+    get testInfo() {
+        return this.options.testInfo;
+    }
+    async init() {
+        // async setup before each test
+    }
+    async destroy() {
+        // async teardown after each test
+    }
+}
+exports.World = World;

package/dist/cucumber/step_definitions/playwright/_.common.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright UUV.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */