@vardot/varbase-e2e 2.0.0

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

@@ -0,0 +1,218 @@
+'use strict';
+
+// All navigation step definitions live in this file: anonymous user, going
+// to the homepage / a specific path, browser history (back/forward), reload,
+// and URL/path assertions.
+
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const { gotoUrl, waitForPageLoad, smartSettle } = require('./varbase-e2e');
+
+// ---------------------------------------------------------------------------
+// Sessions / visits
+// ---------------------------------------------------------------------------
+
+/**
+ * Clear cookies and navigate to the launch URL as an anonymous visitor.
+ *
+ * Example #1: Given I am an anonymous user
+ * Example #2: Given we are an anonymous user
+ * Example #3: Given an anonymous user
+ *
+ */
+Given(/^(I am |we are )?an anonymous user$/, async function (pronounCase) {
+  await this.context.clearCookies();
+  await gotoUrl(this.page, this.launchUrl);
+  await waitForPageLoad(this.page, this.minWaitTime.page || 3000);
+});
+
+/**
+ * Open the homepage.
+ *
+ * Example #1: Given I am on homepage
+ * Example #2: Given I am on the homepage
+ * Example #3: Given I am on frontpage
+ * Example #4: Given I am on the frontpage
+ * Example #5: Given we are on homepage
+ * Example #6: Given we are on the frontpage
+ * Example #7: Given on homepage
+ * Example #8: Given on the homepage
+ * Example #9: Given on frontpage
+ * Example #10: Given on the frontpage
+ *
+ */
+Given(/^(I am |we are )?on( the)* (homepage|frontpage)$/, async function (pronounCase, theCase, pageCase) {
+  const defaultTime = this.minWaitTime.page || 3000;
+  await gotoUrl(this.page, this.launchUrl);
+  await this.page.waitForSelector('body', { state: 'attached', timeout: defaultTime });
+  await waitForPageLoad(this.page, defaultTime);
+});
+
+/**
+ * Open a specific page under the launch URL.
+ *
+ * Example #1: Given I am on "/about-us.html"
+ * Example #2: Given I am on the "/about-us.html" page
+ * Example #3: Given we are on "/user/login"
+ * Example #4: Given we are on the "/contact-us.html" page
+ * Example #5: Given on "/about-us.html"
+ * Example #6: Given on the "/about-us.html" page
+ * Example #7: Given I am on "https://un.org"
+ *
+ */
+Given(/^(I am |we are )*on( the)* "([^"]*)?"( page)*$/, async function (pronounCase, theCase, url, pageCase) {
+  await gotoUrl(this.page, this.launchUrl + url);
+  await this.page.waitForSelector('body', { state: 'attached', timeout: 10000 });
+  await waitForPageLoad(this.page);
+});
+
+/**
+ * Navigate to the homepage.
+ *
+ * Example #1: When I go to homepage
+ * Example #2: When I go to the homepage
+ * Example #3: When I navigate to the homepage
+ * Example #4: When navigating to the homepage
+ * Example #5: When navigating to homepage
+ * Example #6: When navigating to the frontpage
+ * Example #7: When we go to the homepage
+ * Example #8: When we navigate to the homepage
+ *
+ */
+When(/^(I go |I navigate |we go |we navigate |navigating )?to( the)* (homepage|frontpage)$/, async function (pronounCase, theCase, pageCase) {
+  const defaultTime = this.minWaitTime.page || 3000;
+  await gotoUrl(this.page, this.launchUrl);
+  await this.page.waitForSelector('body', { state: 'attached', timeout: defaultTime });
+  await waitForPageLoad(this.page, defaultTime);
+});
+
+/**
+ * Navigate to a specific page.
+ *
+ * Example #1: When I go to "/contact-us.html"
+ * Example #2: When I go to "/user/login"
+ * Example #3: When I navigate to "/admin/dashboard"
+ * Example #4: When navigating to "/products"
+ * Example #5: When we go to "/products"
+ * Example #6: When we navigate to "/terms"
+ *
+ */
+When(/^(I go |I navigate |we go |we navigate |navigating )?to "([^"]*)?"$/, async function (pronounCase, url) {
+  const defaultTime = this.minWaitTime.page || 3000;
+  await gotoUrl(this.page, this.launchUrl + url);
+  await this.page.waitForSelector('body', { state: 'attached', timeout: defaultTime });
+  await waitForPageLoad(this.page, defaultTime);
+});
+
+// ---------------------------------------------------------------------------
+// Browser history + reload
+// ---------------------------------------------------------------------------
+
+/**
+ * Moves forward one page in browser history.
+ *
+ * Example #1: When I move forward one page
+ * Example #2: When we move forward one page
+ * Example #3: And move forward one page
+ *
+ */
+When(/^(I |we )*move forward one page$/, async function (pronounCase) {
+  await this.page.goForward();
+});
+
+/**
+ * Moves backward one page in browser history.
+ *
+ * Example #1: When I move backward one page
+ * Example #2: When we move backward one page
+ * Example #3: And move backward one page
+ *
+ */
+When(/^(I |we )*move backward one page$/, async function (pronounCase) {
+  await this.page.goBack();
+});
+
+/**
+ * Reloads the current page.
+ *
+ * Example #1: When I reload
+ * Example #2: And I reload the page
+ * Example #3: And we reload page
+ * Example #4: And we reload the page
+ *
+ */
+When(/^(I |we )*reload( the)*( page)*$/, async function (pronounCase, theCase, pageCase) {
+  await this.page.reload();
+});
+
+// ---------------------------------------------------------------------------
+// URL / path assertions
+// ---------------------------------------------------------------------------
+
+/**
+ * Assert that the current page is or is not the homepage.
+ *
+ * Example #1: Then I should be on homepage
+ * Example #2: And I should be on the homepage
+ * Example #3: Then I should be on frontpage
+ * Example #4: And should be on the homepage
+ * Example #5: Then should be on homepage
+ * Example #6: And we should be on homepage
+ * Example #7: Then should be on frontpage
+ * Example #8: And we should be on the homepage
+ * Example #9: Then I should not be on homepage
+ * Example #10: And I should not be on the homepage
+ *
+ */
+Then(/^(I |we )*should( not)* be on( the)* (homepage|frontpage)$/, async function (pronounCase, notCase, theCase, pageCase) {
+  const currentUrl = this.page.url();
+  if (notCase) {
+    assert.ok(currentUrl !== this.launchUrl && !currentUrl.startsWith(this.launchUrl + '/'),
+      `Should NOT be on homepage but current URL is: ${currentUrl}`);
+  } else {
+    assert.ok(currentUrl.startsWith(this.launchUrl),
+      `Should be on homepage but current URL is: ${currentUrl}`);
+  }
+});
+
+/**
+ * Assert that the current path is or is not equal to the specified path.
+ *
+ * Example #1: Then I should be on "/"
+ * Example #2: And I should be on "/user/login"
+ * Example #3: And I should be on "https://un.org"
+ * Example #4: Then we should be on the "/" page
+ * Example #5: And we should be on "/user/login"
+ * Example #6: Then should be on the "/user/reset" page
+ * Example #7: Then I should not be on "/"
+ * Example #8: And I should not be on "/user/login"
+ * Example #9: And I should not be on "https://un.org"
+ * Example #10: And we should not be on the "https://un.org" page
+ *
+ */
+Then(/^(I |we )*should( not)* be on( the)* "([^"]*)?"( page)*$/, async function (pronounCase, notCase, theCase, url, pageCase) {
+  const currentUrl = this.page.url();
+  if (notCase) {
+    assert.ok(!currentUrl.includes(url), `URL should NOT contain "${url}" but it is: ${currentUrl}`);
+  } else {
+    assert.ok(currentUrl.includes(url), `URL should contain "${url}" but it is: ${currentUrl}`);
+  }
+});
+
+/**
+ * Assert that the current URL matches or does not match a regex pattern.
+ *
+ * Example #1: Then the url should match "/contact-us.html"
+ * Example #2: Then the url should not match "/contact-us.html"
+ * Example #3: And the url should match "^https://"
+ *
+ */
+Then(/^(the )*url should( not)* match "([^"]*)?"$/, async function (theCase, notCase, pattern) {
+  const currentUrl = this.page.url();
+  const regex = new RegExp(pattern);
+  if (notCase) {
+    assert.ok(!regex.test(currentUrl), `URL "${currentUrl}" should NOT match "${pattern}" but it does.`);
+  } else {
+    assert.ok(regex.test(currentUrl), `URL "${currentUrl}" should match "${pattern}" but it does not.`);
+  }
+});

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

