Vedro Testing Framework

https://vedro.io/docs/
Admin
Vedro is a readable, scalable, and pragmatic Python testing framework. It enables writing test...
Tokens:33,941
Snippets:254
Trust Score:6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install and Run Vedro Scenarios from Command Line

Source: https://vedro.io/docs/quick-start

This snippet provides command-line instructions for setting up Vedro and executing test scenarios. It covers installing the Vedro framework using pip and then running all scenarios located within a specified directory.

```Bash
# Make sure you've installed Vedro first
$ pip install vedro

# Run all scenarios in the directory
$ vedro run scenarios/
```

--------------------------------

### Example Console Output for Vedro Scenario Execution

Source: https://vedro.io/docs/quick-start

This snippet displays a typical console output after successfully running a Vedro test scenario. It shows the test summary, indicating that the 'create file' scenario passed.

```Text
Scenarios
*
 ✔ create file

# --seed a61d255d-721b-4aeb-9ecd-aedcf542cfb2
```

--------------------------------

### Install Vedro Allure Reporter Plugin

Source: https://vedro.io/docs/integrations/allure-reporter

Installs the `vedro-allure-reporter` plugin using the `vedro plugin install` command for a quick and automated setup.

```Shell
$ vedro plugin install vedro-allure-reporter
```

--------------------------------

### Define a Reusable Vedro Context for File Setup

Source: https://vedro.io/docs/quick-start

This Python snippet demonstrates how to define a reusable context in Vedro using the `@vedro.context` decorator. The `existing_file` context creates a file with a specified filename and returns a `Path` object, abstracting common file setup logic for test scenarios.

```python
# contexts/existing_file.py
import vedro
from pathlib import Path as File

@vedro.context
def existing_file(filename: str = 'example.txt') -> File:
    file = File(filename)
    file.touch()
    return file
```

--------------------------------

### Install Multiple Vedro Plugins via CLI

Source: https://vedro.io/docs/guides/using-plugins

This shell command illustrates the usage of the `vedro plugin install` command. It allows users to install multiple Vedro plugins simultaneously from the command line, which also automatically enables them in the project's `vedro.cfg.py` file, simplifying the setup process.

```Shell
$ vedro plugin install vedro-gitlab-reporter \
                       vedro-allure-reporter
```

--------------------------------

### Define a Class-Based Vedro Scenario for File Creation

Source: https://vedro.io/docs/quick-start

This Python snippet demonstrates how to write a class-based test scenario in Vedro. It follows the Arrange-Act-Assert pattern to create a file and verify its existence, using `pathlib.Path` for file operations within `given`, `when`, and `then` methods.

```Python
# scenarios/create_file.py
from pathlib import Path as File
import vedro

class Scenario(vedro.Scenario):
    subject = 'create file'

    def given_new_file(self):
        self.file = File('example.txt')

    def when_creating_file(self):
        self.file.touch()

    def then_file_should_exist(self):
        assert self.file.exists()
```

--------------------------------

### Use Vedro Context in Function-based Scenario

Source: https://vedro.io/docs/quick-start

This Python example demonstrates how to utilize a Vedro context, like `existing_file`, within a function-based test scenario. The context is invoked directly within the `given` block, ensuring the necessary file setup is performed before the test proceeds to write and assert its content, maintaining clear separation of concerns.

```python
from vedro import scenario, given, when, then
from contexts.existing_file import existing_file

@scenario()
def write_data_to_existing_file():
    with given('existing file'):
        file = existing_file()

    with when('writing data'):
        file.write_text('banana')

    with then('file should contain written data'):
        assert file.read_text() == 'banana'
```

--------------------------------

### Install vedro-httpx plugin using Vedro CLI

Source: https://vedro.io/docs/integrations/httpx-client

Demonstrates the quick installation method for the 'vedro-httpx' plugin using the Vedro command-line interface's built-in plugin manager.

```shell
$ vedro plugin install vedro-httpx
```

--------------------------------

### Define a Function-Based Vedro Scenario for File Creation

Source: https://vedro.io/docs/quick-start

This Python snippet illustrates a function-based approach to writing a test scenario in Vedro. It uses decorators (`@scenario`, `given`, `when`, `then`) to define steps for creating a file and asserting its presence, offering a more compact style suitable for unit-level checks.

```Python
# scenarios/create_file.py
from pathlib import Path as File
from vedro import scenario, given, when, then

@scenario()
def create_file():
    with given('new file'):
        file = File('example.txt')

    with when('creating file'):
        file.touch()

    with then('file should exist'):
        assert file.exists()
```

--------------------------------

### Install Vedro and Dependencies

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

Commands to install the necessary Python packages and Vedro plugins required for setting up the testing environment. This includes the core Vedro framework, the HTTPX library for making HTTP requests, and the Vedro D42 Validator plugin.

```Bash
pip install vedro httpx
vedro plugin install vedro-d42-validator
```

--------------------------------

### Defining Given Steps for Scenario Preconditions in Vedro

Source: https://vedro.io/docs/best-practices/naming-for-better-tests

Illustrates how to set up the initial state or preconditions for a Vedro scenario using 'given' steps. Examples include both class-based methods and function-based contexts, highlighting the importance of specific and meaningful names for setup actions.

```Python
class Scenario(vedro.Scenario):
    subject = "log in as registered user"
    ...

    def given_registered_user(self):
        ...
```

