playwright-cucumber-ts-steps 0.1.3 → 0.1.5

package/README.md

@@ -9,17 +9,20 @@
 
 > A collection of reusable Playwright step definitions for Cucumber in TypeScript, designed to streamline end-to-end testing across web, API, and mobile applications.
 
+Here's the updated **README** with all the latest features and corrections integrated into your `playwright-cucumber-ts-steps` package:
+
 ---
 
 ## ✨ Features
 
 - 🧩 Plug-and-play Cucumber step definitions
-- 🎯 Support for UI, API, mobile, iframe, session reuse, and visual testing
-- 🗂️ Alias and Faker support for dynamic data
-- 📸 Optional screenshot/video capture and pixel-diff comparison
-- 🤖 Built with modern Playwright + Cucumber ecosystem
-
----
+- 🎯 Support for **UI**, **API**, **mobile**, **iframe**, **hybrid login**, and **visual testing**
+- 🧠 Smart **session management** via storageState, `localStorage`, `sessionStorage`, and alias reuse
+- 🗂️ **Alias**, **Faker**, `.env`, and dynamic JSON fixture support
+- 📸 **Screenshot** on failure, 🎥 **video recording**, and 🖼️ **visual diff** with baseline comparison
+- 📤 Supports **file upload**, **drag-and-drop**, and **multi-user session flows**
+- 🌐 Fully supports **API requests with inline assertions**, payload from custom folders, and session injection
+- ✅ Compatible with both `Page` and `FrameLocator` contexts (iframe-aware)
 
 ## 📦 Installation
 
@@ -55,33 +58,14 @@ npx playwright install
 
 ## 🛠️ Usage
 
-1. **Import the step definitions** in your Cucumber environment:
-
-   ```ts
-   // e2e/steps/world.ts
-   import { setWorldConstructor } from "@cucumber/cucumber";
-   import { CustomWorld } from "playwright-cucumber-ts-steps";
-
-   setWorldConstructor(CustomWorld);
-   ```
-
-2. **Load step definitions** from the package:
+1. **Load step definitions** from the package:
 
    ```ts
    // e2e/steps/index.ts
-   import "playwright-cucumber-ts-steps";
+   import "playwright-cucumber-ts-steps/register";
    ```
 
-   Or import specific step categories:
-
-   ```ts
-   import "playwright-cucumber-ts-steps/src/assertions";
-   import "playwright-cucumber-ts-steps/src/actions";
-   import "playwright-cucumber-ts-steps/src/forms";
-   import "playwright-cucumber-ts-steps/src/api";
-   ```
-
-3. **Use step definitions in your feature files**:
+2. **Use step definitions in your feature files**:
 
    ```gherkin
    Feature: Login
@@ -149,41 +133,192 @@ export class CustomWorld extends BaseWorld {
 
 ## 📸 Advanced Usage
 
-These features are **optional** and can be implemented in your own `hooks.ts`:
+These features are **optional** and can be implemented in your own `cucumber.js`:
 
 - 📷 **Visual regression testing** with pixelmatch
 - 🎥 **Video recording per scenario**
 - 🔐 **Session reuse** using `storageState`
 
-To keep this package focused, no hooks or reporting setup is included directly. See [`e2e/support/hooks.ts`](./e2e/support/hooks.ts) in the example project for reference.
+---
+
+---
+
+### ✅ Additional Supported Step Features
+
+| Feature Type     | Description                                                                           |
+| ---------------- | ------------------------------------------------------------------------------------- |
+| `fill form data` | Use `When I fill the following "Login" form data:` to perform actions like:           |
+|                  | - `fill`, `click`, `check`, `select`, `upload:<file>`                                 |
+|                  | - `drag:<targetSelector>` for drag-and-drop                                           |
+|                  | - `assert:visible`, `assert:text:<value>`                                             |
+|                  | - `request:<METHOD>:<URL>:<payload>.json`                                             |
+|                  | - `set:localStorage:<key>`, `set:sessionStorage:<key>`                                |
+|                  | - `wait:<ms>`, `reload`, and use alias `@aliasName`                                   |
+| Session Handling | Steps like `I login with a session data "admin.json"`, `I save session as "customer"` |
+| Session Restore  | `I restore session cookies "customer" [with reload] [using localStorage]`             |
+| API Assertions   | Validate JSON response with `assert:json:key=expectedValue`                           |
+
+---
+
+### ✅ Extended Usage Examples
+
+```gherkin
+Scenario: Login and save session
+  When I fill the following "Login" form data:
+    | input[name='email']        | test@example.com            |
+    | input[name='password']     | @userPassword               |
+    | input[type='checkbox']     | check                       |
+    | button:has-text("Sign In") | click                       |
+    | .welcome                   | assert:visible              |
+    | .role                      | assert:text:Admin           |
+  And I save session as "admin"
+
+Scenario: Restore user session
+  Given I restore session cookies "admin" with reload using localStorage
+  When I visit "/dashboard"
+  Then I see text "Welcome back"
+
+Scenario: API login + inject session
+  When I fill the following "Login" form data:
+    | request:POST:/api/login:adminPayload.json | saveAs:loginData     |
+    | set:localStorage:token                    | @loginData.token     |
+    | save session as                           | adminViaAPI          |
+```
 
 ---
 
-## 📁 Folder Structure Suggestion
+### ✅ Folder Structure Suggestion
 
 ```text
 e2e/
