@uuv/cypress 1.3.0

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

@@ -0,0 +1,323 @@
+/*******************************
+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.
+ */
+
+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 {
+    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}`);
+});
+
+When(`je clique`, function() {
+    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);
+    });
+});
+
+////////////////////////////////////////////
+// Context ACTIONS
+////////////////////////////////////////////
+
+Given(`je redimensionne la fenêtre à la vue {string}`, function(viewportPreset: string) {
+    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);
+    }
+);
+
+When(`je positionne le timeout à {int} secondes`, function(newTimeout: number) {
+    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);
+});
+
+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");
+
+    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");
+
+    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
+    });
+});
+
+When(`je reinitialise le contexte`, function() {
+    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);
+    }
+);
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+////////////////////////////////////////////
+// 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();
+        });
+    }
+);
+
+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();
+    });
+});
+
+////////////////////////////////////////////
+// VALIDATION
+////////////////////////////////////////////
+
+/**
+ * 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");
+});
+
+Then(`je ne dois pas voir un élément qui contient {string}`, async function(textContent: string) {
+    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");
+});
+
+Then(`je ne dois pas voir un élément ayant pour testId {string}`, async function(testId: string) {
+    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);
+});
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+Then(`je dois voir un élément ayant pour aria-label {string}`, async function(expectedAriaLabel: string) {
+    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");
+});
+
+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);
+            });
+    }
+);
+
+Then(`je dois consommer le bouchon nommé {string}`, async function(name: string) {
+    cy.wait([`@${name}`]);
+});
+
+Then(`j'attends {int} ms`, async function(ms: number) {
+     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}]`
+                    );
+                });
+            });
+    }
+);
+
+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);
+                });
+            }
+        });
+    }
+);
+
+Then(`je dois voir un élément ayant pour sélecteur {string}`, async function(selector: string) {
+    cy.get(selector).should("exist");
+});
+
+
+Then(
+    `je ne dois pas avoir de problèmes d'accessibilité`,
+    async function() {
+        cy.injectAxe();
+        cy.checkA11y();
+});

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

@@ -0,0 +1,67 @@
+/*******************************
+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.
+ */
+
+import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import "../../../../../../cypress/commands";
+import {
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../../../core-engine";
+
+
+When(`Within a(n) alert named {string}`, function(name: string) {
+    return withinRoleAndName("alert", name);
+});
+
+Then(`I should see a(n) alert named {string}`, async function(name: string) {
+    findWithRoleAndName("alert", name);
+});
+
+Then(
+    `I should not see a(n) alert named {string}`,
+    async function(name: string) {
+        notFoundWithRoleAndName("alert", name);
+    }
+);
+
+Then(
+    `I should see a(n) alert named {string} and containing {string}`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContent("alert", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) alert named {string} and containing {string} disabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentDisable("alert", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) alert named {string} and containing {string} enabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentEnable("alert", name, expectedTextContent);
+    }
+);

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

@@ -0,0 +1,67 @@
+/*******************************
+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.
+ */
+
+import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import "../../../../../../cypress/commands";
+import {
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../../../core-engine";
+
+
+When(`Within a(n) alert dialog named {string}`, function(name: string) {
+    return withinRoleAndName("alertdialog", name);
+});
+
+Then(`I should see a(n) alert dialog named {string}`, async function(name: string) {
+    findWithRoleAndName("alertdialog", name);
+});
+
+Then(
+    `I should not see a(n) alert dialog named {string}`,
+    async function(name: string) {
+        notFoundWithRoleAndName("alertdialog", name);
+    }
+);
+
+Then(
+    `I should see a(n) alert dialog named {string} and containing {string}`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContent("alertdialog", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) alert dialog named {string} and containing {string} disabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentDisable("alertdialog", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) alert dialog named {string} and containing {string} enabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentEnable("alertdialog", name, expectedTextContent);
+    }
+);

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

@@ -0,0 +1,67 @@
+/*******************************
+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.
+ */
+
+import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import "../../../../../../cypress/commands";
+import {
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../../../core-engine";
+
+
+When(`Within a(n) application named {string}`, function(name: string) {
+    return withinRoleAndName("application", name);
+});
+
+Then(`I should see a(n) application named {string}`, async function(name: string) {
+    findWithRoleAndName("application", name);
+});
+
+Then(
+    `I should not see a(n) application named {string}`,
+    async function(name: string) {
+        notFoundWithRoleAndName("application", name);
+    }
+);
+
+Then(
+    `I should see a(n) application named {string} and containing {string}`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContent("application", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) application named {string} and containing {string} disabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentDisable("application", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) application named {string} and containing {string} enabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentEnable("application", name, expectedTextContent);
+    }
+);

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

@@ -0,0 +1,67 @@
+/*******************************
+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.
+ */
+
+import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import "../../../../../../cypress/commands";
+import {
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../../../core-engine";
+
+
+When(`Within a(n) article named {string}`, function(name: string) {
+    return withinRoleAndName("article", name);
+});
+
+Then(`I should see a(n) article named {string}`, async function(name: string) {
+    findWithRoleAndName("article", name);
+});
+
+Then(
+    `I should not see a(n) article named {string}`,
+    async function(name: string) {
+        notFoundWithRoleAndName("article", name);
+    }
+);
+
+Then(
+    `I should see a(n) article named {string} and containing {string}`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContent("article", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) article named {string} and containing {string} disabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentDisable("article", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) article named {string} and containing {string} enabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentEnable("article", name, expectedTextContent);
+    }
+);

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

@@ -0,0 +1,67 @@
+/*******************************
+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.
+ */
+
+import { Then, When, } from "@badeball/cypress-cucumber-preprocessor";
+import "../../../../../../cypress/commands";
+import {
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../../../core-engine";
+
+
+When(`Within a(n) banner named {string}`, function(name: string) {
+    return withinRoleAndName("banner", name);
+});
+
+Then(`I should see a(n) banner named {string}`, async function(name: string) {
+    findWithRoleAndName("banner", name);
+});
+
+Then(
+    `I should not see a(n) banner named {string}`,
+    async function(name: string) {
+        notFoundWithRoleAndName("banner", name);
+    }
+);
+
+Then(
+    `I should see a(n) banner named {string} and containing {string}`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContent("banner", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) banner named {string} and containing {string} disabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentDisable("banner", name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see a(n) banner named {string} and containing {string} enabled`,
+    async function(name: string, expectedTextContent: string) {
+        findWithRoleAndNameAndContentEnable("banner", name, expectedTextContent);
+    }
+);