@uuv/playwright 2.10.0 → 2.11.0

package/src/cucumber/step_definitions/playwright/generated/_en-generated-cucumber-steps-definition.ts

@@ -23,19 +23,20 @@ import { devices, expect } from "@playwright/test";
 import { Page, Locator } from "playwright";
 import { DataTable } from "@cucumber/cucumber";
 import {
-  addCookieWhenValueIsList,
-  COOKIE_NAME, deleteCookieByName,
-  deleteCookieByValue,
-  FILTER_TYPE,
-  findWithRoleAndName,
-  findWithRoleAndNameAndContent,
-  findWithRoleAndNameAndContentDisable,
-  findWithRoleAndNameAndContentEnable,
-  getCookie,
-  getPageOrElement,
-  MockType,
-  notFoundWithRoleAndName,
-  withinRoleAndName
+    addCookieWhenValueIsList,
+    COOKIE_NAME, deleteCookieByName,
+    deleteCookieByValue,
+    FILTER_TYPE,
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameFocused,
+    getCookie,
+    getPageOrElement,
+    MockType,
+    notFoundWithRoleAndName,
+    withinRoleAndName
 } from "../core-engine";
 
 import { Given, When, Then } from "@cucumber/cucumber";
@@ -43,10 +44,16 @@ import { World } from "../../../preprocessor/run/world";
 import { ContextObject, RunOptions } from "axe-core";
 import path from "path";
 
+/**
+ * Sets the viewport dimensions with one of the presets defined by your runtime engine as Cypress: [Link](https://docs.cypress.io/api/commands/viewport#Arguments) or Playwright: [Link](https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json)
+ * */
 Given(`I set viewport to preset {string}`, async function(this: World, viewportPreset: string) {
   await this.page.setViewportSize(devices[viewportPreset].viewport);
 });
 
