schemathesis 3.39.8__py3-none-any.whl → 3.39.10__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import dataclass
 import json
 import warnings
 from functools import wraps
@@ -223,6 +224,87 @@ def add_coverage(
     return test
 
 
+class Template:
+    __slots__ = ("_components", "_template")
+
+    def __init__(self) -> None:
+        self._components: dict[str, DataGenerationMethod] = {}
+        self._template: dict[str, Any] = {}
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._template
+
+    def __getitem__(self, key: str) -> dict:
+        return self._template[key]
+
+    def get(self, key: str, default: Any = None) -> dict:
+        return self._template.get(key, default)
+
+    def add_parameter(self, location: str, name: str, value: coverage.GeneratedValue) -> None:
+        from .specs.openapi.constants import LOCATION_TO_CONTAINER
+
+        component_name = LOCATION_TO_CONTAINER[location]
+        method = self._components.get(component_name)
+        if method is None:
+            self._components[component_name] = value.data_generation_method
+        elif value.data_generation_method == DataGenerationMethod.negative:
+            self._components[component_name] = DataGenerationMethod.negative
+
+        container = self._template.setdefault(component_name, {})
+        if _should_stringify(location, value):
+            container[name] = _stringify_value(value.value, location)
+        else:
+            container[name] = value.value
+
+    def set_body(self, body: coverage.GeneratedValue, media_type: str) -> None:
+        self._template["body"] = body.value
+        self._template["media_type"] = media_type
+        self._components["body"] = body.data_generation_method
+
+    def unmodified(self) -> TemplateValue:
+        return TemplateValue(kwargs=self._template.copy(), components=self._components.copy())
+
+    def with_body(self, *, media_type: str, value: coverage.GeneratedValue) -> TemplateValue:
+        kwargs = {**self._template, "media_type": media_type, "body": value.value}
+        components = {**self._components, "body": value.data_generation_method}
+        return TemplateValue(kwargs=kwargs, components=components)
+
+    def with_parameter(self, *, location: str, name: str, value: coverage.GeneratedValue) -> TemplateValue:
+        from .specs.openapi.constants import LOCATION_TO_CONTAINER
+
+        if _should_stringify(location, value):
+            generated = _stringify_value(value.value, location)
+        else:
+            generated = value.value
+
+        container_name = LOCATION_TO_CONTAINER[location]
+        container = self._template[container_name]
+        kwargs = {**self._template, container_name: {**container, name: generated}}
+        components = {**self._components, container_name: value.data_generation_method}
+        return TemplateValue(kwargs=kwargs, components=components)
+
+
+@dataclass
+class TemplateValue:
+    kwargs: dict[str, Any]
+    components: dict[str, DataGenerationMethod]
+    __slots__ = ("kwargs", "components")
+
+
+def _should_stringify(location: str, value: coverage.GeneratedValue) -> bool:
+    return location in ("header", "cookie", "path", "query") and not isinstance(value.value, str)
+
+
+def _stringify_value(val: Any, location: str) -> str | list[str]:
+    if isinstance(val, list):
+        if location == "query":
+            # Having a list here ensures there will be multiple query parameters wit the same name
+            return [json.dumps(item) for item in val]
+        # use comma-separated values style for arrays
+        return ",".join(json.dumps(sub) for sub in val)
+    return json.dumps(val)
+
+
 def _iter_coverage_cases(
     operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
 ) -> Generator[Case, None, None]:
@@ -239,7 +321,7 @@ def _iter_coverage_cases(
         return json.dumps(val)
 
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
-    template: dict[str, Any] = {}
+    template = Template()
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
         location = parameter.location
@@ -253,11 +335,7 @@ def _iter_coverage_cases(
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
             continue
-        container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-            container[name] = _stringify_value(value.value, location)
-        else:
-            container[name] = value.value
+        template.add_parameter(location, name, value)
         generators[(location, name)] = gen
     if operation.body:
         for body in operation.body:
@@ -274,48 +352,48 @@ def _iter_coverage_cases(
             if isinstance(value, NotSet):
                 continue
             if "body" not in template:
-                template["body"] = value.value
-                template["media_type"] = body.media_type
-            case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
+                template.set_body(value, body.media_type)
+            data = template.with_body(value=value, media_type=body.media_type)
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = value.data_generation_method
             case.meta = _make_meta(
                 description=value.description,
                 location=value.location,
                 parameter=body.media_type,
                 parameter_location="body",
+                **data.components,
             )
             yield case
             for next_value in gen:
-                case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
+                data = template.with_body(value=next_value, media_type=body.media_type)
+                case = operation.make_case(**data.kwargs)
                 case.data_generation_method = next_value.data_generation_method
                 case.meta = _make_meta(
                     description=next_value.description,
                     location=next_value.location,
                     parameter=body.media_type,
                     parameter_location="body",
+                    **data.components,
                 )
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
-        case = operation.make_case(**template)
+        data = template.unmodified()
+        case = operation.make_case(**data.kwargs)
         case.data_generation_method = DataGenerationMethod.positive
-        case.meta = _make_meta(description="Default positive test case")
+        case.meta = _make_meta(description="Default positive test case", **data.components)
         yield case
 
     for (location, name), gen in generators.items():
-        container_name = LOCATION_TO_CONTAINER[location]
-        container = template[container_name]
         for value in gen:
-            if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-                generated = _stringify_value(value.value, location)
-            else:
-                generated = value.value
-            case = operation.make_case(**{**template, container_name: {**container, name: generated}})
+            data = template.with_parameter(location=location, name=name, value=value)
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = value.data_generation_method
             case.meta = _make_meta(
                 description=value.description,
                 location=value.location,
                 parameter=name,
                 parameter_location=location,
+                **data.components,
             )
             yield case
     if DataGenerationMethod.negative in data_generation_methods:
@@ -323,10 +401,11 @@ def _iter_coverage_cases(
         # NOTE: The HEAD method is excluded
         methods = {"get", "put", "post", "delete", "options", "patch", "trace"} - set(operation.schema[operation.path])
         for method in sorted(methods):
-            case = operation.make_case(**template)
+            data = template.unmodified()
+            case = operation.make_case(**data.kwargs)
             case._explicit_method = method
             case.data_generation_method = DataGenerationMethod.negative
-            case.meta = _make_meta(description=f"Unspecified HTTP method: {method.upper()}")
+            case.meta = _make_meta(description=f"Unspecified HTTP method: {method.upper()}", **data.components)
             yield case
         # Generate duplicate query parameters
         if operation.query:
@@ -336,13 +415,17 @@ def _iter_coverage_cases(
                 # I.e. contains just `default` value without any other keywords
                 value = container.get(parameter.name, NOT_SET)
                 if value is not NOT_SET:
-                    case = operation.make_case(**{**template, "query": {**container, parameter.name: [value, value]}})
+                    data = template.unmodified()
+                    case = operation.make_case(
+                        **{**data.kwargs, "query": {**container, parameter.name: [value, value]}}
+                    )
                     case.data_generation_method = DataGenerationMethod.negative
                     case.meta = _make_meta(
                         description=f"Duplicate `{parameter.name}` query parameter",
                         location=None,
                         parameter=parameter.name,
                         parameter_location="query",
+                        **data.components,
                     )
                     yield case
         # Generate missing required parameters
@@ -352,8 +435,9 @@ def _iter_coverage_cases(
                 location = parameter.location
                 container_name = LOCATION_TO_CONTAINER[location]
                 container = template[container_name]
+                data = template.unmodified()
                 case = operation.make_case(
-                    **{**template, container_name: {k: v for k, v in container.items() if k != name}}
+                    **{**data.kwargs, container_name: {k: v for k, v in container.items() if k != name}}
                 )
                 case.data_generation_method = DataGenerationMethod.negative
                 case.meta = _make_meta(
@@ -361,6 +445,7 @@ def _iter_coverage_cases(
                     location=None,
                     parameter=name,
                     parameter_location=location,
+                    **{**data.components, container_name: DataGenerationMethod.negative},
                 )
                 yield case
     # Generate combinations for each location
@@ -397,13 +482,15 @@ def _iter_coverage_cases(
             else:
                 container = container_values
 
-            case = operation.make_case(**{**template, _container_name: container})
+            data = template.unmodified()
+            case = operation.make_case(**{**data.kwargs, _container_name: container})
             case.data_generation_method = _data_generation_method
             case.meta = _make_meta(
                 description=description,
                 location=None,
                 parameter=_parameter,
                 parameter_location=_location,
+                **{**data.components, _container_name: _data_generation_method},
             )
             return case
 
@@ -496,13 +583,18 @@ def _make_meta(
     location: str | None = None,
     parameter: str | None = None,
     parameter_location: str | None = None,
+    query: DataGenerationMethod | None = None,
+    path_parameters: DataGenerationMethod | None = None,
+    headers: DataGenerationMethod | None = None,
+    cookies: DataGenerationMethod | None = None,
+    body: DataGenerationMethod | None = None,
 ) -> GenerationMetadata:
     return GenerationMetadata(
-        query=None,
-        path_parameters=None,
-        headers=None,
-        cookies=None,
-        body=None,
+        query=query,
+        path_parameters=path_parameters,
+        headers=headers,
+        cookies=cookies,
+        body=body,
         phase=TestPhase.COVERAGE,
         description=description,
         location=location,

schemathesis/cli/output/default.py

@@ -14,11 +14,8 @@ import click
 from ... import experimental, service
 from ...constants import (
     DISCORD_LINK,
-    FALSE_VALUES,
     FLAKY_FAILURE_MESSAGE,
-    GITHUB_APP_LINK,
     ISSUE_TRACKER_URL,
-    REPORT_SUGGESTION_ENV_VAR,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
 )
@@ -125,7 +122,7 @@ def get_summary_output(event: events.Finished) -> tuple[str, str]:
         message = "Empty test suite"
         color = "yellow"
     else:
-        message = f'{", ".join(parts)} in {event.running_time:.2f}s'
+        message = f"{', '.join(parts)} in {event.running_time:.2f}s"
         if event.has_failures or event.has_errors:
             color = "red"
         elif event.skipped_count > 0:
@@ -176,7 +173,7 @@ def display_errors(context: ExecutionContext, event: events.Finished) -> None:
             fg="red",
         )
     click.secho(
-        f"\nNeed more help?\n" f"    Join our Discord server: {DISCORD_LINK}",
+        f"\nNeed more help?\n    Join our Discord server: {DISCORD_LINK}",
         fg="red",
     )
 
@@ -499,19 +496,6 @@ def display_statistic(context: ExecutionContext, event: events.Finished) -> None
         elif isinstance(context.report, ServiceReportContext):
             click.echo()
             handle_service_integration(context.report)
-    else:
-        env_var = os.getenv(REPORT_SUGGESTION_ENV_VAR)
-        if env_var is not None and env_var.lower() in FALSE_VALUES:
-            return
-        click.echo(
-            f"\n{bold('Tip')}: Use the {bold('`--report`')} CLI option to visualize test results via Schemathesis.io.\n"
-            "We run additional conformance checks on reports from public repos."
-        )
-        if service.ci.detect() == service.ci.CIProvider.GITHUB:
-            click.echo(
-                "Optionally, for reporting results as PR comments, install the Schemathesis GitHub App:\n\n"
-                f"    {GITHUB_APP_LINK}"
-            )
 
 
 def handle_service_integration(context: ServiceReportContext) -> None:

schemathesis/constants.py

@@ -13,7 +13,6 @@ USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
 SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 DISCORD_LINK = "https://discord.gg/R9ASRAmHnA"
-GITHUB_APP_LINK = "https://github.com/apps/schemathesis"
 # Maximum test running time
 DEFAULT_DEADLINE = 15000
 DEFAULT_RESPONSE_TIMEOUT = 10000
@@ -50,7 +49,6 @@ HOOKS_MODULE_ENV_VAR = "SCHEMATHESIS_HOOKS"
 API_NAME_ENV_VAR = "SCHEMATHESIS_API_NAME"
 BASE_URL_ENV_VAR = "SCHEMATHESIS_BASE_URL"
 WAIT_FOR_SCHEMA_ENV_VAR = "SCHEMATHESIS_WAIT_FOR_SCHEMA"
-REPORT_SUGGESTION_ENV_VAR = "SCHEMATHESIS_REPORT_SUGGESTION"
 
 TRUE_VALUES = ("y", "yes", "t", "true", "on", "1")
 FALSE_VALUES = ("n", "no", "f", "false", "off", "0")

schemathesis/failures.py

@@ -93,8 +93,9 @@ class JSONDecodeErrorContext(FailureContext):
 
     @classmethod
     def from_exception(cls, exc: JSONDecodeError) -> JSONDecodeErrorContext:
+        message = f"Response must be valid JSON with 'Content-Type: application/json' header:\n\n  {exc}"
         return cls(
-            message=str(exc),
+            message=message,
             validation_message=exc.msg,
             document=exc.doc,
             position=exc.pos,

schemathesis/generation/coverage.py

@@ -437,7 +437,12 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
-                elif key == "additionalProperties" and not value and "pattern" not in schema:
+                elif (
+                    key == "additionalProperties"
+                    and not value
+                    and "pattern" not in schema
+                    and schema.get("type") in ["object", None]
+                ):
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield NegativeValue(
                         {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},

schemathesis/internal/deprecation.py

@@ -4,8 +4,7 @@ from typing import Any, Callable
 
 def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:
     warnings.warn(
-        f"{kind} `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. "
-        f"Use {replacement} instead.",
+        f"{kind} `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. Use {replacement} instead.",
         DeprecationWarning,
         stacklevel=1,
     )

schemathesis/models.py

@@ -560,7 +560,7 @@ class Case:
                 sanitize_response(response)
             code_message = self._get_code_message(code_sample_style, response.request, verify=verify)
             raise exception_cls(
-                f"{formatted}\n\n" f"{code_message}",
+                f"{formatted}\n\n{code_message}",
                 causes=tuple(failed_checks),
             )
 

schemathesis/runner/impl/context.py

@@ -69,22 +69,6 @@ class RunnerContext:
     def is_stopped(self) -> bool:
         return self.stop_event.is_set()
 
-    @property
-    def has_all_not_found(self) -> bool:
-        """Check if all responses are 404."""
-        has_not_found = False
-        for entry in self.data.results:
-            for check in entry.checks:
-                if check.response is not None:
-                    if check.response.status_code == 404:
-                        has_not_found = True
-                    else:
-                        # There are non-404 responses, no reason to check any other response
-                        return False
-        # Only happens if all responses are 404, or there are no responses at all.
-        # In the first case, it returns True, for the latter - False
-        return has_not_found
-
     def add_result(self, result: TestResult) -> None:
         self.data.append(result)
 

schemathesis/runner/impl/core.py

@@ -147,6 +147,34 @@ class BaseRunner:
         __probes = None
         __analysis: Result[AnalysisResult, Exception] | None = None
 
+        def _should_warn_about_only_4xx(result: TestResult) -> bool:
+            if all(check.response is None for check in result.checks):
+                return False
+            # Don't warn if we saw any 2xx or 5xx responses
+            if any(
+                check.response.status_code < 400 or check.response.status_code >= 500
+                for check in result.checks
+                if check.response is not None
+            ):
+                return False
+            # Don't duplicate auth warnings
+            if {check.response.status_code for check in result.checks if check.response is not None} <= {401, 403}:
+                return False
+            # At this point we know we only have 4xx responses
+            return True
+
+        def _check_warnings() -> None:
+            for result in ctx.data.results:
+                # Only warn about 4xx responses in successful positive test scenarios
+                if (
+                    all(check.value == Status.success for check in result.checks)
+                    and result.data_generation_method == [DataGenerationMethod.positive]
+                    and _should_warn_about_only_4xx(result)
+                ):
+                    ctx.add_warning(
+                        f"`{result.verbose_name}` returned only 4xx responses during unit tests. Check base URL or adjust data generation settings"
+                    )
+
         def _initialize() -> events.Initialized:
             nonlocal initialized
             initialized = events.Initialized.from_schema(
@@ -159,8 +187,7 @@ class BaseRunner:
             return initialized
 
         def _finish() -> events.Finished:
-            if ctx.has_all_not_found:
-                ctx.add_warning(ALL_NOT_FOUND_WARNING_MESSAGE)
+            _check_warnings()
             return events.Finished.from_results(results=ctx.data, running_time=time.monotonic() - start_time)
 
         def _before_probes() -> events.BeforeProbing:
@@ -742,9 +769,6 @@ def has_too_many_responses_with_status(result: TestResult, status_code: int) ->
     return unauthorized_count / total >= TOO_MANY_RESPONSES_THRESHOLD
 
 
-ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"
-
-
 def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> None:
     """Make Hypothesis use separate database entries for every API operation.
 

schemathesis/specs/openapi/checks.py

@@ -32,10 +32,15 @@ if TYPE_CHECKING:
     from ...transports.responses import GenericResponse
 
 
+def is_unexpected_http_status_case(case: Case) -> bool:
+    # Skip checks for requests using HTTP methods not defined in the API spec
+    return bool(case.meta and case.meta.description and case.meta.description.startswith("Unspecified HTTP method"))
+
+
 def status_code_conformance(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     responses = case.operation.definition.raw.get("responses", {})
     # "default" can be used as the default response object for all HTTP codes that are not covered individually
@@ -66,7 +71,7 @@ def _expand_responses(responses: dict[str | int, Any]) -> Generator[int, None, N
 def content_type_conformance(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     documented_content_types = case.operation.schema.get_content_types(case.operation, response)
     if not documented_content_types:
@@ -124,7 +129,7 @@ def response_headers_conformance(ctx: CheckContext, response: GenericResponse, c
     from .parameters import OpenAPI20Parameter, OpenAPI30Parameter
     from .schemas import BaseOpenAPISchema, OpenApi30, _maybe_raise_one_or_more
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     resolved = case.operation.schema.get_headers(case.operation, response)
     if not resolved:
@@ -209,7 +214,7 @@ def _coerce_header_value(value: str, schema: dict[str, Any]) -> str | int | floa
 def response_schema_conformance(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     return case.operation.validate_response(response)
 
@@ -217,7 +222,7 @@ def response_schema_conformance(ctx: CheckContext, response: GenericResponse, ca
 def negative_data_rejection(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
 
     config = ctx.config.negative_data_rejection
@@ -245,7 +250,7 @@ def negative_data_rejection(ctx: CheckContext, response: GenericResponse, case:
 def positive_data_acceptance(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
 
     config = ctx.config.positive_data_acceptance
@@ -283,7 +288,7 @@ def missing_required_header(ctx: CheckContext, response: GenericResponse, case:
             config = ctx.config.missing_required_header
             allowed_statuses = expand_status_codes(config.allowed_statuses or [])
         if response.status_code not in allowed_statuses:
-            allowed = f"Allowed statuses: {', '.join(map(str,allowed_statuses))}"
+            allowed = f"Allowed statuses: {', '.join(map(str, allowed_statuses))}"
             raise AssertionError(f"Unexpected response status for a missing header: {response.status_code}\n{allowed}")
     return None
 
@@ -333,7 +338,7 @@ def use_after_free(ctx: CheckContext, response: GenericResponse, original: Case)
     from ...transports.responses import get_reason
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(original.operation.schema, BaseOpenAPISchema):
+    if not isinstance(original.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(original):
         return True
     if response.status_code == 404 or not original.source or response.status_code >= 500:
         return None
@@ -373,7 +378,7 @@ def ensure_resource_availability(ctx: CheckContext, response: GenericResponse, o
     from ...transports.responses import get_reason
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(original.operation.schema, BaseOpenAPISchema):
+    if not isinstance(original.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(original):
         return True
     if (
         # Response indicates a client error, even though all available parameters were taken from links
@@ -416,7 +421,7 @@ def ignored_auth(ctx: CheckContext, response: GenericResponse, case: Case) -> bo
     """Check if an operation declares authentication as a requirement but does not actually enforce it."""
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful

schemathesis/specs/openapi/loaders.py

@@ -432,8 +432,7 @@ For more details, check the Open API documentation: {DOC_ENTRY}
 
 Please, stringify the following status codes:"""
 NON_STRING_OBJECT_KEY_MESSAGE = (
-    "The Open API specification requires all keys in the schema to be strings. "
-    "You have some keys that are not strings."
+    "The Open API specification requires all keys in the schema to be strings. You have some keys that are not strings."
 )
 
 

schemathesis/specs/openapi/parameters.py

@@ -359,7 +359,7 @@ MISSING_SCHEMA_OR_CONTENT_MESSAGE = (
 )
 
 INVALID_SCHEMA_MESSAGE = (
-    'Can not generate data for {location} parameter "{name}"! ' "Its schema should be an object, got {schema}"
+    'Can not generate data for {location} parameter "{name}"! Its schema should be an object, got {schema}'
 )
 
 

schemathesis/stateful/state_machine.py

@@ -169,6 +169,7 @@ class APIStateMachine(RuleBasedStateMachine):
         kwargs = self.get_call_kwargs(case)
         start = time.monotonic()
         response = self.call(case, **kwargs)
+        self._transport_kwargs = kwargs
         elapsed = time.monotonic() - start
         self.after_call(response, case)
         self.validate_response(response, case, additional_checks=(use_after_free,))
@@ -297,7 +298,7 @@ class APIStateMachine(RuleBasedStateMachine):
         all provided checks rather than only the first encountered exception.
         """
         __tracebackhide__ = True
-        case.validate_response(response, additional_checks=additional_checks)
+        case.validate_response(response, additional_checks=additional_checks, transport_kwargs=self._transport_kwargs)
 
     def store_result(self, response: GenericResponse, case: Case, elapsed: float) -> StepResult:
         return StepResult(response, case, elapsed)

{schemathesis-3.39.8.dist-info → schemathesis-3.39.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 3.39.8
+Version: 3.39.10
 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.39.8.dist-info → schemathesis-3.39.10.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=d9MgjqKSQ_chQ8a8dCBnSQTAboOt2h3914IAmIZTXUI,24660
+schemathesis/_hypothesis.py,sha256=x1AKO4Cr3LWZQPcRlIvor7ACn5t-mxLJfdHFgpdGHmI,28437
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_patches.py,sha256=Hsbpn4UVeXUQD2Kllrbq01CSWsTYENWa0VJTyhX5C2k,895
@@ -10,15 +10,15 @@ schemathesis/_xml.py,sha256=qc2LydEwIqcSfgqQOJqiYicivA4YFJGKgCBOem_JqNc,8560
 schemathesis/auths.py,sha256=De97IS_iOlC36-jRhkZ2DUndjUpXYgsd8R-nA-iHn88,16837
 schemathesis/checks.py,sha256=YPUI1N5giGBy1072vd77e6HWelGAKrJUmJLEG4oqfF8,2630
 schemathesis/code_samples.py,sha256=rsdTo6ksyUs3ZMhqx0mmmkPSKUCFa--snIOYsXgZd80,4120
-schemathesis/constants.py,sha256=l1YQ7PXhEj9dyf9CTESVUpPOaFCH7iz-Fe8o4v6Th_s,2673
+schemathesis/constants.py,sha256=RHwog2lAz84qG6KCpP1U15A4a9w1xcwbgZ97aY4juQg,2555
 schemathesis/exceptions.py,sha256=5zjPlyVoQNJGbwufplL6ZVV7FEBPBNPHGdlQRJ7xnhE,20449
-schemathesis/failures.py,sha256=fybNkCF2rqH90e3KW_XwpgZnSM6f7_FERcxHT9Pd3NM,7911
+schemathesis/failures.py,sha256=mrDu7F-OrQY8pRMNVtIxTjovhfyIkcXYjnSkRw-OMuQ,8016
 schemathesis/filters.py,sha256=f3c_yXIBwIin-9Y0qU2TkcC1NEM_Mw34jGUHQc0BOyw,17026
 schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=p5AXgjVGtka0jn9MOeyBaRUtNbqZTs4iaJqytYTacHc,14856
 schemathesis/lazy.py,sha256=Ddhkk7Tpc_VcRGYkCtKDmP2gpjxVmEZ3b01ZTNjbm8I,19004
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
-schemathesis/models.py,sha256=4MX3ErKMdueUXGcVPZuvMTbesUglbuj0ukgCmg3nhP8,50014
+schemathesis/models.py,sha256=8V3ZDTq2l45iFB-kE_NWb64iTy-hkf-hXCI-bIp4oxw,50010
 schemathesis/parameters.py,sha256=izlu4MFYT1RWrC4RBxrV6weeCal-ODbdLQLMb0PYCZY,2327
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
@@ -41,7 +41,7 @@ schemathesis/cli/options.py,sha256=yL7nrzKkbGCc4nQya9wpTW48XGz_OT9hOFrzPxRrDe4,2
 schemathesis/cli/reporting.py,sha256=KC3sxSc1u4aFQ-0Q8CQ3G4HTEl7QxlubGnJgNKmVJdQ,3627
 schemathesis/cli/sanitization.py,sha256=Onw_NWZSom6XTVNJ5NHnC0PAhrYAcGzIXJbsBCzLkn4,1005
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
-schemathesis/cli/output/default.py,sha256=IB6q7h-eu4Hg6P-n-NGyraf9s4luN7I3FCDsYCPVa60,39781
+schemathesis/cli/output/default.py,sha256=kRJPcZ5RL9Nsy9k4bSZaRtAezzPiHE6hybdNZLfrEhs,39071
 schemathesis/cli/output/short.py,sha256=CL6-Apxr5tuZ3BL1vecV1MiRY1wDt21g0wiUwZu6mLM,2607
 schemathesis/contrib/__init__.py,sha256=FH8NL8NXgSKBFOF8Jy_EB6T4CJEaiM-tmDhz16B2o4k,187
 schemathesis/contrib/unique_data.py,sha256=cTjJfoNpfLMobUzmGnm3k6kVrZcL34_FMPLlpDDsg4c,1249
@@ -61,12 +61,12 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
 schemathesis/generation/_hypothesis.py,sha256=74fzLPHugZgMQXerWYFAMqCAjtAXz5E4gek7Gnkhli4,1756
 schemathesis/generation/_methods.py,sha256=r8oVlJ71_gXcnEhU-byw2E0R2RswQQFm8U7yGErSqbw,1204
-schemathesis/generation/coverage.py,sha256=YrAvnIywwYR0yjm6rhLZ0foRf4D8CAzT8UKjAFn5eRM,39227
+schemathesis/generation/coverage.py,sha256=1CilQSe2DIdMdeWA6RL22so2bZULPRwc0CQBRxcLRFs,39370
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/checks.py,sha256=YBhldvs-oQTrtvTlz3cjaO9Ri2oQeyobFcquO4Y0UJ8,2720
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
-schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
+schemathesis/internal/deprecation.py,sha256=XnzwSegbbdQyoTF1OGW_s9pdjIfN_Uzzdb2rfah1w2o,1261
 schemathesis/internal/diff.py,sha256=upGqM6s9WDT653wzxK_tqclFCxqkzB0j4wsO1foq5_k,466
 schemathesis/internal/extensions.py,sha256=h0aHRK_PTKfiAufkeBziegQS8537TL-Gr1hPW48q8Yc,790
 schemathesis/internal/jsonschema.py,sha256=-7tF15cXo1ZdhiRFYYfEClXihX2Svc5Loi_Dz1x201k,1157
@@ -79,8 +79,8 @@ schemathesis/runner/events.py,sha256=cRKKSDvHvKLBIyFBz-J0JtAKshbGGKco9eaMyLCgzsY
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
 schemathesis/runner/serialization.py,sha256=vZi1wd9HX9Swp9VJ_hZFeDgy3Y726URpHra-TbPvQhk,20762
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/context.py,sha256=oEdkXnlibVDobDRCMliImQwtX5RPEKgVEwVBCN67mfE,3132
-schemathesis/runner/impl/core.py,sha256=aUeJxW3cvfi5IYwU2GqhDfcKrCK3GtMnsts-qyaIXGQ,48086
+schemathesis/runner/impl/context.py,sha256=KY06FXVOFQ6DBaa_FomSBXL81ULs3D21IW1u3yLqs1E,2434
+schemathesis/runner/impl/core.py,sha256=vNWUu5F36brmhsv0P9UYavXLklQo5O2A6byQmS75enY,49289
 schemathesis/runner/impl/solo.py,sha256=y5QSxgK8nBCEjZVD5BpFvYUXmB6tEjk6TwxAo__NejA,2911
 schemathesis/runner/impl/threadpool.py,sha256=yNR5LYE8f3N_4t42OwSgy0_qdGgBPM7d11F9c9oEAAs,15075
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -107,16 +107,16 @@ schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzM
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
 schemathesis/specs/openapi/_hypothesis.py,sha256=nU8UDn1PzGCre4IVmwIuO9-CZv1KJe1fYY0d2BojhSo,22981
-schemathesis/specs/openapi/checks.py,sha256=q6BbsrNFs9lx7WNJQg-ZnlGN8B5kW7wTq5btqisWF7w,26194
+schemathesis/specs/openapi/checks.py,sha256=NzUoZ0gZMjyC12KfV7J-5ww8IMaaaNiKum4y7bmA_EA,26816
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=Yxw9lS_JKEyi-oJuACT07fm04bqQDlAu-iHwzkeDvE4,3546
 schemathesis/specs/openapi/definitions.py,sha256=WTkWwCgTc3OMxfKsqh6YDoGfZMTThSYrHGp8h0vLAK0,93935
 schemathesis/specs/openapi/examples.py,sha256=hdeq7et8AexYGY2iU6SfMZWJ7G0PbOfapUtc4upNs_4,20483
 schemathesis/specs/openapi/formats.py,sha256=3KtEC-8nQRwMErS-WpMadXsr8R0O-NzYwFisZqMuc-8,2761
 schemathesis/specs/openapi/links.py,sha256=C4Uir2P_EcpqME8ee_a1vdUM8Tm3ZcKNn2YsGjZiMUQ,17935
-schemathesis/specs/openapi/loaders.py,sha256=5B1cgYEBj3h2psPQxzrQ5Xq5owLVGw-u9HsCQIx7yFE,25705
+schemathesis/specs/openapi/loaders.py,sha256=jlTYLoG5sVRh8xycIF2M2VDCZ44M80Sct07a_ycg1Po,25698
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
-schemathesis/specs/openapi/parameters.py,sha256=LUahlWKCDSlp94v2IA1Q90pyeECgO6FmrqbzCU-9Z0Y,14658
+schemathesis/specs/openapi/parameters.py,sha256=X_3PKqUScIiN_vbSFEauPYyxASyFv-_9lZ_9QEZRLqo,14655
 schemathesis/specs/openapi/patterns.py,sha256=OxZp31cBEHv8fwoeYJ9JcdWNHFMIGzRISNN3dCBc9Dg,11260
 schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
 schemathesis/specs/openapi/schemas.py,sha256=JA9SiBnwYg75kYnd4_0CWOuQv_XTfYwuDeGmFe4RtVo,53724
@@ -144,7 +144,7 @@ schemathesis/stateful/context.py,sha256=lpCOVhJEbPOp8F_Z_YvU5ptVTgaKJsllvI1NK28D
 schemathesis/stateful/events.py,sha256=CyYvyQebOaeTn6UevaB7HXOrUhxCWbqXMfQ7pZK7fV8,6727
 schemathesis/stateful/runner.py,sha256=3tRRmWcXp5GCeRWGOtQ9-W0rxljoR06qSCKC4r7EQyY,12672
 schemathesis/stateful/sink.py,sha256=bHYlgh-fMwg1Srxk_XGs0-WV34YccotwH9PGrxCK57A,2474
-schemathesis/stateful/state_machine.py,sha256=PFztY82W5enuXjO6k4Mz8fbHmDJ7Z8OLYZRWtuBeyjg,12956
+schemathesis/stateful/state_machine.py,sha256=EE1T0L21vBU0UHGiCmfPfIfnhU1WptB16h0t1iNVro0,13037
 schemathesis/stateful/statistic.py,sha256=2-uU5xpT9CbMulKgJWLZN6MUpC0Fskf5yXTt4ef4NFA,542
 schemathesis/stateful/validation.py,sha256=23qSZjC1_xRmtCX4OqsyG6pGxdlo6IZYid695ZpDQyU,3747
 schemathesis/transports/__init__.py,sha256=k35qBp-657qnHE9FfCowqO3rqOgCwSUnrdl2vAV3hnQ,12951
@@ -153,8 +153,8 @@ schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZ
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.39.8.dist-info/METADATA,sha256=OIpYE4hvAtDJB6GJJi2xRasTiPIOlRQkoMe0ju0EBDY,11976
-schemathesis-3.39.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-3.39.8.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.39.8.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.39.8.dist-info/RECORD,,
+schemathesis-3.39.10.dist-info/METADATA,sha256=3nOKrS8YGysaLXjvt4uIeysV4bbnLxm1WRoG_DD8W8s,11977
+schemathesis-3.39.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-3.39.10.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.39.10.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.39.10.dist-info/RECORD,,