@uuv/cypress 1.3.0

package/dist/cucumber/step_definitions/cypress/_.common.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuvFoundedElement = exports.uuvFindByTestId = exports.uuvFindByText = exports.uuvFindByLabelText = exports.uuvFindByRole = exports.uuvFindAllByRole = exports.uuvPatchContext = exports.uuvCheckContextFocusedElement = exports.uuvGetContext = void 0;
+const uuvGetContext = () => {
+    return cy.get("@context");
+};
+exports.uuvGetContext = uuvGetContext;
+function uuvCheckContextFocusedElement() {
+    return cy.get("@context")
+        .then(context => {
+        console.log("focusedElement: ", context);
+        if (!context.focusedElement) {
+            throw new Error("No element currently selected");
+        }
+        return context;
+    });
+}
+exports.uuvCheckContextFocusedElement = uuvCheckContextFocusedElement;
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+function uuvPatchContext(partOfContext) {
+    return cy.get("@context").then(context => {
+        cy.wrap({
+            ...context,
+            ...partOfContext
+        }).as("context");
+    });
+}
+exports.uuvPatchContext = uuvPatchContext;
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+function addContextOptions(context, roleOptions) {
+    const retour = {
+        timeout: context.timeout
+    };
+    return Object.assign(roleOptions, retour);
+}
+/* eslint-disable  @typescript-eslint/ban-types */
+function abstractFindBy(callBackFunction, inputToSearch, inputOptions) {
+    return cy.uuvGetContext().then(context => {
+        console.log("context");
+        console.log(context);
+        const parentElement = context.focusedElement;
+        const options = addContextOptions(context, inputOptions);
+        if (parentElement) {
+            console.log("parentElement: ", parentElement);
+            return parentElement.should("exist").within(() => {
+                callBackFunction(inputToSearch, options).as("foundedChildElement");
+            });
+        }
+        cy.wrap(null).as("foundedChildElement");
+        return callBackFunction(inputToSearch, options);
+    });
+}
+function uuvFindAllByRole(role, roleOptions) {
+    return abstractFindBy(cy.findAllByRole, role, roleOptions);
+}
+exports.uuvFindAllByRole = uuvFindAllByRole;
+function uuvFindByRole(role, roleOptions) {
+    return abstractFindBy(cy.findByRole, role, roleOptions);
+}
+exports.uuvFindByRole = uuvFindByRole;
+function uuvFindByLabelText(labelTextToSearch, roleOptions) {
+    return abstractFindBy(cy.findByLabelText, labelTextToSearch, roleOptions);
+}
+exports.uuvFindByLabelText = uuvFindByLabelText;
+function uuvFindByText(textToSearch, roleOptions) {
+    return abstractFindBy(cy.findByText, (content, element) => {
+        const hasText = (elem) => elem.textContent === textToSearch;
+        const elementHasText = hasText(element);
+        const childrenDontHaveText = Array.from(element?.children || []).every(child => !hasText(child));
+        return elementHasText && childrenDontHaveText;
+    }, roleOptions);
+}
+exports.uuvFindByText = uuvFindByText;
+function uuvFindByTestId(testId) {
+    return abstractFindBy(cy.findByTestId, testId, {});
+}
+exports.uuvFindByTestId = uuvFindByTestId;
+function uuvFoundedElement(subject) {
+    return cy.get("@foundedChildElement")
+        .then((response) => {
+        return response !== "empty" && response !== null ? response.foundedChildElement : subject;
+    });
+}
+exports.uuvFoundedElement = uuvFoundedElement;

package/dist/cucumber/step_definitions/cypress/_context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+/// <reference types="cypress" />
+/// <reference types="cypress" />
+import { IContext } from "@uuv/runner-commons";
+export declare class Context implements IContext {
+    focusedElement?: Cypress.Chainable<JQuery<HTMLElement>>;
+    timeout: number | null;
+}

