schemathesis 4.3.0__tar.gz → 4.3.1__tar.gz

{schemathesis-4.3.0 → schemathesis-4.3.1}/.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.1}/.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.1}/.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.1}/.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.1}/.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.1}/.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.1}/.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.1}/.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.1}/CHANGELOG.md

@@ -1,6 +1,21 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.0...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.1...HEAD) - TBD
+
+## [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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.0
+Version: 4.3.1
 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.1}/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.1}/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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.0"
+version = "4.3.1"
 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.1}/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.1}/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.1}/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.1}/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:

{schemathesis-4.3.0 → schemathesis-4.3.1}/src/schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -1,10 +1,20 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any, Callable, Mapping
+
+from hypothesis_jsonschema._canonicalise import (
+    SCHEMA_KEYS as SCHEMA_KEYS_TUPLE,
+)
+from hypothesis_jsonschema._canonicalise import (
+    SCHEMA_OBJECT_KEYS as SCHEMA_OBJECT_KEYS_TUPLE,
+)
+from hypothesis_jsonschema._canonicalise import canonicalish, merged
 
 from schemathesis.core.jsonschema import ALL_KEYWORDS
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY, bundle
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
+from schemathesis.core.transforms import encode_pointer
 from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
 from schemathesis.specs.openapi.adapter.references import maybe_resolve
 from schemathesis.specs.openapi.stateful.dependencies import naming
@@ -13,19 +23,71 @@ if TYPE_CHECKING:
     from schemathesis.core.compat import RefResolver
 
 ROOT_POINTER = "/"
+SCHEMA_KEYS = frozenset(SCHEMA_KEYS_TUPLE)
+SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS_TUPLE)
+
+
+def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
+    if not schema:
+        return schema
+    bundled = schema.get(BUNDLE_STORAGE_KEY, {})
+
+    resolved_cache: dict[str, dict[str, Any]] = {}
+
+    def resolve(ref: str) -> dict[str, Any]:
+        # All references here are bundled, therefore it is safe to avoid full reference resolving
+        if ref in resolved_cache:
+            return resolved_cache[ref]
+        key = ref.split("/")[-1]
+        # No clone needed, as it will be cloned inside `merged`
+        result = resolve_all_refs_inner(bundled[key], resolve=resolve)
+        resolved_cache[ref] = result
+        return result
+
+    return resolve_all_refs_inner(schema, resolve=resolve)
+
+
+def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[str, Any]]) -> dict[str, Any]:
+    if schema is True:
+        return {}
+    if schema is False:
+        return {"not": {}}
+    if not schema:
+        return schema
+
+    reference = schema.get("$ref")
+    if reference is not None:
+        resolved = resolve(reference)
+        if len(schema) == 1 or (len(schema) == 2 and BUNDLE_STORAGE_KEY in schema):
+            return resolved
+        del schema["$ref"]
+        schema.pop(BUNDLE_STORAGE_KEY, None)
+        schema.pop("example", None)
+        return merged([resolve_all_refs_inner(schema, resolve=resolve), resolved])  # type: ignore
+
+    for key, value in schema.items():
+        if key in SCHEMA_KEYS:
+            if isinstance(value, list):
+                schema[key] = [resolve_all_refs_inner(v, resolve=resolve) if isinstance(v, dict) else v for v in value]
+            elif isinstance(value, dict):
+                schema[key] = resolve_all_refs_inner(value, resolve=resolve)
+        if key in SCHEMA_OBJECT_KEYS:
+            schema[key] = {
+                k: resolve_all_refs_inner(v, resolve=resolve) if isinstance(v, dict) else v for k, v in value.items()
+            }
+    return schema
 
 
 def canonicalize(schema: dict[str, Any], resolver: RefResolver) -> Mapping[str, Any]:
     """Transform the input schema into its canonical-ish form."""
