@uuv/cypress 1.6.0 → 1.7.0

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

@@ -3,52 +3,67 @@ NE PAS MODIFIER, FICHIER GENERE
 *******************************/
 
 /**
- * Copyright UUV.
+ * Software Name : UUV
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2023 Orange
+ * SPDX-License-Identifier: MIT
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * This software is distributed under the MIT License,
+ * the text of which is available at https://spdx.org/licenses/MIT.html
+ * or see the "LICENSE" file for more details.
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Authors: NJAKO MOLOM Louis Fredice & SERVICAL Stanley
+ * Software description: Make test writing fast, understandable by any human
+ * understanding English or French.
  */
 
-import { DataTable, Given, Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import { DataTable, Given, Then, When } from "@badeball/cypress-cucumber-preprocessor";
 import { Context } from "../_context";
 import "../../../../cypress/commands";
 import { Method } from "cypress/types/net-stubbing";
-
+import { key, KEY_PRESS } from "@uuv/runner-commons";
 import {
-    assertTextContent,
-    findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
-    notFoundWithRoleAndName,
-    withinRoleAndName
+  assertTextContent,
+  findWithRoleAndName,
+  findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+  notFoundWithRoleAndName,
+  withinRoleAndName
 } from "../core-engine";
 
 When(`I visit path {string}`, function(siteUrl: string) {
-    if (siteUrl.match("^http:\\/\\/|https:\\/\\/")) {
-        return cy.visit(`${siteUrl}`);
-    }
-    return cy.visit(`${Cypress.config().baseUrl}${siteUrl}`);
+  if (siteUrl.match("^http:\\/\\/|https:\\/\\/")) {
+    return cy.visit(`${siteUrl}`);
+  }
+  return cy.visit(`${Cypress.config().baseUrl}${siteUrl}`);
 });
 
 When(`I click`, function() {
-    cy.uuvCheckContextFocusedElement().then(context => {
-        context.focusedElement!.click();
-    });
+  cy.uuvCheckContextFocusedElement().then(context => {
+    context.focusedElement!.click();
+  });
 });
 
 When(`I type the sentence {string}`, function(textToType: string) {
+  cy.uuvCheckContextFocusedElement().then((context) => {
+    context.focusedElement!.focus();
+    context.focusedElement!.type(textToType);
+  });
+});
+
+When(`I press {int} times on {string}`, function(nbTimes: number, key: string) {
+  for (let i = 1; i <= nbTimes; i++) {
     cy.uuvCheckContextFocusedElement().then((context) => {
-        context.focusedElement!.focus();
-        context.focusedElement!.type(textToType);
+      context.focusedElement!.focus();
+      pressKey(context.focusedElement!, key);
     });
+  }
+});
+
+When(`I press {string}`, function(key: string) {
+  cy.uuvCheckContextFocusedElement().then((context) => {
+    context.focusedElement!.focus();
+    pressKey(context.focusedElement!, key);
+  });
 });
 
 ////////////////////////////////////////////
@@ -56,126 +71,126 @@ When(`I type the sentence {string}`, function(textToType: string) {
 ////////////////////////////////////////////
 
 Given(`I set viewport to preset {string}`, function(viewportPreset: string) {
-    return cy.viewport(viewportPreset as Cypress.ViewportPreset);
+  return cy.viewport(viewportPreset as Cypress.ViewportPreset);
 });
 
 Given(
-    `I set viewport with width {int} and height {int}`,
-    function(width: number, height: number) {
-        return cy.viewport(width, height);
-    }
+ `I set viewport with width {int} and height {int}`,
+ function(width: number, height: number) {
+   return cy.viewport(width, height);
+ }
 );
 
 When(`I set timeout with value {int}`, function(newTimeout: number) {
-    return cy.uuvPatchContext({
-        timeout: newTimeout,
-    });
+  return cy.uuvPatchContext({
+    timeout: newTimeout
+  });
 });
 
 When(`Within the element with role {string} and name {string}`, function(role: string, name: string) {
-    return withinRoleAndName(role, name);
+  return withinRoleAndName(role, name);
 });
 
 When(`Within the element with aria-label {string}`, function(expectedAriaLabel: string) {
-    const foundedElement = cy.uuvFindByLabelText(expectedAriaLabel, {})
-        .uuvFoundedElement()
-        .should("exist");
+  const foundedElement = cy.uuvFindByLabelText(expectedAriaLabel, {})
+   .uuvFoundedElement()
+   .should("exist");
 
-    return cy.uuvPatchContext({
-        focusedElement: foundedElement
-    });
+  return cy.uuvPatchContext({
+    focusedElement: foundedElement
+  });
 });
 
 When(`Within the element with testId {string}`, function(testId: string) {
-    const foundedElement = cy.uuvFindByTestId(testId)
-        .uuvFoundedElement()
-        .should("exist");
+  const foundedElement = cy.uuvFindByTestId(testId)
+   .uuvFoundedElement()
+   .should("exist");
 
-    return cy.uuvPatchContext({
-        focusedElement: foundedElement
-    });
+  return cy.uuvPatchContext({
+    focusedElement: foundedElement
+  });
 });
 
 When(`Within the element with selector {string}`, function(selector: string) {
-    const foundedElement = cy.uuvGetContext().then(context => {
-        const parentElement = context.focusedElement;
-        if (parentElement) {
-            console.log("parentElement: ", parentElement);
-            return parentElement.should("exist").within(() => {
-                cy.get(selector).as("foundedChildElement");
-            });
-        }
-        cy.wrap(null).as("foundedChildElement");
-        return cy.get(selector);
-    }).uuvFoundedElement()
-        .should("exist");
-
-    return cy.uuvPatchContext({
-        focusedElement: foundedElement
-    });
+  const foundedElement = cy.uuvGetContext().then(context => {
+    const parentElement = context.focusedElement;
+    if (parentElement) {
+      console.log("parentElement: ", parentElement);
+      return parentElement.should("exist").within(() => {
+        cy.get(selector).as("foundedChildElement");
+      });
+    }
+    cy.wrap(null).as("foundedChildElement");
+    return cy.get(selector);
+  }).uuvFoundedElement()
+   .should("exist");
+
+  return cy.uuvPatchContext({
+    focusedElement: foundedElement
+  });
 });
 
 When(`I reset context`, function() {
-    return cy.wrap(new Context()).as("context");
+  return cy.wrap(new Context()).as("context");
 });
 
 When(
-    `I mock a request {} on url {string} named {string} with content {}`,
-    function(verb: Method, uri: string, name: string, body: any) {
-        return cy
-            .intercept(verb, uri, {
-                body: body,
-            })
-            .as(name);
-    }
+ `I mock a request {} on url {string} named {string} with content {}`,
+ function(verb: Method, uri: string, name: string, body: any) {
+   return cy
+    .intercept(verb, uri, {
+      body: body
+    })
+    .as(name);
+ }
 );
 
 When(
-    `I mock a request {} on url {string} named {string} with status code {int}`,
-    function(verb: Method, uri: string, name: string, statusCode: number) {
-        return cy
-            .intercept(verb, uri, {
-                statusCode: statusCode,
-            })
-            .as(name);
-    }
+ `I mock a request {} on url {string} named {string} with status code {int}`,
+ function(verb: Method, uri: string, name: string, statusCode: number) {
+   return cy
+    .intercept(verb, uri, {
+      statusCode: statusCode
+    })
+    .as(name);
+ }
 );
 
 When(
-    `I mock a request {} on url {string} named {string} with fixture {}`,
-    function(verb: Method, uri: string, name: string, fixture: any) {
-        return cy
-            .intercept(verb, uri, {
-                fixture: fixture,
-            })
-            .as(name);
-    }
+ `I mock a request {} on url {string} named {string} with fixture {}`,
+ function(verb: Method, uri: string, name: string, fixture: any) {
+   return cy
+    .intercept(verb, uri, {
+      fixture: fixture
+    })
+    .as(name);
+ }
 );
 
 ////////////////////////////////////////////
 // INTERCEPTION
 ////////////////////////////////////////////
 When(
-    `I set header(s) for uri {string} and method {string}`,
-    function(url: string, method: string, headersToSet: DataTable) {
-        cy.intercept(method as Method, url, (req) => {
-            req.headers = {
-                ...req.headers,
-                ...headersToSet.rowsHash(),
-            };
-            req.continue();
-        });
-    }
+ `I set header(s) for uri {string} and method {string}`,
+ function(url: string, method: string, headersToSet: DataTable) {
+   cy.intercept(method as Method, url, (req) => {
+     req.headers = {
+       ...req.headers,
+       ...headersToSet.rowsHash()
+     };
+     req.continue();
+   });
+ }
 );
 
 When(`I set header(s) for uri {string}`, function(url: string, headersToSet: DataTable) {
-    cy.intercept(url, (req) => {
-        req.headers = {
-            ...req.headers,
-            ...headersToSet.rowsHash(),
-        };
-        req.continue();
-    });
+  cy.intercept(url, (req) => {
+    req.headers = {
+      ...req.headers,
+      ...headersToSet.rowsHash()
+    };
+    req.continue();
+  });
 });
 
 ////////////////////////////////////////////
@@ -186,138 +201,217 @@ When(`I set header(s) for uri {string}`, function(url: string, headersToSet: Dat
  * Look for an element based on its content
  */
 Then(`I should see an element with content {string}`, async function(textContent: string) {
-    cy.uuvFindByText(textContent, {})
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByText(textContent, {})
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`I should not see an element with content {string}`, async function(textContent: string) {
-    cy.uuvFindByText(textContent, {})
-        .should("not.exist");
+  cy.uuvFindByText(textContent, {})
+   .should("not.exist");
 });
 
 Then(`I should see an element with testId {string}`, async function(testId: string) {
-    cy.uuvFindByTestId(testId)
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByTestId(testId)
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`I should not see an element with testId {string}`, async function(testId: string) {
-    cy.uuvFindByTestId(testId)
-        .should("not.exist");
+  cy.uuvFindByTestId(testId)
+   .should("not.exist");
 });
 
 Then(`I should see an element with role {string} and name {string}`, async function(role: string, name: string) {
-    findWithRoleAndName(role, name);
+  findWithRoleAndName(role, name);
 });
 
 Then(
-    `I should not see an element with role {string} and name {string}`,
-    async function(role: string, name: string) {
-        notFoundWithRoleAndName(role, name);
-    }
+ `I should not see an element with role {string} and name {string}`,
+ async function(role: string, name: string) {
+   notFoundWithRoleAndName(role, name);
+ }
 );
 
 Then(
-    `I should see an element with role {string} and name {string} and content {string}`,
-    async function(expectedRole: string, name: string, expectedTextContent: string) {
-        findWithRoleAndNameAndContent(expectedRole, name, expectedTextContent);
-    }
+ `I should see an element with role {string} and name {string} and content {string}`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContent(expectedRole, name, expectedTextContent);
+ }
 );
 
 Then(
-    `I should see an element with role {string} and name {string} and content {string} disabled`,
-    async function(expectedRole: string, name: string, expectedTextContent: string) {
-        findWithRoleAndNameAndContentDisable(expectedRole, name, expectedTextContent);
-    }
+ `I should see an element with role {string} and name {string} and content {string} disabled`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContentDisable(expectedRole, name, expectedTextContent);
+ }
 );
 
 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) {
-        findWithRoleAndNameAndContentEnable(expectedRole, name, expectedTextContent);
-    }
+ `I should see an element with role {string} and name {string} and content {string} not disabled`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContentEnable(expectedRole, name, expectedTextContent);
+ }
 );
 
 Then(`I should see an element with aria-label {string}`, async function(expectedAriaLabel: string) {
-    cy.uuvFindByLabelText(expectedAriaLabel, {})
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByLabelText(expectedAriaLabel, {})
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`I should not see an element with aria-label {string}`, async function(expectedAriaLabel: string) {
-   cy.uuvFindByLabelText(expectedAriaLabel, {})
-      .should("not.exist");
+  cy.uuvFindByLabelText(expectedAriaLabel, {})
+   .should("not.exist");
 });
 
 Then(
-    `I should see an element with aria-label {string} and content {string}`,
-    async function(expectedAriaLabel: string, expectedTextContent: string) {
-        cy.uuvFindByLabelText(expectedAriaLabel, {})
-            .uuvFoundedElement()
-            .should("exist")
-            .then((response) => {
-                assert.equal(response.length, 1);
-                assertTextContent(response, expectedTextContent);
-            });
-    }
+ `I should see an element with aria-label {string} and content {string}`,
+ async function(expectedAriaLabel: string, expectedTextContent: string) {
+   cy.uuvFindByLabelText(expectedAriaLabel, {})
+    .uuvFoundedElement()
+    .should("exist")
+    .then((response) => {
+      assert.equal(response.length, 1);
+      assertTextContent(response, expectedTextContent);
+    });
+ }
 );
 
 Then(`I should consume a mock named {string}`, async function(name: string) {
-    cy.wait([`@${name}`]);
+  cy.wait([`@${name}`]);
 });
 
 Then(`I wait {int} ms`, async function(ms: number) {
-     cy.wait(ms);
+  cy.wait(ms);
 });
 
 Then(
-    `I should see elements of the list with name {string}`,
-    async function(expectedListName: string, expectedElementsOfList: DataTable) {
-        cy.uuvFindByRole("list", { name: expectedListName })
-            .uuvFoundedElement()
-            .should("exist")
-            .within(() => {
-                return cy.uuvFindAllByRole("listitem", {}).then((listitem) => {
-                    const foundedElement: any[] = [];
-                    for (let i = 0; i < listitem.length; i++) {
-                        foundedElement.push([listitem[i].textContent]);
-                    }
-                    assert.equal(listitem.length, expectedElementsOfList.raw().length);
-                    assert.deepEqual(
-                        foundedElement,
-                        expectedElementsOfList.raw(),
-                        `expected [${expectedElementsOfList.raw()}] to be [${foundedElement}]`
-                    );
-                });
-            });
-    }
+ `I should see elements of the list with name {string}`,
+ async function(expectedListName: string, expectedElementsOfList: DataTable) {
+   cy.uuvFindByRole("list", { name: expectedListName })
+    .uuvFoundedElement()
+    .should("exist")
+    .within(() => {
+      return cy.uuvFindAllByRole("listitem", {}).then((listitem) => {
+        const foundedElement: any[] = [];
+        for (let i = 0; i < listitem.length; i++) {
+          foundedElement.push([listitem[i].textContent]);
+        }
+        assert.equal(listitem.length, expectedElementsOfList.raw().length);
+        assert.deepEqual(
+         foundedElement,
+         expectedElementsOfList.raw(),
+         `expected [${expectedElementsOfList.raw()}] to be [${foundedElement}]`
+        );
+      });
+    });
+ }
 );
 
 Then(
-    `I should see these attributes with values`,
-    async function(expectedAttributeList: DataTable) {
-        cy.uuvCheckContextFocusedElement().then((context) => {
-            const elementToSelect = context.focusedElement!;
-            for (const currentIndex in expectedAttributeList.raw()) {
-                const attributeName = expectedAttributeList.raw()[currentIndex][0];
-                const attributeValue = expectedAttributeList.raw()[currentIndex][1];
-                elementToSelect.then((response) => {
-                    assert.equal(response[0].getAttribute(attributeName), attributeValue);
-                });
-            }
-        });
-    }
+ `I should see these attributes with values`,
+ async function(expectedAttributeList: DataTable) {
+   cy.uuvCheckContextFocusedElement().then((context) => {
+     const elementToSelect = context.focusedElement!;
+     for (const currentIndex in expectedAttributeList.raw()) {
+       const attributeName = expectedAttributeList.raw()[currentIndex][0];
+       const attributeValue = expectedAttributeList.raw()[currentIndex][1];
+       elementToSelect.then((response) => {
+         assert.equal(response[0].getAttribute(attributeName), attributeValue);
+       });
+     }
+   });
+ }
 );
 
 Then(`I should see an element with selector {string}`, async function(selector: string) {
-    cy.get(selector).should("exist");
+  cy.get(selector).should("exist");
 });
 
 
 Then(
-    `I should not have any accessibility issue`,
-    async function() {
-        cy.injectAxe();
-        cy.checkA11y();
-});
+ `I should not have any accessibility issue`,
+ async function() {
+   cy.injectAxe();
+   cy.checkA11y();
+ });
+
+Then(
+ `I should not have any critical accessibility issue`,
+ async function() {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     includedImpacts: ["critical"]
+   });
+ });
+
+Then(
+ `I should not have any accessibility issue with {} impact(s)`,
+ async function(impacts: any) {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     includedImpacts: [impacts]
+   });
+ });
+
+Then(
+ `I should not have any accessibility issue with accessibility standard(s) {}`,
+ async function(tags: any) {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     runOnly: {
+       type: "tag",
+       values: [tags]
+     }
+   });
+ });
+
+Then(
+ `I should not have any accessibility issue with context json fixture {} and option json fixture {}`,
+ async function(context: any, option: any) {
+   cy.injectAxe();
+   cy.fixture(context).then(context => {
+     cy.fixture(option).then(option => {
+       cy.checkA11y(context, option);
+     });
+   });
+ });
+
+Then(
+ `I should not have any accessibility issue with option json fixture {}`,
+ async function(option: any) {
+   cy.injectAxe();
+   cy.fixture(option).then(data => {
+     cy.checkA11y(undefined, data);
+   });
+ });
+
+function pressKey(context: Cypress.Chainable<JQuery<HTMLElement>>, key: string) {
+  switch (key) {
+    case KEY_PRESS.TAB:
+      context.realPress("Tab");
+      break;
+    case KEY_PRESS.REVERSE_TAB:
+      context.realPress(["ShiftLeft", "Tab"]);
+      break;
+    case KEY_PRESS.UP:
+      context.realPress("ArrowUp");
+      break;
+    case KEY_PRESS.DOWN:
+      context.realPress("ArrowDown");
+      break;
+    case KEY_PRESS.LEFT:
+      context.realPress("ArrowLeft");
+      break;
+    case KEY_PRESS.RIGHT:
+      context.realPress("ArrowRight");
+      break;
+    default:
+      console.error("the command" + key + " is unrecognized.");
+      break;
+  }
+  cy.uuvPatchContext({
+    focusedElement: cy.focused()
+  });
+}