@vardot/varbase-e2e 2.0.0

package/docs/step-definitions/when-i-check-checkbox.md

@@ -0,0 +1,60 @@
+
+# When I check "checkbox"
+
+## Step Definition
+
+This step definition serves as a command to mark/select a checkbox.
+
+**Gherkin Pattern:**
+```
+When (I|we)* check "([^"]*)?"
+```
+
+## Description
+
+Define the step of checking the checkbox element specified by id|class|name|label.
+
+## Examples
+
+**Example (1): label**
+```
+When I check "Remember me"
+```
+
+**Example (2): id/class**
+```
+When I check "rememberme"
+```
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I check "Remember me"
+   And I press "Sign in"
+```
+
+### Example 2
+
+```gherkin
+When I check "#newsletter"
+   Then the "#newsletter" checkbox should be checked
+```
+
+### Example 3
+
+```gherkin
+When we check ".terms"
+   And I press "Continue"
+```
+
+### Example 4
+
+```gherkin
+When I check "Subscribe to updates"
+   Then the checkbox "#subscribe" is checked
+```
+

package/docs/step-definitions/when-i-click-link.md

@@ -0,0 +1,51 @@
+
+# When I click "link"
+
+## Step Definition
+
+```gherkin
+When (I|we)* click "([^"]*)?"
+```
+
+## Description
+
+This step definition functions as a command to click a link, ensuring correct navigation to the expected page. It allows you to define the step for clicking the link by its text.
+
+## Example
+
+```gherkin
+When I click "Contact Us"
+```
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I click "About"
+   Then I should be on "/about"
+```
+
+### Example 2
+
+```gherkin
+When I click "Read more"
+   And I wait for AJAX to finish
+```
+
+### Example 3
+
+```gherkin
+When we click "Contact"
+   Then "<form#contact>" should be visible
+```
+
+### Example 4
+
+```gherkin
+When I click "main-nav-link" by attr
+   Then I should see "Pricing"
+```
+

package/docs/step-definitions/when-i-click-operation-text-row.md

@@ -0,0 +1,71 @@
+
+# When I click "operation" in "text" row
+
+## Step Definition
+
+```
+When (I |we )*click "([^"]*)?" in( the)* "([^"]*)?" row$
+```
+
+## Description
+
+This step locates a table, finds a row containing specified identifier text, and clicks on the target text within that row.
+
+## Functionality
+
+The step performs a targeted click on specific text within a table row that contains a given identifier.
+
+## Examples
+
+```
+When I click "Edit" in the "John Smith" row
+```
+
+```
+When I click "Delete" in the "Product A" row
+```
+
+```
+When we click "View Details" in the "Order #12345" row
+```
+
+```
+And I click "Download" in the "Report 2024" row
+```
+
+## Parameters
+
+- **First parameter** ("operation"): The clickable text/action within the row
+- **Second parameter** ("text"): The identifier text that locates the specific row
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I click "Edit" in the "Alice Smith" row
+   Then I should see "Edit user"
+```
+
+### Example 2
+
+```gherkin
+When I click "Delete" in the "Project Alpha" row
+   And I wait for the modal to appear
+```
+
+### Example 3
+
+```gherkin
+When we click "Download" in the "Report 2026" row
+```
+
+### Example 4
+
+```gherkin
+When I click "Approve" in the "Order #1234" row
+   And I wait for AJAX to finish
+```
+

package/docs/step-definitions/when-i-fill.md

@@ -0,0 +1,59 @@
+
+# When I fill in
+
+## Overview
+
+"These step definitions are used to simulate user input of data into different fields or form elements." The purpose is to verify website functionality related to data entry and form submission.
+
+## Available Step Definitions
+
+1. **When I fill in "field" with "value"**
+2. **When I fill in "field" with "value" by its attribute**
+3. **When I fill in "value" for "field"**
+4. **When I fill in "value" for "field" by its attribute**
+5. **When I fill in "field" with:**
+6. **When I fill in "field" with an empty value by its attribute**
+7. **When I fill in the following:**
+8. **When I fill in the following: by its attribute**
+
+Each variant supports different approaches to locating form elements—whether by label text, CSS selectors, or HTML attributes—and accommodates both single-field and multi-field input scenarios.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I fill in "Email" with "alice@example.com"
+   And I press "Sign in"
+```
+
+### Example 2
+
+```gherkin
+When I fill in "username" with "alice" by attr
+   And I fill in "password" with "s3cret" by attr
+```
+
+### Example 3
+
+```gherkin
+When I fill in the following:
+     | First name | Alice |
+     | Last name  | Smith |
+```
+
+### Example 4
+
+```gherkin
+When I fill in "alice" for "#user"
+   And I press "Submit"
+```
+
+### Example 5
+
+```gherkin
+When I fill in "Hello" for "Your message" by its "placeholder" attribute
+```
+