+/**
+ * Sets the viewport dimensions to the specified width and length
+ * */
 Given(
  `I set viewport with width {int} and height {int}`, async function
  (this: World, width: number, height: number) {
@@ -54,79 +61,148 @@ Given(
  }
 );
 
+/**
+ * Start a keyboard navigation session from the top of the page
+ * */
+Given(
+    `I start a keyboard navigation from the top of the page`,
+    async function(this: World) {
+        await this.page.mouse.click(0.5, 0.5);
+        await this.page.keyboard.press("Tab");
+    }
+);
+
+/**
+ * Navigate to the Uri passed as a argument (full url consisting of the BASE_URL + Uri) or navigate to Url if begin with http:// or https://
+ * */
 Given(`I visit path {string}`, { timeout: 60 * 1000 }, async function(this: World, siteUrl: string) {
   await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
   await this.page.goto(`${siteUrl}`);
 });
 
+/**
+ * Triggers a click on the selected element.<br/>Make sure you've selected an element beforehand with the <strong>within...</strong> phrases.
+ * */
 When(`I click`, async function(this: World) {
-  await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
+    const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
+    if ((await keyBoardFocusTargetObj.count()) === 1) {
+        await keyBoardFocusTargetObj.click({ timeout: DEFAULT_TIMEOUT });
+    } else {
+        await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
+    }
 });
 
-
+/**
+ * Triggers a click on the given button with specific name
+ * */
 When(`I click on button named {string}`, async function(this: World, name: string) {
   await click(this, "button", name);
 });
 
+/**
+ * Triggers a click on the element with given role and specific name
+ * */
 When(`I click on element with role {string} and name {string}`, async function(this: World, role: string, name: string) {
   await click(this, role, name);
 });
 
 // TODO : permet de gérer les label accessibles donc pas que les aria : https://playwright.dev/docs/api/class-locator#locator-get-by-label
+/**
+ * Selects the element whose aria-label is specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within the element with aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
   const sanitizedExpectedAriaLabel = encodeURIComponent(expectedAriaLabel).replaceAll("%20", " ");
   await getPageOrElement(this).then((element) => expect(element.getByLabel(sanitizedExpectedAriaLabel, { exact: true })).toHaveCount(1));
   await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: sanitizedExpectedAriaLabel });
 });
+
+/**
+ * Deletes selected element and timeout
+ * */
 When(`I reset context`, async function(this: World) {
   await this.context.clearCookies();
 });
 
+/**
+ * Selects the element whose selector is specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within the element with selector {string}`, async function(this: World, selector: string) {
   await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
   await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR, value: selector });
 });
 
+/**
+ * Writes the sentence passed as a parameter (useful for example to fill in a form field).<br/>Make sure you've selected an element beforehand with the <strong>within...</strong> phrases.
+ * */
 When(`I type the sentence {string}`, async function(this: World, textToType: string) {
-  await getPageOrElement(this).then(async (element: Locator) => {
-    await element.focus({ timeout: 10000 });
-    await element.type(textToType);
-    // console.debug(await showAttributesInLocator(element));
-  });
+    const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
+    if ((await keyBoardFocusTargetObj.count()) === 1) {
+        await keyBoardFocusTargetObj.type(textToType);
+    } else {
+        await getPageOrElement(this).then(async (element: Locator) => {
+            // console.debug(element);
+            await element.focus({ timeout: 10000 });
+            await element.type(textToType);
+        });
+    }
 });
 
-
+/**
+ * Press specified key multiple times using | as: num|{key}
+ * */
 When(`I press {int} times on {string}`, async function(this: World, nbTimes: number, key: string) {
   for (let i = 1; i <= nbTimes; i++) {
-    await getPageOrElement(this).then(async (element: Locator) => {
-      await element.focus({ timeout: 10000 });
-      await pressKey(this, element, key);
-    });
+    await pressKey(this, key);
   }
 });
 
+/**
+ * Press specified key: <table><thead><tr><th>Key</th><th>Description</th></tr></thead><tbody><tr><td>{tab}</td><td>Tabulation</td></tr><tr><td>{reverseTab}</td><td>Reverse tabulation</td></tr><tr><td>{down}</td><td>Arrow Down</td></tr><tr><td>{right}</td><td>Arrow Right</td></tr><tr><td>{left}</td><td>Arrow Left</td></tr><tr><td>{up}</td><td>Arrow Up</td></tr></tbody></table><br/>Make sure you've selected an element beforehand with the <strong>within...</strong> phrases.
+ * */
 When(`I press {string}`, async function(this: World, key: string) {
-  await getPageOrElement(this).then(async (element: Locator) => {
-    await element.focus({ timeout: 10000 });
-    await pressKey(this, element, key);
-  });
+    await pressKey(this, key);
+});
+
+/**
+ * Move to the previous html element that can be reached with back Tab
+ * */
+When(`I go to previous keyboard element`, async function(this: World) {
+    await this.page.keyboard.press("ShiftLeft+Tab");
+});
+
+/**
+ * Move to the next html element that can be reached with Tab
+ * */
+When(`I go to next keyboard element`, async function(this: World) {
+    await this.page.keyboard.press("Tab");
 });
+
+/**
+ * Sets the timeout value (in millisecond) for finding element in the DOM <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`I set timeout with value {int}`, async function(this: World, newTimeout: number) {
   await this.testInfo.setTimeout(newTimeout);
 });
 
-
+/**
+ * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within the element with role {string} and name {string}`, async function(this: World, role: string, name: string) {
   await withinRoleAndName(this, role, name);
 });
 
+/**
+ * Selects the element whose data-testId attribute is specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
+ * */
 When(`within the element with testId {string}`, async function(this: World, testId: string) {
   testId = encodeURIComponent(testId);
   await getPageOrElement(this).then(async (element) => await expect(element.getByTestId(testId)).toHaveCount(1));
   await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.TEST_ID, value: testId });
 });
 