-├── features/
+├── features/                        # .feature files
 ├── step_definitions/
-│   └── index.ts          # import from this package
+│   └── index.ts                    # import from this package
 ├── support/
-│   └── world.ts          # extends CustomWorld
-│   └── hooks.ts          # optional
+│   ├── world.ts                    # CustomWorld extends with iframe support
+│   ├── hooks.ts                    # artifact & session manager
+│   └── helpers/
+│       └── resolveUtils.ts        # alias/env/json resolver
+├── test-data/                      # JSON fixtures
+├── payload/                        # API request payloads
 ```
 
 ---
 
-## 🧪 Example Project
+Here’s a full `cucumber.js` config file that includes **all the configurable options** integrated so far. This supports:
 
-Want to see it in action?
+- ✅ CLI/env override for artifact directories
+- ✅ Visual testing toggle
+- ✅ Screenshot and video toggle
+- ✅ Device emulation via `MOBILE_DEVICE` env or world param
+- ✅ Multiple profiles (`default`, `mobile`, `visual`, `ci`)
+- ✅ Parallel test execution and ts-node for TypeScript support
 
-👉 [https://github.com/qaPaschalE/playwright-cucumber-ts-steps](https://github.com/qaPaschalE/playwright-cucumber-ts-steps)
+---
+
+### ✅ `cucumber.js`
+
+```js
+import path from "path";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const ARTIFACT_DIR = process.env.TEST_ARTIFACT_DIR || "test-artifacts";
+
+const defaultWorldParams = {
+  artifactDir: ARTIFACT_DIR,
+  payloadDir: "payloads",
+  enableScreenshots: process.env.ENABLE_SCREENSHOTS !== "false",
+  enableVideos: process.env.ENABLE_VIDEOS !== "false",
+  enableVisualTest: process.env.ENABLE_VISUAL_TEST === "true",
+  device: process.env.MOBILE_DEVICE || undefined, // e.g., "Pixel 5"
+};
+
+export default {
+  default: {
+    require: ["ts-node/register", "src/test/steps/**/*.ts", "src/test/support/**/*.ts"],
+    format: ["progress", `html:${path.join(ARTIFACT_DIR, "report.html")}`],
+    publishQuiet: true,
+    paths: ["src/test/features/**/*.feature"],
+    parallel: 2,
+    worldParameters: defaultWorldParams,
+  },
+
+  mobile: {
+    require: ["ts-node/register", "src/test/steps/**/*.ts", "src/test/support/**/*.ts"],
+    format: ["progress"],
+    publishQuiet: true,
+    paths: ["src/test/features/**/*.feature"],
+    parallel: 1,
+    tags: "@mobile",
+    worldParameters: {
+      ...defaultWorldParams,
+      device: process.env.MOBILE_DEVICE || "iPhone 13 Pro",
+    },
+  },
+
+  visual: {
+    require: ["ts-node/register", "src/test/steps/**/*.ts", "src/test/support/**/*.ts"],
+    format: ["progress"],
+    publishQuiet: true,
+    paths: ["src/test/features/**/*.feature"],
+    tags: "@visual",
+    worldParameters: {
+      ...defaultWorldParams,
+      enableVisualTest: true,
+    },
+  },
+
+  ci: {
+    require: ["ts-node/register", "src/test/steps/**/*.ts", "src/test/support/**/*.ts"],
+    format: ["progress", `json:${path.join(ARTIFACT_DIR, "report.json")}`],
+    publishQuiet: true,
+    paths: ["src/test/features/**/*.feature"],
+    parallel: 4,
+    worldParameters: {
+      ...defaultWorldParams,
+      enableScreenshots: true,
+      enableVideos: true,
+      enableVisualTest: false,
+    },
+  },
+};
+```
 
 ---
 
+### ✅ Usage Examples
+
+```bash
+# Run default suite
+npx cucumber-js --config cucumber.js
+
+# Run mobile tests with device from env
+MOBILE_DEVICE="Pixel 5" npx cucumber-js --config cucumber.js --profile mobile
+
+# Run visual regression tests
+ENABLE_VISUAL_TEST=true npx cucumber-js --config cucumber.js --profile visual
+
+# Run in CI profile with JSON output
+npx cucumber-js --config cucumber.js --profile ci
+```
+
+---
+
+### ✅ Summary of Supported Options
+
+| Setting            | CLI/Env Variable     | `worldParameters` Key | Purpose                                     |
+| ------------------ | -------------------- | --------------------- | ------------------------------------------- |
+| Screenshot toggle  | `ENABLE_SCREENSHOTS` | `enableScreenshots`   | Capture screenshots on failure              |
+| Video toggle       | `ENABLE_VIDEOS`      | `enableVideos`        | Enable/disable video recording              |
+| Visual testing     | `ENABLE_VISUAL_TEST` | `enableVisualTest`    | Capture and compare visual snapshots        |
+| Artifact directory | `TEST_ARTIFACT_DIR`  | `artifactDir`         | Where to save screenshots, videos, etc.     |
+| Mobile device emu  | `MOBILE_DEVICE`      | `device`              | Device name for Playwright mobile emulation |
+
 ## 🧾 License
 
-[ISC](LICENSE)
+[MIT](LICENSE)
 
 ---
 

package/{dist → lib}/actions/clickSteps.js

@@ -11,6 +11,14 @@ const optionsUtils_1 = require("../helpers/utils/optionsUtils");
     await this.element.click(options);
     this.log?.("🖱️ Clicked on stored element");
 });
+(0, cucumber_1.When)("I click on element {string}", async function (selector, ...rest) {
+    const maybeTable = rest[0];
+    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
+    const element = this.getLocator(selector);
+    await element.click(options);
+    this.element = element;
+    this.log?.(`🖱️ Clicked on element "${selector}"`);
+});
 (0, cucumber_1.When)("I click on button {string}", async function (label, ...rest) {
     const maybeTable = rest[0];
     const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
@@ -151,8 +159,7 @@ const optionsUtils_1 = require("../helpers/utils/optionsUtils");
     this.log?.(`✅ Clicked all ${count} stored elements.`);
 });
 (0, cucumber_1.When)(/^I click on selector "([^"]+)"$/, async function (selector) {
-    const scope = this.getScope();
-    const element = scope.locator(selector);
-    await element.click();
+    const locator = this.getLocator(selector);
+    await locator.click();
     this.log?.(`🖱️ Clicked on selector: ${selector}`);
 });

package/{dist → lib}/actions/debugSteps.js

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 // e2e/step_definitions/common/actions/debugSteps.ts
 const cucumber_1 = require("@cucumber/cucumber");
-(0, cucumber_1.When)("I debug", async function () {
+(0, cucumber_1.When)("I debug with message {string}", async function (message) {
     await this.page.pause();
-    this.log("Paused test for debugging");
-});
-(0, cucumber_1.When)("I log {string}", async function (msg) {
-    this.log(msg);
+    this.log(`Paused test for debugging: ${message}`);
 });

package/{dist → lib}/actions/elementFindSteps.js

@@ -9,6 +9,15 @@ const test_1 = require("@playwright/test");
     this.element = this.page.locator(selector);
     await (0, test_1.expect)(this.element).toHaveCount(1);
 });
+(0, cucumber_1.When)("I find link by text {string}", async function (text) {
+    this.currentLocator = this.getScope().getByRole("link", { name: text });
+});
+(0, cucumber_1.When)("I find heading by text {string}", async function (text) {
+    this.currentLocator = this.getScope().getByRole("heading", { name: text });
+});
+(0, cucumber_1.When)("I find headings by text {string}", async function (text) {
+    this.currentLocator = this.getScope().getByRole("heading", { name: text });
+});
 (0, cucumber_1.When)("I find elements by selector {string}", async function (selector) {
     this.elements = this.page.locator(selector);
     const count = await this.elements.count();
@@ -38,6 +47,9 @@ const test_1 = require("@playwright/test");
     this.element = this.page.getByLabel(label);
     await (0, test_1.expect)(this.element).toHaveCount(1);
 });
+(0, cucumber_1.When)("I find elements by label text {string}", async function (label) {
+    this.currentLocator = this.getScope().getByLabel(label);
+});
 (0, cucumber_1.When)("I find element by alt text {string}", async function (alt) {
     this.element = this.page.getByAltText(alt);
     await (0, test_1.expect)(this.element).toHaveCount(1);
@@ -46,6 +58,9 @@ const test_1 = require("@playwright/test");
     this.element = this.page.getByRole("textbox", { name });
     await (0, test_1.expect)(this.element).toHaveCount(1);
 });
+(0, cucumber_1.When)("I find elements by name {string}", async function (name) {
+    this.currentLocator = this.getScope().locator(`[name="${name}"]`);
+});
 (0, cucumber_1.When)("I find buttons by text {string}", async function (buttonText) {
     // 🧠 Resolve alias
     if (buttonText.startsWith("@")) {
@@ -100,24 +115,6 @@ const test_1 = require("@playwright/test");
     this.elements = locator;
     this.log?.(`Stored ${count} elements with role "${role}"`);
 });
-// When(
-//   "I get {int}{ordinal} element",
-//   async function (this: CustomWorld, index: number) {
-//     if (!this.elements) {
-//       throw new Error(
-//         "No element collection found. Did you call 'find elements by' first?"
-//       );
-//     }
-//     const total = await this.elements.count();
-//     if (index < 1 || index > total) {
-//       throw new Error(
-//         `Index ${index} out of bounds. Found only ${total} elements.`
-//       );
-//     }
-//     this.element = this.elements.nth(index - 1);
-//     this.log?.(`Stored ${index}th element from collection`);
-//   }
-// );
 (0, cucumber_1.When)("I get {int}rd element", async function (index) {
     if (!this.elements)
         throw new Error("No element collection found");

package/lib/actions/fillFormSteps.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cucumber_1 = require("@cucumber/cucumber");
+const test_1 = require("@playwright/test");
+const resolveUtils_1 = require("../helpers/utils/resolveUtils");
+(0, cucumber_1.When)("I fill the following {string} form data:", async function (_formName, dataTable) {
+    // const scope = this.frame ?? this.page;
+    const rows = dataTable.hashes();
+    for (const row of rows) {
+        const target = row.Target.trim();
+        const rawValue = row.Value.trim();
+        const locator = this.getLocator(target);
+        const value = (0, resolveUtils_1.resolveLoginValue)(rawValue, this);
+        // ✅ Assertions
+        if (rawValue.startsWith("assert:")) {
+            const [, type, expected] = rawValue.split(":");
+            if (type === "visible") {
+                await (0, test_1.expect)(locator).toBeVisible();
+            }
+            else if (type === "text") {
+                await (0, test_1.expect)(locator).toHaveText(expected ?? "", {
+                    useInnerText: true,
+                });
+            }
+            else if (type === "value") {
+                await (0, test_1.expect)(locator).toHaveValue(expected ?? "");
+            }
+            else {
+                throw new Error(`❌ Unknown assertion: ${type}`);
+            }
+            continue;
+        }
+        // ✅ UI interactions
+        if (rawValue === "click") {
+            await locator.click();
+            continue;
+        }
+        if (rawValue === "check") {
+            await locator.check();
+            continue;
+        }
+        if (rawValue === "uncheck") {
+            await locator.uncheck();
+            continue;
+        }
+        if (rawValue === "select") {
+            await locator.selectOption({ index: 0 });
+            continue;
+        }
+        // ✅ File upload
+        if (rawValue.startsWith("upload:")) {
+            const filePath = rawValue.split("upload:")[1].trim();
+            const resolvedPath = path_1.default.resolve(filePath);
+            if (!fs_1.default.existsSync(resolvedPath))
+                throw new Error(`File not found: ${filePath}`);
+            await locator.setInputFiles(resolvedPath);
+            continue;
+        }
+        // ✅ Drag and drop
+        if (rawValue.startsWith("drag:")) {
+            const targetSelector = rawValue.split("drag:")[1].trim();
+            const targetLocator = this.getLocator(targetSelector);
+            await locator.dragTo(targetLocator);
+            continue;
+        }
+        // ✅ Local/sessionStorage
+        if (rawValue.startsWith("set:localStorage:")) {
+            const [, , key] = rawValue.split(":");
+            if (typeof key !== "string" || !key) {
+                throw new Error("Local storage key must be a non-empty string");
+            }
+            await this.page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value ?? ""]);
+            continue;
+        }
+        if (rawValue.startsWith("set:sessionStorage:")) {
+            const [, , key] = rawValue.split(":");
+            if (typeof key !== "string" || key === undefined) {
+                throw new Error("Session storage key must be a string");
+            }
+            await this.page.evaluate((args) => {
+                const [k, v] = args;
+                sessionStorage.setItem(k, v);
+            }, [key, value ?? ""]);
+            continue;
+        }
+        // ✅ Wait
+        if (rawValue.startsWith("wait:")) {
+            const [, timeMs] = rawValue.split(":");
+            const waitTime = Number(timeMs);
+            if (!isNaN(waitTime)) {
+                await this.page.waitForTimeout(waitTime);
+            }
+            continue;
+        }
+        // ✅ Reload
+        if (rawValue === "reload") {
+            await this.page.reload();
+            continue;
+        }
+        // ✅ Request handling
+        if (rawValue.startsWith("request:")) {
+            const [, method, url, file] = rawValue.replace("request:", "").split(":");
+            const payloadDir = row.PayloadDir || this.parameters?.payloadDir || "payload";
+            const filePath = path_1.default.resolve(payloadDir, file);
+            if (!fs_1.default.existsSync(filePath)) {
+                throw new Error(`Payload file not found: ${filePath}`);
+            }
+            const payload = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+            const response = await this.page.request[method.toLowerCase()](url, {
+                data: payload,
+            });
+            const responseBody = await response.json();
+            this.data.lastApiResponse = responseBody;
+            this.data.lastStatusCode = response.status();
+            if (row.SaveAs) {
+                this.data[row.SaveAs] = responseBody;
+            }
+            continue;
+        }
+        // ✅ Default: fill
+        if (value !== undefined) {
+            await locator.fill(String(value));
+        }
+    }
+});

package/{dist → lib}/actions/inputSteps.js

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 // e2e/step_definitions/common/actions/inputSteps.ts
+// import fs from "fs";
+// import path from "path";
 const cucumber_1 = require("@cucumber/cucumber");
-const test_1 = require("@playwright/test");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
 const fakerUtils_1 = require("../helpers/utils/fakerUtils");
 const optionsUtils_1 = require("../helpers/utils/optionsUtils");
 (0, cucumber_1.When)("I check", async function (...rest) {
@@ -36,80 +32,17 @@ const optionsUtils_1 = require("../helpers/utils/optionsUtils");
         throw new Error("No input selected");
     await this.element.uncheck(options);
 });
-(0, cucumber_1.When)("I fill the following {string} form data:", async function (_formName, tableData, ...rest) {
-    const maybeOptionsTable = rest[0];
-    const globalOptions = maybeOptionsTable?.rowsHash
-        ? (0, optionsUtils_1.parseClickOptions)(maybeOptionsTable)
-        : {};
-    const rows = tableData.raw().slice(1); // Remove header row
-    for (const [rawTarget, rawValue] of rows) {
-        let element;
-        let resolvedValue;
-        if (rawTarget.startsWith("@")) {
-            element = this.data[rawTarget.slice(1)];
-            if (!element)
-                throw new Error(`No element found for alias: ${rawTarget}`);
-        }
-        else if (await this.page.locator(rawTarget).count()) {
-            element = this.page.locator(rawTarget);
-        }
-        else {
-            element = this.page.getByText(rawTarget, { exact: true }).first();
-        }
-        if (!element)
-            throw new Error(`Unable to resolve element for target: ${rawTarget}`);
-        await element.waitFor({ state: "visible", timeout: 7000 });
-        if (rawValue.startsWith("@")) {
-            resolvedValue = this.data[rawValue.slice(1)];
-            if (!resolvedValue)
-                throw new Error(`No value found for alias: ${rawValue}`);
-        }
-        else {
-            resolvedValue = (0, fakerUtils_1.evaluateFaker)(rawValue);
-        }
-        if (resolvedValue === "Click") {
-            await element.click(globalOptions);
-            this.log?.(`🖱️ Clicked on "${rawTarget}"`);
-        }
-        else if (rawTarget.includes('input[type="file"]')) {
-            const filePath = path_1.default.resolve("test-data", resolvedValue);
-            if (!fs_1.default.existsSync(filePath))
-                throw new Error(`File not found: ${filePath}`);
-            await element.setInputFiles(filePath);
-            this.log?.(`📁 Uploaded file to "${rawTarget}": ${resolvedValue}`);
-        }
-        else {
-            const keyPattern = /{(\w+)}/g;
-            const matches = [...resolvedValue.matchAll(keyPattern)];
-            const keys = matches.map((m) => m[1]);
-            const inputText = resolvedValue.replace(keyPattern, "").trim();
-            const fillOptions = maybeOptionsTable?.rowsHash
-                ? (0, optionsUtils_1.parseFillOptions)(maybeOptionsTable)
-                : {};
-            if (inputText) {
-                await element.fill(inputText, fillOptions);
-                this.log?.(`⌨️ Filled "${rawTarget}" with: ${inputText}`);
-            }
-            for (const key of keys) {
-                await element.focus();
-                await this.page.waitForTimeout(200);
-                await element.press(key);
-                this.log?.(`🎹 Pressed {${key}} on "${rawTarget}"`);
-            }
-        }
-        await (0, test_1.expect)(element).toBeVisible();
-    }
-});
+// const DEFAULT_PAYLOAD_DIR = "payload";
 const typeStep = async function (textOrAlias, ...rest) {
     if (!this.element)
         throw new Error("No element selected");
     const maybeTable = rest[0];
     const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseFillOptions)(maybeTable) : {};
     const text = textOrAlias.startsWith("@")
-        ? this.data[textOrAlias.slice(1)] ??
+        ? (this.data[textOrAlias.slice(1)] ??
             (() => {
                 throw new Error(`No value found for alias "${textOrAlias}"`);
-            })()
+            })())
         : (0, fakerUtils_1.evaluateFaker)(textOrAlias);
     await this.element.fill("");
     await this.element.fill(text, options);
@@ -125,10 +58,10 @@ const typeStep = async function (textOrAlias, ...rest) {
     const maybeTable = rest[0];
     const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseFillOptions)(maybeTable) : {};
     const value = valueOrAlias.startsWith("@")
-        ? this.data[valueOrAlias.slice(1)] ??
+        ? (this.data[valueOrAlias.slice(1)] ??
             (() => {
                 throw new Error(`No value found for alias "${valueOrAlias}"`);
-            })()
+            })())
         : (0, fakerUtils_1.evaluateFaker)(valueOrAlias);
     await this.element.fill(value, options);
     this.data.lastValueSet = value;
@@ -140,8 +73,8 @@ const typeStep = async function (textOrAlias, ...rest) {
     await this.element.fill("");
     this.log?.("🧼 Cleared value of selected element");
 });
-(0, cucumber_1.When)("I submit", async function (...rest) {
-    const maybeTable = rest[0];
+(0, cucumber_1.When)("I submit", async function () {
+    // const maybeTable = rest[0];
     const form = this.element ?? this.page.locator("form");
     await form.evaluate((f) => f.submit());
     this.log?.("📨 Submitted form");

package/{dist → lib}/actions/interceptionSteps.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 // e2e/step_definitions/common/interceptionSteps.ts
 const cucumber_1 = require("@cucumber/cucumber");
+let lastResponse;
 (0, cucumber_1.When)("I intercept URL {string} and stub body:", async function (url, body) {
     let parsedBody;
     try {
@@ -61,3 +62,10 @@ const cucumber_1 = require("@cucumber/cucumber");
     const response = await this.page.request.get(url);
     this.data.lastResponse = response;
 });
+(0, cucumber_1.When)('I make a "{word}" request to {string}', async function (method, url, table) {
+    const options = table ? Object.fromEntries(table.rows()) : {};
+    if (options.body)
+        options.body = JSON.stringify(JSON.parse(options.body));
+    const res = await fetch(url, { method, ...options });
+    lastResponse = res;
+});