```Python
@scenario()
def log_in_as_registered_user():
    ...

    with given("registered user"):
        ...
```

--------------------------------

### Vedro CLI Plugin Management Commands

Source: https://vedro.io/docs/guides/using-plugins

Comprehensive documentation for the Vedro command-line interface (CLI) commands specifically designed for managing plugins. This includes installing and enabling plugins, which streamlines the project setup and configuration process.

```APIDOC
vedro plugin install <plugin_name> [plugin_name ...]
  - Installs and automatically enables specified Vedro plugins.
  - Parameters:
    - plugin_name: The name of the Vedro plugin package to install (e.g., vedro-gitlab-reporter, vedro-allure-reporter). Multiple plugin names can be provided.
  - Returns:
    - Success message upon successful installation and configuration update.
  - Effect:
    - Downloads and installs the plugin package(s) using pip.
    - Modifies the `vedro.cfg.py` file to import and enable the installed plugins by setting `enabled = True` within their respective configuration classes.
  - Example Usage:
    $ vedro plugin install vedro-gitlab-reporter \
                           vedro-allure-reporter
```

--------------------------------

### Install Vedro Debug Prompt Plugin via Manager

Source: https://vedro.io/docs/ai/debug-prompt

This command uses Vedro's built-in plugin manager to quickly install the `vedro-debug-prompt` plugin. It's a one-liner for convenient setup, streamlining the installation process.

```shell
$ vedro plugin install vedro-debug-prompt
```

--------------------------------

### Utilize unittest Fixtures (setUp/tearDown) with Vedro

Source: https://vedro.io/docs/integrations/unittest-bridge

This example illustrates the use of `setUp()` and `tearDown()` lifecycle methods within a `unittest.TestCase`. Vedro fully respects these fixtures, ensuring that the test environment is properly prepared before each test method and cleaned up afterwards, maintaining expected `unittest` behavior.

```python
import unittest

class WidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget('The widget')

    def test_widget_resize(self):
        self.widget.resize(100, 150)
        self.assertEqual(self.widget.size(), (100, 150))
```

--------------------------------

### Install Vedro GitLab Reporter Plugin (Quick)

Source: https://vedro.io/docs/integrations/gitlab-reporter

Quickly install the Vedro GitLab Reporter plugin using the `vedro` command-line interface's plugin manager. This is the recommended method for most users.

```shell
$ vedro plugin install vedro-gitlab-reporter
```

--------------------------------

### Use Vedro Context in Class-based Scenario

Source: https://vedro.io/docs/quick-start

This Python example illustrates how to integrate a defined Vedro context, such as `existing_file`, into a class-based test scenario. The context is called within a `given` step to prepare the test environment, allowing the scenario to focus on the core test logic of writing and verifying file content.

```python
import vedro
from contexts.existing_file import existing_file

class Scenario(vedro.Scenario):
    subject = 'write data to existing file'

    def given_existing_file(self):
        self.file = existing_file()

    def when_writing_data(self):
        self.file.write_text('banana')

    def then_file_should_contain_written_data(self):
        assert self.file.read_text() == 'banana'
```

--------------------------------

### Implement Vedro Scenario Arrange Step (Given)

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

Demonstrates the 'Given' step in a Vedro scenario, where initial data and conditions are prepared before the main action. This specific example sets up a new user's credentials (username and password) for a registration test.

```Python
import vedro

class Scenario(vedro.Scenario):
    subject = "register new user"

    # Arrange step: prepare the necessary data for the test
    def given_new_user(self):
        self.user = {"username": "bob", "password": "qweqwe"}
```

--------------------------------

### Customizing Vedro Runner Options Example

Source: https://vedro.io/docs/integrations/pycharm-plugin

This example demonstrates additional command-line arguments that can be added to the Vedro runner options in PyCharm. `--show-timings` enables step-by-step timing, and `--show-steps` provides detailed output during test runs.

```Shell
--show-timings --show-steps
```

--------------------------------

### Define Vedro Scenario with Multiple Assertions for Single Action

Source: https://vedro.io/docs/quick-start

These Vedro scenarios illustrate the principle of 'one action, many outcomes'. They demonstrate how a single primary action (renaming a file) can lead to multiple observable effects, all of which can be verified within the same scenario. Two styles are shown: a class-based approach and a function-based approach using decorators.

```python
import vedro
from contexts.existing_file import existing_file

class Scenario(vedro.Scenario):
    subject = 'rename existing file'

    def given_existing_file(self):
        self.original_file = existing_file('file.txt')

    def when_renaming_file(self):
        self.renamed_file = self.original_file.rename('new_file.txt')

    def then_renamed_file_should_have_correct_name(self):
        assert self.renamed_file.name == 'new_file.txt'

    def then_renamed_file_should_exist(self):
        assert self.renamed_file.exists()

    def then_original_file_should_no_longer_exist(self):
        assert not self.original_file.exists()
```

```python
from vedro import scenario, given, when, then
from contexts.existing_file import existing_file

@scenario()
def rename_existing_file():
    with given('existing file'):
        original_file = existing_file('file.txt')

    with when('renaming file'):
        renamed_file = original_file.rename('new_file.txt')

    with then('renamed file should have correct name'):
        assert renamed_file.name == 'new_file.txt'

    with then('renamed file should exist'):
        assert renamed_file.exists()

    with then('original file should no longer exist'):
        assert not original_file.exists()
```

