@vardot/varbase-e2e 2.0.0

package/docs/step-definitions/when-i-select-radio-button-value.md

@@ -0,0 +1,62 @@
+
+# When I select radio button "value"
+
+## Step Definition
+
+```
+When (I |we ) select radio button "([^"]*)?"`
+```
+
+## Description
+
+Selects the radio button specified by label text, value, or selector.
+
+## Examples
+
+```
+When I select radio button "Male"
+When I select radio button "female"
+When I select radio button "#gender-male"
+When we select radio button "option1"
+```
+
+## Usage Notes
+
+The step accepts multiple input types: label text, value attributes, or CSS selectors to identify and select the target radio button element.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I select radio button "Male"
+```
+
+### Example 2
+
+```gherkin
+When I select radio button "#gender-female"
+```
+
+### Example 3
+
+```gherkin
+And we select radio button "Premium"
+```
+
+### Example 4
+
+```gherkin
+When I select radio button "monthly"
+   Then the radio button with value "monthly" should be selected
+```
+
+### Example 5
+
+```gherkin
+When I select radio button "Yes"
+   And I press "Continue"
+```
+

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

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

package/docs/step-definitions/when-i-wait-ajax-finish.md

@@ -0,0 +1,64 @@
+
+# When I wait for AJAX to finish
+
+## Step Definition
+
+```gherkin
+'When (I |we )*wait for AJAX to finish'
+```
+
+## Description
+
+"This step waits for an active XMLHttpRequest and Fetch API requests to complete."
+
+## Examples
+
+```gherkin
+When I wait for AJAX to finish
+```
+
+```gherkin
+And I wait for AJAX to finish
+```
+
+```gherkin
+When we wait for AJAX to finish
+```
+
+```gherkin
+And wait for AJAX to finish
+```
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I press "Search"
+   And I wait for AJAX to finish
+   Then I should see "Results"
+```
+
+### Example 2
+
+```gherkin
+When I follow "Inbox"
+   And I wait for AJAX to finish
+   Then I should see at least 1 ".message" element
+```
+
+### Example 3
+
+```gherkin
+And I wait for AJAX to finish
+```
+
+### Example 4
+
+```gherkin
+When we wait for AJAX to finish
+   Then "<.toast-success>" should be visible
+```
+

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

@@ -0,0 +1,62 @@
+
+# When I Wait
+
+## Description
+
+"This step definition indicates that the user will pause or wait for the specified number of seconds/minutes or the maximum number of seconds/minutes before moving to the next step." The functionality is designed for scenarios requiring time-based delays or expected pauses during test execution.
+
+## Available Step Definitions
+
+The "When I wait" category encompasses five distinct variations:
+
+1. **When I wait until the page loaded** - Pauses execution until page load completion
+
+2. **When I wait {number} seconds** - Implements a fixed pause for the specified seconds duration
+
+3. **When I wait max {number} seconds** - Establishes a maximum wait period in seconds with early completion upon condition satisfaction
+
+4. **When I wait {number} minutes** - Creates a fixed pause measured in minutes
+
+5. **When I wait max {number} minutes** - Sets a maximum wait period in minutes, allowing early termination when conditions are met
+
+## Use Cases
+
+These steps prove particularly useful in automated testing scenarios where applications require time-dependent behavior verification or asynchronous operations demand explicit wait periods before proceeding with subsequent test steps.
+
+## More examples
+
+<!-- generated: extended-examples -->
+
+### Example 1
+
+```gherkin
+When I press "Save"
+   And I wait 2 seconds
+   Then I should see "Saved"
+```
+
+### Example 2
+
+```gherkin
+When I follow "Pricing"
+   And I wait until the page is loaded
+```
+
+### Example 3
+
+```gherkin
+And I wait 1 second
+```
+
+### Example 4
+
+```gherkin
+When I wait max of 5 seconds
+```
+
+### Example 5
+
+```gherkin
+And I wait until pending timers settle
+```
+

package/docs/step-definitions.md

@@ -0,0 +1,82 @@
+# Step definitions
+
+A step definition is the bridge between a sentence in a `.feature` file and the
+browser work that sentence stands for. The tester writes the sentence; the step
+definition does the clicking, waiting and asserting.
+
+Varbase E2E ships **495 of them across 44 categories** — the full catalogue,
+one page per category, is in [`steps/`](steps/README.md).
+
+## Start here
+
+| I want to… | Go to |
+| --- | --- |
+| Browse every step by category | [Step catalogue](steps/README.md) |
+| Test a Drupal or Varbase screen | [Drupal and Varbase steps](steps/README.md#drupal-and-varbase) |
+| Look up one topic quickly | [Step reference](04-step-reference.md) |
+| Write my first feature file | [Quick start](00-quick-start.md) |
+| Add a step of my own | [Writing your own](steps/README.md#writing-your-own) |
+
+## What a feature file looks like
+
+```gherkin
+Feature: Example test for "Then I should be on 'page'"
+  As a tester
+  I want to be sure I am on "page"
+
+  Scenario: Check "Then I should be on the 'page'" step definition
+    Given I am on the homepage
+     When I follow "About Us"
+     Then I should be on "about-us.html"
+     When I move backward one page
+     Then I should be on "/"
+```
+
+Nothing is imported and nothing is wired up: cucumber-js loads every
+`*.steps.js` under `tests/step-definitions/` on its own, matches each sentence
+against the shipped patterns, and runs the first one that fits.
+
+## The rules every shipped step follows
+
+- **Pronouns are optional.** `I click`, `we click` and bare `click` all match.
+- **Plain English, never code.** `local storage`, not `localStorage`.
+- **Technical identifiers stay verbatim.** A CSS selector, a JSON Pointer or a
+  header name is domain language, so it is written exactly as it is.
+- **At least five examples per step**, in the JSDoc above the definition and on
+  the catalogue page generated from it.
+- **Failures read as sentences.** A step that cannot do its job explains what it
+  was trying to do and why it could not, rather than surfacing a raw stack
+  trace.
+
+## Per-step pages
+
+Older per-step pages, kept for the links that point at them:
+
+- [Given I am on homepage](step-definitions/given-i-am-homepage.md)
+- [Given I am on "specific" page](step-definitions/given-i-am-specific-page.md)
+- [Given I am an anonymous user](step-definitions/given-i-am-anonymous-user.md)
+- [When I go to the homepage](step-definitions/when-i-go-homepage.md)
+- [When I go to "specific page"](step-definitions/when-i-go-specific-page.md)
+- [When I reload the page](step-definitions/when-i-reload-page.md)
+- [When I move backward one page](step-definitions/when-i-move-backward-one-page.md)
+- [When I move forward one page](step-definitions/when-i-move-forward-one-page.md)
+- [When I fill in](step-definitions/when-i-fill.md)
+- [When I press "button"](step-definitions/when-i-press-button.md)
+- [When I click "link"](step-definitions/when-i-click-link.md)
+- [When I check "checkbox"](step-definitions/when-i-check-checkbox.md)
+- [When I uncheck "checkbox"](step-definitions/when-i-uncheck-checkbox.md)
+- [When I select "option" from "select list"](step-definitions/when-i-select-option-select-list.md)
+- [When I select radio button "value"](step-definitions/when-i-select-radio-button-value.md)
+- [When I click "operation" in "text" row](step-definitions/when-i-click-operation-text-row.md)
+- [When I attach the file "file name" to "element"](step-definitions/when-i-attach-file-file-name-element.md)
+- [When I scroll](step-definitions/when-i-scroll.md)
+- [When I wait](step-definitions/when-i-wait.md)
+- [When I wait for AJAX to finish](step-definitions/when-i-wait-ajax-finish.md)
+- [Then I should see](step-definitions/then-i-should-see.md)
+- [Then I should be](step-definitions/then-i-should-be.md)
+- [Then the "item" checkbox](step-definitions/then-item-checkbox.md)
+- [Then the item should contain](step-definitions/then-item-should-contain.md)
+- [Then the "item" link should contain "url"](step-definitions/then-item-link-should-contain-url.md)
+- [Then the "value" radio button is selected](step-definitions/then-value-radio-button-selected.md)
+- [Then the radio button "value" should be selected](step-definitions/then-radio-button-value-should-be-selected.md)
+- [Then the response status code should be {number}](step-definitions/then-response-status-code-should-be-number.md)

package/docs/steps/README.md

@@ -0,0 +1,137 @@
+# Step definitions
+
+Every step Varbase E2E ships, one page per category, generated from the step
+definitions themselves — so the phrasing, the pattern and the examples on these
+pages are exactly what the runner matches.
+
+**495 steps across 44 categories.**
+
+Cucumber-js loads every `*.steps.js` under `tests/step-definitions/`
+automatically. You never `require()` a step file from a feature: write the
+sentence, and the runner finds it.
+
+## How to read a step
+
+Each entry gives you three things:
+
+- **The sentence** — the heading is a real, runnable Gherkin line. Copy it.
+- **The pattern** — the regular expression the runner matches. It tells you
+  which words are optional (`(?:the )?`) and which are yours to fill in
+  (`"([^"]*)"`).
+- **The examples** — at least five valid phrasings per step, so you can see the
+  shape of the sentence rather than decode the regex.
+
+Every step accepts the pronoun prefix: `I click`, `we click` and bare
+`click` all match.
+
+
+## Drupal and Varbase
+
+Steps for the Drupal and Varbase surfaces the team tests every day — the node and entity forms, the media library, Layout Builder, Drupal Canvas and Varbase's own screens.
+
+| Category | Steps | Page |
+| --- | --- | --- |
+| Drupal core | 27 | [`drupal-core.md`](drupal-core.md) |
+| CKEditor 5 | 4 | [`drupal-ckeditor.md`](drupal-ckeditor.md) |
+| Media library | 4 | [`drupal-media.md`](drupal-media.md) |
+| Content moderation | 3 | [`drupal-moderation.md`](drupal-moderation.md) |
+| Layout Builder | 17 | [`drupal-layout-builder.md`](drupal-layout-builder.md) |
+| Paragraphs | 1 | [`drupal-paragraphs.md`](drupal-paragraphs.md) |
+| Drupal Canvas | 12 | [`drupal-canvas.md`](drupal-canvas.md) |
+| Varbase | 14 | [`varbase.md`](varbase.md) |
+
+**82 steps.**
+
+## User journeys
+
+Driving the browser the way a person does: going somewhere, filling something in, clicking, typing, scrolling.
+
+| Category | Steps | Page |
+| --- | --- | --- |
+| Navigation | 11 | [`navigation.md`](navigation.md) |
+| Actions | 7 | [`action.md`](action.md) |
+| Forms | 13 | [`form.md`](form.md) |
+| Field state | 27 | [`field.md`](field.md) |
+| Pointer input | 9 | [`input.md`](input.md) |
+| Keyboard | 4 | [`keyboard.md`](keyboard.md) |
+| Scrolling | 12 | [`scroll.md`](scroll.md) |
+| Links | 9 | [`link.md`](link.md) |
+| Modals | 9 | [`modal.md`](modal.md) |
+| Browser dialogs | 8 | [`dialog.md`](dialog.md) |
+
+**109 steps.**
+
+## Outcome verification
+
+Asserting what the page ended up showing.
+
+| Category | Steps | Page |
+| --- | --- | --- |
+| Assertions | 14 | [`assertion.md`](assertion.md) |
+| Web-first matchers | 12 | [`web-first.md`](web-first.md) |
+| Element interactions | 19 | [`element.md`](element.md) |
+| Tables | 8 | [`table.md`](table.md) |
+| Meta tags | 3 | [`metatag.md`](metatag.md) |
+| Response headers | 4 | [`response.md`](response.md) |
+
+**60 steps.**
+
+## APIs and data formats
+
+Talking to an endpoint and asserting on what comes back.
+
+| Category | Steps | Page |
+| --- | --- | --- |
+| API (long form) | 22 | [`api.md`](api.md) |
+| REST (short form) | 5 | [`rest.md`](rest.md) |
+| XML responses | 20 | [`xml.md`](xml.md) |
+| YAML responses | 38 | [`yaml.md`](yaml.md) |
+| URL paths | 8 | [`path.md`](path.md) |
+
+**93 steps.**
+
+## Test resilience and instrumentation
+
+Everything that keeps a suite honest and debuggable: waits, mocks, state, capture.
+
+| Category | Steps | Page |
+| --- | --- | --- |
+| Waits | 21 | [`wait.md`](wait.md) |
+| Clock | 7 | [`clock.md`](clock.md) |
+| Network | 10 | [`network.md`](network.md) |
+| Storage | 9 | [`storage.md`](storage.md) |
+| Cookies | 12 | [`cookie.md`](cookie.md) |
+| Auth state | 3 | [`auth.md`](auth.md) |
+| JavaScript errors | 4 | [`javascript.md`](javascript.md) |
+| Accessibility | 26 | [`a11y.md`](a11y.md) |
+| Iframes | 10 | [`iframe.md`](iframe.md) |
+| File downloads | 8 | [`file-download.md`](file-download.md) |
+| Selector registry | 24 | [`selectors.md`](selectors.md) |
+| Responsive viewports | 5 | [`responsive.md`](responsive.md) |
+| Screenshots | 6 | [`screenshot.md`](screenshot.md) |
+| Video recording | 4 | [`video.md`](video.md) |
+| Debug | 2 | [`debug.md`](debug.md) |
+
+**151 steps.**
+
+## Writing your own
+
+When no shipped step fits, add one to your project's own
+`tests/step-definitions/`. Follow the same contract these pages are generated
+from:
+
+- Use a regular expression with the `(?:I |we )*` prefix, never a Cucumber
+  Expression that hard-codes `I`.
+- Plain English in the sentence — `local storage`, not `localStorage`.
+- A JSDoc block above the definition with a one-line description and **at least
+  five `Example #N:` lines** of valid Gherkin.
+- Wrap risky locator work so the tester gets a sentence, not a stack trace.
+
+Search these pages before writing anything: most of what a Varbase suite needs
+is already here.
+
+## Regenerating these pages
+
+They are generated from the JSDoc in `tests/step-definitions/*.steps.js`. Edit
+the step, not the page — a page edited by hand is overwritten on the next
+generation.