schemathesis 3.35.5__tar.gz → 3.36.0__tar.gz

{schemathesis-3.35.5 → schemathesis-3.36.0}/.github/workflows/update-pre-commit.yml

@@ -20,7 +20,7 @@ jobs:
       - run: uvx pre-commit autoupdate
 
       - name: Open pull request
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v7
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           delete-branch: true

{schemathesis-3.35.5 → schemathesis-3.36.0}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.4
+    rev: v0.6.5
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.4
+    rev: v0.6.5
     hooks:
       - id: ruff
 

{schemathesis-3.35.5 → schemathesis-3.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.35.5
+Version: 3.36.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/auth.rst

@@ -443,6 +443,8 @@ For example, you can use refresh tokens for authentication.
             case.headers = case.headers or {}
             case.headers = {"Authorization": f"Bearer {data}"}
 
+.. _third-party-auth:
+
 Third-party implementation
 --------------------------
 

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/changelog.rst

@@ -1,9 +1,37 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.35.5...HEAD>` - TBD
+:version:`Unreleased <v3.36.0...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.36.0:
+
+:version:`3.36.0 <v3.35.5...v3.36.0>` - 2024-09-15
+--------------------------------------------------
+
+**Added**
+
+- Reimplementation of test case deduplication in CLI. It effectively un-deprecates the ``--contrib-unique-data`` CLI option.
+- Extend ``ignored_auth`` to check for incorrect auth.
+- More ``properties`` combinations for the coverage phase.
+- Use the `default` field as a source of valid inputs during the coverage phase.
+
+**Changed**
+
+- Add ``ctx`` as the first argument for all checks. 
+  This is a step towards checks that cover multiple responses at once. 
+- Validate custom check function signatures.
+
+**Deprecated**
+
+- Custom checks that do not accept ``ctx`` as the first argument.
+
+**Fixed**
+
+- Avoid running checks twice in new-style stateful tests.
+- Missing ``timeout`` in certain situations when loading the schema from the network.
+- Ignoring ``with_security_parameters`` in runner in some cases.
+
 .. _v3.35.5:
 
 :version:`3.35.5 <v3.35.4...v3.35.5>` - 2024-09-08

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/cli.rst

@@ -677,11 +677,11 @@ To use your custom checks with Schemathesis CLI, you need to register them via t
 
 
     @schemathesis.check
-    def new_check(response, case):
+    def new_check(ctx, response, case):
         # some awesome assertions!
         pass
 
-The registered check should accept a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
+The registered check should accept ``ctx``, a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
 ``case`` with ``schemathesis.models.Case`` type. This code should be placed in the module you pass to the ``SCHEMATHESIS_HOOKS`` environment variable.
 
 Then your checks will be available in Schemathesis CLI, and you can use them via the ``-c`` command-line option.
@@ -700,7 +700,7 @@ response code is ``200``.
 
 
     @schemathesis.check
-    def conditional_check(response, case):
+    def conditional_check(ctx, response, case):
         if response.status_code == 200:
             ...  # some awesome assertions!
         else:

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/contrib.rst

@@ -6,13 +6,6 @@ Schemathesis ships a set of optional features that could help to tune your tests
 Unique data generation
 ~~~~~~~~~~~~~~~~~~~~~~
 
-.. important::
-
-    The ``--contrib-unique-data`` CLI option and the corresponding ``schemathesis.contrib.unique_data`` hook are **DEPRECATED**. The concept of this feature
-    does not fit the core principles of Hypothesis where strategies are configurable on a per-example basis but this feature implies
-    uniqueness across examples. This leads to cryptic error messages about external state and flaky test runs, therefore it will be removed in
-    Schemathesis 4.0
-
 By default, Schemathesis may generate the same test cases as all data is randomized. If this behavior does not match your expectations, or
 your test budges, you can force Schemathesis to generate unique test cases.
 
@@ -22,6 +15,13 @@ In CLI:
 
     $ st run --contrib-unique-data https://example.schemathesis.io/openapi.json
 
+.. important::
+
+    The ``schemathesis.contrib.unique_data`` hook is **DEPRECATED**. The concept of this feature
+    does not fit the core principles of Hypothesis where strategies are configurable on a per-example basis but this feature implies
+    uniqueness across examples. This leads to cryptic error messages about external state and flaky test runs, therefore it will be removed in
+    Schemathesis 4.0
+
 In Python tests:
 
 .. code:: python

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/extending.rst

@@ -667,7 +667,7 @@ Checks
 Checks in Schemathesis allow you to validate responses from your API, ensuring they adhere to both general and application-specific expectations. 
 They can be particularly useful for checking behaviors that are specific to your application and go beyond the built-in checks provided by Schemathesis.
 
-Define a check as a function taking two parameters: ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
+Define a check as a function taking three parameters: ``ctx``, ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
 
 .. code-block:: python
 
@@ -675,9 +675,10 @@ Define a check as a function taking two parameters: ``response`` and ``case``, a
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         ...
 
+- ``ctx`` holds a context relevant to the current check. Currently unused and is placed here for future-compatibility.
 - ``response`` is the API response, an instance of ``requests.Response`` or ``schemathesis.utils.WSGIResponse``, based on your integration method.
 - ``case`` is the ``schemathesis.Case`` instance used to send data to the application.
 
@@ -691,7 +692,7 @@ Here’s an example of a check that ensures that when an ``item_id`` of 42 is us
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         if case.path_parameters.get("item_id") == 42 and ANSWER not in response.text:
             raise AssertionError("The ultimate answer not found!")
 

{schemathesis-3.35.5 → schemathesis-3.36.0}/docs/faq.rst

@@ -322,6 +322,14 @@ Python:
 
 This adjustment ensures that Schemathesis does not include NULL bytes in strings for all your tests, making them compatible with systems that reject such inputs.
 
+How can I use custom authentication methods with Schemathesis?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Schemathesis supports custom authentication through its extensions system.
+
+For detailed instructions on implementing custom authentication methods or using existing libraries for that, 
+refer to our :ref:`Custom Authentication <custom-auth>` and :ref:`Third-party Authentication <third-party-auth>` sections.
+
 Working with API schemas
 ------------------------
 

{schemathesis-3.35.5 → schemathesis-3.36.0}/example/tests/extensions.py

@@ -17,18 +17,18 @@ schemathesis.openapi.format("fullname", fullname())
 
 
 @schemathesis.hook
-def filter_body(context, body):
+def filter_body(ctx, body):
     """Modification over the default strategy for payload generation."""
     return body.get("id", 10001) > 10000
 
 
 @schemathesis.check
-def not_so_slow(response, case):
+def not_so_slow(ctx, response, case):
     """Custom response check."""
     assert response.elapsed < timedelta(milliseconds=100), "Response is slow!"
 
 
 @schemathesis.target
-def big_response(context):
+def big_response(ctx):
     """Custom data generation target."""
-    return float(len(context.response.content))
+    return float(len(ctx.response.content))

{schemathesis-3.35.5 → schemathesis-3.36.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.35.5"
+version = "3.36.0"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/checks.py

@@ -15,11 +15,12 @@ from .specs.openapi.checks import (
 )
 
 if TYPE_CHECKING:
-    from .models import Case, CheckFunction
+    from .internal.checks import CheckContext, CheckFunction
+    from .models import Case
     from .transports.responses import GenericResponse
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
+def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     from .specs.graphql.schemas import GraphQLCase
     from .specs.graphql.validation import validate_graphql_response
@@ -64,14 +65,16 @@ def register(check: CheckFunction) -> CheckFunction:
     .. code-block:: python
 
         @schemathesis.check
-        def new_check(response, case):
+        def new_check(ctx, response, case):
             # some awesome assertions!
             ...
     """
     from . import cli
+    from .internal.checks import wrap_check
 
+    _check = wrap_check(check)
     global ALL_CHECKS
 
-    ALL_CHECKS += (check,)
-    cli.CHECKS_TYPE.choices += (check.__name__,)  # type: ignore
+    ALL_CHECKS += (_check,)
+    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
     return check

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/cli/__init__.py

@@ -104,13 +104,6 @@ DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
     "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
     "Use `--show-trace` instead"
 )
-DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING = (
-    "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-    "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-    "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-    "This leads to cryptic error messages about external state and flaky test runs, "
-    "therefore it will be removed in Schemathesis 4.0"
-)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
@@ -439,7 +432,7 @@ REPORT_TO_SERVICE = ReportToService()
     "-A",
     type=click.Choice(["basic", "digest"], case_sensitive=False),
     default="basic",
-    help="Specify the authentication method",
+    help="Specify the authentication method. For custom authentication methods, see our Authentication documentation: https://schemathesis.readthedocs.io/en/stable/auth.html#custom-auth",
     show_default=True,
     metavar="",
 )
@@ -949,9 +942,6 @@ def run(
             entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
-    if contrib_unique_data:
-        click.secho(DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING, fg="yellow")
-
     if show_errors_tracebacks:
         click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
         show_trace = show_errors_tracebacks
@@ -1160,8 +1150,6 @@ def run(
         else:
             _fixups.install(fixups)
 
-    if contrib_unique_data:
-        contrib.unique_data.install()
     if contrib_openapi_formats_uuid:
         contrib.openapi.formats.uuid.install()
     if contrib_openapi_fill_missing_examples:
@@ -1197,6 +1185,7 @@ def run(
         seed=hypothesis_seed,
         exit_first=exit_first,
         max_failures=max_failures,
+        unique_data=contrib_unique_data,
         dry_run=dry_run,
         store_interactions=cassette_path is not None,
         checks=selected_checks,
@@ -1321,6 +1310,7 @@ def into_event_stream(
     exit_first: bool,
     max_failures: int | None,
     rate_limit: str | None,
+    unique_data: bool,
     dry_run: bool,
     store_interactions: bool,
     stateful: Stateful | None,
@@ -1364,6 +1354,7 @@ def into_event_stream(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/contrib/unique_data.py

@@ -13,8 +13,7 @@ if TYPE_CHECKING:
 
 def install() -> None:
     warnings.warn(
-        "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-        "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
+        "The `schemathesis.contrib.unique_data` hook is **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
         "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
         "This leads to cryptic error messages about external state and flaky test runs, "
         "therefore it will be removed in Schemathesis 4.0",

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/generation/coverage.py

@@ -238,6 +238,8 @@ def _get_properties(schema: dict | bool) -> dict | bool:
     if isinstance(schema, dict):
         if "example" in schema:
             return {"const": schema["example"]}
+        if "default" in schema:
+            return {"const": schema["default"]}
         if schema.get("examples"):
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
@@ -265,12 +267,19 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     max_length = schema.get("maxLength")
     example = schema.get("example")
     examples = schema.get("examples")
-    if example or examples:
+    default = schema.get("default")
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not min_length and not max_length:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
@@ -327,13 +336,20 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     multiple_of = schema.get("multipleOf")
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not minimum and not maximum:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
@@ -382,13 +398,20 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
     seen = set()
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     else:
         yield PositiveValue(template)
     seen.add(len(template))
@@ -425,19 +448,37 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
+
     else:
         yield PositiveValue(template)
-    # Only required properties
+
     properties = schema.get("properties", {})
-    if set(properties) != set(schema.get("required", {})):
-        only_required = {k: v for k, v in template.items() if k in schema.get("required", [])}
+    required = set(schema.get("required", []))
+    optional = list(set(properties) - required)
+    optional.sort()
+
+    # Generate combinations with required properties and one optional property
+    for name in optional:
+        combo = {k: v for k, v in template.items() if k in required or k == name}
+        if combo != template:
+            yield PositiveValue(combo)
+    # Generate only required properties
+    if set(properties) != required:
+        only_required = {k: v for k, v in template.items() if k in required}
         yield PositiveValue(only_required)
     seen = set()
     for name, sub_schema in properties.items():

schemathesis-3.36.0/src/schemathesis/internal/checks.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from ..models import Case
+    from ..transports.responses import GenericResponse
+    from requests.structures import CaseInsensitiveDict
+
+
+CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
+
+
+@dataclass
+class CheckContext:
+    """Context for Schemathesis checks.
+
+    Provides access to broader test execution data beyond individual test cases.
+    """
+
+    headers: CaseInsensitiveDict | None = None
+
+
+def wrap_check(check: Callable) -> CheckFunction:
+    """Make older checks compatible with the new signature."""
+    signature = inspect.signature(check)
+    parameters = len(signature.parameters)
+
+    if parameters == 3:
+        # New style check, return as is
+        return check
+
+    if parameters == 2:
+        # Old style check, wrap it
+        warnings.warn(
+            f"The check function '{check.__name__}' uses an outdated signature. "
+            "Please update it to accept 'ctx' as the first argument: "
+            "(ctx: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        def wrapper(_: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]:
+            return check(response, case)
+
+        wrapper.__name__ = check.__name__
+
+        return wrapper
+
+    raise ValueError(f"Invalid check function signature. Expected 2 or 3 parameters, got {parameters}")

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/models.py

@@ -17,7 +17,6 @@ from typing import (
     Generic,
     Iterator,
     NoReturn,
-    Optional,
     Sequence,
     Type,
     TypeVar,
@@ -46,6 +45,7 @@ from .exceptions import (
 )
 from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.checks import CheckContext
 from .internal.copy import fast_deepcopy
 from .internal.deprecation import deprecated_function, deprecated_property
 from .internal.output import prepare_response_payload
@@ -65,6 +65,7 @@ if TYPE_CHECKING:
 
     from .auths import AuthStorage
     from .failures import FailureContext
+    from .internal.checks import CheckFunction
     from .schemas import BaseSchema
     from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
@@ -421,6 +422,7 @@ class Case:
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -434,17 +436,30 @@ class Case:
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
         from .checks import ALL_CHECKS
+        from .internal.checks import wrap_check
         from .transports.responses import get_payload, get_reason
 
-        checks = checks or ALL_CHECKS
+        if checks:
+            _checks = tuple(wrap_check(check) for check in checks)
+        else:
+            _checks = checks
+        if additional_checks:
+            _additional_checks = tuple(wrap_check(check) for check in additional_checks)
+        else:
+            _additional_checks = additional_checks
+
+        checks = _checks or ALL_CHECKS
         checks = tuple(check for check in checks if check not in excluded_checks)
-        additional_checks = tuple(check for check in additional_checks if check not in excluded_checks)
+        additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
+        ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
             try:
-                check(response, copied_case)
+                check(ctx, response, copied_case)
             except AssertionError as exc:
                 maybe_set_assertion_message(exc, check.__name__)
                 failed_checks.append(exc)
@@ -514,7 +529,7 @@ class Case:
     ) -> requests.Response:
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
-        self.validate_response(response, checks, code_sample_style=code_sample_style)
+        self.validate_response(response, checks, code_sample_style=code_sample_style, headers=headers)
         return response
 
     def _get_url(self, base_url: str | None) -> str:
@@ -1233,6 +1248,3 @@ class TestResultSet:
     def add_warning(self, warning: str) -> None:
         """Add a new warning to the warnings list."""
         self.warnings.append(warning)
-
-
-CheckFunction = Callable[["GenericResponse", Case], Optional[bool]]

{schemathesis-3.35.5 → schemathesis-3.36.0}/src/schemathesis/runner/__init__.py

@@ -347,6 +347,7 @@ def from_schema(
     exit_first: bool = False,
     max_failures: int | None = None,
     started_at: str | None = None,
+    unique_data: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
     stateful: Stateful | None = None,
@@ -373,7 +374,6 @@ def from_schema(
     probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
-    generation_config = generation_config or GenerationConfig()
     request_config = RequestConfig(
         timeout=request_timeout,
         tls_verify=request_tls_verify,
@@ -405,6 +405,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -430,6 +431,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -455,6 +457,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -481,6 +484,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -506,6 +510,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -530,6 +535,7 @@ def from_schema(
         exit_first=exit_first,
         max_failures=max_failures,
         started_at=started_at,
+        unique_data=unique_data,
         dry_run=dry_run,
         store_interactions=store_interactions,
         stateful=stateful,