@uuv/playwright 1.6.1 → 1.7.0

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

@@ -3,283 +3,382 @@ NE PAS MODIFIER, FICHIER GENERE
 *******************************/
 
 /**
-* 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 { DEFAULT_TIMEOUT, fs, key } from "@uuv/runner-commons";
-import { checkA11y, injectAxe } from "axe-playwright";
+ * 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 { DEFAULT_TIMEOUT, fs, key, KEY_PRESS } from "@uuv/runner-commons";
+import { checkA11y, configureAxe, injectAxe } from "axe-playwright";
 import { Locator } from "playwright";
 import { devices, expect } from "@playwright/test";
 import { Page } from "playwright";
 import { DataTable } from "@cucumber/cucumber";
 import {
-    addCookieWhenValueIsList,
-    COOKIE_NAME, deleteCookieByName,
-    deleteCookieByValue,
-    FILTER_TYPE,
-    findWithRoleAndName,
-    findWithRoleAndNameAndContent,
-    findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
-    getCookie,
-    getPageOrElement,
-    MockType,
-    notFoundWithRoleAndName,
-    withinRoleAndName
+  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";
+import { ContextObject, RunOptions } from "axe-core";
 
 Given(`je redimensionne la fenêtre à la vue {string}`, async function(this: World, viewportPreset: string) {
-    await this.page.setViewportSize(devices[viewportPreset].viewport);
+  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 });
-    }
+ `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}`);
+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 }));
+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) {
-    const sanitizedExpectedAriaLabel = encodeURIComponent(expectedAriaLabel).replaceAll("%20", " ");
-    await getPageOrElement(this).then((element) => expect(element.getByLabel(sanitizedExpectedAriaLabel)).toHaveCount(1));
-    await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: sanitizedExpectedAriaLabel });
+When(`je vais à l'intérieur de l'élément ayant pour aria-label {string}`, async function(this: World, expectedAriaLabel: string) {
+  const sanitizedExpectedAriaLabel = encodeURIComponent(expectedAriaLabel).replaceAll("%20", " ");
+  await getPageOrElement(this).then((element) => expect(element.getByLabel(sanitizedExpectedAriaLabel)).toHaveCount(1));
+  await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: sanitizedExpectedAriaLabel });
 });
-When(`je reinitialise le contexte`, async function (this: World) {
-    await this.context.clearCookies();
+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 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) {
+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.type(textToType);
+    // console.debug(await showAttributesInLocator(element));
+  });
+});
+
+
+When(`j'appuie {int} fois sur {string}`, async function(this: World, nbTimes: number, key: string) {
+  for (let i = 1; i <= nbTimes; i++) {
     await getPageOrElement(this).then(async (element: Locator) => {
-        await element.focus({ timeout: 10000 });
-        await element.fill(textToType);
-         // console.debug(await showAttributesInLocator(element));
+      await element.focus({ timeout: 10000 });
+      await pressKey(this, element, key);
     });
+  }
 });
 
-When(`je positionne le timeout à {int} secondes`,  async function (this: World, newTimeout: number) {
-    await this.testInfo.setTimeout(newTimeout);
+When(`j'appuie sur {string}`, async function(this: World, key: string) {
+  await getPageOrElement(this).then(async (element: Locator) => {
+    await element.focus({ timeout: 10000 });
+    await pressKey(this, element, key);
+  });
+});
+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 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 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 });
-        });
-    }
+ `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 });
-        });
-    }
+ `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 });
-        });
-    }
+ `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));
+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() } });
-        });
-    }
+ `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() } });
-        });
-    }
+ `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 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 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));
+  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));
+  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));
+  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 as Page);
-        await checkA11y(this.page as Page);
-    });
+ `je ne dois pas avoir de problèmes d'accessibilité`,
+ async function(this: World) {
+   await injectAxe(this.page as Page);
+   await checkA11y(this.page as Page);
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec le fichier json suivant d'option {}`,
+ async function(this: World, option: any) {
+   await injectAxe(this.page as Page);
+   const optionFile = await fs.readFileSync(`playwright/fixtures/${option}`);
+   const optionJson = JSON.parse(optionFile.toString());
+   await checkA11y(this.page as Page, undefined, {
+     axeOptions: optionJson as RunOptions
+   });
+ });
+
+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(this: World, context: any, option: any) {
+   await injectAxe(this.page as Page);
+   const contextFile = await fs.readFileSync(`playwright/fixtures/${context}`);
+   const optionFile = await fs.readFileSync(`playwright/fixtures/${option}`);
+   const optionJson = JSON.parse(optionFile.toString());
+   await checkA11y(this.page as Page, JSON.parse(contextFile.toString()) as ContextObject, {
+     axeOptions: optionJson as RunOptions
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité de niveau critique`,
+ async function(this: World) {
+   await injectAxe(this.page as Page);
+   await checkA11y(this.page as Page, undefined, {
+     includedImpacts: ["critical"]
+   });
+ });
+
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec l(es) impact(s) {}`,
+ async function(this: World, impacts: any) {
+   await injectAxe(this.page as Page);
+   await checkA11y(this.page as Page, undefined, {
+     includedImpacts: [impacts]
+   });
+ });
+Then(
+ `je ne dois pas avoir de problèmes d'accessibilité avec le(s) standard(s) {}`,
+ async function(this: World, tags: any) {
+   await injectAxe(this.page as Page);
+   await checkA11y(this.page as Page, undefined, {
+     axeOptions: {
+       runOnly: {
+         type: "tag",
+         values: [tags]
+       }
+     }
+   });
+ });
 
 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);
-    }
+ `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);
-    }
+ `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);
-    }
+ `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);
-    }
+ `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 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));
+  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 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);
+  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(`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);
-            }
-        });
-    }
+ `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());
-        });
-    }
+ `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());
+   });
+ }
 );
 
+async function pressKey(world: World, element: Locator, key: string) {
+  switch (key) {
+    case KEY_PRESS.TAB:
+      await element.press("Tab");
+      break;
+    case KEY_PRESS.REVERSE_TAB:
+      await element.press("ShiftLeft+Tab");
+      break;
+    case KEY_PRESS.UP:
+      await element.press("ArrowUp");
+      break;
+    case KEY_PRESS.DOWN:
+      await element.press("ArrowDown");
+      break;
+    case KEY_PRESS.LEFT:
+      await element.press("ArrowLeft");
+      break;
+    case KEY_PRESS.RIGHT:
+      await element.press("ArrowRight");
+      break;
+    default:
+      console.error("the command" + key + " is unrecognized.");
+      break;
+  }
+  await deleteCookieByName(world, COOKIE_NAME.SELECTED_ELEMENT);
+  await addCookieWhenValueIsList(world, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.SELECTOR_PARENT, value: "*:focus" });
+}
+