@@ -0,0 +1,280 @@
+'use strict';
+
+const { friendly } = require('./varbase-e2e');
+
+// Network interception and mocking via Playwright's `page.route()` API.
+//
+// Lets BDD scenarios stub external dependencies, simulate slow / offline
+// conditions, and assert what the client actually requested — without
+// leaving the test runner. Patterns use Playwright glob matching: `**/path`,
+// `*.gif`, regex inside parentheses, etc.
+//
+// Order matters: register routes BEFORE the action that triggers the request.
+
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+function ensureRequestLog(world) {
+  if (world._requestLog) return;
+  world._requestLog = [];
+  world.page.on('request', (req) => {
+    world._requestLog.push({
+      url: req.url(),
+      method: req.method(),
+      resourceType: req.resourceType(),
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Stubbing
+// ---------------------------------------------------------------------------
+
+/**
+ * Stub a URL pattern with a JSON response body.
+ *
+ * Body is sent verbatim with `Content-Type: application/json` and HTTP 200.
+ *
+ * Example #1: Given the URL "**\/api/users" returns the JSON:
+ *               """
+ *               {"users": [{"id": 1, "name": "Alice"}]}
+ *               """
+ * Example #2: Given the URL "**\/api/me" returns the JSON:
+ *               """
+ *               {"id": 1, "name": "Alice", "role": "admin"}
+ *               """
+ * Example #3: Given the URL "**\/api/products?*" returns the JSON:
+ *               """
+ *               {"items": [], "total": 0}
+ *               """
+ * Example #4: Given the URL "https://api.stripe.com/v1/charges" returns the JSON:
+ *               """
+ *               {"id": "ch_test", "status": "succeeded"}
+ *               """
+ * Example #5: Given the URL "**\/api/feature-flags" returns the JSON:
+ *               """
+ *               {"darkMode": true, "betaUI": false}
+ *               """
+ *
+ */
+Given(/^the URL "([^"]*)" returns the JSON:$/, async function (urlPattern, body) {
+  try {
+    await this.page.route(urlPattern, async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body,
+      });
+    });
+  } catch (e) {
+    throw friendly({
+      action: `register a JSON stub for "${urlPattern}"`,
+      cause: e,
+      hint: `URL pattern uses glob syntax — try "**/api/users" or "*.png".`,
+    });
+  }
+});
+
+/**
+ * Stub a URL pattern with a status code and plain-text body.
+ *
+ * Example #1: Given the URL "**\/api/login" returns status 401 with body "Unauthorized"
+ * Example #2: Given the URL "**\/api/health" returns status 503
+ * Example #3: Given the URL "**\/api/users" returns status 500 with body "Database down"
+ * Example #4: Given the URL "**\/api/orders/*" returns status 404
+ * Example #5: Given the URL "**\/api/admin/*" returns status 403 with body "Forbidden"
+ *
+ */
+Given(/^the URL "([^"]*)" returns status (\d+)(?: with body "([^"]*)")?$/, async function (urlPattern, status, body) {
+  try {
+    await this.page.route(urlPattern, async (route) => {
+      await route.fulfill({ status: parseInt(status, 10), body: body || '' });
+    });
+  } catch (e) {
+    throw friendly({
+      action: `register a status-${status} stub for "${urlPattern}"`,
+      cause: e,
+      hint: `URL pattern uses glob syntax — try "**/api/users" or "*.png".`,
+    });
+  }
+});
+
+/**
+ * Block a URL pattern entirely (network failure simulation).
+ *
+ * Example #1: Given the URL "**\/analytics.js" is blocked
+ * Example #2: Given the URL "**\/google-analytics.com/**" is blocked
+ * Example #3: Given the URL "**\/sentry.io/**" is blocked
+ * Example #4: Given the URL "*.gif" is blocked
+ * Example #5: Given the URL "**\/api/tracking" is blocked
+ *
+ */
+Given(/^the URL "([^"]*)" is blocked$/, async function (urlPattern) {
+  try {
+    await this.page.route(urlPattern, (route) => route.abort());
+  } catch (e) {
+    throw friendly({
+      action: `block "${urlPattern}"`,
+      cause: e,
+      hint: `URL pattern uses glob syntax — try "**/analytics.js" or "*.gif".`,
+    });
+  }
+});
+
+/**
+ * Delay matching requests by N milliseconds (slow-network simulation).
+ *
+ * The request still completes against the real upstream — only its arrival
+ * time at the page is shifted. Useful for verifying loading-state UI.
+ *
+ * Example #1: Given the URL "**\/api/**" is delayed by 1500 ms
+ * Example #2: Given the URL "**\/api/users" is delayed by 3000 ms
+ * Example #3: Given the URL "**\/api/heavy-report" is delayed by 5000 ms
+ * Example #4: Given the URL "*.png" is delayed by 500 ms
+ * Example #5: Given the URL "**\/api/checkout" is delayed by 2000 ms
+ *
+ */
+Given(/^the URL "([^"]*)" is delayed by (\d+) ?ms$/, async function (urlPattern, delay) {
+  const ms = parseInt(delay, 10);
+  try {
+    await this.page.route(urlPattern, async (route) => {
+      await new Promise((r) => setTimeout(r, ms));
+      await route.continue();
+    });
+  } catch (e) {
+    throw friendly({
+      action: `delay "${urlPattern}" by ${ms} ms`,
+      cause: e,
+      hint: `URL pattern uses glob syntax — try "**/api/**" or "*.png".`,
+    });
+  }
+});
+
+/**
+ * Simulate offline mode for the rest of the scenario.
+ *
+ * Example #1: Given the network is offline
+ * Example #2: Given I am on the homepage
+ *               When the network is offline
+ *               And I follow "Refresh"
+ *               Then I should see "Offline"
+ * Example #3: When the network is offline
+ *               And I press "Sync"
+ *               Then I should see "Cannot reach server"
+ * Example #4: Given the network is offline
+ *               And I am on "/dashboard"
+ * Example #5: Given the network is offline
+ *               When I click "Reload"
+ *               Then "<.error-banner>" should be visible
+ *
+ */
+Given(/^the network is offline$/, async function () {
+  try { await this.context.setOffline(true); }
+  catch (e) { throw friendly({ action: 'switch the network offline', cause: e, hint: 'the browser context may have been closed; try a fresh scenario.' }); }
+});
+
+/**
+ * Restore network connectivity after `the network is offline`.
+ *
+ * Example #1: Given the network is online
+ * Example #2: When the network is offline
+ *               And I press "Sync"
+ *               Then I should see "Cannot reach server"
+ *               When the network is online
+ *               And I press "Retry"
+ *               Then I should see "Synced"
+ * Example #3: Given the network is online
+ *               And I am on the homepage
+ * Example #4: When the network is online
+ * Example #5: Given the network is online
+ *               When I follow "Reload"
+ *               Then I should see "Welcome"
+ *
+ */
+Given(/^the network is online$/, async function () {
+  try { await this.context.setOffline(false); }
+  catch (e) { throw friendly({ action: 'switch the network online', cause: e, hint: 'the browser context may have been closed; try a fresh scenario.' }); }
+});
+
+// ---------------------------------------------------------------------------
+// Request logging
+// ---------------------------------------------------------------------------
+
+/**
+ * Start recording every outgoing request for later assertion.
+ *
+ * Example #1: Given I start recording network requests
+ * Example #2: Given I start recording network requests
+ *               When I press "Buy now"
+ *               Then a POST request to "**\/api/checkout" should have been made
+ * Example #3: Given we start recording network requests
+ * Example #4: Given I start recording network requests
+ *               When I follow "Pricing"
+ *               Then no request to "**\/tracking" should have been made
+ * Example #5: Given I start recording network requests
+ *               When I scroll to the bottom
+ *               Then a GET request to "**\/api/feed/page=2" should have been made
+ *
+ */
+Given(/^(I |we )*start recording network requests$/, function () {
+  ensureRequestLog(this);
+});
+
+/**
+ * Assert at least one request matching a URL pattern was recorded.
+ *
+ * Patterns use simple `*` wildcards (regex internally).
+ *
+ * Example #1: Then a request to "**\/api/users" should have been made
+ * Example #2: Then a request to "**\/api/checkout" should have been made
+ * Example #3: Then a request to "**\/api/orders/*" should have been made
+ * Example #4: Then a request to "*.css" should have been made
+ * Example #5: Then a request to "https://api.example.com/**" should have been made
+ *
+ */
+Then(/^a request to "([^"]*)" should have been made$/, function (urlPattern) {
+  ensureRequestLog(this);
+  let re;
+  try { re = new RegExp(urlPattern.replace(/\*/g, '.*')); }
+  catch (e) { throw friendly({ action: `match URL pattern "${urlPattern}"`, cause: e, hint: "URL pattern must be a valid regex or glob; check for unmatched brackets." }); }
+  const found = this._requestLog.some((r) => re.test(r.url));
+  assert.ok(found, `Expected at least one request matching "${urlPattern}".`);
+});
+
+/**
+ * Assert at least one HTTP-method-specific request was recorded.
+ *
+ * Example #1: Then a GET request to "**\/api/users" should have been made
+ * Example #2: Then a POST request to "**\/api/login" should have been made
+ * Example #3: Then a PUT request to "**\/api/users/1" should have been made
+ * Example #4: Then a PATCH request to "**\/api/orders/*" should have been made
+ * Example #5: Then a DELETE request to "**\/api/cart/items/*" should have been made
+ *
+ */
+Then(/^a (GET|POST|PUT|PATCH|DELETE) request to "([^"]*)" should have been made$/, function (method, urlPattern) {
+  ensureRequestLog(this);
+  let re;
+  try { re = new RegExp(urlPattern.replace(/\*/g, '.*')); }
+  catch (e) { throw friendly({ action: `match URL pattern "${urlPattern}"`, cause: e, hint: "URL pattern must be a valid regex or glob; check for unmatched brackets." }); }
+  const found = this._requestLog.some((r) => r.method === method && re.test(r.url));
+  assert.ok(found, `Expected at least one ${method} request matching "${urlPattern}".`);
+});
+
+/**
+ * Assert NO request matching a URL pattern was recorded.
+ *
+ * Example #1: Then no request to "**\/tracking" should have been made
+ * Example #2: Then no request to "**\/google-analytics.com/**" should have been made
+ * Example #3: Then no request to "**\/api/admin/**" should have been made
+ * Example #4: Then no request to "*.gif" should have been made
+ * Example #5: Then no request to "**\/api/v1/legacy/**" should have been made
+ *
+ */
+Then(/^no request to "([^"]*)" should have been made$/, function (urlPattern) {
+  ensureRequestLog(this);
+  let re;
+  try { re = new RegExp(urlPattern.replace(/\*/g, '.*')); }
+  catch (e) { throw friendly({ action: `match URL pattern "${urlPattern}"`, cause: e, hint: "URL pattern must be a valid regex or glob; check for unmatched brackets." }); }
+  const found = this._requestLog.some((r) => re.test(r.url));
+  assert.ok(!found, `Did not expect any request matching "${urlPattern}".`);
+});

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

