schemathesis 3.39.8__tar.gz → 3.39.9__tar.gz

{schemathesis-3.39.8 → schemathesis-3.39.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 3.39.8
+Version: 3.39.9
 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 → schemathesis-3.39.9}/docs/changelog.rst

@@ -1,9 +1,24 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.39.8...HEAD>` - TBD
+:version:`Unreleased <v3.39.9...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.39.9:
+
+:version:`3.39.9 <v3.39.8...v3.39.9>` - 2025-02-01
+--------------------------------------------------
+
+**Fixed**
+
+- Internal error in coverage phase when a parameter is mixing keywords for different types.
+- Do not run irrelevant checks on "Unspecified HTTP method" type of coverage scenarios.
+- Ignoring ``verify=False`` when specified via ``get_call_kwargs`` on a state machine. :issue:`2713`
+
+**Changed**
+
+- Slightly improve the error message on malformed JSON.
+
 .. _v3.39.8:
 
 :version:`3.39.8 <v3.39.7...v3.39.8>` - 2025-01-25

{schemathesis-3.39.8 → schemathesis-3.39.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.39.8"
+version = "3.39.9"
 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.39.8 → schemathesis-3.39.9}/src/schemathesis/cli/output/default.py

@@ -125,7 +125,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 +176,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",
     )
 

{schemathesis-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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-3.39.8 → schemathesis-3.39.9}/src/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 → schemathesis-3.39.9}/test/apps/__init__.py

@@ -48,8 +48,7 @@ def run_app(port: int, operations: list[openapi.schema.Operation], spec: str, fr
             spec
         ]
         click.secho(
-            f"Schemathesis test server is running!\n\n"
-            f"API Schema is available at: http://0.0.0.0:{port}/schema.yaml\n",
+            f"Schemathesis test server is running!\n\nAPI Schema is available at: http://0.0.0.0:{port}/schema.yaml\n",
             bold=True,
         )
         if framework == "aiohttp":

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/cli/__snapshots__/test_commands/test_malformed_json_deduplication[real-Open API 3.0].raw

@@ -20,7 +20,9 @@ ___________________________ GET /api/malformed_json ____________________________
 
 - JSON deserialization error
 
-    Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
+    Response must be valid JSON with 'Content-Type: application/json' header:
+
+      Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
 
 [200] OK:
 

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/cli/__snapshots__/test_commands/test_malformed_json_deduplication[wsgi-Open API 3.0].raw

@@ -20,7 +20,9 @@ ___________________________ GET /api/malformed_json ____________________________
 
 - JSON deserialization error
 
-    Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
+    Response must be valid JSON with 'Content-Type: application/json' header:
+
+      Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
 
 [200] OK:
 

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/cli/test_cassettes.py

@@ -266,8 +266,7 @@ def test_run_subprocess(testdir, cassette_path, hypothesis_max_examples, schema_
     cassette = load_cassette(cassette_path)
     assert len(cassette["http_interactions"]) == 1
     command = (
-        f"st run --cassette-path={cassette_path} "
-        f"--hypothesis-max-examples={hypothesis_max_examples or 2} {schema_url}"
+        f"st run --cassette-path={cassette_path} --hypothesis-max-examples={hypothesis_max_examples or 2} {schema_url}"
     )
     assert cassette["command"] == command
 

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/coverage/test_phase.py

@@ -652,6 +652,72 @@ def test_with_examples_openapi_2(ctx):
     )
 
 