-
+/**
+ * Mock a named API response with body. <i>If you use Playwright as runtime engine, <b>request</b> and <b>named</b> are unused.</i>
+ * */
 When(
  `I mock a request {} on url {string} named {string} with content {}`,
  async function(this: World, verb: string, url: string, name: string, body: any) {
@@ -138,6 +214,9 @@ When(
  }
 );
 
+/**
+ * Mock a named API response with status code
+ * */
 When(
  `I mock a request {} on url {string} named {string} with status code {int}`,
  async function(this: World, verb: string, url: string, name: string, statusCode: number) {
@@ -148,6 +227,9 @@ When(
  }
 );
 
+/**
+ * Mock a named API response with file's extension .json, .js, .coffee, .html, .txt, .csv, .png, .jpg, .jpeg, .gif, .tif, .tiff, .zip
+ * */
 When(
  `I mock a request {} on url {string} named {string} with fixture {}`,
  async function(this: World, verb: string, url: string, name: string, fixture: any) {
@@ -159,10 +241,16 @@ When(
  }
 );
 
+/**
+ * Checks that an Html element exists with the specified selector
+ * */
 Then(`I should see an element with selector {string}`, async function(this: World, selector: string) {
   await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
 });
 
+/**
+ * Sets one or more headers to the indicated http request and only for the Http method (GET / POST / etc...) passed as a argument.<i> If you use Playwright as execution engine, <b>method</b> isn't used.</i>
+ * */
 When(
  `I set header(s) for uri {string} and method {string}`,
  async function(this: World, url: string, method: string, headersToSet: DataTable) {
@@ -173,6 +261,9 @@ When(
  }
 );
 
+/**
+ * Sets one or more headers to the indicated http request
+ * */
 When(
  `I set header(s) for uri {string}`,
  async function(this: World, url: string, headersToSet: DataTable) {
@@ -183,29 +274,47 @@ When(
  }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(`I should see an element with role {string} and name {string}`, async function(this: World, role: string, name: string) {
   await findWithRoleAndName(this, role, name);
 });
 
+/**
+ * Checks that an Html element exists with the specified content
+ * */
 Then(`I should see an element with content {string}`, async function(this: World, textContent: string) {
   // TODO partie pris de faire en exactitude. A voir si on doit faire 2 phrases https://playwright.dev/docs/api/class-locator#locator-get-by-text
   await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(1));
 });
 
+/**
+ * Checks that an Html element does not exists with the specified content
+ * */
 Then(`I should not see an element with content {string}`, async function(this: World, textContent: string) {
   await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(0));
 });
 
+/**
+ * Checks that an Html element exists with the specified data-testid attribute
+ * */
 Then(`I should see an element with testId {string}`, async function(this: World, testId: string) {
   testId = encodeURIComponent(testId);
   await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(1));
 });
 
+/**
+ * Checks that an Html element does not exists with the specified data-testid attribute
+ * */
 Then(`I should not see an element with testId {string}`, async function(this: World, testId: string) {
   testId = encodeURIComponent(testId);
   await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(0));
 });
 
+/**
+ * Check that the current page have no accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md)
+ * */
 Then(
  `I should not have any axe-core accessibility issue`,
  async function(this: World) {
@@ -213,6 +322,9 @@ Then(
    await checkA11y(this.page as Page);
  });
 
+/**
+ * Check that the current page have no accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md) [with an option](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#options-parameter)
+ * */
 Then(
      `I should not have any axe-core accessibility issue with option json fixture {}`,
  async function(this: World, option: any) {
@@ -229,6 +341,9 @@ function getConfigDir(): string {
     return process.env["CONFIG_DIR"] ? process.env["CONFIG_DIR"] : "";
 }
 
+/**
+ * Check that the current page have no accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md) [with an option](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#options-parameter) on the specific [context](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#context-parameter)
+ * */
 Then(
  `I should not have any axe-core accessibility issue with context json fixture {} and option json fixture {}`,
  async function(this: World, context: any, option: any) {
@@ -241,6 +356,9 @@ Then(
    });
  });
 
+/**
+ * Check that the current page have not critical accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md)
+ * */
 Then(
  `I should not have any axe-core critical accessibility issue`,
  async function(this: World) {
@@ -250,6 +368,9 @@ Then(
    });
  });
 
+/**
+ * Check that the current page have not accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md) with one or more impacts in: 'minor','moderate','serious','critical'
+ * */
 Then(
  `I should not have any axe-core accessibility issue with {} impact(s)`,
  async function(this: World, impacts: any) {
@@ -258,6 +379,10 @@ Then(
      includedImpacts: [impacts]
    });
  });
+
+/**
+ * Check that the current page have not accessibility issue for [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md) [with one or more Accessibility Standards](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#axe-core-tags)
+ * */
 Then(
  `I should not have any axe-core accessibility issue with accessibility standard(s) {}`,
  async function(this: World, tags: any) {
@@ -272,12 +397,19 @@ Then(
    });
  });
 
+/**
+ * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
+ * */
 Then(
  `I should not see an element with role {string} and name {string}`,
  async function(this: World, role: string, name: string) {
    await notFoundWithRoleAndName(this, role, name);
  }
 );
+
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
+ * */
 Then(
  `I should see an element with role {string} and name {string} and content {string}`,
  async function(this: World, expectedRole: string, name: string, expectedTextContent: string) {
@@ -285,6 +417,19 @@ Then(
  }
 );
 
+/**
+ * Checks that the Html element with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/) is focused
+ * */
+Then(
+    `the element with role {string} and name {string} should be keyboard focused`,
+    async function(this: World, expectedRole: string, name: string) {
+        await findWithRoleAndNameFocused(this, expectedRole, name);
+    }
+);
+
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
+ * */
 Then(
  `I should see an element with role {string} and name {string} and content {string} disabled`,
  async function(this: World, expectedRole: string, name: string, expectedTextContent: string) {
@@ -292,6 +437,9 @@ Then(
  }
 );
 
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
+ * */
 Then(
  `I should see an element with role {string} and name {string} and content {string} not disabled`,
  async function(this: World, expectedRole: string, name: string, expectedTextContent: string) {
@@ -299,16 +447,25 @@ Then(
  }
 );
 
+/**
+ * Checks that an Html element exists with the specified aria-label attribute
+ * */
 Then(`I should see an element with aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
   expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
   await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel, { exact: true })).toHaveCount(1));
 });
 
+/**
+ * Checks that an Html element does not exists with the specified aria-label attribute
+ * */
 Then(`I should not see an element with aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
   expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
   await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel, { exact: true })).toHaveCount(0));
 });
 
