schemathesis 3.36.1__tar.gz → 3.36.2__tar.gz

{schemathesis-3.36.1 → schemathesis-3.36.2}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.26.7
+        uses: github/codeql-action/init@v3.26.8
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.26.7
+        uses: github/codeql-action/autobuild@v3.26.8
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.26.7
+        uses: github/codeql-action/analyze@v3.26.8

{schemathesis-3.36.1 → schemathesis-3.36.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.1
+Version: 3.36.2
 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.36.1 → schemathesis-3.36.2}/docs/changelog.rst

@@ -1,9 +1,24 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.36.1...HEAD>` - TBD
+:version:`Unreleased <v3.36.2...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.36.2:
+
+:version:`3.36.2 <v3.36.1...v3.36.2>` - 2024-09-26
+--------------------------------------------------
+
+**Changed**
+
+- Merge ``minLength`` & ``maxLength`` into ``pattern`` to avoid extremely slow generation in most popular cases.
+- Avoid generating ``{`` and ``}`` for path parameters.
+- Generate all negative types in the coverage phase.
+
+**Fixed**
+
+- Internal error on incorrect examples during the coverage phase.
+
 .. _v3.36.1:
 
 :version:`3.36.1 <v3.36.0...v3.36.1>` - 2024-09-23

{schemathesis-3.36.1 → schemathesis-3.36.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.36.1"
+version = "3.36.2"
 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.36.1 → schemathesis-3.36.2}/src/schemathesis/generation/coverage.py

@@ -15,7 +15,7 @@ from hypothesis_jsonschema._canonicalise import canonicalish
 
 from schemathesis.constants import NOT_SET
 
-from ._hypothesis import combine_strategies, get_single_example
+from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
 BUFFER_SIZE = 8 * 1024
