@uuv/cypress 1.3.0

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@uuv/cypress",
+  "version": "1.3.0",
+  "type": "commonjs",
+  "author": "Louis Fredice NJAKO MOLOM (https://github.com/luifr10) & Stanley SERVICAL (https://github.com/stanlee974)",
+  "description": "A transpiler from cucumber step definitions to cypress.",
+  "license": "Apache-2.0",
+  "homepage": "https://e2e-test-quest.github.io/uuv/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/e2e-test-quest/uuv"
+  },
+  "bin": {
+    "uuv": "bin/uuv"
+  },
+  "keywords": [
+    "uuv",
+    "UUV",
+    "E2E",
+    "end-to-end",
+    "test",
+    "testing",
+    "cypress",
+    "testing-library",
+    "accessibility",
+    "accessibilité",
+    "a11y",
+    "cucumber",
+    "gherkin"
+  ],
+  "scripts": {
+    "generate:step-definitions": "ts-node generate-step-definitions.ts",
+    "generate:step-definitions-documentation": "ts-node generate-step-definitions-documentation.ts",
+    "package": "npm pack --pack-destination=\"../../dist/packages\"",
+    "postinstall": "node postinstall.js",
+    "test:run": "node test.js --run",
+    "test:open": "node test.js --open",
+    "test": "npm run test:run"
+  },
+  "dependencies": {
+    "@badeball/cypress-cucumber-preprocessor": "16.0.3",
+    "@cypress/webpack-preprocessor": "5.17.0",
+    "@testing-library/cypress": "9.0.0",
+    "@uuv/runner-commons": "1.3.0",
+    "axe-core": "4.7.0",
+    "chalk": "4.1.2",
+    "cucumber-json-report-formatter": "0.1.4",
+    "cypress": "12.11.0",
+    "cypress-axe": "1.4.0",
+    "figlet": "1.6.0",
+    "is-admin": "2.1.1",
+    "minimist": "1.2.8",
+    "multiple-cucumber-html-reporter": "3.3.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/cucumber/**/*",
+    "dist/cypress/**/*",
+    "dist/lib/**/*",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "bin/**/*",
+    "postinstall.js",
+    "target-config/**/*",
+    "src/cucumber/step_definitions/cypress/generated/**/*",
+    "*.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cypress/commands": {
+      "import": "./dist/cypress/commands.js",
+      "require": "./dist/cypress/commands.js",
+      "types": "./dist/cypress/commands.d.ts"
+    },
+    "./cypress/cypress.config": {
+      "import": "./dist/cypress/cypress.config.js",
+      "require": "./dist/cypress/cypress.config.js",
+      "types": "./dist/cypress/cypress.config.d.ts"
+    },
+    "./cucumber/step_definitions": {
+      "import": "./dist/cucumber/step_definitions/**/*.js",
+      "require": "./dist/cucumber/step_definitions/**/*.js",
+      "types": "./dist/cucumber/step_definitions/**/*.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@types/minimist": "1.2.2",
+    "@types/node": "18.15.11",
+    "cross-env": "7.0.3",
+    "eslint-plugin-cypress": "2.13.3",
+    "serve-handler": "6.1.5",
+    "ts-loader": "9.4.2",
+    "tsconfig-paths": "4.2.0",
+    "webpack": "5.81.0"
+  }
+}