package/docs/step-definitions/when-i-go-homepage.md

@@ -0,0 +1,60 @@
+
+# When I go to the homepage
+
+## Step Definition
+
+The Gherkin step pattern for this navigation action is:
+
+```
+When (I go |I navigate |we go |we navigate |navigating )?to( the)* (homepage|frontpage)
+```
+
+## Description
+
+This step definition enables users to navigate to the website's homepage during testing. The implementation varies based on the testing framework, potentially involving clicking navigation elements, entering URLs directly, or executing predefined navigation commands in web applications.
+
+## Usage Examples
+
+```
+When I go to homepage
+
+When I go to the homepage
+
+When I navigate to the homepage
+
+When navigating to the homepage
+
+When navigating to homepage
+
+When navigating to the frontpage
+
+When we go to the homepage
+
+When we navigate to the homepage
+```
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I go to the homepage
+   Then "<#hero>" should be visible
+```
+
+### Example 2
+
+```gherkin
+When we navigate to homepage
+   Then I should see "Welcome"
+```
+
+### Example 3
+
+```gherkin
+When navigating to the frontpage
+   Then I should be on "/"
+```
+

package/docs/step-definitions/when-i-go-specific-page.md

@@ -0,0 +1,67 @@
+
+# When I go to "specific page"
+
+## Step Definition
+
+The Gherkin step syntax is:
+
+```
+When (I go |I navigate |we go |we navigate |navigating )?to "([^"]*)?"
+```
+
+## Description
+
+This step definition enables users to navigate to a particular page within the website under test. The actual implementation varies based on the testing framework employed. For web applications, this typically involves selecting a hyperlink or button, entering a URL directly, or leveraging a built-in navigation function.
+
+## Examples
+
+```
+When I go to "contact"
+
+When I go to "/user/login"
+
+When I navigate to "/admin/dashboard"
+
+When navigating to "/products"
+
+When we go to "/products"
+
+When we navigate to "/terms"
+```
+
+## Key Details
+
+This step accepts flexible phrasing with multiple variations including "go," "navigate," and collective pronouns ("we"). The page identifier is captured as a parameter in quotation marks and can represent either a page name or a complete URL path.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I go to "/about"
+   Then I should see "Our mission"
+```
+
+### Example 2
+
+```gherkin
+When I navigate to "/admin/dashboard"
+   And I wait until the URL contains "/dashboard"
+```
+
+### Example 3
+
+```gherkin
+When we go to "/cart"
+   Then "<#cart-list>" should be visible
+```
+
+### Example 4
+
+```gherkin
+When navigating to "/products"
+   Then I should see at least 5 ".product-card" elements
+```
+

package/docs/step-definitions/when-i-move-backward-one-page.md

@@ -0,0 +1,49 @@
+
+# When I move backward one page
+
+## Gherkin Step
+
+```gherkin
+When (I|we)* move backward one page
+```
+
+## Description
+
+This step definition represents user interaction for navigating backward through a series of pages on a website. It's commonly employed when browsing paginated lists—allowing testers to visit each page, execute necessary tests, and return to the main list page before advancing to the subsequent page.
+
+## Technical Details
+
+- **Sentence Definition Type**: Static (no probabilities)
+- **Common Use Case**: Paginated list navigation and testing workflows
+
+## Related Step Definitions
+
+The documentation includes related navigation steps such as "When I move forward one page" and "When I reload the page," available within the Varbase E2E 2.0.x step definitions library.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I follow "About"
+   And I move backward one page
+   Then I should be on the homepage
+```
+
+### Example 2
+
+```gherkin
+When I go to "/cart"
+   And I move backward one page
+   Then I should be on "/products"
+```
+
+### Example 3
+
+```gherkin
+When we move backward one page
+   And I wait for AJAX to finish
+```
+

package/docs/step-definitions/when-i-move-forward-one-page.md

@@ -0,0 +1,58 @@
+
+# When I move forward one page
+
+## Gherkin Step Definition
+
+```gherkin
+When (I|we)* move forward one page
+```
+
+## Description
+
+This step definition represents a user action for navigating forward through a sequence of pages on a website. It's typically employed after the user has moved backward one or more pages and then decides to advance forward again.
+
+## Usage Context
+
+The step is commonly used in scenarios where:
+- A user has previously navigated backward through multiple pages
+- The user then chooses to move forward one page
+- This action may be repeated for additional forward navigation steps
+
+## Technical Details
+
+- **Static sentence definition**: Yes
+- **Probabilities**: None (static definition)
+
+## Purpose
+
+This step allows test authors to validate browser navigation behavior, simulating user interactions with browser forward button functionality or equivalent page navigation controls.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I move backward one page
+   And I move forward one page
+   Then I should be on "/about"
+```
+
+### Example 2
+
+```gherkin
+When I go to "/x"
+   And I go to "/y"
+   And I move backward one page
+   And I move forward one page
+   Then I should be on "/y"
+```
+
+### Example 3
+
+```gherkin
+When we move forward one page
+   And I wait until the page is interactive
+```
+

