@uuv/cypress 1.6.0 → 1.7.0

package/src/cucumber/step_definitions/cypress/generated/_fr-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(`je visite l'Url {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(`je clique`, function() {
-    cy.uuvCheckContextFocusedElement().then(context => {
-        context.focusedElement!.click();
-    });
+  cy.uuvCheckContextFocusedElement().then(context => {
+    context.focusedElement!.click();
+  });
 });
 
 When(`je saisie le(s) mot(s) {string}`, function(textToType: string) {
+  cy.uuvCheckContextFocusedElement().then((context) => {
+    context.focusedElement!.focus();
+    context.focusedElement!.type(textToType);
+  });
+});
+
+When(`j'appuie {int} fois sur {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(`j'appuie sur {string}`, function(key: string) {
+  cy.uuvCheckContextFocusedElement().then((context) => {
+    context.focusedElement!.focus();
+    pressKey(context.focusedElement!, key);
+  });
 });
 
 ////////////////////////////////////////////
@@ -56,126 +71,126 @@ When(`je saisie le(s) mot(s) {string}`, function(textToType: string) {
 ////////////////////////////////////////////
 
 Given(`je redimensionne la fenêtre à la vue {string}`, function(viewportPreset: string) {
-    return cy.viewport(viewportPreset as Cypress.ViewportPreset);
+  return cy.viewport(viewportPreset as Cypress.ViewportPreset);
 });
 
 Given(
-    `je redimensionne la fenêtre avec une largeur de {int} px et une longueur de {int} px`,
-    function(width: number, height: number) {
-        return cy.viewport(width, height);
-    }
+ `je redimensionne la fenêtre avec une largeur de {int} px et une longueur de {int} px`,
+ function(width: number, height: number) {
+   return cy.viewport(width, height);
+ }
 );
 
 When(`je positionne le timeout à {int} secondes`, function(newTimeout: number) {
-    return cy.uuvPatchContext({
-        timeout: newTimeout,
-    });
+  return cy.uuvPatchContext({
+    timeout: newTimeout
+  });
 });
 
 When(`je vais à l'intérieur de l'élément ayant pour rôle {string} et pour nom {string}`, function(role: string, name: string) {
-    return withinRoleAndName(role, name);
+  return withinRoleAndName(role, name);
 });
 
 When(`je vais à l'intérieur de l'élément ayant pour 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(`je vais à l'intérieur de l'élément ayant pour 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(`je vais à l'intérieur de l'élément ayant pour sélecteur {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(`je reinitialise le contexte`, function() {
-    return cy.wrap(new Context()).as("context");
+  return cy.wrap(new Context()).as("context");
 });
 
 When(
-    `je simule une requête {} sur l'url {string} nommée {string} avec le contenu suivant {}`,
-    function(verb: Method, uri: string, name: string, body: any) {
-        return cy
-            .intercept(verb, uri, {
-                body: body,
-            })
-            .as(name);
-    }
+ `je simule une requête {} sur l'url {string} nommée {string} avec le contenu suivant {}`,
+ function(verb: Method, uri: string, name: string, body: any) {
+   return cy
+    .intercept(verb, uri, {
+      body: body
+    })
+    .as(name);
+ }
 );
 
 When(
-    `je simule une requête {} sur l'url {string} nommée {string} avec le code http {int}`,
-    function(verb: Method, uri: string, name: string, statusCode: number) {
-        return cy
-            .intercept(verb, uri, {
-                statusCode: statusCode,
-            })
-            .as(name);
-    }
+ `je simule une requête {} sur l'url {string} nommée {string} avec le code http {int}`,
+ function(verb: Method, uri: string, name: string, statusCode: number) {
+   return cy
+    .intercept(verb, uri, {
+      statusCode: statusCode
+    })
+    .as(name);
+ }
 );
 
 When(
-    `je simule une requête {} sur l'url {string} nommée {string} avec le fichier suivant {}`,
-    function(verb: Method, uri: string, name: string, fixture: any) {
-        return cy
-            .intercept(verb, uri, {
-                fixture: fixture,
-            })
-            .as(name);
-    }
+ `je simule une requête {} sur l'url {string} nommée {string} avec le fichier suivant {}`,
+ function(verb: Method, uri: string, name: string, fixture: any) {
+   return cy
+    .intercept(verb, uri, {
+      fixture: fixture
+    })
+    .as(name);
+ }
 );
 
 ////////////////////////////////////////////
 // INTERCEPTION
 ////////////////////////////////////////////
 When(
-    `je saisie le(s) header(s) pour l'Uri {string} et la methode {string}`,
-    function(url: string, method: string, headersToSet: DataTable) {
-        cy.intercept(method as Method, url, (req) => {
-            req.headers = {
-                ...req.headers,
-                ...headersToSet.rowsHash(),
-            };
-            req.continue();
-        });
-    }
+ `je saisie le(s) header(s) pour l'Uri {string} et la methode {string}`,
+ function(url: string, method: string, headersToSet: DataTable) {
+   cy.intercept(method as Method, url, (req) => {
+     req.headers = {
+       ...req.headers,
+       ...headersToSet.rowsHash()
+     };
+     req.continue();
+   });
+ }
 );
 
 When(`je saisie le(s) header(s) pour l'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(`je saisie le(s) header(s) pour l'Uri {string}`, function(url: string, head
  * Look for an element based on its content
  */
 Then(`je dois voir un élément qui contient {string}`, async function(textContent: string) {
-    cy.uuvFindByText(textContent, {})
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByText(textContent, {})
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`je ne dois pas voir un élément qui contient {string}`, async function(textContent: string) {
-    cy.uuvFindByText(textContent, {})
-        .should("not.exist");
+  cy.uuvFindByText(textContent, {})
+   .should("not.exist");
 });
 
 Then(`je dois voir un élément ayant pour testId {string}`, async function(testId: string) {
-    cy.uuvFindByTestId(testId)
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByTestId(testId)
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`je ne dois pas voir un élément ayant pour testId {string}`, async function(testId: string) {
-    cy.uuvFindByTestId(testId)
-        .should("not.exist");
+  cy.uuvFindByTestId(testId)
+   .should("not.exist");
 });
 
 Then(`je dois voir un élément avec le rôle {string} et le nom {string}`, async function(role: string, name: string) {
-    findWithRoleAndName(role, name);
+  findWithRoleAndName(role, name);
 });
 
 Then(
-    `je ne dois pas voir un élément avec le rôle {string} et le nom {string}`,
-    async function(role: string, name: string) {
-        notFoundWithRoleAndName(role, name);
-    }
+ `je ne dois pas voir un élément avec le rôle {string} et le nom {string}`,
+ async function(role: string, name: string) {
+   notFoundWithRoleAndName(role, name);
+ }
 );
 
 Then(
-    `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string}`,
-    async function(expectedRole: string, name: string, expectedTextContent: string) {
-        findWithRoleAndNameAndContent(expectedRole, name, expectedTextContent);
-    }
+ `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string}`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContent(expectedRole, name, expectedTextContent);
+ }
 );
 
 Then(
-    `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} inactif`,
-    async function(expectedRole: string, name: string, expectedTextContent: string) {
-        findWithRoleAndNameAndContentDisable(expectedRole, name, expectedTextContent);
-    }
+ `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} inactif`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContentDisable(expectedRole, name, expectedTextContent);
+ }
 );
 
 Then(
-    `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} actif`,
-    async function(expectedRole: string, name: string, expectedTextContent: string) {
-        findWithRoleAndNameAndContentEnable(expectedRole, name, expectedTextContent);
-    }
+ `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} actif`,
+ async function(expectedRole: string, name: string, expectedTextContent: string) {
+   findWithRoleAndNameAndContentEnable(expectedRole, name, expectedTextContent);
+ }
 );
 
 Then(`je dois voir un élément ayant pour aria-label {string}`, async function(expectedAriaLabel: string) {
-    cy.uuvFindByLabelText(expectedAriaLabel, {})
-        .uuvFoundedElement()
-        .should("exist");
+  cy.uuvFindByLabelText(expectedAriaLabel, {})
+   .uuvFoundedElement()
+   .should("exist");
 });
 
 Then(`je ne dois pas voir un élément ayant pour aria-label {string}`, async function(expectedAriaLabel: string) {
-   cy.uuvFindByLabelText(expectedAriaLabel, {})
-      .should("not.exist");
+  cy.uuvFindByLabelText(expectedAriaLabel, {})
+   .should("not.exist");
 });
 
 Then(
-    `je dois voir un élément ayant pour aria-label {string} et pour contenu {string}`,
-    async function(expectedAriaLabel: string, expectedTextContent: string) {
-        cy.uuvFindByLabelText(expectedAriaLabel, {})
-            .uuvFoundedElement()
-            .should("exist")
-            .then((response) => {
-                assert.equal(response.length, 1);
-                assertTextContent(response, expectedTextContent);
-            });
-    }
+ `je dois voir un élément ayant pour aria-label {string} et pour contenu {string}`,
+ async function(expectedAriaLabel: string, expectedTextContent: string) {
+   cy.uuvFindByLabelText(expectedAriaLabel, {})
+    .uuvFoundedElement()
+    .should("exist")
+    .then((response) => {
+      assert.equal(response.length, 1);
+      assertTextContent(response, expectedTextContent);
+    });
+ }
 );
 
 Then(`je dois consommer le bouchon nommé {string}`, async function(name: string) {
-    cy.wait([`@${name}`]);
+  cy.wait([`@${name}`]);
 });
 
 Then(`j'attends {int} ms`, async function(ms: number) {
-     cy.wait(ms);
+  cy.wait(ms);
 });
 
 Then(
-    `je dois voir des elements de la liste ayant pour nom {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}]`
-                    );
-                });
-            });
-    }
+ `je dois voir des elements de la liste ayant pour nom {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(
-    `je dois voir les attributs avec valeurs suivantes`,
-    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);
-                });
-            }
-        });
-    }
+ `je dois voir les attributs avec valeurs suivantes`,
+ 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(`je dois voir un élément ayant pour sélecteur {string}`, async function(selector: string) {
-    cy.get(selector).should("exist");
+  cy.get(selector).should("exist");
 });
 
 
 Then(
-    `je ne dois pas avoir de problèmes d'accessibilité`,
-    async function() {
-        cy.injectAxe();
-        cy.checkA11y();
-});
+ `je ne dois pas avoir de problèmes d'accessibilité`,
+ async function() {
+   cy.injectAxe();
+   cy.checkA11y();
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité de niveau critique`,
+ async function() {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     includedImpacts: ["critical"]
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec l(es) impact(s) {}`,
+ async function(impacts: any) {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     includedImpacts: [impacts]
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec le(s) standard(s) {}`,
+ async function(tags: any) {
+   cy.injectAxe();
+   cy.checkA11y(undefined, {
+     runOnly: {
+       type: "tag",
+       values: [tags]
+     }
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité sur le fichier json suivant de contexte {} et avec le fichier json suivant d'option {}`,
+ async function(context: any, option: any) {
+   cy.injectAxe();
+   cy.fixture(context).then(context => {
+     cy.fixture(option).then(option => {
+       cy.checkA11y(context, option);
+     });
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec le fichier json suivant d'option {}`,
+ 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()
+  });
+}

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_alert.ts

@@ -3,20 +3,19 @@ NE PAS MODIFIER, FICHIER GENERE
 *******************************/
 
 /**
- * Copyright 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
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * 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.
- */
+* Software Name : UUV
+*
+* SPDX-FileCopyrightText: Copyright (c) 2022-2023 Orange
+* SPDX-License-Identifier: MIT
+*
+* 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.
+*
+* Authors: NJAKO MOLOM Louis Fredice & SERVICAL Stanley
+* Software description: Make test writing fast, understandable by any human
+* understanding English or French.
+*/
 
 import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
 import "../../../../../../cypress/commands";