@uuv/playwright 1.14.2 → 1.15.0

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

@@ -18,13 +18,12 @@ NE PAS MODIFIER, FICHIER GENERE
  */
 
 import { DEFAULT_TIMEOUT, fs, key, KEY_PRESS } from "@uuv/runner-commons";
-import { checkA11y, configureAxe, injectAxe } from "axe-playwright";
-import { Locator } from "playwright";
+import { checkA11y, injectAxe } from "axe-playwright";
 import { devices, expect } from "@playwright/test";
-import { Page } from "playwright";
+import { Page, Locator } from "playwright";
 import { DataTable } from "@cucumber/cucumber";
 import {
-  addCookieWhenValueIsList, checkTextContentLocator,
+  addCookieWhenValueIsList,
   COOKIE_NAME, deleteCookieByName,
   deleteCookieByValue,
   FILTER_TYPE,
@@ -42,6 +41,7 @@ import {
 import { Given, When, Then } from "@cucumber/cucumber";
 import { World } from "../../../preprocessor/run/world";
 import { ContextObject, RunOptions } from "axe-core";
+import path from "path";
 
 Given(`je redimensionne la fenêtre à la vue {string}`, async function(this: World, viewportPreset: string) {
   await this.page.setViewportSize(devices[viewportPreset].viewport);
@@ -152,7 +152,7 @@ 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(`uuv/playwright/fixtures/${fixture}`);
+   const data = await fs.readFileSync(path.join(getConfigDir(), `playwright/fixtures/${fixture}`));
    await this.page.route(url, async route => {
      await route.fulfill({ body: data });
    });
@@ -217,19 +217,23 @@ 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 optionFile = await fs.readFileSync(path.join(getConfigDir(), `playwright/fixtures/${option}`));
    const optionJson = JSON.parse(optionFile.toString());
    await checkA11y(this.page as Page, undefined, {
      axeOptions: optionJson as RunOptions
    });
  });
 
+function getConfigDir(): string {
+    return process.env["CONFIG_DIR"] ? process.env["CONFIG_DIR"] : "";
+}
+
 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 contextFile = await fs.readFileSync(path.join(getConfigDir(), `playwright/fixtures/${context}`));
+   const optionFile = await fs.readFileSync(path.join(getConfigDir(), `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

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) alert named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "alert", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+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();
+    });
+});
+
+
 Then(
     `I should see a(n) alert named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) alert dialog named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "alertdialog", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+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();
+    });
+});
+
+
 Then(
     `I should see a(n) alert dialog named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) application named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "application", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the application named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("application", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) application named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) article named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "article", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the article named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("article", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) article named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) banner named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "banner", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the banner named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("banner", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) banner named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) button named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "button", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the button named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("button", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) button named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) cell named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "cell", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the cell named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("cell", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) cell named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) checkbox named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "checkbox", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the checkbox named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("checkbox", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) checkbox named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) column header named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "columnheader", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the column header named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("columnheader", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) column header named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) combo box named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "combobox", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the combo box named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("combobox", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) combo box named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) command named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "command", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the command named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("command", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) command named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) comment named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "comment", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the comment named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("comment", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) comment named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) complementary named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "complementary", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the complementary named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("complementary", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) complementary named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) composite named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "composite", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the composite named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("composite", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) composite named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) contentinfo named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "contentinfo", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the contentinfo named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("contentinfo", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) contentinfo named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) definition named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "definition", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the definition named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("definition", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) definition named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {

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

@@ -21,11 +21,15 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
 When(`Within a(n) dialog named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "dialog", name);
@@ -42,6 +46,16 @@ Then(
     }
 );
 
+When(`I type the sentence {string} in the dialog named {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("dialog", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
     `I should see a(n) dialog named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {