@uuv/playwright 1.3.0

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

@@ -0,0 +1,285 @@
+/*******************************
+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 { DEFAULT_TIMEOUT, fs, key } from "@uuv/runner-commons";
+import { checkA11y, injectAxe } from "axe-playwright";
+import { Locator } from "playwright";
+import { devices, expect } from "@playwright/test";
+import { DataTable } from "@cucumber/cucumber";
+import {
+    addCookieWhenValueIsList,
+    COOKIE_NAME, deleteCookieByName,
+    deleteCookieByValue,
+    FILTER_TYPE,
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getCookie,
+    getPageOrElement,
+    MockType,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../core-engine";
+
+import { Given, When, Then } from "@cucumber/cucumber";
+import { World } from "../../../preprocessor/run/world";
+
+Given(`I set viewport to preset {string}`, async function(this: World, viewportPreset: string) {
+    await this.page.setViewportSize(devices[viewportPreset].viewport);
+});
+
+Given(
+    `I set viewport with width {int} and height {int}`, async function
+    (this: World, width: number, height: number) {
+        await this.page.setViewportSize({ width: width, height: height });
+    }
+);
+
+Given(`I visit path {string}`, { timeout: 60 * 1000 }, async function (this: World, siteUrl: string) {
+    await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    await this.page.goto(`${siteUrl}`);
+});
+
+When(`I click`, async function (this: World) {
+    await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
+});
+
+// TODO : permet de gérer les label accessibles donc pas que les aria : https://playwright.dev/docs/api/class-locator#locator-get-by-label
+When(`Within the element with aria-label {string}`, async function (this: World, expectedAriaLabel: string) {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: expectedAriaLabel });
+});
+When(`I reset context`, async function (this: World) {
+    await this.context.clearCookies();
+});
+
+When(`Within the element with selector {string}`, async function (this: World, selector: string) {
+    await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR, value: selector });
+});
+
+When(`I type the sentence {string}`, async function (this: World, textToType: string) {
+    await getPageOrElement(this).then(async (element: Locator) => {
+        await element.focus({ timeout: 10000 });
+        await element.fill(textToType);
+         // console.debug(await showAttributesInLocator(element));
+    });
+});
+
+When(`I set timeout with value {int}`,  async function (this: World, newTimeout: number) {
+    await this.testInfo.setTimeout(newTimeout);
+});
+
+
+When(`Within the element with role {string} and name {string}`, async function (this: World, role: string, name: string) {
+    await withinRoleAndName(this, role, name);
+});
+
+When(`Within the element with testId {string}`, async function (this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then(async (element) => await expect(element.getByTestId(testId)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.TEST_ID, value: testId });
+});
+
+
+When(
+    `I mock a request {} on url {string} named {string} with content {}`,
+    async function (this: World, verb: string, url: string, name: string, body: any) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        await this.page.route(url, async route => {
+            const json = body;
+            await route.fulfill({ json });
+        });
+    }
+);
+
+When(
+    `I mock a request {} on url {string} named {string} with status code {int}`,
+    async function (this: World, verb: string, url: string, name: string, statusCode: number) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        await this.page.route(url, async route => {
+            await route.fulfill({ status: statusCode });
+        });
+    }
+);
+
+When(
+    `I mock a request {} on url {string} named {string} with fixture {}`,
+    async function (this: World, verb: string, url: string, name: string, fixture: any) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        const data = await fs.readFileSync(`playwright/fixtures/${fixture}`);
+        await this.page.route(url, async route => {
+            await route.fulfill({ body: data });
+        });
+    }
+);
+
+Then(`I should see an element with selector {string}`, async function (this: World, selector: string) {
+    await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
+});
+
+When(
+    `I set header(s) for uri {string} and method {string}`,
+    async function (this: World, url: string, method: string, headersToSet: DataTable) {
+        await this.page.route(url, async route => {
+            const headers = route.request().headers();
+            await route.continue({ headers: { ...headers, ...headersToSet.rowsHash() } });
+        });
+    }
+);
+
+When(
+    `I set header(s) for uri {string}`,
+    async function (this: World, url: string, headersToSet: DataTable) {
+        await this.page.route(url, async route => {
+            const headers = route.request().headers();
+            await route.continue({ headers: { ...headers, ...headersToSet.rowsHash() } });
+        });
+    }
+);
+
+Then(`I should see an element with role {string} and name {string}`, async function (this: World, role: string, name: string) {
+    await findWithRoleAndName(this, role, name);
+});
+
+Then(`I should see an element with content {string}`, async function (this: World, textContent: string) {
+    // TODO partie pris de faire en exactitude. A voir si on doit faire 2 phrases https://playwright.dev/docs/api/class-locator#locator-get-by-text
+    await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(1));
+});
+
+Then(`I should not see an element with content {string}`, async function(this: World, textContent: string) {
+    await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(0));
+});
+
+Then(`I should see an element with testId {string}`, async function(this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(1));
+});
+
+Then(`I should not see an element with testId {string}`, async function(this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(0));
+});
+
+Then(
+    `I should not have any accessibility issue`,
+    async function (this: World) {
+        await injectAxe(this.page);
+        await checkA11y(this.page);
+    });
+
+Then(
+    `I should not see an element with role {string} and name {string}`,
+    async function(this: World, role: string, name: string) {
+        await notFoundWithRoleAndName(this, role, name);
+    }
+);
+Then(
+    `I should see an element with role {string} and name {string} and content {string}`,
+    async function(this: World, expectedRole: string, name: string, expectedTextContent: string) {
+        await findWithRoleAndNameAndContent(this, expectedRole, name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see an element with role {string} and name {string} and content {string} disabled`,
+    async function(this: World, expectedRole: string, name: string, expectedTextContent: string)  {
+        await findWithRoleAndNameAndContentDisable(this, expectedRole, name, expectedTextContent);
+    }
+);
+
+Then(
+    `I should see an element with role {string} and name {string} and content {string} not disabled`,
+    async function(this: World, expectedRole: string, name: string, expectedTextContent: string)  {
+        await findWithRoleAndNameAndContentEnable(this, expectedRole, name, expectedTextContent);
+    }
+);
+
+Then(`I should see an element with aria-label {string}`, async function(this: World, expectedAriaLabel: string)  {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(1));
+});
+
+Then(`I should not see an element with aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(0));
+});
+
+Then(`I should see an element with aria-label {string} and content {string}`, async function(this: World, expectedAriaLabel: string, expectedTextContent: string)  {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then(async (element) => {
+            const byLabel = await element.getByLabel(expectedAriaLabel);
+            await expect(byLabel).toHaveCount(1);
+            await expect(byLabel.filter({ hasText: expectedTextContent })).toHaveCount(1);
+    });
+});
+
+Then(`I should consume a mock named {string}`, async function(this: World, name: string) {
+    const cookie = await getCookie(this, COOKIE_NAME.MOCK_URL);
+    const mockUrls: MockType[] = JSON.parse(cookie.value);
+    const mockUrl: MockType | undefined = mockUrls.find(mock => mock.name === name);
+    await expect(mockUrl).not.toBeUndefined();
+    const requestPromise = await this.page.waitForResponse(mockUrl?.url);
+    const request = await requestPromise;
+    await deleteCookieByValue(this, COOKIE_NAME.MOCK_URL, mockUrl);
+    // console.debug("request: ", request);
+});
+//
+Then(`I wait {int} ms`, async function (this: World, ms: number) {
+    await this.page.waitForTimeout(ms);
+});
+
+Then(
+    `I should see these attributes with values`,
+    async function (this: World, expectedAttributeList: DataTable) {
+        await getPageOrElement(this).then(async (element) => {
+            // console.debug("expectedAttributeList.raw(),", expectedAttributeList.raw())
+            for (const expectedAttribute of expectedAttributeList.raw()) {
+                const attributeName = expectedAttribute[0];
+                const attributeValue = expectedAttribute[1];
+                // await showAttributesInLocator(element);
+                expect(await element.getAttribute(attributeName)).toEqual(attributeValue);
+            }
+        });
+    }
+);
+
+Then(
+    `I should see elements of the list with name {string}`,
+    async function(this: World, expectedListName: string, expectedElementsOfList: DataTable) {
+        await withinRoleAndName(this, "list", expectedListName);
+        await getPageOrElement(this).then(async (element) => {
+            const listitem = await element.getByRole("listitem").all();
+            const foundedElement: any[] = [];
+            for (const element of listitem) {
+                const textContent = await element.textContent();
+                foundedElement.push([textContent]);
+            }
+            await expect(foundedElement.length).toBeGreaterThan(0);
+            // console.debug(`expected [${expectedElementsOfList.raw()}] to be [${foundedElement}]`);
+            await expect(listitem.length).toEqual(expectedElementsOfList.raw().length);
+            await expect(foundedElement).toEqual(expectedElementsOfList.raw());
+        });
+    }
+);
+
+

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

@@ -0,0 +1,285 @@
+/*******************************
+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 { DEFAULT_TIMEOUT, fs, key } from "@uuv/runner-commons";
+import { checkA11y, injectAxe } from "axe-playwright";
+import { Locator } from "playwright";
+import { devices, expect } from "@playwright/test";
+import { DataTable } from "@cucumber/cucumber";
+import {
+    addCookieWhenValueIsList,
+    COOKIE_NAME, deleteCookieByName,
+    deleteCookieByValue,
+    FILTER_TYPE,
+    findWithRoleAndName,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getCookie,
+    getPageOrElement,
+    MockType,
+    notFoundWithRoleAndName,
+    withinRoleAndName
+} from "../core-engine";
+
+import { Given, When, Then } from "@cucumber/cucumber";
+import { World } from "../../../preprocessor/run/world";
+
+Given(`je redimensionne la fenêtre à la vue {string}`, async function(this: World, viewportPreset: string) {
+    await this.page.setViewportSize(devices[viewportPreset].viewport);
+});
+
+Given(
+    `je redimensionne la fenêtre avec une largeur de {int} px et une longueur de {int} px`, async function
+    (this: World, width: number, height: number) {
+        await this.page.setViewportSize({ width: width, height: height });
+    }
+);
+
+Given(`je visite l'Url {string}`, { timeout: 60 * 1000 }, async function (this: World, siteUrl: string) {
+    await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    await this.page.goto(`${siteUrl}`);
+});
+
+When(`je clique`, async function (this: World) {
+    await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
+});
+
+// TODO : permet de gérer les label accessibles donc pas que les aria : https://playwright.dev/docs/api/class-locator#locator-get-by-label
+When(`je vais à l'intérieur de l'élément ayant pour aria-label {string}`, async function (this: World, expectedAriaLabel: string) {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: expectedAriaLabel });
+});
+When(`je reinitialise le contexte`, async function (this: World) {
+    await this.context.clearCookies();
+});
+
+When(`je vais à l'intérieur de l'élément ayant pour sélecteur {string}`, async function (this: World, selector: string) {
+    await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR, value: selector });
+});
+
+When(`je saisie le(s) mot(s) {string}`, async function (this: World, textToType: string) {
+    await getPageOrElement(this).then(async (element: Locator) => {
+        await element.focus({ timeout: 10000 });
+        await element.fill(textToType);
+         // console.debug(await showAttributesInLocator(element));
+    });
+});
+
+When(`je positionne le timeout à {int} secondes`,  async function (this: World, newTimeout: number) {
+    await this.testInfo.setTimeout(newTimeout);
+});
+
+
+When(`je vais à l'intérieur de l'élément ayant pour rôle {string} et pour nom {string}`, async function (this: World, role: string, name: string) {
+    await withinRoleAndName(this, role, name);
+});
+
+When(`je vais à l'intérieur de l'élément ayant pour testId {string}`, async function (this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then(async (element) => await expect(element.getByTestId(testId)).toHaveCount(1));
+    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.TEST_ID, value: testId });
+});
+
+
+When(
+    `je simule une requête {} sur l'url {string} nommée {string} avec le contenu suivant {}`,
+    async function (this: World, verb: string, url: string, name: string, body: any) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        await this.page.route(url, async route => {
+            const json = body;
+            await route.fulfill({ json });
+        });
+    }
+);
+
+When(
+    `je simule une requête {} sur l'url {string} nommée {string} avec le code http {int}`,
+    async function (this: World, verb: string, url: string, name: string, statusCode: number) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        await this.page.route(url, async route => {
+            await route.fulfill({ status: statusCode });
+        });
+    }
+);
+
+When(
+    `je simule une requête {} sur l'url {string} nommée {string} avec le fichier suivant {}`,
+    async function (this: World, verb: string, url: string, name: string, fixture: any) {
+        await addCookieWhenValueIsList(this, COOKIE_NAME.MOCK_URL, { name: name, url: url });
+        const data = await fs.readFileSync(`playwright/fixtures/${fixture}`);
+        await this.page.route(url, async route => {
+            await route.fulfill({ body: data });
+        });
+    }
+);
+
+Then(`je dois voir un élément ayant pour sélecteur {string}`, async function (this: World, selector: string) {
+    await getPageOrElement(this).then((element) => expect(element.locator(selector)).toHaveCount(1));
+});
+
+When(
+    `je saisie le(s) header(s) pour l'Uri {string} et la methode {string}`,
+    async function (this: World, url: string, method: string, headersToSet: DataTable) {
+        await this.page.route(url, async route => {
+            const headers = route.request().headers();
+            await route.continue({ headers: { ...headers, ...headersToSet.rowsHash() } });
+        });
+    }
+);
+
+When(
+    `je saisie le(s) header(s) pour l'Uri {string}`,
+    async function (this: World, url: string, headersToSet: DataTable) {
+        await this.page.route(url, async route => {
+            const headers = route.request().headers();
+            await route.continue({ headers: { ...headers, ...headersToSet.rowsHash() } });
+        });
+    }
+);
+
+Then(`je dois voir un élément avec le rôle {string} et le nom {string}`, async function (this: World, role: string, name: string) {
+    await findWithRoleAndName(this, role, name);
+});
+
+Then(`je dois voir un élément qui contient {string}`, async function (this: World, textContent: string) {
+    // TODO partie pris de faire en exactitude. A voir si on doit faire 2 phrases https://playwright.dev/docs/api/class-locator#locator-get-by-text
+    await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(1));
+});
+
+Then(`je ne dois pas voir un élément qui contient {string}`, async function(this: World, textContent: string) {
+    await getPageOrElement(this).then((element) => expect(element.getByText(textContent, { exact: true })).toHaveCount(0));
+});
+
+Then(`je dois voir un élément ayant pour testId {string}`, async function(this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(1));
+});
+
+Then(`je ne dois pas voir un élément ayant pour testId {string}`, async function(this: World, testId: string) {
+    testId = encodeURIComponent(testId);
+    await getPageOrElement(this).then((element) => expect(element.getByTestId(testId, { exact: true })).toHaveCount(0));
+});
+
+Then(
+    `je ne dois pas avoir de problèmes d'accessibilité`,
+    async function (this: World) {
+        await injectAxe(this.page);
+        await checkA11y(this.page);
+    });
+
+Then(
+    `je ne dois pas voir un élément avec le rôle {string} et le nom {string}`,
+    async function(this: World, role: string, name: string) {
+        await notFoundWithRoleAndName(this, role, name);
+    }
+);
+Then(
+    `je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string}`,
+    async function(this: World, expectedRole: string, name: string, expectedTextContent: string) {
+        await findWithRoleAndNameAndContent(this, 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(this: World, expectedRole: string, name: string, expectedTextContent: string)  {
+        await findWithRoleAndNameAndContentDisable(this, 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(this: World, expectedRole: string, name: string, expectedTextContent: string)  {
+        await findWithRoleAndNameAndContentEnable(this, expectedRole, name, expectedTextContent);
+    }
+);
+
+Then(`je dois voir un élément ayant pour aria-label {string}`, async function(this: World, expectedAriaLabel: string)  {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(1));
+});
+
+Then(`je ne dois pas voir un élément ayant pour aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then((element) => expect(element.getByLabel(expectedAriaLabel)).toHaveCount(0));
+});
+
+Then(`je dois voir un élément ayant pour aria-label {string} et pour contenu {string}`, async function(this: World, expectedAriaLabel: string, expectedTextContent: string)  {
+    expectedAriaLabel = encodeURIComponent(expectedAriaLabel);
+    await getPageOrElement(this).then(async (element) => {
+            const byLabel = await element.getByLabel(expectedAriaLabel);
+            await expect(byLabel).toHaveCount(1);
+            await expect(byLabel.filter({ hasText: expectedTextContent })).toHaveCount(1);
+    });
+});
+
+Then(`je dois consommer le bouchon nommé {string}`, async function(this: World, name: string) {
+    const cookie = await getCookie(this, COOKIE_NAME.MOCK_URL);
+    const mockUrls: MockType[] = JSON.parse(cookie.value);
+    const mockUrl: MockType | undefined = mockUrls.find(mock => mock.name === name);
+    await expect(mockUrl).not.toBeUndefined();
+    const requestPromise = await this.page.waitForResponse(mockUrl?.url);
+    const request = await requestPromise;
+    await deleteCookieByValue(this, COOKIE_NAME.MOCK_URL, mockUrl);
+    // console.debug("request: ", request);
+});
+//
+Then(`j'attends {int} ms`, async function (this: World, ms: number) {
+    await this.page.waitForTimeout(ms);
+});
+
+Then(
+    `je dois voir les attributs avec valeurs suivantes`,
+    async function (this: World, expectedAttributeList: DataTable) {
+        await getPageOrElement(this).then(async (element) => {
+            // console.debug("expectedAttributeList.raw(),", expectedAttributeList.raw())
+            for (const expectedAttribute of expectedAttributeList.raw()) {
+                const attributeName = expectedAttribute[0];
+                const attributeValue = expectedAttribute[1];
+                // await showAttributesInLocator(element);
+                expect(await element.getAttribute(attributeName)).toEqual(attributeValue);
+            }
+        });
+    }
+);
+
+Then(
+    `je dois voir des elements de la liste ayant pour nom {string}`,
+    async function(this: World, expectedListName: string, expectedElementsOfList: DataTable) {
+        await withinRoleAndName(this, "list", expectedListName);
+        await getPageOrElement(this).then(async (element) => {
+            const listitem = await element.getByRole("listitem").all();
+            const foundedElement: any[] = [];
+            for (const element of listitem) {
+                const textContent = await element.textContent();
+                foundedElement.push([textContent]);
+            }
+            await expect(foundedElement.length).toBeGreaterThan(0);
+            // console.debug(`expected [${expectedElementsOfList.raw()}] to be [${foundedElement}]`);
+            await expect(listitem.length).toEqual(expectedElementsOfList.raw().length);
+            await expect(foundedElement).toEqual(expectedElementsOfList.raw());
+        });
+    }
+);
+
+

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

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