@uuv/playwright 1.14.3 → 1.16.0

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

@@ -21,43 +21,57 @@ 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) {
+When(`within an alert dialog named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "alertdialog", name);
 });
 
-Then(`I should see a(n) alert dialog named {string}`, async function (this: World, name: string)  {
+Then(`I should see an alert dialog named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "alertdialog", name);
 });
 
 Then(
-    `I should not see a(n) alert dialog named {string}`,
+    `I should not see an alert dialog named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "alertdialog", name);
     }
 );
 
+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}`,
+    `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);
     }
 );
 
 Then(
-    `I should see a(n) alert dialog named {string} and containing {string} disabled`,
+    `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);
     }
 );
 
 Then(
-    `I should see a(n) alert dialog named {string} and containing {string} enabled`,
+    `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);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within an application named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "application", name);
 });
 
-Then(`I should see a(n) application named {string}`, async function (this: World, name: string)  {
+Then(`I should see an application named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "application", name);
 });
 
 Then(
-    `I should not see a(n) application named {string}`,
+    `I should not see an application named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "application", name);
     }
 );
 
+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}`,
+    `I should see an application named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "application", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) application named {string} and containing {string} disabled`,
+    `I should see an application named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "application", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) application named {string} and containing {string} enabled`,
+    `I should see an application named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "application", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within an article named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "article", name);
 });
 
-Then(`I should see a(n) article named {string}`, async function (this: World, name: string)  {
+Then(`I should see an article named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "article", name);
 });
 
 Then(
-    `I should not see a(n) article named {string}`,
+    `I should not see an article named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "article", name);
     }
 );
 
+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}`,
+    `I should see an article named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "article", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) article named {string} and containing {string} disabled`,
+    `I should see an article named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "article", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) article named {string} and containing {string} enabled`,
+    `I should see an article named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "article", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a banner named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "banner", name);
 });
 
-Then(`I should see a(n) banner named {string}`, async function (this: World, name: string)  {
+Then(`I should see a banner named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "banner", name);
 });
 
 Then(
-    `I should not see a(n) banner named {string}`,
+    `I should not see a banner named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "banner", name);
     }
 );
 
+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}`,
+    `I should see a banner named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) banner named {string} and containing {string} disabled`,
+    `I should see a banner named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) banner named {string} and containing {string} enabled`,
+    `I should see a banner named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "banner", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a button named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "button", name);
 });
 
-Then(`I should see a(n) button named {string}`, async function (this: World, name: string)  {
+Then(`I should see a button named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "button", name);
 });
 
 Then(
-    `I should not see a(n) button named {string}`,
+    `I should not see a button named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "button", name);
     }
 );
 
+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}`,
+    `I should see a button named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "button", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) button named {string} and containing {string} disabled`,
+    `I should see a button named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "button", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) button named {string} and containing {string} enabled`,
+    `I should see a button named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "button", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a cell named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "cell", name);
 });
 
-Then(`I should see a(n) cell named {string}`, async function (this: World, name: string)  {
+Then(`I should see a cell named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "cell", name);
 });
 
 Then(
-    `I should not see a(n) cell named {string}`,
+    `I should not see a cell named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "cell", name);
     }
 );
 
+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}`,
+    `I should see a cell named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} disabled`,
+    `I should see a cell named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} enabled`,
+    `I should see a cell named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "cell", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a checkbox named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "checkbox", name);
 });
 
-Then(`I should see a(n) checkbox named {string}`, async function (this: World, name: string)  {
+Then(`I should see a checkbox named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "checkbox", name);
 });
 
 Then(
-    `I should not see a(n) checkbox named {string}`,
+    `I should not see a checkbox named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "checkbox", name);
     }
 );
 
+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}`,
+    `I should see a checkbox named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} disabled`,
+    `I should see a checkbox named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} enabled`,
+    `I should see a checkbox named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "checkbox", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a column header named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "columnheader", name);
 });
 
-Then(`I should see a(n) column header named {string}`, async function (this: World, name: string)  {
+Then(`I should see a column header named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "columnheader", name);
 });
 
 Then(
-    `I should not see a(n) column header named {string}`,
+    `I should not see a column header named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "columnheader", name);
     }
 );
 
+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}`,
+    `I should see a column header named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} disabled`,
+    `I should see a column header named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} enabled`,
+    `I should see a column header named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "columnheader", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a combo box named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "combobox", name);
 });
 
-Then(`I should see a(n) combo box named {string}`, async function (this: World, name: string)  {
+Then(`I should see a combo box named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "combobox", name);
 });
 
 Then(
-    `I should not see a(n) combo box named {string}`,
+    `I should not see a combo box named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "combobox", name);
     }
 );
 
+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}`,
+    `I should see a combo box named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} disabled`,
+    `I should see a combo box named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} enabled`,
+    `I should see a combo box named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "combobox", name, expectedTextContent);
     }

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

@@ -21,43 +21,57 @@ 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) {
+When(`within a command named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "command", name);
 });
 
-Then(`I should see a(n) command named {string}`, async function (this: World, name: string)  {
+Then(`I should see a command named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "command", name);
 });
 
 Then(
-    `I should not see a(n) command named {string}`,
+    `I should not see a command named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "command", name);
     }
 );
 
+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}`,
+    `I should see a command named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} disabled`,
+    `I should see a command named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} enabled`,
+    `I should see a command named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "command", name, expectedTextContent);
     }