@@ -0,0 +1,141 @@
+'use strict';
+
+// URL path and query parameter assertions, basic auth, history navigation.
+
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+function currentUrl(page) { return new URL(page.url()); }
+
+/**
+ * Assert the current URL pathname equals an expected string (no query/fragment).
+ *
+ * Example #1: Then the path should be "/dashboard"
+ * Example #2: Then the path should be "/about"
+ * Example #3: And the path should be "/checkout/step-2"
+ * Example #4: Then the path should be "/admin/users"
+ * Example #5: Then the path should be "/"
+ *
+ */
+Then('the path should be {string}', async function (path) {
+  assert.strictEqual(currentUrl(this.page).pathname, path);
+});
+
+/**
+ * Assert the current URL pathname is NOT equal to an expected string.
+ *
+ * Example #1: Then the path should not be "/login"
+ * Example #2: Then the path should not be "/error"
+ * Example #3: And the path should not be "/admin"
+ * Example #4: Then the path should not be "/maintenance"
+ * Example #5: Then the path should not be "/forbidden"
+ *
+ */
+Then('the path should not be {string}', async function (path) {
+  assert.notStrictEqual(currentUrl(this.page).pathname, path);
+});
+
+/**
+ * Assert the current URL has the named query parameter (any value).
+ *
+ * Example #1: Then current url should have the "lang" parameter
+ * Example #2: Then current url should have the "page" parameter
+ * Example #3: And current url should have the "q" parameter
+ * Example #4: Then current url should have the "ref" parameter
+ * Example #5: Then current url should have the "sort" parameter
+ *
+ */
+Then('current url should have the {string} parameter', async function (param) {
+  const u = currentUrl(this.page);
+  assert.ok(u.searchParams.has(param), `Query param "${param}" not present in ${u.href}.`);
+});
+
+/**
+ * Assert the current URL has the named query parameter with the exact value.
+ *
+ * Example #1: Then current url should have the "lang" parameter with the "en" value
+ * Example #2: Then current url should have the "page" parameter with the "2" value
+ * Example #3: And current url should have the "sort" parameter with the "price" value
+ * Example #4: Then current url should have the "ref" parameter with the "newsletter" value
+ * Example #5: Then current url should have the "q" parameter with the "laptops" value
+ *
+ */
+Then('current url should have the {string} parameter with the {string} value', async function (param, value) {
+  const u = currentUrl(this.page);
+  assert.strictEqual(u.searchParams.get(param), value);
+});
+
+/**
+ * Assert the current URL does NOT carry the named query parameter.
+ *
+ * Example #1: Then current url should not have the "missing" parameter
+ * Example #2: Then current url should not have the "debug" parameter
+ * Example #3: And current url should not have the "preview" parameter
+ * Example #4: Then current url should not have the "force" parameter
+ * Example #5: Then current url should not have the "test" parameter
+ *
+ */
+Then('current url should not have the {string} parameter', async function (param) {
+  const u = currentUrl(this.page);
+  assert.ok(!u.searchParams.has(param), `Query param "${param}" should not be present.`);
+});
+
+/**
+ * Assert the current URL does NOT carry a parameter+value pair.
+ *
+ * Example #1: Then current url should not have the "lang" parameter with the "fr" value
+ * Example #2: Then current url should not have the "page" parameter with the "100" value
+ * Example #3: And current url should not have the "sort" parameter with the "old" value
+ * Example #4: Then current url should not have the "preview" parameter with the "1" value
+ * Example #5: Then current url should not have the "debug" parameter with the "true" value
+ *
+ */
+Then('current url should not have the {string} parameter with the {string} value', async function (param, value) {
+  const u = currentUrl(this.page);
+  assert.notStrictEqual(u.searchParams.get(param), value);
+});
+
+/**
+ * Re-open the browser context with HTTP basic-auth credentials.
+ *
+ * Example #1: Given the basic authentication with the username "admin" and the password "secret"
+ * Example #2: Given the basic authentication with the username "guest" and the password "guest"
+ * Example #3: And the basic authentication with the username "alice" and the password "s3cret"
+ * Example #4: Given the basic authentication with the username "ci" and the password "ci-token-123"
+ * Example #5: Given the basic authentication with the username "tester" and the password ""
+ *
+ */
+Given('the basic authentication with the username {string} and the password {string}', async function (user, pass) {
+  // Replace context with one that has HTTP basic auth credentials.
+  await this.context.close();
+  const playwright = require('playwright');
+  const playwrightConfig = require(require('path').join(process.cwd(), 'playwright.config'));
+  this.context = await this.playwrightBrowser.newContext({
+    ...playwrightConfig.contextOptions,
+    httpCredentials: { username: user, password: pass },
+  });
+  this.page = await this.context.newPage();
+});
+
+/**
+ * Navigate one step back in the browser history.
+ *
+ * Equivalent to clicking the browser back button. Throws no error if there
+ * is no history (returns null from `page.goBack()`).
+ *
+ * Example #1: When I go back
+ * Example #2: When I follow "About"
+ *               And I go back
+ *               Then I should be on the homepage
+ * Example #3: And I go back
+ * Example #4: When I am on "/cart"
+ *               When I am on "/checkout"
+ *               And I go back
+ *               Then I should be on "/cart"
+ * Example #5: When I go back
+ *               And I wait until the URL contains "/products"
+ *
+ */
+When(/^(I |we )*go back$/, async function (pronoun) {
+  await this.page.goBack();
+});