@@ -157,7 +157,11 @@ def _ignore_unfixable(
             raise
 
 
-def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[GeneratedValue, None, None]:
+def cover_schema_iter(
+    ctx: CoverageContext, schema: dict | bool, seen: set[Any | tuple[type, str]] | None = None
+) -> Generator[GeneratedValue, None, None]:
+    if seen is None:
+        seen = set()
     if isinstance(schema, bool):
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
@@ -174,13 +178,16 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
             yield from _cover_positive_for_type(ctx, schema, ty)
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
-        seen: set[Any | tuple[type, str]] = set()
         for key, value in schema.items():
             with _ignore_unfixable():
                 if key == "enum":
                     yield from _negative_enum(ctx, value)
                 elif key == "const":
-                    yield from _negative_enum(ctx, [value])
+                    for value_ in _negative_enum(ctx, [value]):
+                        k = _to_hashable_key(value_.value)
+                        if k not in seen:
+                            yield value_
+                            seen.add(k)
                 elif key == "type":
                     yield from _negative_type(ctx, seen, value)
                 elif key == "properties":
@@ -192,27 +199,37 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                     yield from _negative_format(ctx, schema, value)
                 elif key == "maximum":
                     next = value + 1
-                    yield NegativeValue(next)
-                    seen.add(next)
+                    if next not in seen:
+                        yield NegativeValue(next)
+                        seen.add(next)
                 elif key == "minimum":
                     next = value - 1
-                    yield NegativeValue(next)
-                    seen.add(next)
+                    if next not in seen:
+                        yield NegativeValue(next)
+                        seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
                     yield NegativeValue(value)
                     seen.add(value)
                 elif key == "multipleOf":
-                    yield from _negative_multiple_of(ctx, schema, value)
+                    for value_ in _negative_multiple_of(ctx, schema, value):
+                        k = _to_hashable_key(value_.value)
+                        if k not in seen:
+                            yield value_
+                            seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
-                        yield NegativeValue(
-                            ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
-                        )
+                        value = ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                        k = _to_hashable_key(value)
+                        if k not in seen:
+                            yield NegativeValue(value)
+                            seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
-                        yield NegativeValue(
-                            ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
-                        )
+                        value = ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                        k = _to_hashable_key(value)
+                        if k not in seen:
+                            yield NegativeValue(value)
+                            seen.add(k)
                 elif key == "uniqueItems" and value:
                     yield from _negative_unique_items(ctx, schema)
                 elif key == "required":
@@ -224,16 +241,16 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
-                        yield from cover_schema_iter(nctx, value[0])
+                        yield from cover_schema_iter(nctx, value[0], seen)
                     else:
                         with _ignore_unfixable():
                             canonical = canonicalish(schema)
-                            yield from cover_schema_iter(nctx, canonical)
+                            yield from cover_schema_iter(nctx, canonical, seen)
                 elif key == "anyOf" or key == "oneOf":
                     nctx = ctx.with_negative()
                     # NOTE: Other sub-schemas are not filtered out
                     for sub_schema in value:
-                        yield from cover_schema_iter(nctx, sub_schema)
+                        yield from cover_schema_iter(nctx, sub_schema, seen)
 
 
 def _get_properties(schema: dict | bool) -> dict | bool:
@@ -584,10 +601,13 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
-    negative_strategy = combine_strategies(tuple(strategies.values())).filter(lambda x: _to_hashable_key(x) not in seen)
-    value = ctx.generate_from(negative_strategy, cached=True)
-    yield NegativeValue(value)
-    seen.add(_to_hashable_key(value))
+    for strat in strategies.values():
+        value = ctx.generate_from(strat, cached=True)
+        hashed = _to_hashable_key(value)
+        if hashed in seen:
+            continue
+        yield NegativeValue(value)
+        seen.add(hashed)
 
 
 def push_examples_to_properties(schema: dict[str, Any]) -> None:
@@ -595,9 +615,10 @@ def push_examples_to_properties(schema: dict[str, Any]) -> None:
     if "examples" in schema and "properties" in schema:
         properties = schema["properties"]
         for example in schema["examples"]:
-            for prop, value in example.items():
-                if prop in properties:
-                    if "examples" not in properties[prop]:
-                        properties[prop]["examples"] = []
-                    if value not in schema["properties"][prop]["examples"]:
-                        properties[prop]["examples"].append(value)
+            if isinstance(example, dict):
+                for prop, value in example.items():
+                    if prop in properties:
+                        if "examples" not in properties[prop]:
+                            properties[prop]["examples"] = []
+                        if value not in schema["properties"][prop]["examples"]:
+                            properties[prop]["examples"].append(value)

{schemathesis-3.36.1 → schemathesis-3.36.2}/src/schemathesis/internal/checks.py

@@ -6,10 +6,11 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
-    from ..types import RawAuth
+    from requests.structures import CaseInsensitiveDict
+
     from ..models import Case
     from ..transports.responses import GenericResponse
-    from requests.structures import CaseInsensitiveDict
+    from ..types import RawAuth
 
 
 CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]

{schemathesis-3.36.1 → schemathesis-3.36.2}/src/schemathesis/specs/openapi/_hypothesis.py

@@ -527,7 +527,12 @@ def is_valid_path(parameters: dict[str, Any]) -> bool:
     disallowed_values = (SLASH, "")
 
     return not any(
-        (value in disallowed_values or is_illegal_surrogate(value) or isinstance(value, str) and SLASH in value)
+        (
+            value in disallowed_values
+            or is_illegal_surrogate(value)
+            or isinstance(value, str)
+            and (SLASH in value or "}" in value or "{" in value)
+        )
         for value in parameters.values()
     )
 

{schemathesis-3.36.1 → schemathesis-3.36.2}/src/schemathesis/specs/openapi/converter.py

@@ -5,6 +5,7 @@ from typing import Any, Callable
 
 from ...internal.copy import fast_deepcopy
 from ...internal.jsonschema import traverse_schema
+from .patterns import update_quantifier
 
 
 def to_json_schema(
@@ -24,6 +25,15 @@ def to_json_schema(
     if schema_type == "file":
         schema["type"] = "string"
         schema["format"] = "binary"
+    pattern = schema.get("pattern")
+    min_length = schema.get("minLength")
+    max_length = schema.get("maxLength")
+    if pattern and (min_length or max_length):
+        new_pattern = update_quantifier(pattern, min_length, max_length)
+        if new_pattern != pattern:
+            schema.pop("minLength", None)
+            schema.pop("maxLength", None)
+            schema["pattern"] = new_pattern
     if schema_type == "object":
         if is_response_schema:
             # Write-only properties should not occur in responses

schemathesis-3.36.2/src/schemathesis/specs/openapi/patterns.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+
+try:  # pragma: no cover
+    import re._constants as sre
+    import re._parser as sre_parse
+except ImportError:
+    import sre_constants as sre
+    import sre_parse
+
+ANCHOR = sre.AT
+REPEATS: tuple
+if hasattr(sre, "POSSESSIVE_REPEAT"):
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT, sre.POSSESSIVE_REPEAT)
+else:
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT)
+LITERAL = sre.LITERAL
+IN = sre.IN
+MAXREPEAT = sre_parse.MAXREPEAT
+
+
+@lru_cache()
+def update_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier of a regular expression based on given min and max lengths."""
+    if not pattern or (min_length in (None, 0) and max_length is None):
+        return pattern
+
+    try:
+        parsed = sre_parse.parse(pattern)
+        return _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+    except re.error:
+        # Invalid pattern
+        return pattern
+
+
+def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle the parsed pattern and update quantifiers based on different cases."""
+    if len(parsed) == 1:
+        op, value = parsed[0]
+        return _update_quantifier(op, value, pattern, min_length, max_length)
+    elif len(parsed) == 2:
+        if parsed[0][0] == ANCHOR:
+            # Starts with an anchor
+            op, value = parsed[1]
+            leading_anchor = pattern[0]
+            return leading_anchor + _update_quantifier(op, value, pattern[1:], min_length, max_length)
+        if parsed[1][0] == ANCHOR:
+            # Ends with an anchor
+            op, value = parsed[0]
+            trailing_anchor = pattern[-1]
+            return _update_quantifier(op, value, pattern[:-1], min_length, max_length) + trailing_anchor
+    elif len(parsed) == 3 and parsed[0][0] == ANCHOR and parsed[2][0] == ANCHOR:
+        op, value = parsed[1]
+        leading_anchor = pattern[0]
+        trailing_anchor = pattern[-1]
+        return leading_anchor + _update_quantifier(op, value, pattern[1:-1], min_length, max_length) + trailing_anchor
+    return pattern
+
+
+def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier based on the operation type and given constraints."""
+    if op in REPEATS:
+        return _handle_repeat_quantifier(value, pattern, min_length, max_length)
+    if op in (LITERAL, IN) and max_length != 0:
+        return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    return pattern
+
+
+def _handle_repeat_quantifier(
+    value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
+) -> str:
+    """Handle repeat quantifiers (e.g., '+', '*', '?')."""
+    min_repeat, max_repeat, _ = value
+    min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
+    if min_length > max_length:
+        return pattern
+    return f"({_strip_quantifier(pattern)})" + _build_quantifier(min_length, max_length)
+
+
+def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle literal or character class quantifiers."""
+    min_length = 1 if min_length is None else max(min_length, 1)
+    return f"({pattern})" + _build_quantifier(min_length, max_length)
+
+
+def _build_quantifier(minimum: int | None, maximum: int | None) -> str:
+    """Construct a quantifier string based on min and max values."""
+    if maximum == MAXREPEAT or maximum is None:
+        return f"{{{minimum or 0},}}"
+    if minimum == maximum:
+        return f"{{{minimum}}}"
+    return f"{{{minimum or 0},{maximum}}}"
+
+
+def _build_size(min_repeat: int, max_repeat: int, min_length: int | None, max_length: int | None) -> tuple[int, int]:
+    """Merge the current repetition constraints with the provided min and max lengths."""
+    if min_length is not None:
+        min_repeat = max(min_repeat, min_length)
+    if max_length is not None:
+        if max_repeat == MAXREPEAT:
+            max_repeat = max_length
+        else:
+            max_repeat = min(max_repeat, max_length)
+    return min_repeat, max_repeat
+
+
+def _strip_quantifier(pattern: str) -> str:
+    """Remove quantifier from the pattern."""
+    # Lazy & posessive quantifiers
+    if pattern.endswith(("*?", "+?", "??", "*+", "?+", "++")):
+        return pattern[:-2]
+    if pattern.endswith(("?", "*", "+")):
+        pattern = pattern[:-1]
+    if pattern.endswith("}"):
+        # Find the start of the exact quantifier and drop everything since that index
+        idx = pattern.rfind("{")
+        pattern = pattern[:idx]
+    return pattern

{schemathesis-3.36.1 → schemathesis-3.36.2}/test/coverage/test_combinations.py

@@ -152,22 +152,22 @@ class NotNumber:
 @pytest.mark.parametrize(
     "schema, expected",
     (
-        ({"type": "null"}, 0),
-        ({"type": "boolean"}, 0),
-        ({"type": ["boolean", "null"]}, 0),
-        ({"enum": [1, 2]}, None),
-        ({"enum": [1, 2, {}]}, None),
-        ({"const": 42}, None),
+        ({"type": "null"}, [0, "", [], {}]),
+        ({"type": "boolean"}, [0, None, "", [], {}]),
+        ({"type": ["boolean", "null"]}, [0, "", [], {}]),
+        ({"enum": [1, 2]}, [None]),
+        ({"enum": [1, 2, {}]}, [None]),
+        ({"const": 42}, [None]),
         ({"multipleOf": 2}, lambda x: x % 2 != 0),
-        ({"format": "date-time"}, AnyString()),
-        ({"format": "hostname"}, AnyString()),
-        ({"format": "unknown"}, AnyString()),
-        ({"uniqueItems": True}, [None, None]),
-        ({"maximum": 5}, 6),
-        ({"minimum": 5}, 4),
-        ({"exclusiveMinimum": 5}, 5),
-        ({"exclusiveMaximum": 5}, 5),
-        ({"required": ["a"]}, {}),
+        ({"format": "date-time"}, [AnyString()]),
+        ({"format": "hostname"}, [AnyString()]),
+        ({"format": "unknown"}, [AnyString()]),
+        ({"uniqueItems": True}, [[None, None]]),
+        ({"maximum": 5}, [6]),
+        ({"minimum": 5}, [4]),
+        ({"exclusiveMinimum": 5}, [5]),
+        ({"exclusiveMaximum": 5}, [5]),
+        ({"required": ["a"]}, [{}]),
     ),
 )
 def test_negative_primitive_schemas(nctx, schema, expected):
@@ -176,7 +176,7 @@ def test_negative_primitive_schemas(nctx, schema, expected):
         assert len(covered) == 1
         assert expected(covered[0])
     else:
-        assert covered == [expected]
+        assert covered == expected
     assert_unique(covered)
     assert_not_conform(covered, schema)
 
@@ -211,13 +211,13 @@ def test_positive_string(ctx, schema, lengths):
 @pytest.mark.parametrize(
     "schema, expected",
     (
-        ({"type": "string"}, [0]),
-        ({"type": "string", "minLength": 5}, [0, "0000"]),
-        ({"type": "string", "maxLength": 10}, [0, "00000000000"]),
-        ({"type": "string", "minLength": 5, "maxLength": 10}, [0, "0000", "00000000000"]),
-        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, ""]),
-        ({"type": "string", "pattern": "^[0-9]"}, [0, ""]),
-        ({"type": "string", "format": "date-time"}, [0, ""]),
+        ({"type": "string"}, [0, None, [], {}]),
+        ({"type": "string", "minLength": 5}, [0, None, [], {}, "0000"]),
+        ({"type": "string", "maxLength": 10}, [0, None, [], {}, "00000000000"]),
+        ({"type": "string", "minLength": 5, "maxLength": 10}, [0, None, [], {}, "0000", "00000000000"]),
+        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, None, [], {}, ""]),
+        ({"type": "string", "pattern": "^[0-9]"}, [0, None, [], {}, ""]),
+        ({"type": "string", "format": "date-time"}, [0, None, [], {}, ""]),
     ),
 )
 def test_negative_string(nctx, schema, expected):
@@ -745,8 +745,32 @@ def test_positive_other(pctx, schema, expected):
                     "bar": "",
                 },
                 {
-                    "foo": "",
+                    "bar": "",
+                    "foo": None,
+                },
+                {
+                    "bar": "",
+                    "foo": [],
+                },
+                {
+                    "bar": "",
+                    "foo": {},
+                },
+                {
                     "bar": 0,
+                    "foo": "",
+                },
+                {
+                    "bar": None,
+                    "foo": "",
+                },
+                {
+                    "bar": [],
+                    "foo": "",
+                },
+                {
+                    "foo": "",
+                    "bar": {},
                 },
                 {
                     "bar": "",
@@ -765,12 +789,36 @@ def test_positive_other(pctx, schema, expected):
             },
             [
                 {
+                    "bar": "",
                     "foo": 0,
+                },
+                {
                     "bar": "",
+                    "foo": None,
+                },
+                {
+                    "bar": "",
+                    "foo": [],
+                },
+                {
+                    "bar": "",
+                    "foo": {},
                 },
                 {
-                    "foo": "",
                     "bar": 0,
+                    "foo": "",
+                },
+                {
+                    "bar": None,
+                    "foo": "",
+                },
+                {
+                    "bar": [],
+                    "foo": "",
+                },
+                {
+                    "bar": {},
+                    "foo": "",
                 },
             ],
         ),
@@ -785,6 +833,15 @@ def test_positive_other(pctx, schema, expected):
                 {
                     "foo": 0,
                 },
+                {
+                    "foo": None,
+                },
+                {
+                    "foo": [],
+                },
+                {
+                    "foo": {},
+                },
                 {
                     "foo": "",
                     "x-schemathesis-unknown-property": 42,
@@ -818,7 +875,7 @@ def test_negative_objects(nctx, schema, expected):
                     {"minimum": 5},
                 ],
             },
-            [4, NotNumber()],
+            [4, AnyNumber(), False, None, "", [], {}],
         ),
         (
             {
@@ -827,7 +884,7 @@ def test_negative_objects(nctx, schema, expected):
                     {"type": "string"},
                 ],
             },
-            [4, 0],
+            [4, 0, None, [], {}],
         ),
         (
             {
@@ -846,7 +903,7 @@ def test_negative_objects(nctx, schema, expected):
                     },
                 ]
             },
-            [ANY, None, 0],
+            [ANY, None, 0, ANY],
         ),
         (
             {

{schemathesis-3.36.1 → schemathesis-3.36.2}/test/coverage/test_examples.py

@@ -1,4 +1,5 @@
 import pytest
+
 from schemathesis.generation.coverage import push_examples_to_properties
 
 
@@ -126,6 +127,22 @@ from schemathesis.generation.coverage import push_examples_to_properties
                 ],
             },
         ),
+        (
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice"]},
+                },
+                "examples": [2],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice"]},
+                },
+                "examples": [2],
+            },
+        ),
     ],
 )
 def test_push_examples_to_properties(schema, expected):