schemathesis 3.35.4__py3-none-any.whl → 3.36.0__py3-none-any.whl

schemathesis/cli/output/default.py

@@ -6,7 +6,6 @@ import shutil
 import textwrap
 import time
 from importlib import metadata
-from queue import Queue
 from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
@@ -44,6 +43,8 @@ from ..handlers import EventHandler
 from ..reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
 
 if TYPE_CHECKING:
+    from queue import Queue
+
     import requests
 
 SPINNER_REPETITION_NUMBER = 10
@@ -372,7 +373,7 @@ def display_analysis(context: ExecutionContext) -> None:
         click.echo()
         if isinstance(analysis, AnalysisSuccess):
             click.secho(analysis.message, bold=True)
-            click.echo("\nAnalysis took: {:.2f}ms".format(analysis.elapsed))
+            click.echo(f"\nAnalysis took: {analysis.elapsed:.2f}ms")
             if analysis.extensions:
                 known = []
                 failed = []
@@ -417,8 +418,8 @@ def display_analysis(context: ExecutionContext) -> None:
             click.secho("Error\n", fg="red", bold=True)
             _display_service_network_error(response)
             click.echo()
-            return None
-        elif isinstance(exception, requests.RequestException):
+            return
+        if isinstance(exception, requests.RequestException):
             message, extras = extract_requests_exception_details(exception)
             suggestion = "Please check your network connection and try again."
             title = "Network Error"
