@uuv/cypress 1.14.3 → 1.16.0

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

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) contentinfo named {string}`, function(name: string) {
+When(`within a contentinfo named {string}`, function(name: string) {
     return withinRoleAndName("contentinfo", name);
 });
 
-Then(`I should see a(n) contentinfo named {string}`, async function(name: string) {
+Then(`I should see a contentinfo named {string}`, async function(name: string) {
     findWithRoleAndName("contentinfo", name);
 });
 
 Then(
-    `I should not see a(n) contentinfo named {string}`,
+    `I should not see a contentinfo named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("contentinfo", name);
     }
 );
 
+When(`I type the sentence {string} in the contentinfo named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("contentinfo", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string}`,
+    `I should see a contentinfo named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string} disabled`,
+    `I should see a contentinfo named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string} enabled`,
+    `I should see a contentinfo named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("contentinfo", name, expectedTextContent);
     }

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

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) definition named {string}`, function(name: string) {
+When(`within a definition named {string}`, function(name: string) {
     return withinRoleAndName("definition", name);
 });
 
-Then(`I should see a(n) definition named {string}`, async function(name: string) {
+Then(`I should see a definition named {string}`, async function(name: string) {
     findWithRoleAndName("definition", name);
 });
 
 Then(
-    `I should not see a(n) definition named {string}`,
+    `I should not see a definition named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("definition", name);
     }
 );
 
+When(`I type the sentence {string} in the definition named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("definition", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) definition named {string} and containing {string}`,
+    `I should see a definition named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) definition named {string} and containing {string} disabled`,
+    `I should see a definition named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) definition named {string} and containing {string} enabled`,
+    `I should see a definition named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("definition", name, expectedTextContent);
     }

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

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) dialog named {string}`, function(name: string) {
+When(`within a dialog named {string}`, function(name: string) {
     return withinRoleAndName("dialog", name);
 });
 
-Then(`I should see a(n) dialog named {string}`, async function(name: string) {
+Then(`I should see a dialog named {string}`, async function(name: string) {
     findWithRoleAndName("dialog", name);
 });
 
 Then(
-    `I should not see a(n) dialog named {string}`,
+    `I should not see a dialog named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("dialog", name);
     }
 );
 
