playwright-cucumber-ts-steps 0.0.4 → 0.0.6

package/dist/assertions/button_and_text_visibility.d.ts

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

package/dist/assertions/button_and_text_visibility.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/cookieSteps.d.ts

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

package/dist/assertions/cookieSteps.js

@@ -0,0 +1,43 @@
+import { Then } from "@cucumber/cucumber";
+/**
+ * THEN: I see cookie "myCookie"
+ */
+Then("I see cookie {string}", async function (cookieName) {
+    const cookies = await this.context.cookies();
+    const cookie = cookies.find((c) => c.name === cookieName);
+    if (!cookie)
+        throw new Error(`Cookie "${cookieName}" not found`);
+});
+/**
+ * THEN: I do not see cookie "myCookie"
+ */
+Then("I do not see cookie {string}", async function (name) {
+    const cookies = await this.context.cookies();
+    const cookie = cookies.find((c) => c.name === name);
+    if (cookie)
+        throw new Error(`Cookie "${name}" was found but should not exist`);
+});
+/**
+ * THEN: I see cookie "sessionId" has value "abc123"
+ */
+Then("I see cookie {string} has value {string}", async function (name, expectedValue) {
+    const cookies = await this.context.cookies();
+    const cookie = cookies.find((c) => c.name === name);
+    if (!cookie)
+        throw new Error(`Cookie "${name}" not found`);
+    if (cookie.value !== expectedValue) {
+        throw new Error(`Expected cookie "${name}" to have value "${expectedValue}", but got "${cookie.value}"`);
+    }
+});
+/**
+ * THEN: I see cookie "token" contains value "auth"
+ */
+Then("I see cookie {string} contains value {string}", async function (name, valuePart) {
+    const cookies = await this.context.cookies();
+    const cookie = cookies.find((c) => c.name === name);
+    if (!cookie)
+        throw new Error(`Cookie "${name}" not found`);
+    if (!cookie.value.includes(valuePart)) {
+        throw new Error(`Cookie "${name}" does not contain value "${valuePart}"`);
+    }
+});

package/dist/assertions/elementSteps.d.ts

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

package/dist/assertions/elementSteps.js

