@esimplicity/stack-tests 0.1.0 → 0.1.1

package/dist/{chunk-YPUQQZM2.js → chunk-73J5FNGG.js}

@@ -93,23 +93,23 @@ function registerApiHttpSteps(test) {
     world.lastContentType = result.contentType;
     world.lastResponse = result.response;
   }
-  When("I GET {string}", { tags: "@api" }, async ({ api, world }, path) => {
+  When("I GET {string}", { tags: "@api or @hybrid" }, async ({ api, world }, path) => {
     await send({ api, world }, "GET", path);
   });
-  When("I DELETE {string}", { tags: "@api" }, async ({ api, world }, path) => {
+  When("I DELETE {string}", { tags: "@api or @hybrid" }, async ({ api, world }, path) => {
     await send({ api, world }, "DELETE", path);
   });
-  When("I POST {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+  When("I POST {string} with JSON body:", { tags: "@api or @hybrid" }, async ({ api, world }, path, docString) => {
     const interpolated = interpolate(docString ?? "", world.vars);
     const parsed = tryParseJson(interpolated) ?? interpolated;
     await send({ api, world }, "POST", path, parsed);
   });
-  When("I PATCH {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+  When("I PATCH {string} with JSON body:", { tags: "@api or @hybrid" }, async ({ api, world }, path, docString) => {
     const interpolated = interpolate(docString ?? "", world.vars);
     const parsed = tryParseJson(interpolated) ?? interpolated;
     await send({ api, world }, "PATCH", path, parsed);
   });
-  When("I PUT {string} with JSON body:", { tags: "@api" }, async ({ api, world }, path, docString) => {
+  When("I PUT {string} with JSON body:", { tags: "@api or @hybrid" }, async ({ api, world }, path, docString) => {
     const interpolated = interpolate(docString ?? "", world.vars);
     const parsed = tryParseJson(interpolated) ?? interpolated;
     await send({ api, world }, "PUT", path, parsed);
@@ -121,22 +121,22 @@ import { createBdd as createBdd2 } from "playwright-bdd";
 import { expect as expect2 } from "@playwright/test";
 function registerApiAssertionSteps(test) {
   const { Then } = createBdd2(test);
-  Then("the response status should be {int}", { tags: "@api" }, async ({ world }, code) => {
+  Then("the response status should be {int}", { tags: "@api or @hybrid" }, async ({ world }, code) => {
     expect2(world.lastStatus, `Unexpected status. Body: ${world.lastText}`).toBe(code);
   });
-  Then("the response should be a JSON array", { tags: "@api" }, async ({ world }) => {
+  Then("the response should be a JSON array", { tags: "@api or @hybrid" }, async ({ world }) => {
     expect2(Array.isArray(world.lastJson), `Expected JSON array. Body: ${world.lastText}`).toBe(true);
   });
-  Then("the response should be a JSON object", { tags: "@api" }, async ({ world }) => {
+  Then("the response should be a JSON object", { tags: "@api or @hybrid" }, async ({ world }) => {
     const v = world.lastJson;
     expect2(v !== null && typeof v === "object" && !Array.isArray(v), `Expected JSON object. Body: ${world.lastText}`).toBe(true);
   });
-  Then("the value at {string} should equal {string}", { tags: "@api" }, async ({ world }, path, expectedRaw) => {
+  Then("the value at {string} should equal {string}", { tags: "@api or @hybrid" }, async ({ world }, path, expectedRaw) => {
     const actual = selectPath(world.lastJson, path);
     const expected = parseExpected(expectedRaw, world);
     expect2(actual).toEqual(expected);
   });
-  Then("I store the value at {string} as {string}", { tags: "@api" }, async ({ world, cleanup }, path, varName) => {
+  Then("I store the value at {string} as {string}", { tags: "@api or @hybrid" }, async ({ world, cleanup }, path, varName) => {
     const val = selectPath(world.lastJson, path);
     world.vars[varName] = String(val);
     cleanup.registerFromVar(world, varName, val, world.lastJson);
@@ -147,13 +147,13 @@ function registerApiAssertionSteps(test) {
 import { createBdd as createBdd3 } from "playwright-bdd";
 function registerApiAuthSteps(test) {
   const { Given } = createBdd3(test);
-  Given("I am authenticated as an admin via API", { tags: "@api" }, async ({ auth, world }) => {
+  Given("I am authenticated as an admin via API", { tags: "@api or @hybrid" }, async ({ auth, world }) => {
     await auth.apiLoginAsAdmin(world);
   });
-  Given("I am authenticated as a user via API", { tags: "@api" }, async ({ auth, world }) => {
+  Given("I am authenticated as a user via API", { tags: "@api or @hybrid" }, async ({ auth, world }) => {
     await auth.apiLoginAsUser(world);
   });
-  Given("I set bearer token from variable {string}", { tags: "@api" }, async ({ auth, world }, varName) => {
+  Given("I set bearer token from variable {string}", { tags: "@api or @hybrid" }, async ({ auth, world }, varName) => {
     const token = world.vars[varName];
     if (!token) throw new Error(`No token found in variable '${varName}'`);
     auth.apiSetBearer(world, token);
@@ -210,31 +210,31 @@ function registerSharedVarSteps(test) {
 import { createBdd as createBdd7 } from "playwright-bdd";
 function registerUiBasicSteps(test) {
   const { Given, When, Then } = createBdd7(test);
-  Given("I navigate to {string}", { tags: "@ui" }, async ({ ui, world }, path) => {
+  Given("I navigate to {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, path) => {
     await ui.goto(interpolate(path, world.vars));
   });
-  When("I click the button {string}", { tags: "@ui" }, async ({ ui, world }, name) => {
+  When("I click the button {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, name) => {
     await ui.clickButton(interpolate(name, world.vars));
   });
-  When("I click the link {string}", { tags: "@ui" }, async ({ ui, world }, name) => {
+  When("I click the link {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, name) => {
     await ui.clickLink(interpolate(name, world.vars));
   });
-  When("I fill the placeholder {string} with {string}", { tags: "@ui" }, async ({ ui, world }, placeholder, value) => {
+  When("I fill the placeholder {string} with {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, placeholder, value) => {
     await ui.fillPlaceholder(interpolate(placeholder, world.vars), interpolate(value, world.vars));
   });
-  When("I fill the field {string} with {string}", { tags: "@ui" }, async ({ ui, world }, label, value) => {
+  When("I fill the field {string} with {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, label, value) => {
     await ui.fillLabel(interpolate(label, world.vars), interpolate(value, world.vars));
   });
-  When("I log in as admin in UI", { tags: "@ui" }, async ({ auth, world }) => {
+  When("I log in as admin in UI", { tags: "@ui or @hybrid" }, async ({ auth, world }) => {
     await auth.uiLoginAsAdmin(world);
   });
-  When("I log in as user in UI", { tags: "@ui" }, async ({ auth, world }) => {
+  When("I log in as user in UI", { tags: "@ui or @hybrid" }, async ({ auth, world }) => {
     await auth.uiLoginAsUser(world);
   });
-  Then("I should see text {string}", { tags: "@ui" }, async ({ ui, world }, text) => {
+  Then("I should see text {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, text) => {
     await ui.expectText(interpolate(text, world.vars));
   });
-  Then("the URL should contain {string}", { tags: "@ui" }, async ({ ui, world }, part) => {
+  Then("the URL should contain {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, part) => {
     await ui.expectUrlContains(interpolate(part, world.vars));
   });
 }
@@ -339,36 +339,36 @@ function parseRegex(input) {
 }
 function registerWizardSteps(test) {
   const { Given, When, Then } = createBdd8(test);
-  Given("I open {string} page", { tags: "@ui" }, async ({ ui, world }, urlOrVar) => {
+  Given("I open {string} page", { tags: "@ui or @hybrid" }, async ({ ui, world }, urlOrVar) => {
     await ui.goto(resolveValue(urlOrVar, world));
   });
-  Given("I open {string} in the browser", { tags: "@ui" }, async ({ ui, world }, urlOrVar) => {
+  Given("I open {string} in the browser", { tags: "@ui or @hybrid" }, async ({ ui, world }, urlOrVar) => {
     await ui.goto(resolveValue(urlOrVar, world));
   });
-  When("I go back in the browser", { tags: "@ui" }, async ({ ui }) => {
+  When("I go back in the browser", { tags: "@ui or @hybrid" }, async ({ ui }) => {
     await ui.goBack();
   });
-  When("I save the current URL as {string}", { tags: "@ui" }, async ({ ui, world }, varName) => {
+  When("I save the current URL as {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, varName) => {
     world.vars[varName] = await ui.getCurrentUrl();
   });
-  When("I save the current url as {string}", { tags: "@ui" }, async ({ ui, world }, varName) => {
+  When("I save the current url as {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, varName) => {
     world.vars[varName] = await ui.getCurrentUrl();
   });
-  Then("I zoom to {string} in the browser", { tags: "@ui" }, async ({ ui, world }, scale) => {
+  Then("I zoom to {string} in the browser", { tags: "@ui or @hybrid" }, async ({ ui, world }, scale) => {
     await ui.zoomTo(parseNumber(scale, world));
   });
-  When("I reload the page", { tags: "@ui" }, async ({ ui }) => {
+  When("I reload the page", { tags: "@ui or @hybrid" }, async ({ ui }) => {
     await ui.reload();
   });
-  Then("I wait {string} seconds", { tags: "@ui" }, async ({ ui, world }, seconds) => {
+  Then("I wait {string} seconds", { tags: "@ui or @hybrid" }, async ({ ui, world }, seconds) => {
     await ui.waitSeconds(parseNumber(seconds, world));
   });
-  Then("I wait for the page to load", { tags: "@ui" }, async ({ ui }) => {
+  Then("I wait for the page to load", { tags: "@ui or @hybrid" }, async ({ ui }) => {
     await ui.waitForPageLoad();
   });
   When(
     "I get a part of the URL based on {string} regular expression and save it as {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, regexString, varName) => {
       const url = await ui.getCurrentUrl();
       const regex = parseRegex(resolveValue(regexString, world));
@@ -377,7 +377,7 @@ function registerWizardSteps(test) {
       world.vars[varName] = match[1] ?? match[0];
     }
   );
-  Then("I {string} {string}", { tags: "@ui" }, async ({ ui, world }, action, value) => {
+  Then("I {string} {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, action, value) => {
     const verb = action.trim().toLowerCase();
     const resolved = resolveValue(value, world);
     if (verb === "type") {
@@ -392,7 +392,7 @@ function registerWizardSteps(test) {
   });
   When(
     "I {string} the {string} element that contains {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, clickMode, elementType, text) => {
       await ui.clickElementThatContains(
         asClickMode(resolveValue(clickMode, world)),
@@ -403,7 +403,7 @@ function registerWizardSteps(test) {
   );
   When(
     "I {string} the {string} element with {string} {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, clickMode, ordinal, text, method) => {
       await ui.clickElementWith(
         asClickMode(resolveValue(clickMode, world)),
@@ -413,12 +413,12 @@ function registerWizardSteps(test) {
       );
     }
   );
-  When("I click on the top left corner of the page", { tags: "@ui" }, async ({ page }) => {
+  When("I click on the top left corner of the page", { tags: "@ui or @hybrid" }, async ({ page }) => {
     await page.mouse.click(0, 0);
   });
   When(
     "If its visible, I {string} the {string} element with {string} {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ page, ui, world }, clickMode, ordinal, text, method) => {
       const idx = parseOrdinalIndex(ordinal, world);
       const resolvedText = resolveValue(text, world);
@@ -429,12 +429,12 @@ function registerWizardSteps(test) {
       await ui.clickElementWith(asClickMode(resolveValue(clickMode, world)), ordinal, resolvedText, resolvedMethod);
     }
   );
-  Then("I fill {string} into the {string} dropdown", { tags: "@ui" }, async ({ ui, world }, value, label) => {
+  Then("I fill {string} into the {string} dropdown", { tags: "@ui or @hybrid" }, async ({ ui, world }, value, label) => {
     await ui.fillDropdown(resolveValue(value, world), resolveValue(label, world));
   });
   When(
     "I {string} {string} in the {string} element with {string} {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, action, value, ordinal, text, method) => {
       await ui.inputInElement(
         asInputMode(resolveValue(action, world)),
@@ -447,33 +447,33 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify if a new tab which URL {string} {string} opens",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, mode, expected) => {
       await ui.expectNewTabUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
     }
   );
   Then(
     "I verify if a new tab which url {string} {string} opens",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, mode, expected) => {
       await ui.expectNewTabUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
     }
   );
-  Then("I verify if the URL {string} {string}", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the URL {string} {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, mode, expected) => {
     await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
   });
-  Then("I verify if the url {string} {string}", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the url {string} {string}", { tags: "@ui or @hybrid" }, async ({ ui, world }, mode, expected) => {
     await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
   });
-  Then("I verify if the URL {string} {string} opens", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the URL {string} {string} opens", { tags: "@ui or @hybrid" }, async ({ ui, world }, mode, expected) => {
     await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
   });
-  Then("I verify if the url {string} {string} opens", { tags: "@ui" }, async ({ ui, world }, mode, expected) => {
+  Then("I verify if the url {string} {string} opens", { tags: "@ui or @hybrid" }, async ({ ui, world }, mode, expected) => {
     await ui.expectUrl(asUrlAssertMode(resolveValue(mode, world)), resolveValue(expected, world));
   });
   Then(
     "I verify that a {string} element with {string} text {string} visible",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, elementType, text, assertion) => {
       const normalized = resolveValue(assertion, world).trim().toLowerCase();
       const shouldBeVisible = normalized === "is";
@@ -485,7 +485,7 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify that {string} element with {string} {string} is {string}",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, ordinal, text, method, state) => {
       await ui.expectElementState(
         resolveValue(ordinal, world),
@@ -497,7 +497,7 @@ function registerWizardSteps(test) {
   );
   Then(
     "I verify that {string} element with {string} {string} becomes {string} during {string} seconds",
-    { tags: "@ui" },
+    { tags: "@ui or @hybrid" },
     async ({ ui, world }, ordinal, text, method, state, seconds) => {
       await ui.expectElementStateWithin(
         resolveValue(ordinal, world),

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   registerWizardSteps,
   selectPath,
   tryParseJson
-} from "./chunk-YPUQQZM2.js";
+} from "./chunk-73J5FNGG.js";
 
 // src/fixtures.ts
 import { test as base } from "playwright-bdd";

package/dist/steps/index.js

@@ -14,7 +14,7 @@ import {
   registerUiBasicSteps,
   registerUiSteps,
   registerWizardSteps
-} from "../chunk-YPUQQZM2.js";
+} from "../chunk-73J5FNGG.js";
 export {
   registerApiAssertionSteps,
   registerApiAuthSteps,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esimplicity/stack-tests",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -56,10 +56,7 @@
     }
   },
   "devDependencies": {
-    "@playwright/test": "^1.49.0",
     "@types/node": "^22.10.0",
-    "playwright-bdd": "^8.3.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.3"
+    "tsup": "^8.3.0"
   }
 }