package/docs/step-definitions/when-i-press-button.md

@@ -0,0 +1,58 @@
+
+# When I press "button"
+
+## Step Definition
+
+**Gherkin Syntax:**
+```
+When (I|we)* press "([^"]*)?"
+```
+
+## Description
+
+This step definition executes a command to press a button by its text, ensuring the correct execution of the expected action.
+
+## Example
+
+**By text:**
+```
+When I press "Log In"
+```
+
+## Related Documentation
+
+This step is part of the Varbase E2E 2.0.x Step Definitions documentation and has a sub-variant:
+- When I press "button" by attribute
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I press "Sign in"
+   And I wait until the URL contains "/dashboard"
+```
+
+### Example 2
+
+```gherkin
+When I press the "Submit" button
+   And I wait for AJAX to finish
+```
+
+### Example 3
+
+```gherkin
+When we press "Cancel"
+   Then I should not see the modal
+```
+
+### Example 4
+
+```gherkin
+When I press "save-btn" by attr
+   Then I should see "Saved"
+```
+

package/docs/step-definitions/when-i-reload-page.md

@@ -0,0 +1,51 @@
+
+# When I reload the page
+
+## Step Definition
+
+```gherkin
+When (I|we)* reload( the)* page
+```
+
+## Description
+
+This step definition is employed in website testing to signal that the user is refreshing the current page. It's typically used after executing an event on the page, when results are expected to appear following a page reload.
+
+## Usage Examples
+
+```gherkin
+When I reload the page
+When we reload page
+```
+
+## Context
+
+The step definition supports flexible phrasing with optional words, allowing testers to write natural language scenarios. It's part of the Varbase E2E 2.0.x testing framework and appears within the broader "Step Definitions" documentation section alongside other navigation and interaction steps.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I reload
+   Then I should see "Welcome"
+```
+
+### Example 2
+
+```gherkin
+When I press "Save"
+   And I reload the page
+   Then I should see "Saved"
+```
+
+### Example 3
+
+```gherkin
+When we reload page
+   And I wait for AJAX to finish
+   Then "<.spinner>" should not be visible
+```
+

package/docs/step-definitions/when-i-scroll.md

@@ -0,0 +1,73 @@
+
+# When I Scroll
+
+## Overview
+
+"Use this step when you want to simulate a scroll action on the page during your automated testing scenario. It can be helpful to test lazy-loaded elements, infinite scroll areas, or to simply bring specific elements into view."
+
+## Available Scroll Step Definitions
+
+The following scroll-related steps are available in Varbase E2E 2.0.x:
+
+- When I scroll down
+- When I scroll up
+- When I scroll to top
+- When I scroll to the bottom
+- When I scroll to top of "<selector>"
+- When I scroll to bottom of "<selector>"
+- When I scroll right
+- When I scroll left
+- When I scroll to start
+- When I scroll to the end
+- When I scroll to start of "<selector>"
+- When I scroll to end of "<selector>"
+
+Each step enables testing of different scrolling behaviors to validate page functionality, element visibility, and lazy-loading mechanisms within automated testing scenarios.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I scroll down
+```
+
+### Example 2
+
+```gherkin
+When I scroll down 800
+```
+
+### Example 3
+
+```gherkin
+And I scroll to the top
+```
+
+### Example 4
+
+```gherkin
+When I scroll to the bottom
+   And I wait for AJAX to finish
+```
+
+### Example 5
+
+```gherkin
+When I scroll to top of "#sidebar"
+```
+
+### Example 6
+
+```gherkin
+And we scroll to bottom of "#log-panel"
+```
+
+### Example 7
+
+```gherkin
+When I scroll right 500
+```
+

package/docs/step-definitions/when-i-select-option-select-list.md

@@ -0,0 +1,53 @@
+
+# When I select "option" from "select list"
+
+## Step Definition
+
+```
+When (I|we)* select "([^"]*)?" from "([^"]*)?"
+```
+
+## Description
+
+"This step definition acts as a command to select an option from a dropdown list." The mechanism identifies a select element by its associated label, then selects the matching option based on its displayed text.
+
+## Example
+
+**Selection by label:**
+
+```
+When we select "Mercedes" from "Cars"
+```
+
+This syntax allows test authors to select dropdown values using human-readable option names and field labels rather than technical selectors.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I select "Mercedes" from "Cars"
+   Then I should see "Mercedes selected"
+```
+
+### Example 2
+
+```gherkin
+When I select "saab" from "#cars"
+```
+
+### Example 3
+
+```gherkin
+When we select "English" from "Language"
+```
+
+### Example 4
+
+```gherkin
+When I select "Premium" from "Plan"
+   And I press "Continue"
+```
+