@uuv/playwright 3.4.0 → 3.4.1

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

@@ -20,26 +20,25 @@ import { DEFAULT_TIMEOUT, fs, KEY_PRESS } from "@uuv/runner-commons";
 
 import { checkA11y, injectAxe } from "axe-playwright";
 import { devices, expect } from "@playwright/test";
-import { Page, Locator } from "playwright";
-import { DataTable } from "@cucumber/cucumber";
+import { Locator, Page } from "playwright";
+import { DataTable, Given, Then, When } from "@cucumber/cucumber";
 import {
-    addCookieWhenValueIsList,
-    COOKIE_NAME, deleteCookieByName,
-    deleteCookieByValue,
-    FILTER_TYPE,
-    findWithRoleAndName,
-    findWithRoleAndNameAndContent,
-    findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable,
-    findWithRoleAndNameFocused,
-    getCookie,
-    getPageOrElement,
-    MockType,
-    notFoundWithRoleAndName,
-    withinRoleAndName
+  addCookie,
+  COOKIE_NAME,
+  deleteCookieByName,
+  FILTER_TYPE,
+  findWithRoleAndName,
+  findWithRoleAndNameAndContent,
+  findWithRoleAndNameAndContentDisable,
+  findWithRoleAndNameAndContentEnable,
+  findWithRoleAndNameFocused,
+  getCookie,
+  getPageOrElement,
+  MockCookie,
+  notFoundWithRoleAndName,
+  SelectedElementCookie,
+  withinRoleAndName
 } from "../core-engine";
-
-import { Given, When, Then } from "@cucumber/cucumber";
 import { World } from "../../../preprocessor/run/world";
 import { ContextObject, RunOptions } from "axe-core";
 import path from "path";
@@ -65,10 +64,10 @@ Given(
  * Démarre une session de navigation au clavier à partir du haut de la page<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 Given(
-    `je commence une navigation au clavier depuis le haut de la page`,
-    async function(this: World) {
-        await this.page.mouse.click(0.5, 0.5);
-    }
+ `je commence une navigation au clavier depuis le haut de la page`,
+ async function(this: World) {
+   await this.page.mouse.click(0.5, 0.5);
+ }
 );
 
 /**
@@ -83,12 +82,12 @@ Given(`je visite l'Url {string}`, { timeout: 60 * 1000 }, async function(this: W
  * Déclenche un click sur l'élément sélectionné.<br/>Assurez vous d'avoir effectué une sélection d'élément avant avec les phrases <strong>Je vais à l'intérieur...</strong>.
  * */
 When(`je clique`, async function(this: World) {
-    const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
-    if ((await keyBoardFocusTargetObj.count()) === 1) {
-        await keyBoardFocusTargetObj.click({ timeout: DEFAULT_TIMEOUT });
-    } else {
-        await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
-    }
+  const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
+  if ((await keyBoardFocusTargetObj.count()) === 1) {
+    await keyBoardFocusTargetObj.click({ timeout: DEFAULT_TIMEOUT });
+  } else {
+    await getPageOrElement(this).then((element: Locator) => element.click({ timeout: DEFAULT_TIMEOUT }));
+  }
 });
 
 /**
@@ -112,14 +111,14 @@ When(`je clique sur l'élément avec le rôle {string} et le nom {string}`, asyn
 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, { exact: true })).toHaveCount(1));
-  await addCookieWhenValueIsList(this, COOKIE_NAME.SELECTED_ELEMENT, { name: FILTER_TYPE.ARIA_LABEL, value: sanitizedExpectedAriaLabel });
+  await addCookie(this, COOKIE_NAME.SELECTED_ELEMENT, new SelectedElementCookie(FILTER_TYPE.ARIA_LABEL, sanitizedExpectedAriaLabel));
 });
 
 /**
  * Supprime l'élément sélectionné et le timeout du contexte
  * */
 When(`je reinitialise le contexte`, async function(this: World) {
-  await this.context.clearCookies();
+  await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
 });
 
 /**
@@ -127,23 +126,23 @@ When(`je reinitialise le contexte`, async function(this: World) {
  * */
 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 });