@@ -0,0 +1,84 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+//
+// ✅ ELEMENT EXISTS
+//
+Then(/^I see element "([^"]+)" exists$/, async function (selector) {
+    const el = await this.page.locator(selector);
+    await expect(el).toHaveCount(1);
+});
+Then("I see element exists", async function () {
+    var _a, _b, _c;
+    if (!this.element)
+        throw new Error("No element stored in context");
+    const count = (_c = (await ((_b = (_a = this.element).count) === null || _b === void 0 ? void 0 : _b.call(_a)))) !== null && _c !== void 0 ? _c : 1;
+    if (count === 0)
+        throw new Error("Element does not exist");
+});
+Then("I see element does not exist", async function () {
+    var _a, _b, _c;
+    if (!this.element)
+        throw new Error("No element stored in context");
+    const count = (_c = (await ((_b = (_a = this.element).count) === null || _b === void 0 ? void 0 : _b.call(_a)))) !== null && _c !== void 0 ? _c : 1;
+    if (count > 0)
+        throw new Error("Element exists but should not");
+});
+Then("I see element is visible", async function () {
+    if (!this.element)
+        throw new Error("No element in context");
+    const isVisible = await this.element.isVisible();
+    if (!isVisible)
+        throw new Error("Element is not visible");
+});
+Then("I see element is not visible", async function () {
+    if (!this.element)
+        throw new Error("No element in context");
+    const isVisible = await this.element.isVisible();
+    if (isVisible)
+        throw new Error("Element is visible but should not be");
+});
+Then(/^I see element "([^"]+)" does not exist$/, async function (selector) {
+    const el = await this.page.locator(selector);
+    await expect(el).toHaveCount(0);
+});
+//
+// 👁️ ELEMENT VISIBILITY
+//
+Then(/^I see element "([^"]+)" is visible$/, async function (selector) {
+    const el = this.page.locator(selector);
+    await expect(el).toBeVisible();
+});
+Then(/^I see element "([^"]+)" is not visible$/, async function (selector) {
+    const el = this.page.locator(selector);
+    await expect(el).not.toBeVisible();
+});
+//
+// 🔎 ATTRIBUTE ASSERTIONS
+//
+Then(/^I see element "([^"]+)" attribute "([^"]+)" equals "(.*)"$/, async function (selector, attribute, expected) {
+    const el = this.page.locator(selector);
+    await expect(el).toHaveAttribute(attribute, expected);
+});
+Then("I see element has attribute {string}", async function (attr) {
+    if (!this.element)
+        throw new Error("No element in context");
+    const value = await this.element.getAttribute(attr);
+    if (value === null)
+        throw new Error(`Attribute "${attr}" not found`);
+});
+Then("I see element attribute {string} contains {string}", async function (attr, part) {
+    if (!this.element)
+        throw new Error("No element in context");
+    const value = await this.element.getAttribute(attr);
+    if (!(value === null || value === void 0 ? void 0 : value.includes(part))) {
+        throw new Error(`Attribute "${attr}" does not contain "${part}". Got: "${value}"`);
+    }
+});
+Then(/^I see element "([^"]+)" attribute "([^"]+)" contains "(.*)"$/, async function (selector, attribute, substring) {
+    const attr = await this.page.locator(selector).getAttribute(attribute);
+    expect(attr === null || attr === void 0 ? void 0 : attr.includes(substring)).toBeTruthy();
+});
+Then(/^I see element "([^"]+)" has attribute "([^"]+)"$/, async function (selector, attribute) {
+    const attr = await this.page.locator(selector).getAttribute(attribute);
+    expect(attr).not.toBeNull();
+});

package/dist/assertions/formInputSteps.d.ts

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

package/dist/assertions/formInputSteps.js

@@ -0,0 +1,85 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+//
+// 🧾 INPUT VALUES
+//
+Then(/^I see input "([^"]+)" has value "(.*)"$/, async function (selector, value) {
+    const el = this.page.locator(selector);
+    await expect(el).toHaveValue(value);
+});
+Then("I see input value {string}", async function (expected) {
+    if (!this.element)
+        throw new Error("No element stored in context");
+    const value = await this.element.inputValue();
+    expect(value).toBe(expected);
+});
+Then("I see input value contains {string}", async function (part) {
+    if (!this.element)
+        throw new Error("No element stored in context");
+    const value = await this.element.inputValue();
+    expect(value).toContain(part);
+});
+Then(/^I see input "([^"]+)" value contains "(.*)"$/, async function (selector, partial) {
+    const val = await this.page.locator(selector).inputValue();
+    expect(val).toContain(partial);
+});
+//
+// 📝 TEXTAREA VALUES
+//
+Then(/^I see textarea "([^"]+)" has value "(.*)"$/, async function (selector, value) {
+    const el = this.page.locator(selector);
+    await expect(el).toHaveValue(value);
+});
+Then("I see textarea value {string}", async function (expected) {
+    if (!this.element)
+        throw new Error("No textarea selected");
+    const value = await this.element.inputValue();
+    if (value !== expected)
+        throw new Error(`Expected "${expected}", got "${value}"`);
+});
+Then("I see textarea value contains {string}", async function (part) {
+    if (!this.element)
+        throw new Error("No textarea selected");
+    const value = await this.element.inputValue();
+    if (!value.includes(part)) {
+        throw new Error(`Textarea does not contain "${part}". Got: "${value}"`);
+    }
+});
+Then(/^I see textarea "([^"]+)" value contains "(.*)"$/, async function (selector, partial) {
+    const val = await this.page.locator(selector).inputValue();
+    expect(val).toContain(partial);
+});
+//
+// ✅ GENERIC VALUE MATCHING
+//
+Then(/^I see value "(.*)" in "([^"]+)"$/, async function (value, selector) {
+    const el = this.page.locator(selector);
+    await expect(el).toHaveValue(value);
+});
+Then(/^I do not see value "(.*)" in "([^"]+)"$/, async function (value, selector) {
+    const actual = await this.page.locator(selector).inputValue();
+    expect(actual).not.toBe(value);
+});
+//
+// ⬇️ OPTION IN SELECT
+//
+Then(/^I see option "(.*)"$/, async function (optionText) {
+    const el = this.page.locator(`option`, { hasText: optionText });
+    await expect(el).toHaveCount(1);
+});
+Then("I see option {string}", async function (optionText) {
+    const option = this.page.locator("option", { hasText: optionText });
+    if (!(await option.isVisible())) {
+        throw new Error(`Option "${optionText}" not visible`);
+    }
+});
+Then("I do not see option {string}", async function (optionText) {
+    const option = this.page.locator("option", { hasText: optionText });
+    if ((await option.count()) > 0 && (await option.first().isVisible())) {
+        throw new Error(`Option "${optionText}" is visible but should not be`);
+    }
+});
+Then(/^I do not see option "(.*)"$/, async function (optionText) {
+    const el = this.page.locator(`option`, { hasText: optionText });
+    await expect(el).toHaveCount(0);
+});