+def test_mixed_type_keyword(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "parameters": [
+                        {
+                            "name": "key",
+                            "in": "query",
+                            "required": False,
+                            "schema": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string",
+                                    "enum": ["a", "b"],
+                                    "additionalProperties": False,
+                                },
+                            },
+                        },
+                    ],
+                    "responses": {"default": {"description": "OK"}},
+                }
+            },
+        }
+    )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.negative],
+        [
+            {
+                "query": {"key": ["0", "0"]},
+            },
+            {
+                "query": {"key": [ANY]},
+            },
+            {
+                "query": {"key": ["{}"]},
+            },
+            {
+                "query": {"key": ["[null, null]"]},
+            },
+            {
+                "query": {"key": ["null"]},
+            },
+            {
+                "query": {"key": ["false"]},
+            },
+            {
+                "query": {"key": ["0"]},
+            },
+            {
+                "query": {"key": "{}"},
+            },
+            {
+                "query": {"key": ""},
+            },
+            {
+                "query": {"key": "null"},
+            },
+            {
+                "query": {"key": "false"},
+            },
+        ],
+    )
+
+
 def test_negative_patterns(ctx):
     schema = ctx.openapi.build_schema(
         {

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/specs/openapi/stateful/test_stateful.py

@@ -418,3 +418,34 @@ GET /api/users/{user_id}
 def test_aggregate_responses():
     responses = {201: 2, 204: 3, 301: 1, 400: 1, 404: 1, 500: 1, 503: 1, None: 5}
     assert _aggregate_responses(responses) == {"2xx": 5, "4xx": 2, "5xx": 2, "Total": 9}
+
+
+@pytest.mark.openapi_version("3.0")
+@pytest.mark.operations("create_user", "get_user", "update_user")
+def test_passing_transport_kwargs(app_schema, openapi3_base_url, mocker):
+    schema = schemathesis.openapi.from_dict(app_schema, base_url=openapi3_base_url)
+
+    mocker.patch(
+        "schemathesis.specs.openapi.checks._get_security_parameters",
+        return_value=[{"name": "token", "required": True, "in": "query"}],
+    )
+    mocked = mocker.patch("schemathesis.specs.openapi.checks._contains_auth")
+
+    headers = {"Authorization": "Bearer SECRET!", "Content-Type": "application/json"}
+    kwargs = {"verify": False, "headers": headers}
+
+    # State machine should properly pass transport kwargs to `validate_response`
+    class APIWorkflow(schema.as_state_machine()):
+        def before_call(self, case) -> None:
+            case.body = {"first_name": "foo", "last_name": "bar"}
+            case.query = {}
+
+        def get_call_kwargs(self, case):
+            return kwargs
+
+    try:
+        APIWorkflow.run()
+    except Exception:
+        pass
+
+    assert mocked.call_args.args[0].transport_kwargs == kwargs

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/specs/openapi/test_checks.py

@@ -11,6 +11,7 @@ from schemathesis.specs.openapi.checks import (
     has_only_additional_properties_in_non_body_parameters,
     negative_data_rejection,
     positive_data_acceptance,
+    response_schema_conformance,
 )
 
 
@@ -174,6 +175,46 @@ def test_negative_data_rejection_on_additional_properties(response_factory, samp
     assert negative_data_rejection(CheckContext(override=None, auth=None, headers=None), response, case) is None
 
 
+def test_response_schema_conformance_with_unspecified_method(response_factory, sample_schema):
+    response = response_factory.requests()
+    sample_schema["paths"]["/test"]["post"]["responses"] = {
+        "200": {
+            "description": "Successful response",
+            "content": {
+                "application/json": {
+                    "schema": {
+                        "type": "object",
+                        "properties": {"id": {"type": "integer"}, "name": {"type": "string"}},
+                        "required": ["id", "name"],
+                    }
+                }
+            },
+        }
+    }
+    schema = schemathesis.openapi.from_dict(sample_schema)
+    operation = schema["/test"]["POST"]
+    meta = build_metadata()
+    meta.description = "Unspecified HTTP method: PUT"
+    case = Case(
+        operation=operation,
+        generation_time=0.0,
+        meta=meta,
+        data_generation_method=DataGenerationMethod.negative,
+    )
+
+    result = response_schema_conformance(
+        CheckContext(
+            override=None,
+            auth=None,
+            headers=None,
+            transport_kwargs=None,
+        ),
+        response,
+        case,
+    )
+    assert result is True
+
+
 @pytest.mark.parametrize(
     ("status_code", "allowed_statuses", "is_positive", "should_raise"),
     [

{schemathesis-3.39.8 → schemathesis-3.39.9}/test/specs/openapi/test_patterns.py

@@ -147,16 +147,16 @@ def test_update_quantifier_random(data):
 
     # Assert that the generated string meets the length constraints
     if min_length is not None:
-        assert (
-            len(generated) >= min_length
-        ), f"Generated string '{generated}' is shorter than min_length {min_length}\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
+        assert len(generated) >= min_length, (
+            f"Generated string '{generated}' is shorter than min_length {min_length}\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
+        )
     if max_length is not None:
-        assert (
-            len(generated) <= max_length
-        ), f"Generated string '{generated}' is longer than max_length {max_length}.\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
-    assert re.search(
-        pattern, generated
-    ), f"Generated string '{generated}' does not match the pattern.\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
+        assert len(generated) <= max_length, (
+            f"Generated string '{generated}' is longer than max_length {max_length}.\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
+        )
+    assert re.search(pattern, generated), (
+        f"Generated string '{generated}' does not match the pattern.\nOriginal pattern: {pattern}\nModified pattern: {modified_pattern}"
+    )
 
 
 def is_valid_regex(pattern: str) -> bool: