@vardot/varbase-e2e 2.0.0

package/tests/step-definitions/cookie.steps.js

@@ -0,0 +1,216 @@
+'use strict';
+
+// Cookie existence and value assertions (exact and partial matching) using
+// Playwright's `BrowserContext.cookies()` API.
+
+const { Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+async function getCookies(world) {
+  return world.context ? await world.context.cookies() : [];
+}
+
+function findByName(cookies, name) {
+  return cookies.find((c) => c.name === name);
+}
+
+function findByPartialName(cookies, partial) {
+  return cookies.find((c) => c.name.indexOf(partial) !== -1);
+}
+
+/**
+ * Assert that a cookie with the exact name exists in the browser context.
+ *
+ * Example #1: Then a cookie with the name "session_id" should exist
+ * Example #2: Then a cookie with the name "auth_token" should exist
+ * Example #3: And a cookie with the name "lang" should exist
+ * Example #4: Then a cookie with the name "consent" should exist
+ * Example #5: When I press "Sign in"
+ *               Then a cookie with the name "session" should exist
+ *
+ */
+Then('a cookie with the name {string} should exist', async function (name) {
+  const cookies = await getCookies(this);
+  assert.ok(findByName(cookies, name), `Cookie "${name}" was not found.`);
+});
+
+/**
+ * Assert that a cookie with the exact name AND exact value exists.
+ *
+ * Example #1: Then a cookie with the name "lang" and the value "en" should exist
+ * Example #2: Then a cookie with the name "consent" and the value "accepted" should exist
+ * Example #3: And a cookie with the name "ab_bucket" and the value "variant-b" should exist
+ * Example #4: Then a cookie with the name "theme" and the value "dark" should exist
+ * Example #5: When I check "Remember me"
+ *               And I press "Sign in"
+ *               Then a cookie with the name "remember" and the value "1" should exist
+ *
+ */
+Then('a cookie with the name {string} and the value {string} should exist', async function (name, value) {
+  const cookies = await getCookies(this);
+  const c = findByName(cookies, name);
+  assert.ok(c, `Cookie "${name}" was not found.`);
+  assert.strictEqual(c.value, value, `Cookie "${name}" has value "${c.value}", expected "${value}".`);
+});
+
+/**
+ * Assert a cookie with the exact name has a value containing a substring.
+ *
+ * Example #1: Then a cookie with the name "session_id" and a value containing "abc" should exist
+ * Example #2: Then a cookie with the name "auth" and a value containing "Bearer" should exist
+ * Example #3: And a cookie with the name "preferences" and a value containing "darkmode" should exist
+ * Example #4: Then a cookie with the name "tracking" and a value containing "v2-" should exist
+ * Example #5: Then a cookie with the name "csrf" and a value containing "token=" should exist
+ *
+ */
+Then('a cookie with the name {string} and a value containing {string} should exist', async function (name, partial) {
+  const cookies = await getCookies(this);
+  const c = findByName(cookies, name);
+  assert.ok(c, `Cookie "${name}" was not found.`);
+  assert.ok(c.value.indexOf(partial) !== -1, `Cookie "${name}" value "${c.value}" does not contain "${partial}".`);
+});
+
+/**
+ * Assert a cookie whose name contains a substring exists.
+ *
+ * Example #1: Then a cookie with a name containing "session" should exist
+ * Example #2: Then a cookie with a name containing "_csrf" should exist
+ * Example #3: And a cookie with a name containing "tracking" should exist
+ * Example #4: Then a cookie with a name containing "auth" should exist
+ * Example #5: Then a cookie with a name containing "lang_" should exist
+ *
+ */
+Then('a cookie with a name containing {string} should exist', async function (partial) {
+  const cookies = await getCookies(this);
+  assert.ok(findByPartialName(cookies, partial), `No cookie with name containing "${partial}" was found.`);
+});
+
+/**
+ * Assert a cookie whose name contains a substring has the exact value.
+ *
+ * Example #1: Then a cookie with a name containing "session" and the value "active" should exist
+ * Example #2: Then a cookie with a name containing "auth" and the value "1" should exist
+ * Example #3: And a cookie with a name containing "lang_" and the value "en" should exist
+ * Example #4: Then a cookie with a name containing "feature_" and the value "on" should exist
+ * Example #5: Then a cookie with a name containing "_pref" and the value "dark" should exist
+ *
+ */
+Then('a cookie with a name containing {string} and the value {string} should exist', async function (partial, value) {
+  const cookies = await getCookies(this);
+  const found = cookies.find((c) => c.name.indexOf(partial) !== -1 && c.value === value);
+  assert.ok(found, `No cookie with name containing "${partial}" and value "${value}" was found.`);
+});
+
+/**
+ * Assert a cookie whose name contains substring A has a value containing substring B.
+ *
+ * Example #1: Then a cookie with a name containing "session" and a value containing "active" should exist
+ * Example #2: Then a cookie with a name containing "auth" and a value containing "Bearer" should exist
+ * Example #3: And a cookie with a name containing "tracking" and a value containing "v2-" should exist
+ * Example #4: Then a cookie with a name containing "csrf" and a value containing "token=" should exist
+ * Example #5: Then a cookie with a name containing "_pref" and a value containing "dark" should exist
+ *
+ */
+Then('a cookie with a name containing {string} and a value containing {string} should exist', async function (partialName, partialValue) {
+  const cookies = await getCookies(this);
+  const found = cookies.find((c) => c.name.indexOf(partialName) !== -1 && c.value.indexOf(partialValue) !== -1);
+  assert.ok(found, `No cookie with name containing "${partialName}" and value containing "${partialValue}" was found.`);
+});
+
+/**
+ * Assert a cookie with the exact name does NOT exist.
+ *
+ * Example #1: Then a cookie with the name "session_id" should not exist
+ * Example #2: Then a cookie with the name "auth_token" should not exist
+ * Example #3: And a cookie with the name "tracking" should not exist
+ * Example #4: When I press "Logout"
+ *               Then a cookie with the name "session" should not exist
+ * Example #5: Given all cookies are cleared
+ *               Then a cookie with the name "lang" should not exist
+ *
+ */
+Then('a cookie with the name {string} should not exist', async function (name) {
+  const cookies = await getCookies(this);
+  assert.ok(!findByName(cookies, name), `Cookie "${name}" should not exist but it does.`);
+});
+
+/**
+ * Assert a cookie with the exact name+value does NOT exist.
+ *
+ * Example #1: Then a cookie with the name "lang" and the value "fr" should not exist
+ * Example #2: Then a cookie with the name "consent" and the value "rejected" should not exist
+ * Example #3: And a cookie with the name "theme" and the value "dark" should not exist
+ * Example #4: Then a cookie with the name "ab_bucket" and the value "variant-c" should not exist
+ * Example #5: Then a cookie with the name "remember" and the value "0" should not exist
+ *
+ */
+Then('a cookie with the name {string} and the value {string} should not exist', async function (name, value) {
+  const cookies = await getCookies(this);
+  const c = findByName(cookies, name);
+  assert.ok(!c || c.value !== value, `Cookie "${name}" with value "${value}" should not exist.`);
+});
+
+/**
+ * Assert a cookie with the exact name does not contain a substring in its value.
+ *
+ * Example #1: Then a cookie with the name "preferences" and a value containing "lightmode" should not exist
+ * Example #2: Then a cookie with the name "tracking" and a value containing "v1-" should not exist
+ * Example #3: And a cookie with the name "auth" and a value containing "Basic" should not exist
+ * Example #4: Then a cookie with the name "session" and a value containing "expired" should not exist
+ * Example #5: Then a cookie with the name "csrf" and a value containing "invalid" should not exist
+ *
+ */
+Then('a cookie with the name {string} and a value containing {string} should not exist', async function (name, partial) {
+  const cookies = await getCookies(this);
+  const c = findByName(cookies, name);
+  assert.ok(!c || c.value.indexOf(partial) === -1, `Cookie "${name}" should not contain value "${partial}".`);
+});
+
+/**
+ * Assert no cookie name contains a substring.
+ *
+ * Example #1: Then a cookie with a name containing "old_" should not exist
+ * Example #2: Then a cookie with a name containing "_legacy" should not exist
+ * Example #3: And a cookie with a name containing "deprecated" should not exist
+ * Example #4: Given all cookies are cleared
+ *               Then a cookie with a name containing "session" should not exist
+ * Example #5: When I press "Logout"
+ *               Then a cookie with a name containing "auth" should not exist
+ *
+ */
+Then('a cookie with a name containing {string} should not exist', async function (partial) {
+  const cookies = await getCookies(this);
+  assert.ok(!findByPartialName(cookies, partial), `Cookie with name containing "${partial}" should not exist.`);
+});
+
+/**
+ * Assert no cookie name+value pair (with partial name) matches.
+ *
+ * Example #1: Then a cookie with a name containing "session" and the value "expired" should not exist
+ * Example #2: Then a cookie with a name containing "auth" and the value "anonymous" should not exist
+ * Example #3: And a cookie with a name containing "feature_" and the value "off" should not exist
+ * Example #4: Then a cookie with a name containing "lang_" and the value "xx" should not exist
+ * Example #5: Then a cookie with a name containing "_pref" and the value "default" should not exist
+ *
+ */
+Then('a cookie with a name containing {string} and the value {string} should not exist', async function (partial, value) {
+  const cookies = await getCookies(this);
+  const found = cookies.find((c) => c.name.indexOf(partial) !== -1 && c.value === value);
+  assert.ok(!found, `Cookie with name containing "${partial}" and value "${value}" should not exist.`);
+});
+
+/**
+ * Assert no cookie partial-name + partial-value pair matches.
+ *
+ * Example #1: Then a cookie with a name containing "session" and a value containing "old" should not exist
+ * Example #2: Then a cookie with a name containing "auth" and a value containing "Basic" should not exist
+ * Example #3: And a cookie with a name containing "tracking" and a value containing "v0-" should not exist
+ * Example #4: Then a cookie with a name containing "_pref" and a value containing "lightmode" should not exist
+ * Example #5: Then a cookie with a name containing "csrf" and a value containing "invalid" should not exist
+ *
+ */
+Then('a cookie with a name containing {string} and a value containing {string} should not exist', async function (partialName, partialValue) {
+  const cookies = await getCookies(this);
+  const found = cookies.find((c) => c.name.indexOf(partialName) !== -1 && c.value.indexOf(partialValue) !== -1);
+  assert.ok(!found, `Cookie with name containing "${partialName}" and value containing "${partialValue}" should not exist.`);
+});

package/tests/step-definitions/debug.steps.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// Debug helpers — print current URL, full HTML response, etc. Use sparingly
+// and strip before merging.
+
+const { Then } = require('@cucumber/cucumber');
+
+/**
+ * Print the current page URL to console (debug).
+ *
+ * Example #1: Then print current URL
+ * Example #2: When print current URL
+ * Example #3: And print current URL
+ */
+Then(/^print current URL$/, function () {
+  try {
+    console.log('\n--- Current URL ---');
+    console.log(`  ${this.page.url()}`);
+  } catch (e) {
+    console.log(`\n--- Current URL unavailable: ${e.message} ---`);
+  }
+});
+
+/**
+ * Print the full page HTML (last response) to console (debug).
+ *
+ * Example #1: Then print last response
+ * Example #2: When print last response
+ * Example #3: And print last response
+ */
+Then(/^print last response$/, async function () {
+  try {
+    const html = await this.page.content();
+    console.log('\n--- Last Response (HTML) ---');
+    console.log(html);
+  } catch (e) {
+    console.log(`\n--- Last response unavailable: ${e.message} ---`);
+  }
+});

package/tests/step-definitions/dialog.steps.js

@@ -0,0 +1,193 @@
+'use strict';
+
+// Browser dialog handlers (alert / confirm / prompt / beforeunload).
+// Mirrors Playwright's `page.on('dialog')` API with BDD-friendly phrasing.
+//
+// Attach a handler BEFORE the action that triggers the dialog. Handlers
+// queue dialog messages onto `this._lastDialog` so assertions can inspect
+// them after the action completes.
+
+const { Given, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+// Single shared attach() — handles single-shot ("next") and persistent
+// ("all") variants via the `once` flag.
+function attach(world, action, promptInput, once) {
+  if (world._dialogHandler) {
+    try { world.page.off('dialog', world._dialogHandler); } catch { /* ignore */ }
+  }
+  world._lastDialog = null;
+  world._dialogHandler = async (dialog) => {
+    world._lastDialog = {
+      type: dialog.type(),
+      message: dialog.message(),
+      defaultValue: dialog.defaultValue(),
+    };
+    try {
+      if (action === 'accept') {
+        if (typeof promptInput === 'string' && dialog.type() === 'prompt') {
+          await dialog.accept(promptInput);
+        } else {
+          await dialog.accept();
+        }
+      } else {
+        await dialog.dismiss();
+      }
+    } catch { /* dialog may have closed already */ }
+    if (once) {
+      try { world.page.off('dialog', world._dialogHandler); } catch { /* ignore */ }
+      world._dialogHandler = null;
+    }
+  };
+  world.page.on('dialog', world._dialogHandler);
+}
+
+/**
+ * Auto-accept the next native browser dialog (alert / confirm / prompt).
+ *
+ * Example #1: Given I will accept the next dialog
+ *               When I click "Delete"
+ * Example #2: Given we will accept the next dialog
+ *               When I press "Confirm"
+ * Example #3: Given I will accept the next dialog
+ *               When I click "Save changes"
+ *               Then I should see "Saved"
+ * Example #4: Given I will accept the next dialog
+ *               When I follow "Leave page"
+ * Example #5: Given I will accept the next dialog
+ *               When I press "Reset password"
+ *               Then the last dialog type should be "confirm"
+ *
+ */
+Given(/^(I |we )*will accept the next dialog$/, function () {
+  attach(this, 'accept', undefined, true);
+});
+
+/**
+ * Auto-dismiss the next native browser dialog.
+ *
+ * Example #1: Given I will dismiss the next dialog
+ *               When I click "Leave page"
+ * Example #2: Given we will dismiss the next dialog
+ *               When I press "Cancel reset"
+ * Example #3: Given I will dismiss the next dialog
+ *               When I follow "Other site"
+ *               Then I should be on the homepage
+ * Example #4: Given I will dismiss the next dialog
+ *               When I press "Delete"
+ *               Then "<.row>" should still be visible
+ * Example #5: Given I will dismiss the next dialog
+ *               When I close the tab
+ *
+ */
+Given(/^(I |we )*will dismiss the next dialog$/, function () {
+  attach(this, 'dismiss', undefined, true);
+});
+
+/**
+ * Auto-accept the next prompt with the supplied text input.
+ *
+ * Example #1: Given I will accept the next dialog with "alice@example.com"
+ *               When I press "Reset password"
+ * Example #2: Given I will accept the next dialog with "Yes"
+ *               When I click "Continue"
+ * Example #3: Given we will accept the next dialog with "Bug report"
+ *               When I press "Open feedback prompt"
+ * Example #4: Given I will accept the next dialog with "12345"
+ *               When I follow "Set order ID"
+ * Example #5: Given I will accept the next dialog with "https://example.com"
+ *               When I press "Add link"
+ *
+ */
+Given(/^(I |we )*will accept the next dialog with "([^"]*)"$/, function (pronoun, input) {
+  attach(this, 'accept', input, true);
+});
+
+/**
+ * Assert the most recently captured dialog message equals an expected value.
+ *
+ * Example #1: Then the last dialog message should be "Are you sure?"
+ * Example #2: Then the last dialog message should be "Delete this item?"
+ * Example #3: And the last dialog message should be "Leave site?"
+ * Example #4: Then the last dialog message should be "Save changes?"
+ * Example #5: When I press "Reset"
+ *               Then the last dialog message should be "Reset all settings?"
+ *
+ */
+Then(/^the last dialog message should be "([^"]*)"$/, function (text) {
+  assert.ok(this._lastDialog, 'No dialog has been captured.');
+  assert.strictEqual(this._lastDialog.message, text,
+    `Expected dialog message "${text}", got "${this._lastDialog.message}".`);
+});
+
+/**
+ * Assert the most recently captured dialog message contains an expected substring.
+ *
+ * Example #1: Then the last dialog message should contain "Are you sure"
+ * Example #2: Then the last dialog message should contain "delete"
+ * Example #3: And the last dialog message should contain "leave"
+ * Example #4: Then the last dialog message should contain "save"
+ * Example #5: When I click "Cancel order"
+ *               Then the last dialog message should contain "cancel"
+ *
+ */
+Then(/^the last dialog message should contain "([^"]*)"$/, function (text) {
+  assert.ok(this._lastDialog, 'No dialog has been captured.');
+  assert.ok(this._lastDialog.message.includes(text),
+    `Dialog message "${this._lastDialog.message}" does not contain "${text}".`);
+});
+
+/**
+ * Assert the most recently captured dialog type matches one of `alert`,
+ * `confirm`, `prompt`, or `beforeunload`.
+ *
+ * Example #1: Then the last dialog type should be "confirm"
+ * Example #2: Then the last dialog type should be "alert"
+ * Example #3: And the last dialog type should be "prompt"
+ * Example #4: Then the last dialog type should be "beforeunload"
+ * Example #5: When I press "Reset password"
+ *               Then the last dialog type should be "prompt"
+ *
+ */
+Then(/^the last dialog type should be "([^"]*)"$/, function (type) {
+  assert.ok(this._lastDialog, 'No dialog has been captured.');
+  assert.strictEqual(this._lastDialog.type, type,
+    `Expected dialog type "${type}", got "${this._lastDialog.type}".`);
+});
+
+/**
+ * Auto-accept EVERY native browser dialog raised in this scenario.
+ *
+ * Persistent variant of "I will accept the next dialog" — handler stays
+ * attached for the rest of the scenario.
+ *
+ * Example #1: Given I accept all confirmation dialogs
+ * Example #2: Given we accept all confirmation dialogs
+ *               When I click "Delete all"
+ * Example #3: And I accept all confirmation dialogs
+ * Example #4: Given I accept all confirmation dialogs
+ *               When I press "Reset settings"
+ * Example #5: Given I accept all confirmation dialogs
+ *               When I follow "Discard changes"
+ *
+ */
+Given(/^(I |we )*accept all confirmation dialogs$/, function () {
+  attach(this, 'accept', undefined, false);
+});
+
+/**
+ * Auto-dismiss EVERY native browser dialog raised in this scenario.
+ *
+ * Example #1: Given I do not accept any confirmation dialogs
+ * Example #2: Given we do not accept any confirmation dialogs
+ *               When I click "Delete"
+ * Example #3: And I do not accept any confirmation dialogs
+ * Example #4: Given I do not accept any confirmation dialogs
+ *               When I press "Cancel reset"
+ * Example #5: Given I do not accept any confirmation dialogs
+ *               When I follow "Leave page"
+ *
+ */
+Given(/^(I |we )*do not accept any confirmation dialogs$/, function () {
+  attach(this, 'dismiss', undefined, false);
+});