package/dist/assertions/locationSteps.d.ts

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

package/dist/assertions/locationSteps.js

@@ -0,0 +1,69 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+//
+// 🌐 URL
+//
+Then("I see URL {string}", async function (expected) {
+    const url = this.page.url();
+    expect(url).toBe(expected);
+});
+Then("I do not see URL {string}", async function (notExpected) {
+    const url = this.page.url();
+    if (url === notExpected)
+        throw new Error(`Expected not to be on URL "${notExpected}"`);
+});
+Then("I see URL contains {string}", async function (expected) {
+    const url = this.page.url();
+    expect(url).toContain(expected);
+});
+Then("I do not see URL contains {string}", async function (notExpected) {
+    const url = this.page.url();
+    if (url.includes(notExpected)) {
+        throw new Error(`URL should not contain "${notExpected}", but got "${url}"`);
+    }
+});
+//
+// 📍 LOCATION PARTS
+//
+Then("I see location {string}", async function (expected) {
+    const location = await this.page.evaluate(() => window.location.href);
+    if (location !== expected) {
+        throw new Error(`Expected location to be "${expected}", but got "${location}"`);
+    }
+});
+Then("I see pathname {string}", async function (expected) {
+    const pathname = await this.page.evaluate(() => window.location.pathname);
+    if (pathname !== expected) {
+        throw new Error(`Expected pathname "${expected}", but got "${pathname}"`);
+    }
+});
+Then("I see pathname contains {string}", async function (part) {
+    const pathname = await this.page.evaluate(() => window.location.pathname);
+    if (!pathname.includes(part)) {
+        throw new Error(`Pathname does not contain "${part}". Got: "${pathname}"`);
+    }
+});
+Then("I see hash {string}", async function (expected) {
+    const hash = await this.page.evaluate(() => window.location.hash);
+    if (hash !== expected) {
+        throw new Error(`Expected hash "${expected}", but got "${hash}"`);
+    }
+});
+Then("I see hash contains {string}", async function (part) {
+    const hash = await this.page.evaluate(() => window.location.hash);
+    if (!hash.includes(part)) {
+        throw new Error(`Expected hash to contain "${part}", but got "${hash}"`);
+    }
+});
+Then("I see search {string}", async function (expected) {
+    const search = await this.page.evaluate(() => window.location.search);
+    if (search !== expected) {
+        throw new Error(`Expected search to be "${expected}", but got "${search}"`);
+    }
+});
+Then("I see search contains {string}", async function (part) {
+    const search = await this.page.evaluate(() => window.location.search);
+    if (!search.includes(part)) {
+        throw new Error(`Search does not contain "${part}". Got: "${search}"`);
+    }
+});

package/dist/assertions/roleTestIdSteps.d.ts

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

package/dist/assertions/roleTestIdSteps.js

@@ -0,0 +1,24 @@
+import { Then } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+//
+// 🧩 ROLE-BASED ELEMENTS
+//
+Then(/^I see role "(.*)" with name "(.*)"$/, async function (role, name) {
+    const el = this.page.getByRole(role, { name, exact: true });
+    await expect(el).toBeVisible();
+});
+Then(/^I do not see role "(.*)" with name "(.*)"$/, async function (role, name) {
+    const el = this.page.getByRole(role, { name, exact: true });
+    await expect(el).toHaveCount(0);
+});
+//
+// 🏷️ TEST ID-BASED ELEMENTS
+//
+Then(/^I see testid "(.*)"$/, async function (testId) {
+    const el = this.page.getByTestId(testId);
+    await expect(el).toBeVisible();
+});
+Then(/^I do not see testid "(.*)"$/, async function (testId) {
+    const el = this.page.getByTestId(testId);
+    await expect(el).toHaveCount(0);
+});

package/dist/assertions/semanticSteps.d.ts

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

package/dist/assertions/semanticSteps.js

