schemathesis 3.38.2__py3-none-any.whl → 3.38.4__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -5,8 +5,8 @@ from __future__ import annotations
 import asyncio
 import json
 import warnings
-from copy import copy
 from functools import wraps
+from itertools import combinations
 from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
@@ -23,6 +23,7 @@ from .experimental import COVERAGE_PHASE
 from .generation import DataGenerationMethod, GenerationConfig, combine_strategies, coverage, get_single_example
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher
 from .models import APIOperation, Case, GenerationMetadata, TestPhase
+from .parameters import ParameterSet
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .types import NotSet
@@ -223,18 +224,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
 
-    meta = GenerationMetadata(
-        query=None,
-        path_parameters=None,
-        headers=None,
-        cookies=None,
-        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)
@@ -275,25 +264,27 @@ def _iter_coverage_cases(
                 template["media_type"] = body.media_type
             case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
             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"
+            case.meta = _make_meta(
+                description=value.description,
+                location=value.location,
+                parameter=body.media_type,
+                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"
+                case.meta = _make_meta(
+                    description=next_value.description,
+                    location=next_value.location,
+                    parameter=body.media_type,
+                    parameter_location="body",
+                )
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
         case = operation.make_case(**template)
         case.data_generation_method = DataGenerationMethod.positive
-        case.meta = copy(meta)
+        case.meta = _make_meta(description="Default positive test case")
         yield case
     for (location, name), gen in generators.items():
         container_name = LOCATION_TO_CONTAINER[location]
@@ -305,11 +296,12 @@ def _iter_coverage_cases(
                 generated = value.value
             case = operation.make_case(**{**template, container_name: {**container, name: generated}})
             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
+            case.meta = _make_meta(
+                description=value.description,
+                location=value.location,
+                parameter=name,
+                parameter_location=location,
+            )
             yield case
     # Generate missing required parameters
     if DataGenerationMethod.negative in data_generation_methods:
@@ -323,12 +315,115 @@ def _iter_coverage_cases(
                     **{**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
+                case.meta = _make_meta(
+                    description=f"Missing `{name}` at {location}",
+                    location=parameter.location,
+                    parameter=name,
+                    parameter_location=location,
+                )
                 yield case
+    # Generate combinations for each location
+    for location, parameter_set in [
+        ("query", operation.query),
+        ("header", operation.headers),
+        ("cookie", operation.cookies),
+    ]:
+        if not parameter_set:
+            continue
+
+        container_name = LOCATION_TO_CONTAINER[location]
+        base_container = template.get(container_name, {})
+
+        # Get required and optional parameters
+        required = {p.name for p in parameter_set if p.is_required}
+        all_params = {p.name for p in parameter_set}
+        optional = sorted(all_params - required)
+
+        # Helper function to create and yield a case
+        def make_case(container_values: dict, description: str, _location: str, _container_name: str) -> Case:
+            if _location in ("header", "cookie"):
+                container = {
+                    name: json.dumps(val) if not isinstance(val, str) else val for name, val in container_values.items()
+                }
+            else:
+                container = container_values
+
+            case = operation.make_case(**{**template, _container_name: container})
+            case.data_generation_method = DataGenerationMethod.positive
+            case.meta = _make_meta(
+                description=description,
+                location=_location,
+                parameter_location=_location,
+            )
+            return case
+
+        def _combination_schema(
+            combination: dict[str, Any], _required: set[str], _parameter_set: ParameterSet
+        ) -> dict[str, Any]:
+            return {
+                "properties": {
+                    parameter.name: parameter.as_json_schema(operation)
+                    for parameter in _parameter_set
+                    if parameter.name in combination
+                },
+                "required": list(_required),
+                "additionalProperties": False,
+            }
+
+        def _yield_negative(
+            subschema: dict[str, Any], _location: str, _container_name: str
+        ) -> Generator[Case, None, None]:
+            for more in coverage.cover_schema_iter(
+                coverage.CoverageContext(data_generation_methods=[DataGenerationMethod.negative]),
+                subschema,
+            ):
+                yield make_case(more.value, more.description, _location, _container_name)
+
+        # 1. Generate only required properties
+        if required and all_params != required:
+            only_required = {k: v for k, v in base_container.items() if k in required}
+            yield make_case(only_required, "Only required properties", location, container_name)
+            if DataGenerationMethod.negative in data_generation_methods:
+                subschema = _combination_schema(only_required, required, parameter_set)
+                yield from _yield_negative(subschema, location, container_name)
+
+        # 2. Generate combinations with required properties and one optional property
+        for opt_param in optional:
+            combo = {k: v for k, v in base_container.items() if k in required or k == opt_param}
+            if combo != base_container:
+                yield make_case(combo, f"All required properties and optional '{opt_param}'", location, container_name)
+                if DataGenerationMethod.negative in data_generation_methods:
+                    subschema = _combination_schema(combo, required, parameter_set)
+                    yield from _yield_negative(subschema, location, container_name)
+
+        # 3. Generate one combination for each size from 2 to N-1 of optional parameters
+        if len(optional) > 1:
+            for size in range(2, len(optional)):
+                for combination in combinations(optional, size):
+                    combo = {k: v for k, v in base_container.items() if k in required or k in combination}
+                    if combo != base_container:
+                        yield make_case(combo, f"All required and {size} optional properties", location, container_name)
+
+
+def _make_meta(
+    *,
+    description: str,
+    location: str | None = None,
+    parameter: str | None = None,
+    parameter_location: str | None = None,
+) -> GenerationMetadata:
+    return GenerationMetadata(
+        query=None,
+        path_parameters=None,
+        headers=None,
+        cookies=None,
+        body=None,
+        phase=TestPhase.COVERAGE,
+        description=description,
+        location=location,
+        parameter=parameter,
+        parameter_location=parameter_location,
+    )
 
 
 def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:

schemathesis/schemas.py

@@ -49,6 +49,7 @@ from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
 if TYPE_CHECKING:
     import hypothesis
     from hypothesis.strategies import SearchStrategy
+    from hypothesis.vendor.pretty import RepresentationPrinter
     from pyrate_limiter import Limiter
 
     from .stateful import Stateful, StatefulTest
@@ -102,6 +103,9 @@ class BaseSchema(Mapping):
     def __post_init__(self) -> None:
         self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
 
+    def _repr_pretty_(self, printer: RepresentationPrinter, cycle: bool) -> None:
+        return None
+
     def include(
         self,
         func: MatcherFunc | None = None,

{schemathesis-3.38.2.dist-info → schemathesis-3.38.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.38.2
+Version: 3.38.4
 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.38.2.dist-info → schemathesis-3.38.4.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=-fXguhIC3AoSzgf5ZzQI6W9M7_lSwsf2wTVzbiGAK58,16595
+schemathesis/_hypothesis.py,sha256=lm0J9uQFENfm7-6_wEaNKshGF1wmZebfZJ9G_sUhlqE,20839
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_patches.py,sha256=Hsbpn4UVeXUQD2Kllrbq01CSWsTYENWa0VJTyhX5C2k,895
@@ -22,7 +22,7 @@ schemathesis/models.py,sha256=2kMMJ3JVe4_91uhRxgsZ_G1FOyksxTiYAo52M5asWLA,49868
 schemathesis/parameters.py,sha256=_LN3NL5XwoRfvjcU8o2ArrNFK9sbBZo25UFdxuywkRw,2425
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
-schemathesis/schemas.py,sha256=3xTZOZ1lLdAdwLAkiW0eakRb96mQ0MpbcwmrT-XO4KA,20457
+schemathesis/schemas.py,sha256=KyG8IUNv7_3tPBzT9ARGDmUVEPvHHj6f1wW7GYbfvI4,20623
 schemathesis/serializers.py,sha256=HyYVSVR71FhWfIErnH6OoGLOa4tkh9mTeVUTIpzEW24,11739
 schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
@@ -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.38.2.dist-info/METADATA,sha256=hqeX6MagooG7ljuzUgKYAIxgixMTXQj0xmAy3bC-VJw,12956
-schemathesis-3.38.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.38.2.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.38.2.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.38.2.dist-info/RECORD,,
+schemathesis-3.38.4.dist-info/METADATA,sha256=hXln3HxI_xM3plasHcuEeu6OkknqAZgZBAZr-LJZxE0,12956
+schemathesis-3.38.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.38.4.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.38.4.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.38.4.dist-info/RECORD,,