-    from hypothesis_jsonschema._canonicalise import canonicalish
-    from hypothesis_jsonschema._resolve import resolve_all_refs
-
     # Canonicalisation in `hypothesis_jsonschema` requires all references to be resovable and non-recursive
     # On the Schemathesis side bundling solves this problem
     bundled = bundle(schema, resolver, inline_recursive=True)
     canonicalized = canonicalish(bundled)
     resolved = resolve_all_refs(canonicalized)
     resolved.pop(BUNDLE_STORAGE_KEY, None)
+    if "allOf" in resolved or "anyOf" in resolved or "oneOf" in resolved:
+        return canonicalish(resolved)
     return resolved
 
 
@@ -149,16 +211,28 @@ def unwrap_schema(
         _, resolved_resource = maybe_resolve(resource_schema, resolver, "")
 
         return UnwrappedSchema(
-            pointer=f"/_embedded/{hal_field}", schema=resolved_resource, ref=resource_schema.get("$ref")
+            pointer=f"/_embedded/{encode_pointer(hal_field)}", schema=resolved_resource, ref=resource_schema.get("$ref")
         )
 
     # Pagination wrapper
     array_field = _is_pagination_wrapper(schema=schema, path=path, parent_ref=parent_ref, resolver=resolver)
     if array_field:
         array_schema = properties[array_field]
-        _, resolved_array = maybe_resolve(array_schema, resolver, "")
-
-        return UnwrappedSchema(pointer=f"/{array_field}", schema=resolved_array, ref=array_schema.get("$ref"))
+        _, resolved = maybe_resolve(array_schema, resolver, "")
+        pointer = f"/{encode_pointer(array_field)}"
+
+        # Try to unwrap one more time
+        if resolved.get("type") == "array" or "items" in resolved:
+            nested_items = resolved.get("items")
+            if isinstance(nested_items, dict):
+                _, resolved_items = maybe_resolve(nested_items, resolver, "")
+                external_tag = _detect_externally_tagged_pattern(resolved_items, path)
+                if external_tag:
+                    nested_properties = resolved_items["properties"][external_tag]
+                    _, resolved = maybe_resolve(nested_properties, resolver, "")
+                    pointer += f"/{encode_pointer(external_tag)}"
+
+        return UnwrappedSchema(pointer=pointer, schema=resolved, ref=array_schema.get("$ref"))
 
     # External tag
     external_tag = _detect_externally_tagged_pattern(schema, path)
@@ -170,7 +244,7 @@ def unwrap_schema(
         ref = resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
 
         _, resolved = maybe_resolve(resolved, resolver, "")
-        return UnwrappedSchema(pointer=f"/{external_tag}", schema=resolved, ref=ref)
+        return UnwrappedSchema(pointer=f"/{encode_pointer(external_tag)}", schema=resolved, ref=ref)
 
     # No wrapper - single object at root
     return UnwrappedSchema(pointer="/", schema=schema, ref=schema.get("$ref"))
@@ -326,11 +400,14 @@ def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> s
     if not resource_name:
         return None
 
+    # For example, for `DataRequest`:
     possible_names = {
-        # "merchant"
+        # `datarequest`
         resource_name.lower(),
-        # "merchants"
+        # `datarequests`
         naming.to_plural(resource_name.lower()),
+        # `data_request`
+        naming.to_snake_case(resource_name),
     }
 
     for name, subschema in properties.items():

{schemathesis-4.3.0 → schemathesis-4.3.1}/test/coverage/test_phase.py

@@ -1812,6 +1812,26 @@ def test_path_parameters_without_constraints_negative(ctx):
     )
 
 
+def test_path_parameters_with_unsupported_regex_pattern(ctx):
+    schema = build_schema(
+        ctx,
+        [
+            {
+                "name": "foo_id",
+                "in": "path",
+                "required": True,
+                "schema": {"pattern": "'^[-._\\p{L}\\p{N}]+$'"},
+            },
+        ],
+        path="/foo/{foo_id}",
+    )
+    assert_negative_coverage(
+        schema,
+        [],
+        ("/foo/{foo_id}", "post"),
+    )
+
+
 def test_query_without_constraints_negative(ctx):
     # When there are no constraints, then we can't generate negative values as everything will match the previous schema, only missing parameter
     schema = build_schema(