playwright-cucumber-ts-steps 0.0.5 → 0.0.7

package/dist/actions/interceptionSteps.js

@@ -1,15 +1,5 @@
 // e2e/step_definitions/common/interceptionSteps.ts
-import { When, Then } from "@cucumber/cucumber";
-import { expect } from "@playwright/test";
-When("I intercept URL {string}", async function (url) {
-    this.interceptedRequests = [];
-    await this.page.route(url, (route, request) => {
-        this.interceptedRequests.push(request);
-        this.log(`Intercepted request to: ${request.url()}`);
-        route.continue();
-    });
-    this.log(`Setup interception for URL: "${url}"`);
-});
+import { When } from "@cucumber/cucumber";
 When("I intercept URL {string} and stub body:", async function (url, body) {
     let parsedBody;
     try {
@@ -29,7 +19,7 @@ When("I intercept URL {string} and stub body:", async function (url, body) {
     this.log(`Intercepted and stubbed URL "${url}" with body: ${JSON.stringify(parsedBody)}`);
 });
 //Making Direct API Requests (Optional, Advanced)
-When("I make a request to {string}", async function (url) {
+When("I make request to {string}", async function (url) {
     const response = await this.page.request.get(url);
     const status = response.status();
     const body = await response.text();
@@ -51,14 +41,21 @@ When("I make a POST request to {string} with JSON body:", async function (url, d
     this.data.lastResponse = { status, body };
     this.log(`Made POST request to "${url}" — Status: ${status}`);
 });
-// 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}`);
+When("I intercept URL {string}", async function (url) {
+    await this.page.route(url, async (route) => {
+        await route.continue();
+    });
 });
-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}"`);
+When("I intercept URL {string} and stub body {string}", async function (url, body) {
+    await this.page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "application/json",
+            body,
+        });
+    });
+});
+When("I make a request to {string}", async function (url) {
+    const response = await this.page.request.get(url);
+    this.data.lastResponse = response;
 });

package/dist/assertions/InterceptionRequests.d.ts

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

package/dist/assertions/InterceptionRequests.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/index.d.ts

@@ -1,28 +1,28 @@
-export * from "./actions/Interception & Requests";
+export * from "./actions/clickSteps";
+export * from "./actions/cookieSteps";
+export * from "./actions/debugSteps";
+export * from "./actions/elementFindSteps";
+export * from "./actions/inputSteps";
+export * from "./actions/interceptionSteps";
+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/cookieSteps";
 export * from "./assertions/elementSteps";
 export * from "./assertions/formInputSteps";
+export * from "./assertions/InterceptionRequests";
 export * from "./assertions/locationSteps";
-export * from "./actions/miscSteps";
 export * from "./assertions/roleTestIdSteps";
 export * from "./assertions/semanticSteps";
 export * from "./assertions/storageSteps";
+export * from "./assertions/visualSteps";
 export * from "./custom_setups/global-login";
-export * from "./actions/Interception & Requests";
-export * from "./actions/cookieSteps";
-export * from "./actions/clickSteps";
-export * from "./actions/cookieSteps";
-export * from "./actions/debugSteps";
-export * from "./actions/elementFindSteps";
-export * from "./actions/inputSteps";
-export * from "./actions/mouseSteps";
-export * from "./actions/scrollSteps";
-export * from "./actions/storageSteps";
 export * from "./custom_setups/loginHooks";
 export * from "./iframes/frames";
+export * from "./helpers/compareSnapshots";
+export * from "./helpers/hooks";
 export * from "./helpers/utils";
 export * from "./helpers/world";
-export * from "./helpers/hooks";
-export * from "./helpers/compareSnapshots";
 export type { CustomWorld } from "./helpers/world";

package/dist/index.js

@@ -1,29 +1,29 @@
 //src/index.ts
-export * from "./actions/Interception & Requests";
+export * from "./actions/clickSteps";
+export * from "./actions/cookieSteps";
+export * from "./actions/debugSteps";
+export * from "./actions/elementFindSteps";
+export * from "./actions/inputSteps";
+export * from "./actions/interceptionSteps";
+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/cookieSteps";
 export * from "./assertions/elementSteps";
 export * from "./assertions/formInputSteps";
+export * from "./assertions/InterceptionRequests";
 export * from "./assertions/locationSteps";
-export * from "./actions/miscSteps";
 export * from "./assertions/roleTestIdSteps";
 export * from "./assertions/semanticSteps";
 export * from "./assertions/storageSteps";
+export * from "./assertions/visualSteps";
 export * from "./custom_setups/global-login";
-export * from "./actions/Interception & Requests";
-export * from "./actions/cookieSteps";
-export * from "./actions/clickSteps";
-export * from "./actions/cookieSteps";
-export * from "./actions/debugSteps";
-export * from "./actions/elementFindSteps";
-export * from "./actions/inputSteps";
-export * from "./actions/mouseSteps";
-export * from "./actions/scrollSteps";
-export * from "./actions/storageSteps";
 export * from "./custom_setups/loginHooks";
 export * from "./iframes/frames";
 // Export core utilities and helpers
+export * from "./helpers/compareSnapshots";
+export * from "./helpers/hooks";
 export * from "./helpers/utils";
 export * from "./helpers/world";
-export * from "./helpers/hooks";
-export * from "./helpers/compareSnapshots";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-cucumber-ts-steps",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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",