@@ -0,0 +1,52 @@
+import { Then } from "@cucumber/cucumber";
+//
+// 🧠 HEADINGS
+//
+Then("I see heading {string}", async function (text) {
+    const heading = await this.page
+        .locator("h1, h2, h3, h4, h5, h6", { hasText: text })
+        .first();
+    if (!(await heading.isVisible())) {
+        throw new Error(`Heading "${text}" not found or not visible`);
+    }
+});
+Then("I do not see heading {string}", async function (text) {
+    const heading = this.page.locator("h1, h2, h3, h4, h5, h6", {
+        hasText: text,
+    });
+    if ((await heading.count()) > 0) {
+        const visible = await heading.first().isVisible();
+        if (visible)
+            throw new Error(`Heading "${text}" is visible but should not be`);
+    }
+});
+//
+// 🏷️ LABELS
+//
+Then("I see label {string}", async function (text) {
+    const label = this.page.getByLabel(text);
+    if (!(await label.isVisible())) {
+        throw new Error(`Label "${text}" not visible`);
+    }
+});
+Then("I do not see label {string}", async function (text) {
+    const label = this.page.getByLabel(text);
+    if ((await label.count()) > 0 && (await label.first().isVisible())) {
+        throw new Error(`Label "${text}" is visible but should not be`);
+    }
+});
+//
+// 🔗 LINKS
+//
+Then("I see link {string}", async function (text) {
+    const link = this.page.getByRole("link", { name: text });
+    if (!(await link.isVisible())) {
+        throw new Error(`Link "${text}" not visible`);
+    }
+});
+Then("I do not see link {string}", async function (text) {
+    const link = this.page.getByRole("link", { name: text });
+    if ((await link.count()) > 0 && (await link.first().isVisible())) {
+        throw new Error(`Link "${text}" is visible but should not be`);
+    }
+});

package/dist/assertions/storageSteps.d.ts

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

package/dist/assertions/storageSteps.js

@@ -0,0 +1,70 @@
+import { When, Then } from "@cucumber/cucumber";
+import fs from "fs";
+import path from "path";
+//
+// 🗃 LOCAL STORAGE
+//
+Then("I see local storage item {string}", async function (key) {
+    const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
+    if (value === null)
+        throw new Error(`Local storage item "${key}" not found`);
+});
+Then("I do not see local storage item {string}", async function (key) {
+    const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
+    if (value !== null)
+        throw new Error(`Expected localStorage["${key}"] to be null, but got "${value}"`);
+});
+Then("I see local storage item {string} equals {string}", async function (key, expected) {
+    const actual = await this.page.evaluate((k) => localStorage.getItem(k), key);
+    if (actual !== expected) {
+        throw new Error(`Expected localStorage["${key}"] to be "${expected}", but got "${actual}"`);
+    }
+});
+Then("I see local storage item {string} contains {string}", async function (key, part) {
+    const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
+    if (!value || !value.includes(part)) {
+        throw new Error(`localStorage["${key}"] does not contain "${part}". Got: "${value}"`);
+    }
+});
+//
+// 🗂 SESSION STORAGE
+//
+Then("I see session storage item {string}", async function (key) {
+    const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
+    if (value === null)
+        throw new Error(`Session storage item "${key}" not found`);
+});
+Then("I do not see session storage item {string}", async function (key) {
+    const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
+    if (value !== null)
+        throw new Error(`Expected sessionStorage["${key}"] to be null, but got "${value}"`);
+});
+When("I clear all saved session files", async function () {
+    var _a, _b;
+    const authDir = path.resolve("e2e/support/helper/auth");
+    if (fs.existsSync(authDir)) {
+        const files = fs.readdirSync(authDir);
+        for (const file of files) {
+            const filePath = path.join(authDir, file);
+            if (fs.lstatSync(filePath).isFile()) {
+                fs.unlinkSync(filePath);
+                (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🧹 Deleted session file: ${file}`);
+            }
+        }
+    }
+    else {
+        (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `⚠️ Auth directory not found at ${authDir}`);
+    }
+});
+Then("I see session storage item {string} equals {string}", async function (key, expected) {
+    const actual = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
+    if (actual !== expected) {
+        throw new Error(`Expected sessionStorage["${key}"] to be "${expected}", but got "${actual}"`);
+    }
+});
+Then("I see session storage item {string} contains {string}", async function (key, part) {
+    const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
+    if (!value || !value.includes(part)) {
+        throw new Error(`sessionStorage["${key}"] does not contain "${part}". Got: "${value}"`);
+    }
+});

package/dist/assertions/visualSteps.d.ts

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