--------------------------------

### Install vedro-httpx package via pip

Source: https://vedro.io/docs/integrations/httpx-client

Provides instructions for manually installing the 'vedro-httpx' Python package using the pip package installer.

```shell
$ pip install vedro-httpx
```

--------------------------------

### Install Vedro Debug Prompt Plugin Manually with pip

Source: https://vedro.io/docs/ai/debug-prompt

This command installs the `vedro-debug-prompt` Python package using `pip`, the standard Python package installer. This is the initial step for users preferring a manual plugin setup, ensuring the package dependencies are met.

```shell
$ pip install vedro-debug-prompt
```

--------------------------------

### Install Vedro Allure Reporter Plugin

Source: https://vedro.io/docs/guides/using-plugins

This shell command installs the `vedro_allure_reporter` package using pip, making the plugin available in your Python environment. It is a necessary first step before configuring the plugin within the Vedro framework.

```Shell
$ pip install vedro_allure_reporter
```

--------------------------------

### Example Output: Vedro Tests with File Paths

Source: https://vedro.io/docs/basics/assertions-and-reporting

Illustrates the output of Vedro tests when `show_paths` is enabled, showing the file path where each scenario is defined.

```text
Scenarios
* auth / login
 ✔ login as registered user
   > scenarios/auth/login/login_as_registered_user.py:5
 ✔ try to login as nonexisting user
   > scenarios/auth/login/try_to_login_as_nonexisting_user.py:8
 ✔ try to login with incorrect password
   > scenarios/auth/login/try_to_login_with_incorrect_password.py:9

# 3 scenarios, 3 passed, 0 failed, 0 skipped (0.81s)
```

--------------------------------

### Example Output of Successful Vedro Test Run

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

This snippet shows the typical console output after a successful execution of Vedro tests. It summarizes the test results, indicating the number of scenarios passed, failed, and skipped, along with the total execution time.

```shell
Scenarios
*
 ✔ register new user

# 1 scenarios, 1 passed, 0 failed, 0 skipped (0.25s)

```

--------------------------------

### Example Console Output of Top Vedro Plugins

Source: https://vedro.io/docs/guides/using-plugins

This snippet shows the formatted table output generated by the `vedro plugin top` command. It provides details for each popular plugin, including its package name, a concise description, a link to its project page, and its popularity ranking.

```console
┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
┃ Package                ┃ Description                             ┃ URL                                     ┃ Popularity ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
│ vedro-allure-reporter  │ Allure reporter for Vedro framework     │ pypi.org/project/vedro-allure-reporter  │       2677 │
│ vedro-gitlab-reporter  │ GitLab reporter with collapsable        │ pypi.org/project/vedro-gitlab-reporter  │       2671 │
│                        │ sections for Vedro framework            │                                         │            │
│ vedro-interactive      │ Interactive mode for Vedro framework    │ pypi.org/project/vedro-interactive      │        640 │
│ vedro-advanced-tags    │ Vedro tags with boolean logic           │ pypi.org/project/vedro-advanced-tags    │        357 │
└────────────────────────┴─────────────────────────────────────────┴─────────────────────────────────────────┴────────────┘
```

--------------------------------

### Install coverage.py for Python Projects

Source: https://vedro.io/docs/guides/measuring-coverage

This command installs the `coverage.py` library, a standard tool in the Python ecosystem for measuring code coverage, ensuring it's available for tracking test execution.

```Shell
$ pip install coverage
```

--------------------------------

### Example of Hardcoded User Credentials

Source: https://vedro.io/docs/tutorial/api/chapter2-data-models

A simple Python snippet demonstrating the use of hardcoded `username` and `password` variables. While straightforward, this approach can lead to test flakiness and failures when unique data is required for each test run.

```python
username = "bob"
password = "qweqwe"

```

--------------------------------

### Implement Vedro Scenario Act Step (When)

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

Shows the 'When' step in a Vedro scenario, representing the primary action or interaction with the system under test. In this example, an HTTP POST request is made to the '/auth/register' endpoint of the chat API using the `httpx` library to simulate a new user registration.

```Python
import vedro
import httpx

API_URL = "https://chat-api-tutorial.vedro.io/m254a856tp"

class Scenario(vedro.Scenario):
    subject = "register new user"

    # Arrange step: prepare the necessary data for the test
    def given_new_user(self):
        self.user = {"username": "bob", "password": "qweqwe"}

    # Act step: perform the primary action
    def when_guest_registers(self):
        self.response = httpx.post(f"{API_URL}/auth/register", json=self.user)
```

--------------------------------

### Install Vedro Allure Reporter Package via Pip

Source: https://vedro.io/docs/integrations/allure-reporter

Installs the `vedro-allure-reporter` Python package using the standard pip package manager, which is part of the manual installation process.

```Shell
$ pip install vedro-allure-reporter
```

--------------------------------

### List All Installed Vedro Plugins

Source: https://vedro.io/docs/guides/using-plugins

This command-line utility lists all plugins currently installed in your Vedro project. It provides a comprehensive overview including the plugin's name, associated package, a brief description of its functionality, its version number, and whether it is currently enabled or disabled within the project configuration. This helps in auditing and managing project dependencies.

