schemathesis 4.3.0__py3-none-any.whl → 4.3.1__py3-none-any.whl

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/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/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/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/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.dist-info → schemathesis-4.3.1.dist-info}/METADATA

@@ -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.dist-info → schemathesis-4.3.1.dist-info}/RECORD

@@ -99,7 +99,7 @@ schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
-schemathesis/generation/hypothesis/builder.py,sha256=ZdY68aDGeZLLtIld288KF_O6ardFKZdFMBogwltTx2o,38362
+schemathesis/generation/hypothesis/builder.py,sha256=tnDN_0MNT48mAO421JmcI3E0U2zeeTX-mjF3KXmpc7A,38629
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -110,7 +110,7 @@ schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
 schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
-schemathesis/openapi/checks.py,sha256=VaQRxko6KwZL6saIzc4uUgJa_fj086O7Y6QFK8Zg-7A,12419
+schemathesis/openapi/checks.py,sha256=nrkkagRqg-HOsDCAMbJqCnHyBZEA2PpRV_AB8lI_I9c,13080
 schemathesis/openapi/loaders.py,sha256=-DSFWcvD_PmekTyy0qZrJ1YYODh9C1KuAJJIytEnS1s,10733
 schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/openapi/generation/filters.py,sha256=pY9cUZdL_kQK80Z2aylTOqqa12zmaYUlYC5BfYgeQMk,2395
@@ -167,10 +167,10 @@ schemathesis/specs/openapi/stateful/links.py,sha256=G6vqW6JFOdhF044ZjG6PsSwAHU1y
 schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=epBYtVw7q9mkV-UtlJNbfJQgwAs9d5jkOJYkyEeUMvE,3348
 schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=5niLSz7-wl-sP9cJdnYBItwEeLuzJr3nw4XIMT3yt98,6764
 schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=4MXJzCat1bU-tmwAM7OH2dFBys_YHCJw9wTgd9Hib3c,9728
-schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=4cOlVf_diyHTcsYGjaGYEGbuAG4DaVkly_8z0Wwrjlo,5126
+schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=1aaa8vc56tsyOAKAvD8oPk55S-qbzrCBYe1kCk3Y9VY,9052
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
-schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=Kl-1SjbZPWbQn9-M5QQBMdEN-WIroxHKVzgbfNHyGuw,9273
-schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=oL3b-DWG7wsMzVyL-z99xb-6vg8fWryRD8voh__hK0Y,10734
+schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=7E2Z6LvomSRrp_0vCD_adzoux0wBLEjKi_EiSqiN43U,9664
+schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=pNV2GibNW8042KrdfUQBdJEkGj_dd84bTHbqunba48k,13976
 schemathesis/specs/openapi/types/__init__.py,sha256=VPsWtLJle__Kodw_QqtQ3OuvBzBcCIKsTOrXy3eA7OU,66
 schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzBXqerccLpo,1468
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
@@ -179,8 +179,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.0.dist-info/METADATA,sha256=AIqtw5GycgCYvcZZy6hzMZNTet6ckzc_Vdtkv2A0SyU,8540
-schemathesis-4.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.0.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.0.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.0.dist-info/RECORD,,
+schemathesis-4.3.1.dist-info/METADATA,sha256=cJcbDVPtmrVZIVWanF1tJxF1Vbhel76KAhpzJLj_KHs,8540
+schemathesis-4.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.1.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.1.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.1.dist-info/RECORD,,