+When(`I type the sentence {string} in the dialog named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("dialog", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) dialog named {string} and containing {string}`,
+    `I should see a dialog named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("dialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) dialog named {string} and containing {string} disabled`,
+    `I should see a dialog named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("dialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) dialog named {string} and containing {string} enabled`,
+    `I should see a dialog named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("dialog", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_directory.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) directory named {string}`, function(name: string) {
+When(`within a directory named {string}`, function(name: string) {
     return withinRoleAndName("directory", name);
 });
 
-Then(`I should see a(n) directory named {string}`, async function(name: string) {
+Then(`I should see a directory named {string}`, async function(name: string) {
     findWithRoleAndName("directory", name);
 });
 
 Then(
-    `I should not see a(n) directory named {string}`,
+    `I should not see a directory named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("directory", name);
     }
 );
 
+When(`I type the sentence {string} in the directory named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("directory", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) directory named {string} and containing {string}`,
+    `I should see a directory named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("directory", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) directory named {string} and containing {string} disabled`,
+    `I should see a directory named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("directory", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) directory named {string} and containing {string} enabled`,
+    `I should see a directory named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("directory", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_document.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) document named {string}`, function(name: string) {
+When(`within a document named {string}`, function(name: string) {
     return withinRoleAndName("document", name);
 });
 
-Then(`I should see a(n) document named {string}`, async function(name: string) {
+Then(`I should see a document named {string}`, async function(name: string) {
     findWithRoleAndName("document", name);
 });
 
 Then(
-    `I should not see a(n) document named {string}`,
+    `I should not see a document named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("document", name);
     }
 );
 
+When(`I type the sentence {string} in the document named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("document", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) document named {string} and containing {string}`,
+    `I should see a document named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("document", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) document named {string} and containing {string} disabled`,
+    `I should see a document named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("document", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) document named {string} and containing {string} enabled`,
+    `I should see a document named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("document", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_feed.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) flow named {string}`, function(name: string) {
+When(`within a flow named {string}`, function(name: string) {
     return withinRoleAndName("feed", name);
 });
 
-Then(`I should see a(n) flow named {string}`, async function(name: string) {
+Then(`I should see a flow named {string}`, async function(name: string) {
     findWithRoleAndName("feed", name);
 });
 
 Then(
-    `I should not see a(n) flow named {string}`,
+    `I should not see a flow named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("feed", name);
     }
 );
 
+When(`I type the sentence {string} in the flow named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("feed", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) flow named {string} and containing {string}`,
+    `I should see a flow named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("feed", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) flow named {string} and containing {string} disabled`,
+    `I should see a flow named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("feed", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) flow named {string} and containing {string} enabled`,
+    `I should see a flow named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("feed", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_figure.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) figure named {string}`, function(name: string) {
+When(`within a figure named {string}`, function(name: string) {
     return withinRoleAndName("figure", name);
 });
 
-Then(`I should see a(n) figure named {string}`, async function(name: string) {
+Then(`I should see a figure named {string}`, async function(name: string) {
     findWithRoleAndName("figure", name);
 });
 
 Then(
-    `I should not see a(n) figure named {string}`,
+    `I should not see a figure named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("figure", name);
     }
 );
 
+When(`I type the sentence {string} in the figure named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("figure", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) figure named {string} and containing {string}`,
+    `I should see a figure named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("figure", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) figure named {string} and containing {string} disabled`,
+    `I should see a figure named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("figure", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) figure named {string} and containing {string} enabled`,
+    `I should see a figure named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("figure", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_form.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) form named {string}`, function(name: string) {
+When(`within a form named {string}`, function(name: string) {
     return withinRoleAndName("form", name);
 });
 
-Then(`I should see a(n) form named {string}`, async function(name: string) {
+Then(`I should see a form named {string}`, async function(name: string) {
     findWithRoleAndName("form", name);
 });
 
 Then(
-    `I should not see a(n) form named {string}`,
+    `I should not see a form named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("form", name);
     }
 );
 
+When(`I type the sentence {string} in the form named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("form", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) form named {string} and containing {string}`,
+    `I should see a form named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("form", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) form named {string} and containing {string} disabled`,
+    `I should see a form named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("form", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) form named {string} and containing {string} enabled`,
+    `I should see a form named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("form", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_generic.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) generic named {string}`, function(name: string) {
+When(`within a generic named {string}`, function(name: string) {
     return withinRoleAndName("generic", name);
 });
 
-Then(`I should see a(n) generic named {string}`, async function(name: string) {
+Then(`I should see a generic named {string}`, async function(name: string) {
     findWithRoleAndName("generic", name);
 });
 
 Then(
-    `I should not see a(n) generic named {string}`,
+    `I should not see a generic named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("generic", name);
     }
 );
 
+When(`I type the sentence {string} in the generic named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("generic", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) generic named {string} and containing {string}`,
+    `I should see a generic named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("generic", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) generic named {string} and containing {string} disabled`,
+    `I should see a generic named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("generic", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) generic named {string} and containing {string} enabled`,
+    `I should see a generic named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("generic", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_grid.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) grid named {string}`, function(name: string) {
+When(`within a grid named {string}`, function(name: string) {
     return withinRoleAndName("grid", name);
 });
 
-Then(`I should see a(n) grid named {string}`, async function(name: string) {
+Then(`I should see a grid named {string}`, async function(name: string) {
     findWithRoleAndName("grid", name);
 });
 
 Then(
-    `I should not see a(n) grid named {string}`,
+    `I should not see a grid named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("grid", name);
     }
 );
 
+When(`I type the sentence {string} in the grid named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("grid", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) grid named {string} and containing {string}`,
+    `I should see a grid named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("grid", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) grid named {string} and containing {string} disabled`,
+    `I should see a grid named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("grid", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) grid named {string} and containing {string} enabled`,
+    `I should see a grid named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("grid", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_gridcell.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) grid cell named {string}`, function(name: string) {
+When(`within a grid cell named {string}`, function(name: string) {
     return withinRoleAndName("gridcell", name);
 });
 
-Then(`I should see a(n) grid cell named {string}`, async function(name: string) {
+Then(`I should see a grid cell named {string}`, async function(name: string) {
     findWithRoleAndName("gridcell", name);
 });
 
 Then(
-    `I should not see a(n) grid cell named {string}`,
+    `I should not see a grid cell named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("gridcell", name);
     }
 );
 
+When(`I type the sentence {string} in the grid cell named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("gridcell", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) grid cell named {string} and containing {string}`,
+    `I should see a grid cell named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("gridcell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) grid cell named {string} and containing {string} disabled`,
+    `I should see a grid cell named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("gridcell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) grid cell named {string} and containing {string} enabled`,
+    `I should see a grid cell named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("gridcell", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_group.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) group named {string}`, function(name: string) {
+When(`within a group named {string}`, function(name: string) {
     return withinRoleAndName("group", name);
 });
 
-Then(`I should see a(n) group named {string}`, async function(name: string) {
+Then(`I should see a group named {string}`, async function(name: string) {
     findWithRoleAndName("group", name);
 });
 
 Then(
-    `I should not see a(n) group named {string}`,
+    `I should not see a group named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("group", name);
     }
 );
 
+When(`I type the sentence {string} in the group named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("group", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) group named {string} and containing {string}`,
+    `I should see a group named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("group", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) group named {string} and containing {string} disabled`,
+    `I should see a group named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("group", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) group named {string} and containing {string} enabled`,
+    `I should see a group named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("group", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_heading.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) title named {string}`, function(name: string) {
+When(`within a title named {string}`, function(name: string) {
     return withinRoleAndName("heading", name);
 });
 
-Then(`I should see a(n) title named {string}`, async function(name: string) {
+Then(`I should see a title named {string}`, async function(name: string) {
     findWithRoleAndName("heading", name);
 });
 
 Then(
-    `I should not see a(n) title named {string}`,
+    `I should not see a title named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("heading", name);
     }
 );
 
+When(`I type the sentence {string} in the title named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("heading", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) title named {string} and containing {string}`,
+    `I should see a title named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("heading", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) title named {string} and containing {string} disabled`,
+    `I should see a title named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("heading", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) title named {string} and containing {string} enabled`,
+    `I should see a title named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("heading", name, expectedTextContent);
     }