+  await addCookie(this, COOKIE_NAME.SELECTED_ELEMENT, new SelectedElementCookie(FILTER_TYPE.SELECTOR, selector));
 });
 
 /**
  * Saisit de la phrase passée en paramètre (utile par exemple pour remplir un champ de formulaire).<br/>Assurez vous d'avoir effectué une sélection d'élément avant avec les phrases <strong>Je vais à l'intérieur...</strong>.
  * */
 When(`je saisie le(s) mot(s) {string}`, async function(this: World, textToType: string) {
-    const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
-    if ((await keyBoardFocusTargetObj.count()) === 1) {
-        await keyBoardFocusTargetObj.type(textToType);
-    } else {
-        await getPageOrElement(this).then(async (element: Locator) => {
-            // console.debug(element);
-            await element.focus({ timeout: 10000 });
-            await element.type(textToType);
-        });
-    }
+  const keyBoardFocusTargetObj = keyBoardFocusTarget(this);
+  if ((await keyBoardFocusTargetObj.count()) === 1) {
+    await keyBoardFocusTargetObj.type(textToType);
+  } else {
+    await getPageOrElement(this).then(async (element: Locator) => {
+      // console.debug(element);
+      await element.focus({ timeout: 10000 });
+      await element.type(textToType);
+    });
+  }
 });
 
 /**
@@ -159,21 +158,21 @@ When(`j'appuie {int} fois sur {string}`, async function(this: World, nbTimes: nu
  * Simule un appui sur la touche spécifiée : <table><thead><tr><th>Touche</th><th>Description</th></tr></thead><tbody><tr><td>{tab}</td><td>Tabulation</td></tr><tr><td>{reverseTab}</td><td>Tabulation arrière</td></tr><tr><td>{down}</td><td>Flèche du bas</td></tr><tr><td>{right}</td><td>Flèche de droite</td></tr><tr><td>{left}</td><td>Flèche de gauche</td></tr><tr><td>{up}</td><td>Flèche du haut</td></tr></tbody></table>.<br/>Assurez vous d'avoir effectué une sélection d'élément avant avec les phrases <strong>Je vais à l'intérieur...</strong>.
  * */
 When(`j'appuie sur {string}`, async function(this: World, key: string) {
-    await pressKey(this, key);
+  await pressKey(this, key);
 });
 
 /**
  * se déplace au précédent élément HTML atteignable avec la tabulation retour<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 When(`je vais au précédent élément au clavier`, async function(this: World) {
-    await this.page.keyboard.press("ShiftLeft+Tab");
+  await this.page.keyboard.press("ShiftLeft+Tab");
 });
 
 /**
  * se déplace au prochain élément HTML atteignable avec la tabulation<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 When(`je vais au prochain élément au clavier`, async function(this: World) {
-    await this.page.keyboard.press("Tab");
+  await this.page.keyboard.press("Tab");
 });
 
 /**
@@ -196,7 +195,7 @@ When(`je vais à l'intérieur de l'élément ayant pour rôle {string} et pour n
 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 });
+  await addCookie(this, COOKIE_NAME.SELECTED_ELEMENT, new SelectedElementCookie(FILTER_TYPE.TEST_ID, testId));
 });
 
 /**
@@ -205,10 +204,10 @@ When(`je vais à l'intérieur de l'élément ayant pour testId {string}`, async
 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 addCookie(this, COOKIE_NAME.MOCK_URL, new MockCookie(name, url, verb));
    await this.page.route(url, async route => {
-     const json = body;
-     await route.fulfill({ json });
+     await route.fulfill({ body });
+     await afterMock(this, url, verb, name);
    });
  }
 );
@@ -219,9 +218,10 @@ When(
 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 addCookie(this, COOKIE_NAME.MOCK_URL, new MockCookie(name, url, verb));
    await this.page.route(url, async route => {
      await route.fulfill({ status: statusCode });
+     await afterMock(this, url, verb, name);
    });
  }
 );
@@ -232,10 +232,12 @@ When(
 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(path.join(getConfigDir(), `playwright/fixtures/${fixture}`));
+   await addCookie(this, COOKIE_NAME.MOCK_URL, new MockCookie(name, url, verb));
+   const data = fs.readFileSync(path.join(getConfigDir(), `playwright/fixtures/${fixture}`), "utf8");
    await this.page.route(url, async route => {
      await route.fulfill({ body: data });
+     await afterMock(this, url, verb, name);
+
    });
  }
 );
@@ -325,7 +327,7 @@ Then(
  * Vérifie sur la page courante qu'il n'y a aucune erreur d'accessibilité [axe-core](https://github.com/dequelabs/axe-core/blob/develop/doc/rule-descriptions.md) [avec l'option](https://github.com/dequelabs/axe-core/blob/HEAD/doc/API.md#options-parameter)
  * */
 Then(
-     `je ne dois pas avoir de problèmes d'accessibilité axe-core avec le fichier json suivant d'option {}`,
+ `je ne dois pas avoir de problèmes d'accessibilité axe-core avec le fichier json suivant d'option {}`,
  async function(this: World, option: any) {
    await injectAxe(this.page as Page);
    const optionFile = await fs.readFileSync(path.join(getConfigDir(), `playwright/fixtures/${option}`));
@@ -336,8 +338,8 @@ Then(
  });
 
 function getConfigDir(): string {
-    // eslint-disable-next-line dot-notation
-    return process.env["CONFIG_DIR"] ? process.env["CONFIG_DIR"] : "";
+  // eslint-disable-next-line dot-notation
+  return process.env["CONFIG_DIR"] ? process.env["CONFIG_DIR"] : "";
 }
 
 /**
@@ -420,10 +422,10 @@ Then(
  * Vérifie que l'élément Html avec le [rôle accessible](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) est focus<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 Then(
-    `l'élément avec le rôle {string} et le nom {string} doit avoir le focus clavier`,
-    async function(this: World, expectedRole: string, name: string) {
-        await findWithRoleAndNameFocused(this, expectedRole, name);
-    }
+ `l'élément avec le rôle {string} et le nom {string} doit avoir le focus clavier`,
+ async function(this: World, expectedRole: string, name: string) {
+   await findWithRoleAndNameFocused(this, expectedRole, name);
+ }
 );
 
 /**
@@ -432,7 +434,7 @@ Then(
 Then(
  `l'élément avec le sélecteur {string} doit avoir le focus clavier`,
  async function(this: World, selector: string) {
-   await getPageOrElement(this).then( async(element) => {
+   await getPageOrElement(this).then(async (element) => {
      const locator = element.locator(selector);
      await locator.focus({ timeout: 10000 });
      await expect(locator).toHaveCount(1);
@@ -492,16 +494,16 @@ Then(`je dois voir un élément ayant pour aria-label {string} et pour contenu {
  * Se déplace au précédent élément HTML atteignable avec la tabulation et vérifie que l'élément Html avec le [rôle accessible](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) a le focus clavier<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 When(`le précédent élément avec le focus clavier doit avoir le role {string} et le nom {string}`, async function(this: World, expectedRole: string, name: string) {
-    await this.page.keyboard.press("ShiftLeft+Tab");
-    await findWithRoleAndNameFocused(this, expectedRole, name);
+  await this.page.keyboard.press("ShiftLeft+Tab");
+  await findWithRoleAndNameFocused(this, expectedRole, name);
 });
 
 /**
  * "Se déplace au prochain élément HTML atteignable avec la tabulation et vérifie que l'élément Html avec le [rôle accessible](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) et le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) a le focus clavier<br/><a target='_blank' href='https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-keyboard.feature'>Exemples</a>
  * */
 When(`le prochain élément avec le focus clavier doit avoir le role {string} et le nom {string}`, async function(this: World, expectedRole: string, name: string) {
-    await this.page.keyboard.press("Tab");
-    await findWithRoleAndNameFocused(this, expectedRole, name);
+  await this.page.keyboard.press("Tab");
+  await findWithRoleAndNameFocused(this, expectedRole, name);
 });
 
 
@@ -510,13 +512,21 @@ When(`le prochain élément avec le focus clavier doit avoir le role {string} et
  * */
 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);
+  expect(() => {
+    if (!cookie.isValid()) {
+      throw new Error(`Mock ${name} must be defined before use this sentence`);
+    }
+  }).not.toThrow();
+
+  await expect.poll(async () => {
+    const cookie = await getCookie(this, COOKIE_NAME.MOCK_URL);
+    const mockUrls: MockCookie[] = JSON.parse(cookie.value);
+    const mockUrl = mockUrls.find(mock => mock.name === name);
+    if (mockUrl) {
+      return mockUrl?.isConsumed;
+    }
+    return false;
+  }).toBeDefined();
 });
 
 /**
@@ -567,42 +577,60 @@ Then(
 );
 
 async function pressKey(world: World, key: string) {
-    switch (key) {
-        case KEY_PRESS.TAB:
-            await world.page.keyboard.press("Tab");
-            break;
-        case KEY_PRESS.REVERSE_TAB:
-            await world.page.keyboard.press("ShiftLeft+Tab");
-            break;
-        case KEY_PRESS.UP:
-            await world.page.keyboard.press("ArrowUp");
-            break;
-        case KEY_PRESS.DOWN:
-            await world.page.keyboard.press("ArrowDown");
-            break;
-        case KEY_PRESS.LEFT:
-            await world.page.keyboard.press("ArrowLeft");
-            break;
-        case KEY_PRESS.RIGHT:
-            await world.page.keyboard.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" });
+  switch (key) {
+    case KEY_PRESS.TAB:
+      await world.page.keyboard.press("Tab");
+      break;
+    case KEY_PRESS.REVERSE_TAB:
+      await world.page.keyboard.press("ShiftLeft+Tab");
+      break;
+    case KEY_PRESS.UP:
+      await world.page.keyboard.press("ArrowUp");
+      break;
+    case KEY_PRESS.DOWN:
+      await world.page.keyboard.press("ArrowDown");
+      break;
+    case KEY_PRESS.LEFT:
+      await world.page.keyboard.press("ArrowLeft");
+      break;
+    case KEY_PRESS.RIGHT:
+      await world.page.keyboard.press("ArrowRight");
+      break;
+    default:
+      console.error("the command" + key + " is unrecognized.");
+      break;
+  }
+  await deleteCookieByName(world, COOKIE_NAME.SELECTED_ELEMENT);
+  await addCookie(world, COOKIE_NAME.SELECTED_ELEMENT, new SelectedElementCookie(FILTER_TYPE.SELECTOR_PARENT, "*:focus"));
 }
 
 async function click(world: World, role: any, name: string) {
   await getPageOrElement(world).then(async (element) => {
-      const byRole = element.getByRole(role, { name: name, includeHidden: true, exact: true });
-      await expect(byRole).toHaveCount(1);
-      await byRole.click({ timeout: DEFAULT_TIMEOUT });
-      await world.context.clearCookies();
+    const byRole = element.getByRole(role, { name: name, includeHidden: true, exact: true });
+    await expect(byRole).toHaveCount(1);
+    await byRole.click({ timeout: DEFAULT_TIMEOUT });
+    await world.page.waitForLoadState();
+    await deleteCookieByName(world, COOKIE_NAME.SELECTED_ELEMENT);
   });
 }
 
 function keyBoardFocusTarget(world: World) {
-    return world.page.locator(":focus");
+  return world.page.locator(":focus");
+}
+
+async function setMockAsConsumed(name: string, mock: MockCookie, world: World<any>) {
+  const newMockCookie = new MockCookie(name, mock.url, mock.verb);
+  newMockCookie.isConsumed = true;
+  await addCookie(world, COOKIE_NAME.MOCK_URL, newMockCookie);
+}
+
+async function afterMock(world: World, url: string, verb: string, name: string) {
+  await world.page.waitForResponse(url);
+  const cookie = await getCookie(world, COOKIE_NAME.MOCK_URL);
+  const mockCookie: MockCookie[] = JSON.parse(cookie.value);
+  for (const mock of mockCookie) {
+    if (mock.name === name && mock.verb === verb && mock.url === url) {
+      await setMockAsConsumed(name, mock, world);
+    }
+  }
 }

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

@@ -19,13 +19,14 @@ NE PAS MODIFIER, FICHIER GENERE
 
 import { Then, When } from "@cucumber/cucumber";
 import {
-    findWithRoleAndName,
-    findWithRoleAndNameAndContent,
-    findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
-    getPageOrElement,
-    notFoundWithRoleAndName,
-    withinRoleAndName
+  COOKIE_NAME, deleteCookieByName,
+  findWithRoleAndName,
+  findWithRoleAndNameAndContent,
+  findWithRoleAndNameAndContentDisable,
+  findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
+  getPageOrElement,
+  notFoundWithRoleAndName,
+  withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
@@ -35,25 +36,25 @@ import { expect } from "@playwright/test";
 /**
  * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
  * */
-When(`within an alert named {string}`, async function (this: World, name: string) {
-    return await withinRoleAndName(this, "alert", name);
+When(`within an alert named {string}`, async function(this: World, name: string) {
+  return await withinRoleAndName(this, "alert", name);
 });
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
  * */
-Then(`I should see an alert named {string}`, async function (this: World, name: string)  {
-    await findWithRoleAndName(this, "alert", name);
+Then(`I should see an alert named {string}`, async function(this: World, name: string) {
+  await findWithRoleAndName(this, "alert", name);
 });
 
 /**
  * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
  * */
 Then(
-    `I should not see an alert named {string}`,
-    async function (this: World, name: string)  {
-       await notFoundWithRoleAndName(this, "alert", name);
-    }
+ `I should not see an alert named {string}`,
+ async function(this: World, name: string) {
+   await notFoundWithRoleAndName(this, "alert", name);
+ }
 );
 
 // End of General Section
@@ -63,12 +64,12 @@ Then(
  * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
  * */
 When(`I type the sentence {string} in the alert named {string}`, async function(this: World, textToType: string, name: string) {
-    await getPageOrElement(this).then(async (element) => {
-        const byRole = await element.getByRole("alert", { name: name, includeHidden: true, exact: true });
-        await expect(byRole).toHaveCount(1);
-        await byRole.type(textToType);
-        await this.context.clearCookies();
-    });
+  await getPageOrElement(this).then(async (element) => {
+    const byRole = await element.getByRole("alert", { name: name, includeHidden: true, exact: true });
+    await expect(byRole).toHaveCount(1);
+    await byRole.type(textToType);
+    await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+  });
 });
 
 // End of Type Section
@@ -78,30 +79,30 @@ When(`I type the sentence {string} in the alert named {string}`, async function(
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
  * */
 Then(
-    `I should see an alert named {string} and containing {string}`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContent(this, "alert", name, expectedTextContent);
-    }
+ `I should see an alert named {string} and containing {string}`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContent(this, "alert", name, expectedTextContent);
+ }
 );
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 Then(
-    `I should see an alert named {string} and containing {string} disabled`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContentDisable(this, "alert", name, expectedTextContent);
-    }
+ `I should see an alert named {string} and containing {string} disabled`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContentDisable(this, "alert", name, expectedTextContent);
+ }
 );
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 Then(
-    `I should see an alert named {string} and containing {string} enabled`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContentEnable(this, "alert", name, expectedTextContent);
-    }
+ `I should see an alert named {string} and containing {string} enabled`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContentEnable(this, "alert", name, expectedTextContent);
+ }
 );
 
 // End of Content Section

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

@@ -19,13 +19,14 @@ NE PAS MODIFIER, FICHIER GENERE
 
 import { Then, When } from "@cucumber/cucumber";
 import {
-    findWithRoleAndName,
-    findWithRoleAndNameAndContent,
-    findWithRoleAndNameAndContentDisable,
-    findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
-    getPageOrElement,
-    notFoundWithRoleAndName,
-    withinRoleAndName
+  COOKIE_NAME, deleteCookieByName,
+  findWithRoleAndName,
+  findWithRoleAndNameAndContent,
+  findWithRoleAndNameAndContentDisable,
+  findWithRoleAndNameAndContentEnable, findWithRoleAndNameFocused,
+  getPageOrElement,
+  notFoundWithRoleAndName,
+  withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
@@ -35,25 +36,25 @@ import { expect } from "@playwright/test";
 /**
  * Selects the element whose [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and accessible [name](https://russmaxdesign.github.io/html-elements-names/) are specified <br />⚠ remember to deselect the element with <b>[I reset context](#i-reset-context)</b> if you're no longer acting on it
  * */
-When(`within an alert dialog named {string}`, async function (this: World, name: string) {
-    return await withinRoleAndName(this, "alertdialog", name);
+When(`within an alert dialog named {string}`, async function(this: World, name: string) {
+  return await withinRoleAndName(this, "alertdialog", name);
 });
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
  * */
-Then(`I should see an alert dialog named {string}`, async function (this: World, name: string)  {
-    await findWithRoleAndName(this, "alertdialog", name);
+Then(`I should see an alert dialog named {string}`, async function(this: World, name: string) {
+  await findWithRoleAndName(this, "alertdialog", name);
 });
 
 /**
  * Checks that an Html element does not exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) and [name](https://russmaxdesign.github.io/html-elements-names/)
  * */
 Then(
-    `I should not see an alert dialog named {string}`,
-    async function (this: World, name: string)  {
-       await notFoundWithRoleAndName(this, "alertdialog", name);
-    }
+ `I should not see an alert dialog named {string}`,
+ async function(this: World, name: string) {
+   await notFoundWithRoleAndName(this, "alertdialog", name);
+ }
 );
 
 // End of General Section
@@ -63,12 +64,12 @@ Then(
  * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
  * */
 When(`I type the sentence {string} in the alert dialog named {string}`, async function(this: World, textToType: string, name: string) {
-    await getPageOrElement(this).then(async (element) => {
-        const byRole = await element.getByRole("alertdialog", { name: name, includeHidden: true, exact: true });
-        await expect(byRole).toHaveCount(1);
-        await byRole.type(textToType);
-        await this.context.clearCookies();
-    });
+  await getPageOrElement(this).then(async (element) => {
+    const byRole = await element.getByRole("alertdialog", { name: name, includeHidden: true, exact: true });
+    await expect(byRole).toHaveCount(1);
+    await byRole.type(textToType);
+    await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+  });
 });
 
 // End of Type Section
@@ -78,30 +79,30 @@ When(`I type the sentence {string} in the alert dialog named {string}`, async fu
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content
  * */
 Then(
-    `I should see an alert dialog named {string} and containing {string}`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContent(this, "alertdialog", name, expectedTextContent);
-    }
+ `I should see an alert dialog named {string} and containing {string}`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContent(this, "alertdialog", name, expectedTextContent);
+ }
 );
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 Then(
-    `I should see an alert dialog named {string} and containing {string} disabled`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContentDisable(this, "alertdialog", name, expectedTextContent);
-    }
+ `I should see an alert dialog named {string} and containing {string} disabled`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContentDisable(this, "alertdialog", name, expectedTextContent);
+ }
 );
 
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 Then(
-    `I should see an alert dialog named {string} and containing {string} enabled`,
-    async function (this: World, name: string, expectedTextContent: string)  {
-        await findWithRoleAndNameAndContentEnable(this, "alertdialog", name, expectedTextContent);
-    }
+ `I should see an alert dialog named {string} and containing {string} enabled`,
+ async function(this: World, name: string, expectedTextContent: string) {
+   await findWithRoleAndNameAndContentEnable(this, "alertdialog", name, expectedTextContent);
+ }
 );
 
 // End of Content Section