@@ -649,7 +650,6 @@ def wait_for_report_handler(queue: Queue, title: str, timeout: float = service.W
 
 def create_spinner(repetitions: int) -> Generator[str, None, None]:
     """A simple spinner that yields its individual characters."""
-    assert repetitions > 0, "The number of repetitions should be greater than zero"
     while True:
         for ch in "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏":
             # Skip branch coverage, as it is not possible because of the assertion above

schemathesis/cli/reporting.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 from itertools import groupby
-from typing import Callable, Generator, Iterator
+from typing import TYPE_CHECKING, Callable, Generator, Iterator
 
 import click
 
-from ..code_samples import CodeSampleStyle
 from ..exceptions import RuntimeErrorType
 from ..runner.serialization import SerializedCheck, deduplicate_failures
 
+if TYPE_CHECKING:
+    from ..code_samples import CodeSampleStyle
+
 TEST_CASE_ID_TITLE = "Test Case ID"
 
 

schemathesis/code_samples.py

@@ -6,11 +6,12 @@ from shlex import quote
 from typing import TYPE_CHECKING
 
 from .constants import SCHEMATHESIS_TEST_CASE_HEADER
-from .types import Headers
 
 if TYPE_CHECKING:
     from requests.structures import CaseInsensitiveDict
 
+    from .types import Headers
+
 
 @lru_cache
 def get_excluded_headers() -> CaseInsensitiveDict:
@@ -120,9 +121,9 @@ def _generate_requests(
     url = _escape_single_quotes(url)
     command = f"requests.{method.lower()}('{url}'"
     if body:
-        command += f", data={repr(body)}"
+        command += f", data={body!r}"
     if headers:
-        command += f", headers={repr(headers)}"
+        command += f", headers={headers!r}"
     if not verify:
         command += ", verify=False"
     command += ")"

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/exceptions.py

@@ -5,21 +5,22 @@ import re
 import traceback
 from dataclasses import dataclass, field
 from hashlib import sha1
-from json import JSONDecodeError
-from types import TracebackType
 from typing import TYPE_CHECKING, Any, Callable, Generator, NoReturn
 
 from .constants import SERIALIZERS_SUGGESTION_MESSAGE
-from .failures import FailureContext
 from .internal.output import truncate_json
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+    from types import TracebackType
+
     import hypothesis.errors
     from graphql.error import GraphQLFormattedError
     from jsonschema import RefResolutionError, ValidationError
     from jsonschema import SchemaError as JsonSchemaError
     from requests import RequestException
 
+    from .failures import FailureContext
     from .transports.responses import GenericResponse
 
 

schemathesis/extra/_flask.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
-from flask import Flask
+from typing import TYPE_CHECKING
 
 from . import _server
 
+if TYPE_CHECKING:
+    from flask import Flask
+
 
 def run_server(app: Flask, port: int | None = None, timeout: float = 0.05) -> int:
     """Start a thread with the given aiohttp application."""

schemathesis/extra/pytest_plugin.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 import unittest
 from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Generator, Type, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type, cast
 
 import pytest
 from _pytest import fixtures, nodes
 from _pytest.config import hookimpl
-from _pytest.fixtures import FuncFixtureInfo
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
 from hypothesis import reporting
 from hypothesis.errors import InvalidArgument, Unsatisfiable
@@ -30,7 +29,6 @@ from ..exceptions import (
     UsageError,
 )
 from ..internal.result import Ok, Result
-from ..models import APIOperation
 from ..utils import (
     PARAMETRIZE_MARKER,
     fail_on_no_matches,
@@ -42,6 +40,11 @@ from ..utils import (
     validate_given_args,
 )
 
+if TYPE_CHECKING:
+    from _pytest.fixtures import FuncFixtureInfo
+
+    from ..models import APIOperation
+
 
 class SchemathesisFunction(Function):
     def __init__(

schemathesis/failures.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 import textwrap
 from dataclasses import dataclass
-from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any
 
 from schemathesis.internal.output import OutputConfig
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+
     from graphql.error import GraphQLFormattedError
     from jsonschema import ValidationError
 

schemathesis/filters.py

@@ -54,7 +54,7 @@ class Matcher:
             func = partial(by_value_list, attribute=attribute, expected=expected)
         else:
             func = partial(by_value, attribute=attribute, expected=expected)
-        label = f"{attribute}={repr(expected)}"
+        label = f"{attribute}={expected!r}"
         return cls(func, label=label, _hash=hash(label))
 
     @classmethod
@@ -68,7 +68,7 @@ class Matcher:
                 flags = 0
             regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
-        label = f"{attribute}_regex={repr(regex)}"
+        label = f"{attribute}_regex={regex!r}"
         return cls(func, label=label, _hash=hash(label))
 
     def match(self, ctx: HasAPIOperation) -> bool:

schemathesis/generation/__init__.py

@@ -4,8 +4,8 @@ import random
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from ._hypothesis import add_single_example, combine_strategies, get_single_example  # noqa: E402
-from ._methods import DataGenerationMethod, DataGenerationMethodInput  # noqa: E402
+from ._hypothesis import add_single_example, combine_strategies, get_single_example
+from ._methods import DataGenerationMethod, DataGenerationMethodInput
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy

schemathesis/generation/_hypothesis.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     from hypothesis import strategies as st
 
 
-@lru_cache()
+@lru_cache
 def default_settings() -> settings:
     from hypothesis import HealthCheck, Phase, Verbosity, settings
 

schemathesis/generation/coverage.py

@@ -4,7 +4,7 @@ import json
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any, Generator, Set, Type, TypeVar, cast
+from typing import Any, Generator, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
@@ -140,8 +140,8 @@ def _ignore_unfixable(
     *,
     # Cache exception types here as `jsonschema` uses a custom `__getattr__` on the module level
     # and it may cause errors during the interpreter shutdown
-    ref_error: Type[Exception] = jsonschema.RefResolutionError,
-    schema_error: Type[Exception] = jsonschema.SchemaError,
+    ref_error: type[Exception] = jsonschema.RefResolutionError,
+    schema_error: type[Exception] = jsonschema.SchemaError,
 ) -> Generator:
     try:
         yield
@@ -172,7 +172,7 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
             yield from _cover_positive_for_type(ctx, schema, ty)
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
-        seen: Set[Any | tuple[type, str]] = set()
+        seen: set[Any | tuple[type, str]] = set()
         for key, value in schema.items():
             with _ignore_unfixable():
                 if key == "enum":
@@ -238,7 +238,9 @@ def _get_properties(schema: dict | bool) -> dict | bool:
     if isinstance(schema, dict):
         if "example" in schema:
             return {"const": schema["example"]}
-        if "examples" in schema and schema["examples"]:
+        if "default" in schema:
+            return {"const": schema["default"]}
+        if schema.get("examples"):
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
             return _get_template_schema(schema, "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/graphql.py

@@ -1,4 +1,3 @@
-# Public API
 from .specs.graphql import nodes  # noqa: F401
 from .specs.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi  # noqa: F401
 from .specs.graphql.scalars import scalar  # noqa: F401

schemathesis/hooks.py

@@ -6,11 +6,10 @@ from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
 
 from .filters import FilterSet, attach_filter_chain
 from .internal.deprecation import deprecated_property
-from .types import GenericTest
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
@@ -18,6 +17,7 @@ if TYPE_CHECKING:
     from .models import APIOperation, Case
     from .schemas import BaseSchema
     from .transports.responses import GenericResponse
+    from .types import GenericTest
 
 
 @unique
@@ -108,7 +108,7 @@ class HookDispatcher:
     """
 
     scope: HookScope
-    _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
     def __post_init__(self) -> None:

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/lazy.py

@@ -2,15 +2,13 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from inspect import signature
-from typing import Any, Callable, Generator
+from typing import TYPE_CHECKING, Any, Callable, Generator
 
 import pytest
-from _pytest.fixtures import FixtureRequest
 from hypothesis.core import HypothesisHandle
 from hypothesis.errors import Flaky
 from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
 from hypothesis.internal.reflection import impersonate
-from pyrate_limiter import Limiter
 from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures, get_interesting_origin
@@ -20,14 +18,10 @@ from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
 from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
-from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.deprecation import warn_filtration_arguments
-from .internal.output import OutputConfig
 from .internal.result import Ok
-from .models import APIOperation
 from .schemas import BaseSchema
-from .types import Filter, GenericTest, NotSet
 from .utils import (
     GivenInput,
     fail_on_no_matches,
@@ -39,6 +33,15 @@ from .utils import (
     validate_given_args,
 )
 
+if TYPE_CHECKING:
+    from _pytest.fixtures import FixtureRequest
+    from pyrate_limiter import Limiter
+
+    from .generation import DataGenerationMethodInput, GenerationConfig
+    from .internal.output import OutputConfig
+    from .models import APIOperation
+    from .types import Filter, GenericTest, NotSet
+
 
 @dataclass
 class LazySchema:

schemathesis/loaders.py

@@ -51,13 +51,13 @@ def _raise_for_status(response: GenericResponse) -> None:
         else:
             type_ = SchemaErrorType.HTTP_CLIENT_ERROR
     else:
-        return None
+        return
     raise SchemaError(message=message, type=type_, url=response.request.url, response=response, extras=[])
 
 
 def load_app(path: str) -> Any:
     """Import an application from a string."""
-    path, name = (re.split(r":(?![\\/])", path, maxsplit=1) + [""])[:2]
+    path, name = ([*re.split(":(?![\\\\/])", path, maxsplit=1), ""])[:2]
     __import__(path)
     # accessing the module from sys.modules returns a proper module, while `__import__`
     # may return a parent module (system dependent)
@@ -92,7 +92,7 @@ def get_yaml_loader() -> type[yaml.SafeLoader]:
                        |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
                        |[-+]?\.(?:inf|Inf|INF)
                        |\.(?:nan|NaN|NAN))$""",
-            re.X,
+            re.VERBOSE,
         ),
         list("-+0123456789."),
     )