+/**
+ * Checks that an Html element exists with the specified aria-label attribute and content
+ * */
 Then(`I should see an element with aria-label {string} and content {string}`, async function(this: World, expectedAriaLabel: string, expectedTextContent: string) {
   expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
   await getPageOrElement(this).then(async (element) => {
@@ -318,6 +475,9 @@ Then(`I should see an element with aria-label {string} and content {string}`, as
   });
 });
 
+/**
+ * Wait that a named mock has been consumed until timeout
+ * */
 Then(`I should consume a mock named {string}`, async function(this: World, name: string) {
   const cookie = await getCookie(this, COOKIE_NAME.MOCK_URL);
   const mockUrls: MockType[] = JSON.parse(cookie.value);
@@ -328,11 +488,17 @@ Then(`I should consume a mock named {string}`, async function(this: World, name:
   await deleteCookieByValue(this, COOKIE_NAME.MOCK_URL, mockUrl);
   // console.debug("request: ", request);
 });
-//
+
+/**
+ * Wait milliseconds. <b>Warning:</b> use this sentence <b>in production</b> can make your <b>test flaky</b>.
+ * */
 Then(`I wait {int} ms`, async function(this: World, ms: number) {
   await this.page.waitForTimeout(ms);
 });
 
+/**
+ * Checks Html attributes of the selected element
+ * */
 Then(
  `I should see these attributes with values`,
  async function(this: World, expectedAttributeList: DataTable) {
@@ -348,6 +514,9 @@ Then(
  }
 );
 
+/**
+ * Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) containing list items.<br/> <u>Example</u>\n```gherkin\nThen I should see a list named "test-list" and containing\n| First element   |\n| Second element  |\n| Third element   |\n```
+ * */
 Then(
  `I should see a list named {string} and containing`,
  async function(this: World, expectedListName: string, expectedElementsOfList: DataTable) {
@@ -367,32 +536,32 @@ Then(
  }
 );
 
-async function pressKey(world: World, element: Locator, key: string) {
-  switch (key) {
-    case KEY_PRESS.TAB:
-      await element.press("Tab");
-      break;
-    case KEY_PRESS.REVERSE_TAB:
-      await element.press("ShiftLeft+Tab");
-      break;
-    case KEY_PRESS.UP:
-      await element.press("ArrowUp");
-      break;
-    case KEY_PRESS.DOWN:
-      await element.press("ArrowDown");
-      break;
-    case KEY_PRESS.LEFT:
-      await element.press("ArrowLeft");
-      break;
-    case KEY_PRESS.RIGHT:
-      await element.press("ArrowRight");
-      break;
-    default:
-      console.error("the command" + key + " is unrecognized.");
-      break;
-  }
-  await deleteCookieByName(world, COOKIE_NAME.SELECTED_ELEMENT);
-  await addCookieWhenValueIsList(world, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR_PARENT, value: "*:focus" });
+async function pressKey(world: World, key: string) {
+    switch (key) {
+        case KEY_PRESS.TAB:
+            await world.page.keyboard.press("Tab");
+            break;
+        case KEY_PRESS.REVERSE_TAB:
+            await world.page.keyboard.press("ShiftLeft+Tab");
+            break;
+        case KEY_PRESS.UP:
+            await world.page.keyboard.press("ArrowUp");
+            break;
+        case KEY_PRESS.DOWN:
+            await world.page.keyboard.press("ArrowDown");
+            break;
+        case KEY_PRESS.LEFT:
+            await world.page.keyboard.press("ArrowLeft");
+            break;
+        case KEY_PRESS.RIGHT:
+            await world.page.keyboard.press("ArrowRight");
+            break;
+        default:
+            console.error("the command" + key + " is unrecognized.");
+            break;
+    }
+    await deleteCookieByName(world, COOKIE_NAME.SELECTED_ELEMENT);
+    await addCookieWhenValueIsList(world, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR_PARENT, value: "*:focus" });
 }
 
 async function click(world: World, role: any, name: string) {
@@ -404,4 +573,6 @@ async function click(world: World, role: any, name: string) {
   });
 }
 
-
+function keyBoardFocusTarget(world: World) {
+    return world.page.locator(":focus");
+}