package/dist/cucumber/step_definitions/cypress/_context.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const runner_commons_1 = require("@uuv/runner-commons");
+class Context {
+    focusedElement;
+    timeout = runner_commons_1.DEFAULT_TIMEOUT;
+}
+exports.Context = Context;

package/dist/cucumber/step_definitions/cypress/core-engine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { Context } from "./_context";
+export declare function assertTextContent<Subject>(response: Subject, expectedTextContent: string): void;
+export declare function findWithRoleAndName(role: string, name: string): void;
+export declare function withinRoleAndName(role: string, name: string): Cypress.Chainable<Context>;
+export declare function notFoundWithRoleAndName(role: string, name: string): void;
+export declare function findWithRoleAndNameAndContent(expectedRole: string, name: string, expectedTextContent: string): void;
+export declare function findWithRoleAndNameAndContentDisable(expectedRole: string, name: string, expectedTextContent: string): void;
+export declare function findWithRoleAndNameAndContentEnable(expectedRole: string, name: string, expectedTextContent: string): void;

package/dist/cucumber/step_definitions/cypress/core-engine.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWithRoleAndNameAndContentEnable = exports.findWithRoleAndNameAndContentDisable = exports.findWithRoleAndNameAndContent = exports.notFoundWithRoleAndName = exports.withinRoleAndName = exports.findWithRoleAndName = exports.assertTextContent = void 0;
+const _context_1 = require("./_context");
+beforeEach(function () {
+    cy.wrap(new _context_1.Context()).as("context");
+});
+function assertTextContent(response, expectedTextContent) {
+    try {
+        assert.equal(response[0].textContent, expectedTextContent);
+    }
+    catch (e) {
+        /* eslint-disable  @typescript-eslint/no-explicit-any */
+        assert.equal(response[0].value, expectedTextContent);
+    }
+}
+exports.assertTextContent = assertTextContent;
+function findWithRoleAndName(role, name) {
+    cy.uuvFindByRole(role, { name })
+        .uuvFoundedElement()
+        .should("exist");
+}
+exports.findWithRoleAndName = findWithRoleAndName;
+function withinRoleAndName(role, name) {
+    const foundedElement = cy.uuvFindByRole(role, { name, hidden: true })
+        .uuvFoundedElement()
+        .should("exist");
+    return cy.uuvPatchContext({
+        focusedElement: foundedElement
+    });
+}
+exports.withinRoleAndName = withinRoleAndName;
+function notFoundWithRoleAndName(role, name) {
+    cy.uuvFindByRole(role, { name })
+        .should("not.exist");
+}
+exports.notFoundWithRoleAndName = notFoundWithRoleAndName;
+function findWithRoleAndNameAndContent(expectedRole, name, expectedTextContent) {
+    cy.uuvFindByRole(expectedRole, { name })
+        .uuvFoundedElement()
+        .should("exist")
+        .then((response) => {
+        assert.equal(response.length, 1);
+        assertTextContent(response, expectedTextContent);
+    });
+}
+exports.findWithRoleAndNameAndContent = findWithRoleAndNameAndContent;
+function findWithRoleAndNameAndContentDisable(expectedRole, name, expectedTextContent) {
+    cy.uuvFindByRole(expectedRole, { name })
+        .uuvFoundedElement()
+        .should("exist")
+        .then((response) => {
+        assert.equal(response.length, 1);
+        assertTextContent(response, expectedTextContent);
+    })
+        .invoke("attr", "disabled")
+        .should("eq", "disabled");
+}
+exports.findWithRoleAndNameAndContentDisable = findWithRoleAndNameAndContentDisable;
+function findWithRoleAndNameAndContentEnable(expectedRole, name, expectedTextContent) {
+    cy.uuvFindByRole(expectedRole, { name })
+        .uuvFoundedElement()
+        .should("exist")
+        .then((response) => {
+        assert.equal(response.length, 1);
+        assertTextContent(response, expectedTextContent);
+    })
+        .invoke("attr", "disabled")
+        .should("eq", undefined);
+}
+exports.findWithRoleAndNameAndContentEnable = findWithRoleAndNameAndContentEnable;

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

