schemathesis 4.3.0__tar.gz → 4.3.2__tar.gz

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/build.yml

@@ -33,7 +33,7 @@ jobs:
         with:
           python-version: 3.11
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uvx pre-commit run --all-files
 
@@ -55,7 +55,7 @@ jobs:
         with:
           python-version: ${{ matrix.python }}
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - if: ${{ matrix.tox_env }}
         run: uvx --with="tox" --with="tox-gh-actions" --with="tox-uv" tox -e ${{ matrix.tox_env }}
@@ -86,7 +86,7 @@ jobs:
         with:
           python-version: "3.12"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uv tool install ".[dev]"
 

{schemathesis-4.3.0 → schemathesis-4.3.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.30.6
+        uses: github/codeql-action/init@v4.30.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.30.6
+        uses: github/codeql-action/autobuild@v4.30.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.30.6
+        uses: github/codeql-action/analyze@v4.30.8

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/codspeed.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           python-version: "3.12"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - name: Run benchmarks
         uses: CodSpeedHQ/action@v4

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/memory-benchmark.yml

@@ -21,7 +21,7 @@ jobs:
         with:
           python-version: '3.13'
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uv pip install '.' 'memray==1.18.0' --system
 

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/release.yml

@@ -109,7 +109,7 @@ jobs:
         with:
           python-version: "3.10"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - name: Build package
         run: uvx hatchling build

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/test-corpus.yml

@@ -21,9 +21,9 @@ jobs:
         with:
           python-version: "3.11"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
-      - run: uvx --from=".[tests]" pytest test-corpus/test_default.py -n auto -k test_default --durations=20 --dist=worksteal
+      - run: uvx --from=".[tests]" pytest test-corpus/test_corpus.py -n auto -k test_default --durations=20 --dist=worksteal
 
   corpus-coverage:
     name: Corpus tests for the coverage phase
@@ -38,9 +38,9 @@ jobs:
         with:
           python-version: "3.11"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
-      - run: uvx --from=".[tests]" pytest test-corpus/test_default.py -n auto -k test_coverage_phase --durations=20 --dist=worksteal
+      - run: uvx --from=".[tests]" pytest test-corpus/test_corpus.py -n auto -k test_coverage_phase --durations=20 --dist=worksteal
 
   corpus-inference:
     name: Corpus tests for dependency inference
@@ -55,6 +55,6 @@ jobs:
         with:
           python-version: "3.11"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uvx --from=".[tests]" pytest test-corpus/test_inference.py -n auto --durations=20 --dist=worksteal

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/test-hypothesis.yml

@@ -19,6 +19,6 @@ jobs:
         with:
           python-version: "3.11"
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uvx --from=".[tests]" pytest -m hypothesis -m hypothesis_nested --hypothesis-profile CI test

{schemathesis-4.3.0 → schemathesis-4.3.2}/.github/workflows/update-pre-commit.yml

@@ -15,7 +15,7 @@ jobs:
           fetch-depth: 1
           submodules: true
 
-      - uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v7
 
       - run: uvx pre-commit autoupdate
 

{schemathesis-4.3.0 → schemathesis-4.3.2}/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.0...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.2...HEAD) - TBD
+
+## [4.3.2](https://github.com/schemathesis/schemathesis/compare/v4.3.1...v4.3.2) - 2025-10-14
+
+### :bug: Fixed
+
+- Incorrect reference resolution scope change when resolving responses. [#1184](https://github.com/schemathesis/schemathesis/issues/1184)
+
+### :wrench: Changed
+
+- Display cycles in error messages for infinitely recursive schemas.
+
+## [4.3.1](https://github.com/schemathesis/schemathesis/compare/v4.3.0...v4.3.1) - 2025-10-14
+
+### :bug: Fixed
+
+- Path parameters with unsupported regex patterns now use sample values instead of failing generation during the coverage phase.
+
+### :wrench: Changed
+
+- Response schema validation errors now display the failing keyword first to prevent truncation.
+- Support more scenarios for dependency inference.
+
+### :racing_car: Performance
+
+- Up to 2x performance improvement for dependency inference.
 
 ## [4.3.0](https://github.com/schemathesis/schemathesis/compare/v4.2.2...v4.3.0) - 2025-10-13
 

{schemathesis-4.3.0 → schemathesis-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.0
+Version: 4.3.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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.3.0 → schemathesis-4.3.2}/docs/reference/cli.md

@@ -500,7 +500,15 @@ These options control how Schemathesis generates test data for API testing:
     **Type**: `Integer`  
     **Range**: `≥1`  
 
-    Maximum number of test cases per API operation.
+    Maximum number of test cases generated per API operation. Must be greater than or equal to 1.
+
+    Schemathesis generates diverse examples based on your API schema, distributed across enabled generation modes (e.g., positive and negative test cases). See [Data Generation](../explanations/data-generation.md) for details.
+
+    This setting has different effects depending on the test phase:
+
+    - In **fuzzing** phase: Controls the maximum number of examples generated per API operation
+    - In **stateful** phase: Determines the maximum number of distinct API call sequences
+    - In **examples** and **coverage** phases: Has no effect, as these use predetermined test cases
 
     ```console
     $ st run openapi.yaml --max-examples 100

{schemathesis-4.3.0 → schemathesis-4.3.2}/docs/reference/configuration.md

@@ -822,6 +822,8 @@ The following settings control how Schemathesis generates test data for your API
 
     Maximum number of test cases generated per API operation. Must be greater than or equal to 1.
 
+    Schemathesis generates diverse examples based on your API schema, distributed across enabled generation modes (e.g., positive and negative test cases). See [Data Generation](../explanations/data-generation.md) for details.
+
     This setting has different effects depending on the test phase:
 
     - In **fuzzing** phase: Controls the maximum number of examples generated per API operation

{schemathesis-4.3.0 → schemathesis-4.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.0"
+version = "4.3.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-4.3.0 → schemathesis-4.3.2}/src/schemathesis/core/errors.py

@@ -298,13 +298,17 @@ class UnresolvableReference(SchemathesisError):
 
 
 class InfiniteRecursiveReference(SchemathesisError):
-    """Required recursive reference creates a cycle."""
+    """A schema has required references forming an infinite cycle."""
 
-    def __init__(self, reference: str) -> None:
+    def __init__(self, reference: str, cycle: list[str]) -> None:
         self.reference = reference
+        self.cycle = cycle
 
     def __str__(self) -> str:
-        return f"Required reference `{self.reference}` creates a cycle"
+        if len(self.cycle) == 1:
+            return f"Schema `{self.reference}` has a required reference to itself"
+        cycle_str = " ->\n  ".join(self.cycle + [self.cycle[0]])
+        return f"Schema `{self.reference}` has required references forming a cycle:\n\n  {cycle_str}"
 
 
 class SerializationNotPossible(SerializationError):

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/core/jsonschema/bundler.py

@@ -73,7 +73,9 @@ class Bundler:
                         raise BundleError(reference, resolved_schema)
                     def_name = get_def_name(resolved_uri)
 
-                    is_recursive_reference = resolved_uri in resolver._scopes_stack
+                    scopes = resolver._scopes_stack
+
+                    is_recursive_reference = resolved_uri in scopes
                     has_recursive_references |= is_recursive_reference
                     if inline_recursive and is_recursive_reference:
                         # This is a recursive reference! As of Sep 2025, `hypothesis-jsonschema` does not support
@@ -91,9 +93,9 @@ class Bundler:
                         cloned = deepclone(resolved_schema)
                         remaining_references = sanitize(cloned)
                         if reference in remaining_references:
-                            # This schema is either infinitely recursive or the sanitization logic misses it, in any
-                            # event, we git up here
-                            raise InfiniteRecursiveReference(reference)
+                            # This schema is either infinitely recursive or the sanitization logic misses it
+                            cycle = scopes[scopes.index(resolved_uri) :]
+                            raise InfiniteRecursiveReference(reference, cycle)
 
                         result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
                         # Recursive references need `$ref` to be in them, which is only possible with `dict`

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/generation/hypothesis/builder.py

@@ -579,8 +579,16 @@ def _iter_coverage_cases(
                     ),
                     schema,
                 )
-                value = next(gen, NOT_SET)
-                assert not isinstance(value, NotSet), f"It should always be possible: {schema!r}"
+                value = next(
+                    gen,
+                    coverage.GeneratedValue(
+                        "value",
+                        generation_mode=GenerationMode.NEGATIVE,
+                        description="Sample value for unsupported path parameter pattern",
+                        parameter=name,
+                        location="/",
+                    ),
+                )
                 template.add_parameter(location, name, value)
                 continue
             continue

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/openapi/checks.py

@@ -125,8 +125,20 @@ class JsonSchemaError(Failure):
         exc: ValidationError,
         config: OutputConfig | None = None,
     ) -> JsonSchemaError:
+        schema_path = list(exc.absolute_schema_path)
+
+        # Reorder schema to prioritize the failing keyword in the output
+        schema_to_display = exc.schema
+        if isinstance(schema_to_display, dict) and schema_path:
+            failing_keyword = schema_path[-1]
+            if isinstance(failing_keyword, str) and failing_keyword in schema_to_display:
+                # Create a new dict with the failing keyword first
+                schema_to_display = {
+                    failing_keyword: schema_to_display[failing_keyword],
+                    **{k: v for k, v in schema_to_display.items() if k != failing_keyword},
+                }
         schema = textwrap.indent(
-            truncate_json(exc.schema, config=config or OutputConfig(), max_lines=20), prefix="    "
+            truncate_json(schema_to_display, config=config or OutputConfig(), max_lines=20), prefix="    "
         )
         value = textwrap.indent(
             truncate_json(exc.instance, config=config or OutputConfig(), max_lines=20), prefix="    "

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/specs/openapi/adapter/responses.py

@@ -177,11 +177,11 @@ def _iter_resolved_responses(
 ) -> Iterator[tuple[str, OpenApiResponse]]:
     for key, response in definition.items():
         status_code = str(key)
-        scope, resolved = maybe_resolve(response, resolver, scope)
+        new_scope, resolved = maybe_resolve(response, resolver, scope)
         yield (
             status_code,
             OpenApiResponse(
-                status_code=status_code, definition=resolved, resolver=resolver, scope=scope, adapter=adapter
+                status_code=status_code, definition=resolved, resolver=resolver, scope=new_scope, adapter=adapter
             ),
         )
 
@@ -300,10 +300,10 @@ def _iter_resolved_headers(
     definition: types.v3.Headers, resolver: RefResolver, scope: str, adapter: SpecificationAdapter
 ) -> Iterator[tuple[str, OpenApiResponseHeader]]:
     for name, header in definition.items():
-        scope, resolved = maybe_resolve(header, resolver, scope)
+        new_scope, resolved = maybe_resolve(header, resolver, scope)
         yield (
             name,
-            OpenApiResponseHeader(name=name, definition=resolved, resolver=resolver, scope=scope, adapter=adapter),
+            OpenApiResponseHeader(name=name, definition=resolved, resolver=resolver, scope=new_scope, adapter=adapter),
         )
 
 

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/specs/openapi/examples.py

@@ -219,7 +219,8 @@ def _resolve_bundled(
                 # Try to remove recursive references to avoid infinite recursion
                 remaining_references = references.sanitize(schema)
                 if reference in remaining_references:
-                    raise InfiniteRecursiveReference(reference)
+                    cycle = list(reference_path[reference_path.index(reference) :])
+                    raise InfiniteRecursiveReference(reference, cycle)
 
             new_path = reference_path + (reference,)
 

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -26,12 +26,184 @@ def from_path(path: str) -> str | None:
     return to_pascal_case(singular)
 
 
+IRREGULAR_TO_PLURAL = {
+    "echo": "echoes",
+    "dingo": "dingoes",
+    "volcano": "volcanoes",
+    "tornado": "tornadoes",
+    "torpedo": "torpedoes",
+    "genus": "genera",
+    "viscus": "viscera",
+    "stigma": "stigmata",
+    "stoma": "stomata",
+    "dogma": "dogmata",
+    "lemma": "lemmata",
+    "anathema": "anathemata",
+    "ox": "oxen",
+    "axe": "axes",
+    "die": "dice",
+    "yes": "yeses",
+    "foot": "feet",
+    "eave": "eaves",
+    "goose": "geese",
+    "tooth": "teeth",
+    "quiz": "quizzes",
+    "human": "humans",
+    "proof": "proofs",
+    "carve": "carves",
+    "valve": "valves",
+    "looey": "looies",
+    "thief": "thieves",
+    "groove": "grooves",
+    "pickaxe": "pickaxes",
+    "passerby": "passersby",
+    "canvas": "canvases",
+    "use": "uses",
+    "case": "cases",
+    "vase": "vases",
+    "house": "houses",
+    "mouse": "mice",
+    "reuse": "reuses",
+    "abuse": "abuses",
+    "excuse": "excuses",
+    "cause": "causes",
+    "pause": "pauses",
+    "base": "bases",
+    "phase": "phases",
+    "rose": "roses",
+    "dose": "doses",
+    "nose": "noses",
+    "horse": "horses",
+    "course": "courses",
+    "purpose": "purposes",
+    "response": "responses",
+    "sense": "senses",
+    "tense": "tenses",
+    "expense": "expenses",
+    "license": "licenses",
+    "defense": "defenses",
+}
+IRREGULAR_TO_SINGULAR = {v: k for k, v in IRREGULAR_TO_PLURAL.items()}
+UNCOUNTABLE = frozenset(
+    [
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        "sheep",
+        "deer",
+        "species",
+        "series",
+        "means",
+    ]
+)
+
+
 def to_singular(word: str) -> str:
-    if word.endswith("ies"):
+    if word in UNCOUNTABLE:
+        return word
+    known = IRREGULAR_TO_SINGULAR.get(word)
+    if known is not None:
+        return known
+    if word.endswith("ies") and len(word) > 3 and word[-4] not in "aeiou":
         return word[:-3] + "y"
     if word.endswith("sses"):
         return word[:-2]
-    if word.endswith(("ses", "xes", "zes", "ches", "shes")):
+    if word.endswith(("xes", "zes", "ches", "shes")):
+        return word[:-2]
+    # Handle "ses" ending: check if it was "se" + "s" or "s" + "es"
+    if word.endswith("ses") and len(word) > 3:
+        # "gases" has 's' at position -3, formed from "gas" + "es"
+        # "statuses" has 's' at position -3, formed from "status" + "es"
         return word[:-2]
     if word.endswith("s"):
         return word[:-1]
@@ -39,8 +211,13 @@ def to_singular(word: str) -> str:
 
 
 def to_plural(word: str) -> str:
-    # party -> parties (inverse of ies -> y)
-    if word.endswith("y"):
+    if word in UNCOUNTABLE:
+        return word
+    known = IRREGULAR_TO_PLURAL.get(word)
+    if known is not None:
+        return known
+    # Only change y -> ies after consonants (party -> parties, not day -> days)
+    if word.endswith("y") and len(word) > 1 and word[-2] not in "aeiou":
         return word[:-1] + "ies"
     # class -> classes
     if word.endswith("ss"):

{schemathesis-4.3.0 → schemathesis-4.3.2}/src/schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -91,6 +91,13 @@ def iter_resources_from_response(
     parent_ref = schema.get("$ref")
     _, resolved = maybe_resolve(schema, resolver, "")
 
+    # Sometimes data is wrapped in `data` field
+    pointer = None
+    properties = resolved.get("properties", {})
+    if properties and list(properties) == ["data"]:
+        pointer = "/data"
+        resolved = properties["data"]
+
     resolved = try_unwrap_composition(resolved, resolver)
 
     if "allOf" in resolved:
@@ -130,7 +137,12 @@ def iter_resources_from_response(
 
     if result is not None:
         resource, cardinality = result
-        yield ExtractedResource(resource=resource, cardinality=cardinality, pointer=unwrapped.pointer)
+        if pointer:
+            if unwrapped.pointer != ROOT_POINTER:
+                pointer += unwrapped.pointer
+        else:
+            pointer = unwrapped.pointer
+        yield ExtractedResource(resource=resource, cardinality=cardinality, pointer=pointer)
 
 
 def _recover_ref_from_allof(*, branches: list[dict], pointer: str, resolver: RefResolver) -> str | None: