schemathesis 3.38.2__tar.gz → 3.38.4__tar.gz

{schemathesis-3.38.2 → schemathesis-3.38.4}/.pre-commit-config.yaml

@@ -25,12 +25,12 @@ repos:
       - id: yamllint
 
   - repo: https://github.com/codingjoe/relint
-    rev: 3.3.0
+    rev: 3.3.1
     hooks:
       - id: relint
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.12.0
+    rev: v1.13.0
     hooks:
       - id: mypy
         exclude: ^(docs/|test/|test-corpus/|example/|benches/).*$
@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.0
+    rev: v0.7.1
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.0
+    rev: v0.7.1
     hooks:
       - id: ruff
 

{schemathesis-3.38.2 → schemathesis-3.38.4}/PKG-INFO

@@ -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 → schemathesis-3.38.4}/docs/changelog.rst

@@ -1,9 +1,28 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.38.2...HEAD>` - TBD
+:version:`Unreleased <v3.38.4...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.38.4:
+
+:version:`3.38.4 <v3.38.3...v3.38.4>` - 2024-10-29
+--------------------------------------------------
+
+**Changed**
+
+- Generate more negative combinations during the coverage phase.
+
+.. _v3.38.3:
+
+:version:`3.38.3 <v3.38.2...v3.38.3>` - 2024-10-26
+--------------------------------------------------
+
+**Changed**
+
+- Generate more negative combinations during the coverage phase.
+- Ensure text description is always present for test cases in the coverage phase.
+
 .. _v3.38.2:
 
 :version:`3.38.2 <v3.38.1...v3.38.2>` - 2024-10-22

{schemathesis-3.38.2 → schemathesis-3.38.4}/example/requirements-app.txt

@@ -28,5 +28,5 @@ sqlalchemy==1.4.50
     # via
     #   -r requirements-app.in
     #   flask-sqlalchemy
-werkzeug==3.0.3
+werkzeug==3.0.6
     # via flask

{schemathesis-3.38.2 → schemathesis-3.38.4}/example/requirements-pytest.txt

@@ -114,7 +114,7 @@ typing-extensions==4.8.0
     # via schemathesis
 urllib3==2.2.2
     # via requests
-werkzeug==3.0.3
+werkzeug==3.0.6
     # via schemathesis
 yarl==1.9.3
     # via schemathesis

{schemathesis-3.38.2 → schemathesis-3.38.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.38.2"
+version = "3.38.4"
 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.38.2 → schemathesis-3.38.4}/src/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-3.38.2 → schemathesis-3.38.4}/src/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 → schemathesis-3.38.4}/test/coverage/test_phase.py

@@ -298,6 +298,82 @@ def test_with_examples_openapi_3(ctx):
     )
 
 
+def test_with_optional_parameters(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "parameters": [
+                        {"in": "query", "name": "q1", "schema": {"type": "string"}, "required": True, "example": "A1"},
+                        {"in": "query", "name": "q2", "schema": {"type": "integer"}, "required": False, "example": 10},
+                        {"in": "query", "name": "q3", "schema": {"type": "integer"}, "required": False, "example": 15},
+                        {"in": "query", "name": "q4", "schema": {"type": "integer"}, "required": False, "example": 20},
+                    ],
+                    "responses": {"default": {"description": "OK"}},
+                }
+            },
+        }
+    )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.positive],
+        [
+            {
+                "query": {
+                    "q1": "A1",
+                    "q3": 15,
+                    "q4": 20,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q2": 10,
+                    "q4": 20,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q2": 10,
+                    "q3": 15,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q4": 20,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q3": 15,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q2": 10,
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                },
+            },
+            {
+                "query": {
+                    "q1": "A1",
+                    "q2": 10,
+                    "q3": 15,
+                    "q4": 20,
+                },
+            },
+        ],
+    )
+
+
 def test_with_example_openapi_3(ctx):
     schema = ctx.openapi.build_schema(
         {

{schemathesis-3.38.2 → schemathesis-3.38.4}/test/service/test_extensions.py

@@ -513,7 +513,7 @@ import schemathesis
 
 @schemathesis.check
 def port_check(ctx, response, case):
-    value = re.findall("getByDate\(value: (\d+)\)", case.body)[0]
+    value = re.findall(r"getByDate\(value: (\d+)\)", case.body)[0]
     assert 1 <= int(value) <= 65535, "Invalid port"
 """
     )