```shell
$ vedro plugin list
```

--------------------------------

### Install Vedro UnitTest Plugin via Pip

Source: https://vedro.io/docs/integrations/unittest-bridge

This command installs the `vedro-unittest` package using pip, the standard Python package installer. This is an alternative manual installation method for the plugin.

```Shell
$ pip install vedro-unittest
```

--------------------------------

### Example Output: Vedro Tests with Step Timings

Source: https://vedro.io/docs/basics/assertions-and-reporting

Illustrates the output of Vedro tests when `show_timings` and `show_steps` are enabled, showing execution times for individual steps within a scenario.

```text
Scenarios
* auth / login
 ✔ login as registered user (0.36s)
   ✔ given user (0.19s)
   ✔ when user logs in (0.18s)
   ✔ then it should return success response (0.00s)
   ✔ and it should return created token (0.00s)

# 1 scenarios, 1 passed, 0 failed, 0 skipped (0.36s)
```

--------------------------------

### Example: Generating OpenAPI Spec with Custom Options

Source: https://vedro.io/docs/integrations/httpx-client

This example demonstrates a practical invocation of the `vedro_httpx` command, applying both a base URL filter and disabling JSON-Schema constraints. The output OpenAPI specification is redirected to an `openapi.yaml` file, ready for use with tools like Swagger UI or Redoc.

```Shell
$ vedro_httpx .vedro/artifacts \
    --base-url http://localhost:8080/api/v1 \
    --no-constraints > openapi.yaml
```

--------------------------------

### Example Output: Vedro Tests with Scenario Timings

Source: https://vedro.io/docs/basics/assertions-and-reporting

Illustrates the default output of Vedro tests with scenario-level timings enabled, showing execution times for each scenario.

```text
Scenarios
* auth / login
 ✔ login as registered user (0.21s)
 ✔ try to login as nonexisting user (0.11s)
 ✔ try to login with incorrect password (0.22s)

# 3 scenarios, 3 passed, 0 failed, 0 skipped (0.53s)
```

--------------------------------

### Install Vedro UnitTest Plugin via CLI

Source: https://vedro.io/docs/integrations/unittest-bridge

This command installs the `vedro-unittest` plugin using Vedro's built-in plugin manager, providing a quick way to integrate `unittest` functionality into your Vedro project.

```Shell
$ vedro plugin install vedro-unittest
```

--------------------------------

### Install Vedro GitLab Reporter Plugin (Manual via pip)

Source: https://vedro.io/docs/integrations/gitlab-reporter

Manually install the `vedro-gitlab-reporter` Python package using pip. This step is necessary before enabling the plugin in the Vedro configuration.

```shell
$ pip install vedro-gitlab-reporter
```

--------------------------------

### Create a Parameterized Vedro Scenario with HTTP Requests

Source: https://vedro.io/docs/features/parameterized-scenarios

This Python example demonstrates how to define a Vedro scenario that runs multiple times with different HTTP status codes (200, 404) using the `@vedro.params` decorator. It utilizes the `httpx` library to make HTTP GET requests to `httpbin.org` and asserts the response status against the parameterized value.

```python
import httpx
import vedro
from vedro import params

class Scenario(vedro.Scenario):
    subject = "get status"

    @params(200)
    @params(404)
    def __init__(self, status):
        self.status = status

    def given_url(self):
        self.url = f"https://httpbin.org/status/{self.status}"

    def when_user_sends_request(self):
        self.response = httpx.get(self.url)

    def then_it_should_return_expected_status(self):
        assert self.response.status_code == self.status
```

--------------------------------

### Install flake8-vedro

Source: https://vedro.io/docs/features/anti-flaky

Installs the `flake8-vedro` package using pip, making the specialized linter available for checking Vedro test scenarios against defined best practices.

```shell
$ pip install flake8-vedro
```

--------------------------------

### Example Output: Full Assertion Diff

Source: https://vedro.io/docs/basics/assertions-and-reporting

Shows the full assertion difference output in Vedro, providing complete context for debugging complex data structure mismatches.

```text
AssertionError
>>> assert actual == expected
    {
        'total': 1,
        'items': [
            {
  -             'task_id': 1,
  +             'task_id': 2,
                'description': 'Implement user authentication system',
                'status': 'in progress',
                'assignee': 'Bob',
  -             'due_date': '2024-07-14'
  +             'due_date': '2024-07-15'
            }
        ]
    }
```

--------------------------------

### Install flake8-vedro via pip

Source: https://vedro.io/docs/integrations/flake8-linter

This command installs the `flake8-vedro` package using pip, making the linter available in your Python environment for Vedro project analysis.

```Shell
$ pip install flake8-vedro
```

--------------------------------

### Generating Unique User Data with d42

Source: https://vedro.io/docs/tutorial/api/chapter2-data-models

This Python example demonstrates how to generate unique user data using the `d42.fake` function based on the `NewUserSchema`. Each call to `fake(NewUserSchema)` produces a distinct dictionary, effectively solving the problem of hardcoded test data and ensuring test independence.

```python
from d42 import fake

fake(NewUserSchema)
# {'username': 'mwpd', 'password': 'EMiqcS2L9 x6UgxUuirjT9'}

fake(NewUserSchema)
# {'username': 'kqnhsrqito', 'password': 'XXlYxBaiXAvzj5Yp9pdR'}

fake(NewUserSchema)

```

