playwright-cucumber-ts-steps 0.0.8 → 0.0.9

package/dist/assertions/buttonAndTextVisibilitySteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/assertions/buttonAndTextVisibilitySteps.js

@@ -0,0 +1,172 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+import { evaluateFaker } from "../helpers/utils/fakerUtils";
+Then("I count {int} elements", async function (expectedCount) {
+    if (!this.elements)
+        throw new Error("No elements found to count");
+    const count = await this.elements.count();
+    await this.page.waitForLoadState("networkidle");
+    expect(count).toBe(expectedCount);
+});
+/**
+ * THEN: I see button "Submit"
+ */
+Then(/^I see button "(.*)"$/, async function (rawText) {
+    let buttonText = rawText.startsWith("@")
+        ? this.data[rawText.slice(1)]
+        : rawText;
+    if (!buttonText) {
+        throw new Error(`No value found for alias: "${rawText}"`);
+    }
+    const button = this.page.getByRole("button", {
+        name: buttonText,
+        exact: false,
+    });
+    await this.page.waitForLoadState("networkidle");
+    await expect(button).toBeVisible();
+});
+/**
+ * THEN: I do not see button "Cancel"
+ */
+Then(/^I do not see button "(.*)"$/, async function (rawText) {
+    let buttonText = rawText.startsWith("@")
+        ? this.data[rawText.slice(1)]
+        : rawText;
+    if (!buttonText) {
+        throw new Error(`No value found for alias: "${rawText}"`);
+    }
+    const button = this.page.getByRole("button", {
+        name: buttonText,
+        exact: false,
+    });
+    await this.page.waitForLoadState("networkidle");
+    const count = await button.count();
+    for (let i = 0; i < count; i++) {
+        const item = button.nth(i);
+        if (await item.isVisible()) {
+            throw new Error(`Button "${buttonText}" is visible but should not be`);
+        }
+    }
+});
+/**
+ * THEN: I see text "Welcome"
+ */
+Then("I see text {string}", async function (expected) {
+    var _a;
+    const scope = this.getScope(); // ✅ Supports iframe OR main page
+    const locator = scope.locator(`text=${expected}`);
+    await locator.waitFor({ state: "visible", timeout: 5000 });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `✅ Verified text visible: ${expected}`);
+});
+/**
+ * THEN: I do not see text "Error"
+ */
+Then("I do not see text {string}", async function (text) {
+    await this.page.waitForLoadState("networkidle");
+    const locator = this.page.locator(`:has-text("${text}")`);
+    const count = await locator.count();
+    for (let i = 0; i < count; i++) {
+        const item = locator.nth(i);
+        if (await item.isVisible()) {
+            throw new Error(`Text "${text}" is visible but should not be`);
+        }
+    }
+});
+/**
+ * THEN: I see visible text "Dashboard"
+ */
+Then("I see visible text {string}", async function (text) {
+    await this.page.waitForLoadState("networkidle");
+    const locator = this.page.locator(`:text-is("${text}")`);
+    if (!(await locator.first().isVisible())) {
+        throw new Error(`Visible text "${text}" not found`);
+    }
+});
+/**
+ * THEN: I do not see visible text "Logout"
+ */
+Then("I do not see visible text {string}", async function (text) {
+    const locator = this.page.locator(`:text-is("${text}")`);
+    if ((await locator.count()) > 0 && (await locator.first().isVisible())) {
+        throw new Error(`Visible text "${text}" should not be visible`);
+    }
+});
+Then("I see value {string}", async function (expected) {
+    if (!this.element)
+        throw new Error("No element selected");
+    const value = await this.element.inputValue();
+    if (value !== expected) {
+        throw new Error(`Expected value "${expected}", but got "${value}"`);
+    }
+});
+Then("I do not see value {string}", async function (unwanted) {
+    if (!this.element)
+        throw new Error("No element selected");
+    const value = await this.element.inputValue();
+    if (value === unwanted) {
+        throw new Error(`Value "${unwanted}" is present but should not be`);
+    }
+});
+//
+// 📃 VISIBLE TEXT ASSERTIONS
+//
+Then(/^I do not see text "(.*)"$/, async function (unexpectedText) {
+    const el = this.page.getByText(unexpectedText, { exact: true });
+    await expect(el).toHaveCount(0);
+});
+//
+// 🆕 Visible Text - Alias for clarity (optional if you want separate steps for naming)
+//
+Then("I see {string} in the element", async function (expected) {
+    var _a;
+    const element = this.element;
+    if (!element)
+        throw new Error("No element selected");
+    // ✅ Resolve alias
+    if (expected.startsWith("@")) {
+        const alias = expected.substring(1);
+        expected = this.data[alias];
+        if (!expected)
+            throw new Error(`No data stored for alias "@${alias}"`);
+    }
+    // ✅ Resolve faker syntax
+    expected = evaluateFaker(expected);
+    const textContent = await element.textContent();
+    if (!textContent)
+        throw new Error("Element has no text content");
+    expect(textContent).toContain(expected);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Verified "${expected}" in element text`);
+});
+Then("I see @{word} in the element", async function (alias) {
+    var _a;
+    const storedValue = this.data[alias];
+    if (!storedValue) {
+        throw new Error(`No value found in data storage under alias "@${alias}".`);
+    }
+    if (!this.element) {
+        throw new Error("No element found. You must get an element before asserting its contents.");
+    }
+    const actualText = ((_a = (await this.element.textContent())) === null || _a === void 0 ? void 0 : _a.trim()) || "";
+    expect(actualText).toContain(storedValue);
+    this.log(`Verified element contains value from "@${alias}" = "${storedValue}". Actual: "${actualText}"`);
+});
+Then("I see button {string} is disabled", async function (rawText) {
+    var _a;
+    // Resolve alias
+    let buttonText = rawText.startsWith("@")
+        ? this.data[rawText.slice(1)]
+        : rawText;
+    if (!buttonText) {
+        throw new Error(`No value found for alias: "${rawText}"`);
+    }
+    const button = this.page.getByRole("button", {
+        name: buttonText,
+        exact: false,
+    });
+    await expect(button).toBeVisible({ timeout: 5000 });
+    const isDisabled = await button.isDisabled();
+    if (!isDisabled) {
+        throw new Error(`🚫 Button "${buttonText}" is not disabled as expected.`);
+    }
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `✅ Verified button "${buttonText}" is disabled.`);
+});

package/dist/assertions/interceptionRequestsSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/assertions/interceptionRequestsSteps.js

@@ -0,0 +1,191 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+// Accessing the Last Response
+Then("I should see response status {int}", function (expectedStatus) {
+    var _a;
+    expect((_a = this.data.lastResponse) === null || _a === void 0 ? void 0 : _a.status).toBe(expectedStatus);
+    this.log(`Verified response status is ${expectedStatus}`);
+});
+Then("I should see response body contains {string}", function (expectedText) {
+    var _a;
+    expect((_a = this.data.lastResponse) === null || _a === void 0 ? void 0 : _a.body).toContain(expectedText);
+    this.log(`Verified response body contains "${expectedText}"`);
+});
+Then("I see response body {string}", async function (expected) {
+    const res = this.data.lastResponse;
+    const body = await res.text();
+    if (body !== expected)
+        throw new Error(`Expected body "${expected}", got "${body}"`);
+});
+Then("I see response body contains {string}", async function (part) {
+    const res = this.data.lastResponse;
+    const body = await res.text();
+    if (!body.includes(part))
+        throw new Error(`Body does not contain "${part}"`);
+});
+Then("I see response body matches JSON schema {string}", async function (schemaPath) {
+    const res = this.data.lastResponse;
+    const body = await res.text();
+    const schema = require(schemaPath); // Assuming schema is a JSON file
+    const Ajv = require("ajv");
+    const ajv = new Ajv();
+    const validate = ajv.compile(schema);
+    const valid = validate(JSON.parse(body));
+    if (!valid) {
+        throw new Error(`Response body does not match schema: ${ajv.errorsText(validate.errors)}`);
+    }
+});
+Then("I see response header {string} equals {string}", async function (headerName, expectedValue) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (headerValue !== expectedValue) {
+        throw new Error(`Expected header "${headerName}" to be "${expectedValue}", got "${headerValue}"`);
+    }
+    this.log(`Verified response header "${headerName}" equals "${expectedValue}"`);
+});
+Then("I see response header {string} contains {string}", async function (headerName, expectedValue) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (!headerValue || !headerValue.includes(expectedValue)) {
+        throw new Error(`Expected header "${headerName}" to contain "${expectedValue}", got "${headerValue}"`);
+    }
+    this.log(`Verified response header "${headerName}" contains "${expectedValue}"`);
+});
+Then("I see response header {string} does not contain {string}", async function (headerName, unexpectedValue) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (headerValue && headerValue.includes(unexpectedValue)) {
+        throw new Error(`Expected header "${headerName}" to not contain "${unexpectedValue}", but it does`);
+    }
+    this.log(`Verified response header "${headerName}" does not contain "${unexpectedValue}"`);
+});
+Then("I see response header {string} does not equal {string}", async function (headerName, unexpectedValue) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (headerValue === unexpectedValue) {
+        throw new Error(`Expected header "${headerName}" to not equal "${unexpectedValue}", but it does`);
+    }
+    this.log(`Verified response header "${headerName}" does not equal "${unexpectedValue}"`);
+});
+Then("I see response header {string} exists", async function (headerName) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (!headerValue) {
+        throw new Error(`Expected header "${headerName}" to exist, but it does not`);
+    }
+    this.log(`Verified response header "${headerName}" exists`);
+});
+Then("I see response header {string} does not exist", async function (headerName) {
+    const res = this.data.lastResponse;
+    const headerValue = res.headers()[headerName.toLowerCase()];
+    if (headerValue) {
+        throw new Error(`Expected header "${headerName}" to not exist, but it does`);
+    }
+    this.log(`Verified response header "${headerName}" does not exist`);
+});
+Then("I see response status {int}", async function (status) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const actual = res.status();
+    if (actual !== status)
+        throw new Error(`Expected status ${status}, got ${actual}`);
+});
+Then("I see response status is not {int}", async function (status) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const actual = res.status();
+    if (actual === status)
+        throw new Error(`Expected status not to be ${status}, but it is`);
+});
+Then("I see response body matches JSON schema", async function (schema) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    const Ajv = require("ajv");
+    const ajv = new Ajv();
+    const validate = ajv.compile(schema);
+    const valid = validate(JSON.parse(body));
+    if (!valid) {
+        throw new Error(`Response body does not match schema: ${ajv.errorsText(validate.errors)}`);
+    }
+    this.log(`Response body matches JSON schema`);
+});
+Then("I see response body is empty", async function () {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    if (body.trim() !== "") {
+        throw new Error(`Expected empty response body, got "${body}"`);
+    }
+    this.log(`Verified response body is empty`);
+});
+Then("I see response body is not empty", async function () {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    if (body.trim() === "") {
+        throw new Error(`Expected non-empty response body, got empty`);
+    }
+    this.log(`Verified response body is not empty`);
+});
+Then("I see response body matches {string}", async function (expected) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    if (body !== expected) {
+        throw new Error(`Expected body "${expected}", got "${body}"`);
+    }
+    this.log(`Verified response body matches: ${expected}`);
+});
+Then("I see response body contains {string}", async function (part) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    if (!body.includes(part)) {
+        throw new Error(`Body does not contain "${part}"`);
+    }
+    this.log(`Verified response body contains: ${part}`);
+});
+Then("I see response body does not contain {string}", async function (part) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    if (body.includes(part)) {
+        throw new Error(`Body contains "${part}", but it should not`);
+    }
+    this.log(`Verified response body does not contain: ${part}`);
+});
+Then("I see response body is JSON", async function () {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    try {
+        JSON.parse(body);
+        this.log(`Verified response body is valid JSON`);
+    }
+    catch (e) {
+        throw new Error(`Response body is not valid JSON: ${e.message}`);
+    }
+});
+Then("I see response body is not JSON", async function () {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const body = await res.text();
+    try {
+        JSON.parse(body);
+        throw new Error(`Expected response body to not be JSON, but it is`);
+    }
+    catch (e) {
+        this.log(`Verified response body is not JSON: ${e.message}`);
+    }
+});

package/dist/custom_setups/globalLogin.d.ts

@@ -0,0 +1,2 @@
+declare function globalSetup(): Promise<void>;
+export default globalSetup;

package/dist/custom_setups/globalLogin.js

@@ -0,0 +1,20 @@
+// global-setup.ts
+import { chromium } from "@playwright/test";
+import path from "path";
+async function globalSetup() {
+    const browser = await chromium.launch();
+    const page = await browser.newPage();
+    // Navigate to login and log in
+    await page.goto(process.env.PLAYWRIGHT_BASE_URL || "http://demoqa.com");
+    await page.getByPlaceholder("Email").fill("user@example.com");
+    await page.getByPlaceholder("Password").fill("SuperSecret123");
+    await page.getByRole("button", { name: "Login" }).click();
+    // Wait for navigation or some indicator that login is complete
+    await page.waitForURL("**/dashboard");
+    // Save session to file
+    await page
+        .context()
+        .storageState({ path: path.resolve(__dirname, "storageState.json") });
+    await browser.close();
+}
+export default globalSetup;

package/dist/index.d.ts

@@ -8,19 +8,19 @@ export * from "./actions/miscSteps";
 export * from "./actions/mouseSteps";
 export * from "./actions/scrollSteps";
 export * from "./actions/storageSteps";
-export * from "./assertions/button_and_text_visibility";
+export * from "./assertions/buttonAndTextVisibilitySteps";
 export * from "./assertions/cookieSteps";
 export * from "./assertions/elementSteps";
 export * from "./assertions/formInputSteps";
-export * from "./assertions/InterceptionRequests";
+export * from "./assertions/interceptionRequestsSteps";
 export * from "./assertions/locationSteps";
 export * from "./assertions/roleTestIdSteps";
 export * from "./assertions/semanticSteps";
 export * from "./assertions/storageSteps";
 export * from "./assertions/visualSteps";
-export * from "./custom_setups/global-login";
-export * from "./custom_setups/loginHooks";
 export * from "./iframes/frames";
+export * from "./custom_setups/globalLogin";
+export * from "./custom_setups/loginHooks";
 export * from "./helpers/compareSnapshots";
 export * from "./helpers/hooks";
 export * from "./helpers/utils";

package/dist/index.js

@@ -1,4 +1,4 @@
-//src/index.ts
+// Actions
 export * from "./actions/clickSteps";
 export * from "./actions/cookieSteps";
 export * from "./actions/debugSteps";
@@ -9,20 +9,23 @@ export * from "./actions/miscSteps";
 export * from "./actions/mouseSteps";
 export * from "./actions/scrollSteps";
 export * from "./actions/storageSteps";
-export * from "./assertions/button_and_text_visibility";
+// Assertions
+export * from "./assertions/buttonAndTextVisibilitySteps";
 export * from "./assertions/cookieSteps";
 export * from "./assertions/elementSteps";
 export * from "./assertions/formInputSteps";
-export * from "./assertions/InterceptionRequests";
+export * from "./assertions/interceptionRequestsSteps";
 export * from "./assertions/locationSteps";
 export * from "./assertions/roleTestIdSteps";
 export * from "./assertions/semanticSteps";
 export * from "./assertions/storageSteps";
 export * from "./assertions/visualSteps";
-export * from "./custom_setups/global-login";
-export * from "./custom_setups/loginHooks";
+// Iframes
 export * from "./iframes/frames";
-// Export core utilities and helpers
+// Setup (custom hooks, login, etc.)
+export * from "./custom_setups/globalLogin";
+export * from "./custom_setups/loginHooks";
+// Core helpers and utilities
 export * from "./helpers/compareSnapshots";
 export * from "./helpers/hooks";
 export * from "./helpers/utils";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-cucumber-ts-steps",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "A collection of reusable Playwright step definitions for Cucumber in TypeScript, designed to streamline end-to-end testing across web, API, and mobile applications.",
   "type": "module",
   "main": "dist/index.js",