@@ -0,0 +1,4 @@
+/*******************************
+NE PAS MODIFIER, FICHIER GENERE
+*******************************/
+import "../../../../cypress/commands";

package/dist/cucumber/step_definitions/cypress/generated/_en-generated-cucumber-steps-definition.js

@@ -0,0 +1,233 @@
+"use strict";
+/*******************************
+NE PAS MODIFIER, FICHIER GENERE
+*******************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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 cypress_cucumber_preprocessor_1 = require("@badeball/cypress-cucumber-preprocessor");
+const _context_1 = require("../_context");
+require("../../../../cypress/commands");
+const core_engine_1 = require("../core-engine");
+(0, cypress_cucumber_preprocessor_1.When)(`I visit path {string}`, function (siteUrl) {
+    if (siteUrl.match("^http:\\/\\/|https:\\/\\/")) {
+        return cy.visit(`${siteUrl}`);
+    }
+    return cy.visit(`${Cypress.config().baseUrl}${siteUrl}`);
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I click`, function () {
+    cy.uuvCheckContextFocusedElement().then(context => {
+        context.focusedElement.click();
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I type the sentence {string}`, function (textToType) {
+    cy.uuvCheckContextFocusedElement().then((context) => {
+        context.focusedElement.focus();
+        context.focusedElement.type(textToType);
+    });
+});
+////////////////////////////////////////////
+// Context ACTIONS
+////////////////////////////////////////////
+(0, cypress_cucumber_preprocessor_1.Given)(`I set viewport to preset {string}`, function (viewportPreset) {
+    return cy.viewport(viewportPreset);
+});
+(0, cypress_cucumber_preprocessor_1.Given)(`I set viewport with width {int} and height {int}`, function (width, height) {
+    return cy.viewport(width, height);
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I set timeout with value {int}`, function (newTimeout) {
+    return cy.uuvPatchContext({
+        timeout: newTimeout,
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`Within the element with role {string} and name {string}`, function (role, name) {
+    return (0, core_engine_1.withinRoleAndName)(role, name);
+});
+(0, cypress_cucumber_preprocessor_1.When)(`Within the element with aria-label {string}`, function (expectedAriaLabel) {
+    const foundedElement = cy.uuvFindByLabelText(expectedAriaLabel, {})
+        .uuvFoundedElement()
+        .should("exist");
+    return cy.uuvPatchContext({
+        focusedElement: foundedElement
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`Within the element with testId {string}`, function (testId) {
+    const foundedElement = cy.uuvFindByTestId(testId)
+        .uuvFoundedElement()
+        .should("exist");
+    return cy.uuvPatchContext({
+        focusedElement: foundedElement
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`Within the element with selector {string}`, function (selector) {
+    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
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I reset context`, function () {
+    return cy.wrap(new _context_1.Context()).as("context");
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I mock a request {} on url {string} named {string} with content {}`, function (verb, uri, name, body) {
+    return cy
+        .intercept(verb, uri, {
+        body: body,
+    })
+        .as(name);
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I mock a request {} on url {string} named {string} with status code {int}`, function (verb, uri, name, statusCode) {
+    return cy
+        .intercept(verb, uri, {
+        statusCode: statusCode,
+    })
+        .as(name);
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I mock a request {} on url {string} named {string} with fixture {}`, function (verb, uri, name, fixture) {
+    return cy
+        .intercept(verb, uri, {
+        fixture: fixture,
+    })
+        .as(name);
+});
+////////////////////////////////////////////
+// INTERCEPTION
+////////////////////////////////////////////
+(0, cypress_cucumber_preprocessor_1.When)(`I set header(s) for uri {string} and method {string}`, function (url, method, headersToSet) {
+    cy.intercept(method, url, (req) => {
+        req.headers = {
+            ...req.headers,
+            ...headersToSet.rowsHash(),
+        };
+        req.continue();
+    });
+});
+(0, cypress_cucumber_preprocessor_1.When)(`I set header(s) for uri {string}`, function (url, headersToSet) {
+    cy.intercept(url, (req) => {
+        req.headers = {
+            ...req.headers,
+            ...headersToSet.rowsHash(),
+        };
+        req.continue();
+    });
+});
+////////////////////////////////////////////
+// VALIDATION
+////////////////////////////////////////////
+/**
+ * Look for an element based on its content
+ */
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with content {string}`, async function (textContent) {
+    cy.uuvFindByText(textContent, {})
+        .uuvFoundedElement()
+        .should("exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should not see an element with content {string}`, async function (textContent) {
+    cy.uuvFindByText(textContent, {})
+        .should("not.exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with testId {string}`, async function (testId) {
+    cy.uuvFindByTestId(testId)
+        .uuvFoundedElement()
+        .should("exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should not see an element with testId {string}`, async function (testId) {
+    cy.uuvFindByTestId(testId)
+        .should("not.exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with role {string} and name {string}`, async function (role, name) {
+    (0, core_engine_1.findWithRoleAndName)(role, name);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should not see an element with role {string} and name {string}`, async function (role, name) {
+    (0, core_engine_1.notFoundWithRoleAndName)(role, name);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with role {string} and name {string} and content {string}`, async function (expectedRole, name, expectedTextContent) {
+    (0, core_engine_1.findWithRoleAndNameAndContent)(expectedRole, name, expectedTextContent);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with role {string} and name {string} and content {string} disabled`, async function (expectedRole, name, expectedTextContent) {
+    (0, core_engine_1.findWithRoleAndNameAndContentDisable)(expectedRole, name, expectedTextContent);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with role {string} and name {string} and content {string} not disabled`, async function (expectedRole, name, expectedTextContent) {
+    (0, core_engine_1.findWithRoleAndNameAndContentEnable)(expectedRole, name, expectedTextContent);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with aria-label {string}`, async function (expectedAriaLabel) {
+    cy.uuvFindByLabelText(expectedAriaLabel, {})
+        .uuvFoundedElement()
+        .should("exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should not see an element with aria-label {string}`, async function (expectedAriaLabel) {
+    cy.uuvFindByLabelText(expectedAriaLabel, {})
+        .should("not.exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with aria-label {string} and content {string}`, async function (expectedAriaLabel, expectedTextContent) {
+    cy.uuvFindByLabelText(expectedAriaLabel, {})
+        .uuvFoundedElement()
+        .should("exist")
+        .then((response) => {
+        assert.equal(response.length, 1);
+        (0, core_engine_1.assertTextContent)(response, expectedTextContent);
+    });
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should consume a mock named {string}`, async function (name) {
+    cy.wait([`@${name}`]);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I wait {int} ms`, async function (ms) {
+    cy.wait(ms);
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see elements of the list with name {string}`, async function (expectedListName, expectedElementsOfList) {
+    cy.uuvFindByRole("list", { name: expectedListName })
+        .uuvFoundedElement()
+        .should("exist")
+        .within(() => {
+        return cy.uuvFindAllByRole("listitem", {}).then((listitem) => {
+            const foundedElement = [];
+            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}]`);
+        });
+    });
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see these attributes with values`, async function (expectedAttributeList) {
+    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);
+            });
+        }
+    });
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should see an element with selector {string}`, async function (selector) {
+    cy.get(selector).should("exist");
+});
+(0, cypress_cucumber_preprocessor_1.Then)(`I should not have any accessibility issue`, async function () {
+    cy.injectAxe();
+    cy.checkA11y();
+});

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

@@ -0,0 +1,4 @@
+/*******************************
+NE PAS MODIFIER, FICHIER GENERE
+*******************************/
+import "../../../../cypress/commands";