@uuv/cypress 2.1.0 → 2.2.0

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

@@ -24,13 +24,19 @@ import { Method } from "cypress/types/net-stubbing";
 import { KEY_PRESS } from "@uuv/runner-commons";
 
 import {
-  assertTextContent,
-  findWithRoleAndName,
-  findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
-  notFoundWithRoleAndName,
-  withinRoleAndName
+    assertTextContent,
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
 } from "../core-engine";
+import { A11yReferenceEnum } from "@uuv/a11y";
 
+/**
+ * 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://
+ * */
 When(`I visit path {string}`, function(siteUrl: string) {
   if (siteUrl.match("^http:\\/\\/|https:\\/\\/")) {
     return cy.visit(`${siteUrl}`);
@@ -38,20 +44,32 @@ When(`I visit path {string}`, function(siteUrl: string) {
   return cy.visit(`${Cypress.config().baseUrl}${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`, function() {
   cy.uuvCheckContextFocusedElement().then(context => {
     context.focusedElement!.click();
   });
 });
 
+/**
+ * Triggers a click on the given button with specific name
+ * */
 When(`I click on button named {string}`, function(name: string) {
   click("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}`, function(role: string, name: string) {
   click(role, name);
 });
 
+/**
+ * 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}`, function(textToType: string) {
   cy.uuvCheckContextFocusedElement().then((context) => {
     context.focusedElement!.focus();
@@ -59,6 +77,9 @@ When(`I type the sentence {string}`, function(textToType: string) {
   });
 });
 
+/**
+ * Press specified key multiple times using | as: num|{key}
+ * */
 When(`I press {int} times on {string}`, function(nbTimes: number, key: string) {
   for (let i = 1; i <= nbTimes; i++) {
     cy.uuvCheckContextFocusedElement().then((context) => {
@@ -68,6 +89,9 @@ When(`I press {int} times on {string}`, function(nbTimes: number, key: string) {
   }
 });
 
+/**
+ * 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}`, function(key: string) {
   cy.uuvCheckContextFocusedElement().then((context) => {
     context.focusedElement!.focus();
@@ -79,10 +103,16 @@ When(`I press {string}`, function(key: string) {
 // Context ACTIONS
 ////////////////////////////////////////////
 
+/**
+ * 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}`, function(viewportPreset: string) {
   return cy.viewport(viewportPreset as Cypress.ViewportPreset);
 });
 
+/**
+ * Sets the viewport dimensions to the specified width and length
+ * */
 Given(
  `I set viewport with width {int} and height {int}`,
  function(width: number, height: number) {
@@ -90,16 +120,25 @@ Given(
  }
 );
 
+/**
+ * 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}`, function(newTimeout: number) {
   return cy.uuvPatchContext({
     timeout: newTimeout
   });
 });
 
+/**
+ * key.when.withinElement.description
+ * */
 When(`within the element with role {string} and name {string}`, function(role: string, name: string) {
   return withinRoleAndName(role, name);
 });
 
+/**
+ * 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}`, function(expectedAriaLabel: string) {
   const foundedElement = cy.uuvFindByLabelText(expectedAriaLabel, {})
    .uuvFoundedElement()
@@ -110,6 +149,9 @@ When(`within the element with aria-label {string}`, function(expectedAriaLabel:
   });
 });
 
+/**
+ * key.when.withinElement.description
+ * */
 When(`within the element with testId {string}`, function(testId: string) {
   const foundedElement = cy.uuvFindByTestId(testId)
    .uuvFoundedElement()
@@ -120,6 +162,9 @@ When(`within the element with testId {string}`, function(testId: string) {
   });
 });
 
+/**
+ * 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}`, function(selector: string) {
   const foundedElement = cy.uuvGetContext().then(context => {
     const parentElement = context.focusedElement;
@@ -139,10 +184,16 @@ When(`within the element with selector {string}`, function(selector: string) {
   });
 });
 
+/**
+ * Deletes selected element and timeout
+ * */
 When(`I reset context`, function() {
   return cy.wrap(new Context()).as("context");
 });
 
+/**
+ * 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 {}`,
  function(verb: Method, uri: string, name: string, body: any) {
@@ -154,6 +205,9 @@ When(
  }
 );
 
+/**
+ * Mock a named API response with status code
+ * */
 When(
  `I mock a request {} on url {string} named {string} with status code {int}`,
  function(verb: Method, uri: string, name: string, statusCode: number) {
@@ -165,6 +219,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 {}`,
  function(verb: Method, uri: string, name: string, fixture: any) {
@@ -179,6 +236,9 @@ When(
 ////////////////////////////////////////////
 // INTERCEPTION
 ////////////////////////////////////////////
+/**
+ * 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}`,
  function(url: string, method: string, headersToSet: DataTable) {
@@ -192,6 +252,9 @@ When(
  }
 );
 
+/**
+ * Sets one or more headers to the indicated http request
+ * */
 When(`I set header(s) for uri {string}`, function(url: string, headersToSet: DataTable) {
   cy.intercept(url, (req) => {
     req.headers = {
@@ -207,34 +270,49 @@ When(`I set header(s) for uri {string}`, function(url: string, headersToSet: Dat
 ////////////////////////////////////////////
 
 /**
- * Look for an element based on its content
- */
+ * Checks that an Html element exists with the specified content
+ * */
 Then(`I should see an element with content {string}`, async function(textContent: string) {
   cy.uuvFindByText(textContent, {})
    .uuvFoundedElement()
    .should("exist");
 });
 
+/**
+ * Checks that an Html element does not exists with the specified content
+ * */
 Then(`I should not see an element with content {string}`, async function(textContent: string) {
   cy.uuvFindByText(textContent, {})
    .should("not.exist");
 });
 
+/**
+ * Checks that an Html element exists with the specified data-testid attribute
+ * */
 Then(`I should see an element with testId {string}`, async function(testId: string) {
   cy.uuvFindByTestId(testId)
    .uuvFoundedElement()
    .should("exist");
 });
 
+/**
+ * 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(testId: string) {
   cy.uuvFindByTestId(testId)
    .should("not.exist");
 });
 
+/**
+ * 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(role: string, name: string) {
   findWithRoleAndName(role, name);
 });
 
+/**
+ * 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(role: string, name: string) {
@@ -242,6 +320,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
+ * */
 Then(
  `I should see an element with role {string} and name {string} and content {string}`,
  async function(expectedRole: string, name: string, expectedTextContent: string) {
@@ -249,6 +330,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 true
+ * */
 Then(
  `I should see an element with role {string} and name {string} and content {string} disabled`,
  async function(expectedRole: string, name: string, expectedTextContent: string) {
@@ -256,6 +340,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(expectedRole: string, name: string, expectedTextContent: string) {
@@ -263,17 +350,26 @@ 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(expectedAriaLabel: string) {
   cy.uuvFindByLabelText(expectedAriaLabel, {})
    .uuvFoundedElement()
    .should("exist");
 });
 
+/**
+ * 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(expectedAriaLabel: string) {
   cy.uuvFindByLabelText(expectedAriaLabel, {})
    .should("not.exist");
 });
 
+/**
+ * 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(expectedAriaLabel: string, expectedTextContent: string) {
@@ -287,14 +383,23 @@ Then(
  }
 );
 
+/**
+ * Wait that a named mock has been consumed until timeout
+ * */
 Then(`I should consume a mock named {string}`, async function(name: string) {
   cy.wait([`@${name}`]);
 });
 
+/**
+ * key.when.click.withContext.description
+ * */
 Then(`I wait {int} ms`, async function(ms: number) {
   cy.wait(ms);
 });
 
+/**
+ * Checks that there is a list with the specified [name](https://russmaxdesign.github.io/html-elements-names/) and content.<br/> See this <a href='https://github.com/Orange-OpenSource/uuv/blob/9e3c9914420c6d527f7ad8b0017a0f8e26250f86/example/weather-app.feature#L17'>example</a>
+ * */
 Then(
  `I should see elements of the list with name {string}`,
  async function(expectedListName: string, expectedElementsOfList: DataTable) {
@@ -311,13 +416,16 @@ Then(
         assert.deepEqual(
          foundedElement,
          expectedElementsOfList.raw(),
-         `expected [${expectedElementsOfList.raw()}] to be [${foundedElement}]`
+         `expected [${foundedElement}] to be [${expectedElementsOfList.raw()}]`
         );
       });
     });
  }
 );
 
+/**
+ * Checks Html attributes of the selected element
+ * */
 Then(
  `I should see these attributes with values`,
  async function(expectedAttributeList: DataTable) {
@@ -334,20 +442,28 @@ Then(
  }
 );
 
+/**
+ * Checks that an Html element exists with the specified selector
+ * */
 Then(`I should see an element with selector {string}`, async function(selector: string) {
   cy.get(selector).should("exist");
 });
 
-
+/**
+ * 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 accessibility issue`,
+ `I should not have any axe-core accessibility issue`,
  async function() {
    cy.injectAxe();
    cy.checkA11y();
  });
 
+/**
+ * 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 critical accessibility issue`,
+ `I should not have any axe-core critical accessibility issue`,
  async function() {
    cy.injectAxe();
    cy.checkA11y(undefined, {
@@ -355,8 +471,11 @@ 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 accessibility issue with {} impact(s)`,
+ `I should not have any axe-core accessibility issue with {} impact(s)`,
  async function(impacts: any) {
    cy.injectAxe();
    cy.checkA11y(undefined, {
@@ -364,8 +483,11 @@ 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 Accessibility Standards](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#axe-core-tags)
+ * */
 Then(
- `I should not have any accessibility issue with accessibility standard(s) {}`,
+ `I should not have any axe-core accessibility issue with accessibility standard(s) {}`,
  async function(tags: any) {
    cy.injectAxe();
    cy.checkA11y(undefined, {
@@ -376,8 +498,11 @@ Then(
    });
  });
 
+/**
+ * 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 accessibility issue with context json fixture {} and option json fixture {}`,
+ `I should not have any axe-core accessibility issue with context json fixture {} and option json fixture {}`,
  async function(context: any, option: any) {
    cy.injectAxe();
    cy.fixture(context).then(context => {
@@ -387,8 +512,11 @@ Then(
    });
  });
 
+/**
+ * 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 accessibility issue with option json fixture {}`,
+ `I should not have any axe-core accessibility issue with option json fixture {}`,
  async function(option: any) {
    cy.injectAxe();
    cy.fixture(option).then(data => {
@@ -396,6 +524,53 @@ Then(
    });
  });
 
+
+/**
+ * Check that the current page have no [accessibility issue](https://accessibilite.numerique.gouv.fr/methode/criteres-et-tests/) with one of reference : RGAA
+ * */
+Then(
+ `I should not have any rgaa accessibility issue`,
+ async function() {
+     cy.injectUvvA11y();
+     cy.checkUvvA11y(A11yReferenceEnum.RGAA);
+    // const versionAlix = "5.2.1";
+    // cy.url().then(async (url) => {
+        // const rgaaChecker = new RgaaChecker(url);
+        // return rgaaChecker.validate()
+        //     .pipe(
+        //         tap((result: A11yResult) => {
+        //             result.ruleResults.forEach(ruleResult => {
+        //                 logValidatingA11yRule(result.reference, ruleResult);
+        //                 logA11yRuleResult(result.reference, ruleResult);
+        //             });
+        //             assert.equal(result.status, A11yResultStatus.SUCCESS, "A11y validation failed");
+        //         })
+        //     )
+        //     .toPromise();
+        // switch (reference) {
+        //     case "RGAA":
+        //         await new RgaaChecker(url, a11yCypressEngine).checkCriteria();
+        //     // new AlixError(versionAlix).checkCriteria();
+        //     // new AlixWarning(versionAlix).checkCriteria();
+        //     // new AlixAdvice(versionAlix).checkCriteria();
+        //     // new AlixObsolete(versionAlix).checkCriteria();
+        //     case "WCAG-WEB":
+        //         break;
+        //     case "WCAG-ANDROID":
+        //         break;
+        //     case "WCAG-IOS":
+        //         break;
+        // }
+    // });
+ });
+
+Then(
+    `I should have the following result based on the rgaa reference`,
+    async function(expectedResult: string) {
+        cy.injectUvvA11y();
+        cy.checkUvvA11y(A11yReferenceEnum.RGAA, JSON.parse(expectedResult));
+});
+
 function pressKey(context: Cypress.Chainable<JQuery<HTMLElement>>, key: string) {
   switch (key) {
     case KEY_PRESS.TAB:
@@ -436,3 +611,4 @@ function click(role: string, name: string) {
     }
   });
 }
+