--------------------------------

### Define a Vedro scenario for linting demonstration

Source: https://vedro.io/docs/integrations/flake8-linter

This Python code defines a `vedro.Scenario` class with methods for setting up a book ID, retrieving book details via HTTPX, and asserting the response. It serves as a practical example for demonstrating `flake8-vedro` linting capabilities.

```Python
# ./scenarios/get_book_details.py
import vedro
import httpx

class Scenario(vedro.Scenario):
    subject = ""

    def given_book_id(self):
        self.book_id = 1234

    def when_user_retrieves_book(self):
        self.response = httpx.get(f"/api/books/{self.book_id}")

    def then_it_should_return_book_details(self):
        assert self.response.json() == {
            "id": self.book_id,
            "title": "The Great Gatsby",
            "author": "F. Scott Fitzgerald",
        }
```

--------------------------------

### Vedro Context: Registering a User for Scenarios

Source: https://vedro.io/docs/tutorial/api/chapter3-contexts

This Python function, decorated with `@vedro.context`, defines a reusable context for registering a user via an API. It takes user data as input, performs a POST request to the registration endpoint, and raises an exception if the registration fails, ensuring a clean setup for subsequent scenario steps.

```python
# ./contexts/registered_user.py
import vedro
import httpx

API_URL = "https://chat-api-tutorial.vedro.io/9zsjgn8l4k"

@vedro.context
def registered_user(user):
    response = httpx.post(f"{API_URL}/auth/register", json=user)
    response.raise_for_status()
    return
```

--------------------------------

### Implement Synchronous Vedro Scenario for User Login

Source: https://vedro.io/docs/integrations/httpx-client

This example shows how to integrate the synchronous `AuthAPI` interface into a Vedro test scenario. It defines `given`, `when`, and `then` steps to simulate a registered user logging in, including an assertion on the HTTP response status code.

```python
import vedro
from contexts import registered_user
from interfaces import AuthAPI

class Scenario(vedro.Scenario):
    subject = "login as registered user"

    def given_user(self):
        self.user = registered_user()

    def when_user_logs_in(self):
        self.response = AuthAPI().login(self.user["username"], self.user["password"])

    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200
```

--------------------------------

### Example Output: Default Assertion Diff

Source: https://vedro.io/docs/basics/assertions-and-reporting

Shows the default trimmed assertion difference output in Vedro, highlighting only the changed lines for quick identification of issues.

```text
AssertionError
>>> assert actual == expected
            {
  -             'task_id': 1,
  +             'task_id': 2,
                'description': 'Implement user authentication system',
  ...
                'assignee': 'Bob',
  -             'due_date': '2024-07-14'
  +             'due_date': '2024-07-15'
            }
```

--------------------------------

### Implementing an HTTP API Client for Vedro Tests

Source: https://vedro.io/docs/best-practices/scenario-based-tests

Illustrates how to create a custom HTTP API client using `vedro_httpx` to encapsulate API interactions. This example shows a `login` method, promoting reusability and cleaner test step implementations.

```Python
from vedro_httpx import Response, SyncHTTPInterface

class ChatApi(SyncHTTPInterface):
    def login(self, username: str, password: str) -> Response:
        return self._request("POST", "/auth/login", json={
            "username": username,
            "password": password
        })
```

--------------------------------

### Implement Asynchronous Vedro Scenario for User Login

Source: https://vedro.io/docs/integrations/httpx-client

This example shows how to integrate the asynchronous `AuthAPI` interface into a Vedro test scenario. It defines `given`, `when`, and `then` steps to simulate a registered user logging in, including an assertion on the HTTP response status code.

```python
import vedro
from contexts import registered_user
from interfaces import AuthAPI

class Scenario(vedro.Scenario):
    subject = "login as registered user"

    async def given_user(self):
        self.user = await registered_user()

    async def when_user_logs_in(self):
        self.response = await AuthAPI().login(self.user["username"], self.user["password"])

    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200
```

--------------------------------

### Install Vedro Git changed plugin for automated flakiness detection

Source: https://vedro.io/docs/features/anti-flaky

This command installs the `vedro-git-changed` plugin, which automates the process of identifying and running only the test scenarios that have been modified relative to a specified Git branch. This helps in targeted flakiness detection and ensures that new or modified tests are scrutinized.

```Shell
$ vedro plugin install vedro-git-changed
```

--------------------------------

### GitHub Actions configuration for Vedro flakiness detection

Source: https://vedro.io/docs/features/anti-flaky

This GitHub Actions workflow illustrates how to set up automated flakiness detection with Vedro in a GitHub CI/CD pipeline. It checks out code, sets up Python, installs dependencies, and runs changed tests repeatedly in random order, providing a robust quality check for pull requests.

```YAML
on:
  push:
    branches-ignore:
      - 'main'
    paths:
      - 'scenarios/**'

jobs:
  run_changed_tests:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout Code
      uses: actions/checkout@v4
      with:
        fetch-depth: 0

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'

    - name: Install Dependencies
      run: pip install -r requirements.txt

    - name: Run Changed Tests
      run: vedro run --changed-against-branch=main -N 10 --order-random
```

--------------------------------

### Example Output of Random Scenario Execution

Source: https://vedro.io/docs/features/scenario-ordering