package/postinstall.js

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+const fs = require("fs");
+const PROJECT_DIR = `${__dirname}/../../../`;
+const CLI_DIR = `${__dirname}/dist/lib`;
+const TARGET_CONFIG_DIR = `${__dirname}/target-config`;
+
+function copyFile(fileToCopy, originFolder, destFolder) {
+    if (fs.existsSync(`${originFolder}/${fileToCopy}`)) {
+        if (!fs.existsSync(destFolder)) {
+            fs.mkdirSync(destFolder, { recursive: true });
+        }
+        fs.copyFile(`${originFolder}/${fileToCopy}`, `${destFolder}/${fileToCopy}`, (err) => {
+            if (err) {
+throw err;
+}
+            console.log(`File ${destFolder}/${fileToCopy} created`);
+        });
+    }
+}
+
+function copyFileIfMissing(fileToCopy, originFolder, destFolder) {
+    if (!fs.existsSync(`${destFolder}/${fileToCopy}`)) {
+        copyFile(fileToCopy, originFolder, destFolder);
+    }
+}
+
+function main () {
+    if (fs.existsSync(`${PROJECT_DIR}/package.json`) && !fs.existsSync(`${PROJECT_DIR}/.no-postinstall`)) {
+        //copyFile('uuv-cli.js', `${CLI_DIR}`, `${PROJECT_DIR}`);
+        copyFileIfMissing("cypress.config.ts", `${TARGET_CONFIG_DIR}`, `${PROJECT_DIR}/uuv`);
+        copyFileIfMissing("command.ts", `${TARGET_CONFIG_DIR}`, `${PROJECT_DIR}/uuv/cypress/support`);
+        copyFileIfMissing(".cypress-cucumber-preprocessorrc.json", `${TARGET_CONFIG_DIR}`, `${PROJECT_DIR}`);
+    } else {
+        console.log("postinstall - Nothing to copy");
+    }
+}
+
+main();

package/src/cucumber/step_definitions/cypress/generated/_en-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(`I visit path {string}`, function(siteUrl: string) {
+    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();
+    });
+});
+
+When(`I type the sentence {string}`, function(textToType: string) {
+    cy.uuvCheckContextFocusedElement().then((context) => {
+        context.focusedElement!.focus();
+        context.focusedElement!.type(textToType);
+    });
+});
+
+////////////////////////////////////////////
+// Context ACTIONS
+////////////////////////////////////////////
+
+Given(`I set viewport to preset {string}`, function(viewportPreset: string) {
+    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);
+    }
+);
+
+When(`I set timeout with value {int}`, function(newTimeout: number) {
+    return cy.uuvPatchContext({
+        timeout: newTimeout,
+    });
+});
+
+When(`Within the element with role {string} and name {string}`, function(role: string, name: string) {
+    return withinRoleAndName(role, name);
+});
+
+When(`Within the element with aria-label {string}`, function(expectedAriaLabel: string) {
+    const foundedElement = cy.uuvFindByLabelText(expectedAriaLabel, {})
+        .uuvFoundedElement()
+        .should("exist");
+
+    return cy.uuvPatchContext({
+        focusedElement: foundedElement
+    });
+});
+
+When(`Within the element with testId {string}`, function(testId: string) {
+    const foundedElement = cy.uuvFindByTestId(testId)
+        .uuvFoundedElement()
+        .should("exist");
+
+    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
+    });
+});
+
+When(`I reset context`, function() {
+    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);
+    }
+);
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+////////////////////////////////////////////
+// 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();
+        });
+    }
+);
+
+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();
+    });
+});
+
+////////////////////////////////////////////
+// VALIDATION
+////////////////////////////////////////////
+
+/**
+ * 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");
+});
+
+Then(`I should not see an element with content {string}`, async function(textContent: string) {
+    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");
+});
+
+Then(`I should not see an element with testId {string}`, async function(testId: string) {
+    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);
+});
+
+Then(
+    `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);
+    }
+);
+
+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);
+    }
+);
+
+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);
+    }
+);
+
+Then(`I should see an element with aria-label {string}`, async function(expectedAriaLabel: string) {
+    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");
+});
+
+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);
+            });
+    }
+);
+
+Then(`I should consume a mock named {string}`, async function(name: string) {
+    cy.wait([`@${name}`]);
+});
+
+Then(`I wait {int} ms`, async function(ms: number) {
+     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}]`
+                    );
+                });
+            });
+    }
+);
+
+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);
+                });
+            }
+        });
+    }
+);
+
+Then(`I should see an element with selector {string}`, async function(selector: string) {
+    cy.get(selector).should("exist");
+});
+
+
+Then(
+    `I should not have any accessibility issue`,
+    async function() {
+        cy.injectAxe();
+        cy.checkA11y();
+});