schemathesis 3.37.1__py3-none-any.whl → 3.38.1__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -6,15 +6,16 @@ import asyncio
 import json
 import warnings
 from copy import copy
+from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
 from hypothesis.internal.entropy import deterministic_PRNG
-from hypothesis.internal.reflection import proxies
 from jsonschema.exceptions import SchemaError
 
+from . import _patches
 from .auths import get_auth_storage_from_test
 from .constants import DEFAULT_DEADLINE, NOT_SET
 from .exceptions import OperationSchemaError, SerializationNotPossible
@@ -29,11 +30,13 @@ from .types import NotSet
 if TYPE_CHECKING:
     from .utils import GivenInput
 
-# Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
+# Forcefully initializes Hypothesis' global PRNG to avoid races that initialize it
 # if e.g. Schemathesis CLI is used with multiple workers
 with deterministic_PRNG():
     pass
 
+_patches.install()
+
 
 def create_test(
     *,
@@ -72,7 +75,7 @@ def create_test(
     # tests in multiple threads because Hypothesis stores some internal attributes on function objects and re-writing
     # them from different threads may lead to unpredictable side-effects.
 
-    @proxies(test)  # type: ignore
+    @wraps(test)
     def test_function(*args: Any, **kwargs: Any) -> Any:
         __tracebackhide__ = True
         return test(*args, **kwargs)
@@ -220,7 +223,6 @@ def _iter_coverage_cases(
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
     from .specs.openapi.examples import find_in_responses, find_matching_in_responses
 
-    ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
     meta = GenerationMetadata(
         query=None,
         path_parameters=None,
@@ -229,15 +231,20 @@ def _iter_coverage_cases(
         body=None,
         phase=TestPhase.COVERAGE,
         description=None,
+        location=None,
+        parameter=None,
+        parameter_location=None,
     )
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
-        schema = parameter.as_json_schema(operation)
+        schema = parameter.as_json_schema(operation, update_quantifiers=False)
         for value in find_matching_in_responses(responses, parameter.name):
             schema.setdefault("examples", []).append(value)
-        gen = coverage.cover_schema_iter(ctx, schema)
+        gen = coverage.cover_schema_iter(
+            coverage.CoverageContext(data_generation_methods=data_generation_methods), schema
+        )
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
             continue
@@ -251,13 +258,15 @@ def _iter_coverage_cases(
         generators[(location, name)] = gen
     if operation.body:
         for body in operation.body:
-            schema = body.as_json_schema(operation)
+            schema = body.as_json_schema(operation, update_quantifiers=False)
             # Definition could be a list for Open API 2.0
             definition = body.definition if isinstance(body.definition, dict) else {}
             examples = [example["value"] for example in definition.get("examples", {}).values() if "value" in example]
             if examples:
                 schema.setdefault("examples", []).extend(examples)
-            gen = coverage.cover_schema_iter(ctx, schema)
+            gen = coverage.cover_schema_iter(
+                coverage.CoverageContext(data_generation_methods=data_generation_methods), schema
+            )
             value = next(gen, NOT_SET)
             if isinstance(value, NotSet):
                 continue
@@ -268,12 +277,18 @@ def _iter_coverage_cases(
             case.data_generation_method = value.data_generation_method
             case.meta = copy(meta)
             case.meta.description = value.description
+            case.meta.location = value.location
+            case.meta.parameter = body.media_type
+            case.meta.parameter_location = "body"
             yield case
             for next_value in gen:
                 case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
                 case.data_generation_method = next_value.data_generation_method
                 case.meta = copy(meta)
                 case.meta.description = next_value.description
+                case.meta.location = next_value.location
+                case.meta.parameter = body.media_type
+                case.meta.parameter_location = "body"
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
         case = operation.make_case(**template)
@@ -292,7 +307,28 @@ def _iter_coverage_cases(
             case.data_generation_method = value.data_generation_method
             case.meta = copy(meta)
             case.meta.description = value.description
+            case.meta.location = value.location
+            case.meta.parameter = name
+            case.meta.parameter_location = location
             yield case
+    # Generate missing required parameters
+    if DataGenerationMethod.negative in data_generation_methods:
+        for parameter in operation.iter_parameters():
+            if parameter.is_required:
+                name = parameter.name
+                location = parameter.location
+                container_name = LOCATION_TO_CONTAINER[location]
+                container = template[container_name]
+                case = operation.make_case(
+                    **{**template, container_name: {k: v for k, v in container.items() if k != name}}
+                )
+                case.data_generation_method = DataGenerationMethod.negative
+                case.meta = copy(meta)
+                case.meta.description = f"Missing `{name}` at {location}"
+                case.meta.location = parameter.location
+                case.meta.parameter = name
+                case.meta.parameter_location = location
+                yield case
 
 
 def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:

schemathesis/_patches.py

@@ -0,0 +1,21 @@
+"""A set of performance-related patches."""
+
+from typing import Any
+
+
+def install() -> None:
+    from hypothesis.internal.reflection import is_first_param_referenced_in_function
+    from hypothesis.strategies._internal import core
+    from hypothesis_jsonschema import _from_schema, _resolve
+
+    from .internal.copy import fast_deepcopy
+
+    # This one is used a lot, and under the hood it re-parses the AST of the same function
+    def _is_first_param_referenced_in_function(f: Any) -> bool:
+        if f.__name__ == "from_object_schema" and f.__module__ == "hypothesis_jsonschema._from_schema":
+            return True
+        return is_first_param_referenced_in_function(f)
+
+    core.is_first_param_referenced_in_function = _is_first_param_referenced_in_function  # type: ignore
+    _resolve.deepcopy = fast_deepcopy  # type: ignore
+    _from_schema.deepcopy = fast_deepcopy  # type: ignore

schemathesis/cli/__init__.py

@@ -36,7 +36,7 @@ from ..filters import FilterSet, expression_to_filter_function, is_deprecated
 from ..fixups import ALL_FIXUPS
 from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
-from ..internal.checks import CheckConfig, PositiveDataAcceptanceConfig
+from ..internal.checks import CheckConfig
 from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists

schemathesis/cli/cassettes.py

@@ -244,6 +244,24 @@ http_interactions:"""
                     write_double_quoted(stream, interaction.description)
                 else:
                     stream.write("null")
+
+                stream.write("\n    location: ")
+                if interaction.location is not None:
+                    write_double_quoted(stream, interaction.location)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    parameter: ")
+                if interaction.parameter is not None:
+                    write_double_quoted(stream, interaction.parameter)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    parameter_location: ")
+                if interaction.parameter_location is not None:
+                    write_double_quoted(stream, interaction.parameter_location)
+                else:
+                    stream.write("null")
                 stream.write(
                     f"""
   phase: {phase}

schemathesis/extra/pytest_plugin.py

@@ -200,7 +200,7 @@ class SchemathesisCase(PyCollector):
             kwargs["_ispytest"] = True
         metafunc = Metafunc(definition, fixtureinfo, self.config, **kwargs)
         methods = []
-        if hasattr(module, "pytest_generate_tests"):
+        if module is not None and hasattr(module, "pytest_generate_tests"):
             methods.append(module.pytest_generate_tests)
         if hasattr(cls, "pytest_generate_tests"):
             cls = cast(Type, cls)

schemathesis/generation/_hypothesis.py

@@ -43,6 +43,8 @@ def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> Non
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)
 
+    example_generating_inner_function._hypothesis_internal_database_key = b""  # type: ignore
+
     if SCHEMATHESIS_BENCHMARK_SEED is not None:
         example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)