This block shows a typical console output after running Vedro scenarios in random order. It lists the executed scenarios, their status, and the generated seed that can be used for reproduction.

```Console Output
Scenarios
*
 ✔ sign in via email
 ✔ sign out
 ✔ sign in via social

# --seed bae6dceb-a55a-4895-9f26-4d3ff56a9fea
# 3 scenarios, 3 passed, 0 failed, 0 skipped (0.12s)
```

--------------------------------

### Auto-generated Vedro Configuration for Enabled Plugins

Source: https://vedro.io/docs/guides/using-plugins

This Python code block shows the structure of the `vedro.cfg.py` file after using the `vedro plugin install` command. It demonstrates how the plugin manager automatically imports and enables the specified plugins (`GitlabReporter`, `AllureReporter`) within the `Config.Plugins` class, preserving explicit configuration.

```Python
import vedro_gitlab_reporter
import vedro_allure_reporter
import vedro

class Config(vedro.Config):

    class Plugins(vedro.Config.Plugins):

        class GitlabReporter(vedro_gitlab_reporter.GitlabReporter):
            enabled = True

        class AllureReporter(vedro_allure_reporter.AllureReporter):
            enabled = True
```

--------------------------------

### Example Output of Vedro Dry Run

Source: https://vedro.io/docs/features/tags

This snippet presents a typical console output from a Vedro --dry-run command. It lists the scenarios identified for execution based on the applied tags, showing their names, status, and file locations, which helps in verifying the tag-based selection.

```text
Scenarios
* auth / login
 ✔ login as registered user
   > scenarios/auth/login/login_as_registered_user.py

 ✔ try to login as nonexisting user
   > scenarios/auth/login/try_to_login_as_nonexisting_user.py

 ✔ try to login with incorrect password
   > scenarios/auth/login/try_to_login_with_incorrect_password.py

# 3 scenarios, 3 passed, 0 failed, 0 skipped
```

--------------------------------

### Chat Platform API Endpoints Overview

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

An overview of the key API endpoints for the chat platform, detailing methods for user authentication (registration and login) and message handling (sending and retrieving messages). These endpoints are crucial for interacting with the chat service.

```APIDOC
POST /auth/register
  - Description: Register a new user with a username and password

POST /auth/login
  - Description: Authenticate an existing user

POST /chats/<chat_id>/messages
  - Description: Send a message to a chat with the specified chat_id. A new chat will be created if it doesn't already exist

GET /chats/<chat_id>/messages
  - Description: Retrieve messages for a chat with the specified chat_id
```

--------------------------------

### Set Up Parallel Vedro Tests in GitLab CI

Source: https://vedro.io/docs/features/parallel-execution

Provides a GitLab CI configuration (`.gitlab-ci.yml`) for running Vedro tests in parallel using the `parallel` keyword. It includes steps for setting up the Python environment, installing dependencies, and executing Vedro, adjusting for GitLab's 1-based `CI_NODE_INDEX`.

```YAML
test:
  image: python:3.12
  parallel: 2
  before_script:
    - pip install -r requirements.txt
  script:
    - vedro run --slicer-total=$CI_NODE_TOTAL --slicer-index=$((CI_NODE_INDEX-1))
```

--------------------------------

### GitLab CI configuration for Vedro flakiness detection

Source: https://vedro.io/docs/features/anti-flaky

This GitLab CI configuration demonstrates how to integrate Vedro's flakiness detection features into a CI pipeline. It sets up a Python environment, installs dependencies, and runs changed tests multiple times in random order, ensuring robust quality gates for new or modified scenarios before merging.

```YAML
run_changed_tests:
  stage: test
  image: python:3.11
  before_script:
    - pip install -r requirements.txt
  script:
    - vedro run --changed-against-branch=main -N 10 --order-random
  only:
    refs:
      - branches
    changes:
      - scenarios/**/*
```

--------------------------------

### Filter and Run Vedro Scenarios by Allure Labels

Source: https://vedro.io/docs/integrations/allure-reporter

This command-line interface (CLI) example demonstrates how to use the `vedro run` command with the `--allure-labels` argument to selectively execute test scenarios. You can specify one or more `label=value` pairs to match scenarios annotated with corresponding Allure labels. This is useful for running specific test suites or features.

```Shell
$ vedro run --allure-labels label1=val1 label2=val2 ...
```

```Shell
$ vedro run --allure-labels epic="User Profile Management" feature="Updating Profile Details"
```

--------------------------------

### Configure Parallel Vedro Tests in GitHub Actions

Source: https://vedro.io/docs/features/parallel-execution

Illustrates a GitHub Actions workflow configuration (`.github/workflows/test.yml`) that leverages a matrix strategy to run Vedro tests in parallel. It sets up Python, installs dependencies, and executes Vedro with dynamic `--slicer-total` and `--slicer-index` values derived from the matrix.

```YAML
name: Test

on: push

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-total: [2]
        node-index: [0, 1]

    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.12'
    - name: Install Dependencies
      run: pip install -r requirements.txt
    - name: Run Tests
      run: vedro run --slicer-total=${{ matrix.node-total }} --slicer-index=${{ matrix.node-index }}
```

--------------------------------

### Python API Definition: Correct Dynamic Path Handling

Source: https://vedro.io/docs/integrations/httpx-client

This Python example demonstrates the recommended method for defining API routes with dynamic path segments using the `segments` argument. This approach ensures that the OpenAPI generator produces a single, clean path (e.g., `/users/{username}`) and correctly documents `{username}` as a path parameter, resulting in a precise and readable specification.

```Python
class AsyncAuthAPI(AsyncHTTPInterface):
    async def get_user(self, username: str) -> Response:
        return await self._request("GET", "/users/{username}", segments={
            "username": username
        })
```

--------------------------------

### Illustrating unittest Test Execution Order in Python

Source: https://vedro.io/docs/integrations/unittest-bridge

This Python unittest example demonstrates a typical test class structure where `setUpClass` and `tearDownClass` manage shared state, and `test_1` and `test_2` execute sequentially. It highlights how unittest allows for a predetermined test execution order, which Vedro discourages due to potential dependencies and flakiness.

```python
import unittest

class MyTestCase(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        # Set up shared state
        ...

    def test_1(self):
        # Relies on shared state
        ...

    def test_2(self):
        # Also relies on shared state
        ...

    @classmethod
    def tearDownClass(cls):
        # Clean up shared state
        ...

```

--------------------------------

### Run Vedro Tests with Verbose Output

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

This shell command executes all Vedro test scenarios found in the `scenarios/` directory. The `-v` flag enables verbose output, providing more detailed information about the test run, which is helpful for debugging.

```shell
$ vedro run -v

```

--------------------------------

### Vedro BDD Scenario for API User Registration

Source: https://vedro.io/docs/tutorial/api/chapter1-first-steps

This Python code defines a Vedro test scenario following the Arrange (given), Act (when), Assert (then) pattern. It simulates user registration via an API call using `httpx` and verifies the successful response.

```python
import vedro
import httpx

API_URL = "https://chat-api-tutorial.vedro.io/cwf2f2h2v9"

class Scenario(vedro.Scenario):
    subject = "register new user"

    # Arrange step: prepare the necessary data for the test
    def given_new_user(self):
        self.user = {"username": "bob", "password": "qweqwe"}

    # Act step: perform the primary action
    def when_guest_registers(self):
        self.response = httpx.post(f"{API_URL}/auth/register", json=self.user)

    # Assert step: verify that the system behaved as expected
    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200

```

--------------------------------

### Initial Vedro Scenario for User Registration

Source: https://vedro.io/docs/tutorial/api/chapter2-data-models

This Python `vedro` scenario demonstrates a basic user registration test. It uses `httpx` to send a POST request to a chat API with hardcoded user credentials and asserts a 200 status code. This initial approach highlights the problem of test fragility due to static data.

```python
import vedro
import httpx

API_URL = "https://chat-api-tutorial.vedro.io/z30drbqltj"

class Scenario(vedro.Scenario):
    subject = "register new user"

    # Arrange step: prepare the necessary data for the test
    def given_new_user(self):
        self.user = {"username": "bob", "password": "qweqwe"}

    # Act step: perform the primary action
    def when_guest_registers(self):
        self.response = httpx.post(f"{API_URL}/auth/register", json=self.user)

    # Assert step: verify that the system behaved as expected
    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200

```

--------------------------------

### Run Vedro scenarios from a directory using Selective Discoverer

Source: https://vedro.io/docs/exp/selective-discoverer

Shows how to use the Selective Discoverer to execute all scenarios found within a designated directory. This approach significantly reduces startup time by limiting the scope of module discovery to only the specified directory's contents.

```Shell
vedro run --exp-selective-discoverer scenarios/auth/
```

--------------------------------

### Illustrate Repetitive API Endpoint Usage (Python)

Source: https://vedro.io/docs/tutorial/api/chapter4-interfaces

This Python snippet highlights the issue of hardcoded and repetitive API endpoint usage across multiple files (`scenarios/register_new_user.py` and `contexts/registered_user.py`). It demonstrates how identical API calls to `/auth/register` can lead to maintenance challenges if the endpoint or base URL changes.

```python
# ./scenarios/register_new_user.py
httpx.post(f"{API_URL}/auth/register", json=self.user)
```

```python
# ./contexts/registered_user.py
httpx.post(f"{API_URL}/auth/register", json=user)
```

--------------------------------

### Attach Artifacts to Vedro Allure Report

Source: https://vedro.io/docs/integrations/allure-reporter

These examples illustrate how to attach various types of artifacts to the Allure report within a Vedro context. The first example shows attaching a file-based artifact, while the second demonstrates attaching an in-memory artifact.

```python
import vedro
from vedro.plugins.artifacted import attach_artifact, FileArtifact
from PIL import Image
from pathlib import Path

@vedro.context
def generated_profile_picture(filename="picture.png") -> Image:
    image = Image.new("RGB", size=(100, 100))
    image.save(filename, format="png")

    artifact = FileArtifact(filename, "image/png", Path(filename))
    attach_artifact(artifact)

    return image
```

```python
import vedro
from vedro.plugins.artifacted import attach_artifact, MemoryArtifact
from PIL import Image
from io import BytesIO

@vedro.context
def generated_profile_picture(filename="picture.png") -> Image:
    binary = BytesIO()
    image = Image.new("RGB", size=(100, 100))
    image.save(binary, format="png")

    artifact = MemoryArtifact(filename, "image/png", binary.getvalue())
    attach_artifact(artifact)

    return image
```

--------------------------------

### Vedro Scenario: Register New User via API

Source: https://vedro.io/docs/tutorial/api/chapter3-contexts

This Vedro scenario defines the steps to register a new user against a chat API. It utilizes the `httpx` library for making a POST request and `d42` for generating fake user data, asserting a successful 200 status code and correct response body matching the schema.

```python
import vedro
import httpx
from d42 import fake
from schemas.user import NewUserSchema

API_URL = "https://chat-api-tutorial.vedro.io/xlezlhfi2q"

class Scenario(vedro.Scenario):
    subject = "register new user"

    def given_new_user(self):
        self.user = fake(NewUserSchema)

    def when_guest_registers(self):
        self.response = httpx.post(f"{API_URL}/auth/register", json=self.user)

    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200

    def and_then_it_should_return_created_user(self):
        assert self.response.json() == NewUserSchema % self.user
```

--------------------------------

### Defining a New User Data Model with d42

Source: https://vedro.io/docs/tutorial/api/chapter2-data-models

This Python code defines a `NewUserSchema` using the `d42` library to model user registration data. It specifies that `username` must be 3-12 lowercase letters and `password` must be at least 6 characters long, enabling the generation of valid and unique user data for testing.

```python
from string import ascii_lowercase
from d42 import schema

NewUserSchema = schema.dict({
    "username": schema.str.alphabet(ascii_lowercase).len(3, 12),
    "password": schema.str.len(6, ...),
})

```

--------------------------------

### Define Scenario Tags in Vedro

Source: https://vedro.io/docs/integrations/allure-reporter

This example demonstrates how to define tags for a Vedro scenario. Tags, such as 'API', can be attached to scenarios and will appear in the Allure report if the `attach_tags` option is enabled in the Allure Reporter configuration.

```python
import vedro

class Scenario(vedro.Scenario):
    subject = "update profile picture"
    tags = ["API"]
```

--------------------------------

### Unsupported Dynamic Test Skipping in Vedro

Source: https://vedro.io/docs/integrations/unittest-bridge

An example illustrating the attempt to dynamically skip a test using `self.skipTest()` within a `unittest.TestCase`. This practice is not supported by Vedro, as it prioritizes deterministic test execution over runtime skipping.

```python
import unittest

class MyTestCase(unittest.TestCase):
    def test_feature(self):
        if not some_condition():
            self.skipTest("Feature not available")
```

--------------------------------

### Run Vedro Tests with Step-Level Timings

Source: https://vedro.io/docs/basics/assertions-and-reporting

Executes Vedro tests from the command line, enabling both scenario-level and step-level timings for detailed performance profiling and living documentation.

```bash
$ vedro run --show-timings --show-steps
```

--------------------------------

### Vedro Project Structure for Scenario-Based Tests

Source: https://vedro.io/docs/best-practices/scenario-based-tests

Illustrates the recommended directory structure for organizing Vedro scenarios, providing a high-level overview of the test suite and promoting modularity and scalability.

```Filesystem
* chat_api/
└── scenarios/
    ├── auth/
    │   ├── register_new_user.py
    │   ├── login_as_registered_user.py
    │   └── try_to_login_as_nonexisting_user.py
    ├── send_message/
    │   ├── send_message.py
    │   └── try_to_send_message_as_unauthorized_user.py
    └── get_messages/
        ├── get_messages.py
        └── try_to_get_messages_as_unauthorized_user.py
```

--------------------------------

### Implement Vedro Scenario for User Login

Source: https://vedro.io/docs/tutorial/api/chapter4-interfaces

This Vedro scenario demonstrates how to test user login functionality. It sets up a fake user, registers them using the `registered_user` context, attempts to log in via `ChatApi`, and then asserts that the response is successful (HTTP 200) and returns a valid authentication token matching the expected schema.

```python
import vedro
from d42 import fake
from schemas.user import NewUserSchema
from contexts.registered_user import registered_user
from schemas.token import AuthTokenSchema
from interfaces.chat_api import ChatApi

class Scenario(vedro.Scenario):
    subject = "login as registered user"

    def given_user(self):
        self.user = fake(NewUserSchema)
        registered_user(self.user)

    def when_user_logs_in(self):
        self.response = ChatApi().login(self.user)

    def then_it_should_return_success_response(self):
        assert self.response.status_code == 200

    def and_it_should_return_created_token(self):
        assert self.response.json() == AuthTokenSchema % {
            "username": self.user["username"]
        }
```

--------------------------------

### Example output of Flake8 linting errors

Source: https://vedro.io/docs/integrations/flake8-linter

This output demonstrates typical linting errors reported by Flake8, including standard Python style issues (E302) and custom `flake8-vedro` rules (VDR105) specific to Vedro scenarios.

```Shell
./scenarios/get_book_details.py:4:1: E302 expected 2 blank lines, found 1
./scenarios/get_book_details.py:5:5: VDR105 subject in scenario should not be empty
```

--------------------------------

### Check for linting errors with flake8-vedro

Source: https://vedro.io/docs/features/anti-flaky

Executes the `flake8` command to run the linter, which, with `flake8-vedro` installed, will apply Vedro-specific rules and checks to identify best practice violations and linting errors in your test suite.

```shell
$ flake8
```
Tokens:
Raw