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

schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+
+def from_parameter(parameter: str, path: str) -> str | None:
+    # TODO: support other naming patterns
+    # Named like "userId" -> look for "User" resource
+    if parameter.endswith("Id"):
+        return to_pascal_case(parameter[:-2])
+    # Named like "user_id" -> look for "User" resource
+    elif parameter.endswith("_id"):
+        return to_pascal_case(parameter[:-3])
+    # Just "id" -> infer from path context
+    elif parameter == "id":
+        return from_path(path)
+    return None
+
+
+def from_path(path: str) -> str | None:
+    segments = [s for s in path.split("/") if s and "{" not in s]
+
+    if not segments:
+        # API Root
+        return None
+
+    singular = to_singular(segments[-1])
+    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 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(("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]
+    return word
+
+
+def to_plural(word: str) -> str:
+    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"):
+        return word + "es"
+    # words that normally take -es: box -> boxes
+    if word.endswith(("s", "x", "z", "ch", "sh")):
+        return word + "es"
+    # just add 's' (car -> cars)
+    return word + "s"
+
+
+def to_pascal_case(text: str) -> str:
+    parts = text.replace("-", "_").split("_")
+    return "".join(word.capitalize() for word in parts if word)
+
+
+def to_snake_case(text: str) -> str:
+    text = text.replace("-", "_")
+    # Insert underscores before uppercase letters
+    result = []
+    for i, char in enumerate(text):
+        # Add underscore before uppercase (except at start)
+        if i > 0 and char.isupper():
+            result.append("_")
+        result.append(char.lower())
+    return "".join(result)
+
+
+def find_matching_field(*, parameter: str, resource: str, fields: list[str]) -> str | None:
+    """Find which resource field matches the parameter name."""
+    if not fields:
+        return None
+
+    # Exact match
+    if parameter in fields:
+        return parameter
+
+    # Normalize for fuzzy matching
+    parameter_normalized = _normalize_for_matching(parameter)
+    resource_normalized = _normalize_for_matching(resource)
+
+    # Normalized exact match
+    # `brandId` -> `Brand.BrandId`
+    for field in fields:
+        if _normalize_for_matching(field) == parameter_normalized:
+            return field
+
+    # Extract parameter components
+    parameter_prefix, param_suffix = _split_parameter_name(parameter)
+    parameter_prefix_normalized = _normalize_for_matching(parameter_prefix)
+
+    # Parameter has resource prefix, field might not
+    # Example: `channelId` - `Channel.id`
+    if parameter_prefix and parameter_prefix_normalized == resource_normalized:
+        suffix_normalized = _normalize_for_matching(param_suffix)
+
+        for field in fields:
+            field_normalized = _normalize_for_matching(field)
+            if field_normalized == suffix_normalized:
+                return field
+
+    # Parameter has no prefix, field might have resource prefix
+    # Example: `id` - `Channel.channelId`
+    if not parameter_prefix and param_suffix:
+        expected_field_normalized = resource_normalized + _normalize_for_matching(param_suffix)
+
+        for field in fields:
+            field_normalized = _normalize_for_matching(field)
+            if field_normalized == expected_field_normalized:
+                return field
+
+    return None
+
+
+def _normalize_for_matching(text: str) -> str:
+    """Normalize text for case-insensitive, separator-insensitive matching.
+
+    Examples:
+        "channelId" -> "channelid"
+        "channel_id" -> "channelid"
+        "ChannelId" -> "channelid"
+        "Channel" -> "channel"
+
+    """
+    return text.lower().replace("_", "").replace("-", "")
+
+
+def _split_parameter_name(param_name: str) -> tuple[str, str]:
+    """Split parameter into (prefix, suffix) components.
+
+    Examples:
+        "channelId" -> ("channel", "Id")
+        "userId" -> ("user", "Id")
+        "user_id" -> ("user", "_id")
+        "id" -> ("", "id")
+        "channel_id" -> ("channel", "_id")
+
+    """
+    if param_name.endswith("Id") and len(param_name) > 2:
+        return (param_name[:-2], "Id")
+
+    if param_name.endswith("_id") and len(param_name) > 3:
+        return (param_name[:-3], "_id")
+
+    return ("", param_name)
+
+
+def strip_affixes(name: str, prefixes: list[str], suffixes: list[str]) -> str:
+    """Remove common prefixes and suffixes from a name (case-insensitive)."""
+    result = name.strip()
+    name_lower = result.lower()
+
+    # Remove one matching prefix
+    for prefix in prefixes:
+        if name_lower.startswith(prefix):
+            result = result[len(prefix) :]
+            break
+
+    # Remove one matching suffix
+    for suffix in suffixes:
+        if name_lower.endswith(suffix):
+            result = result[: -len(suffix)]
+            break
+
+    return result.strip()

schemathesis/specs/openapi/stateful/dependencies/outputs.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterator
+
+from schemathesis.specs.openapi.stateful.dependencies.models import CanonicalizationCache, OutputSlot, ResourceMap
+from schemathesis.specs.openapi.stateful.dependencies.resources import extract_resources_from_responses
+
+if TYPE_CHECKING:
+    from schemathesis.core.compat import RefResolver
+    from schemathesis.specs.openapi.schemas import APIOperation
+
+
+def extract_outputs(
+    *,
+    operation: APIOperation,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> Iterator[OutputSlot]:
+    """Extract resources from API operation's responses."""
+    for response, extracted in extract_resources_from_responses(
+        operation=operation,
+        resources=resources,
+        updated_resources=updated_resources,
+        resolver=resolver,
+        canonicalization_cache=canonicalization_cache,
+    ):
+        yield OutputSlot(
+            resource=extracted.resource,
+            pointer=extracted.pointer,
+            cardinality=extracted.cardinality,
+            status_code=response.status_code,
+        )

schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterator, Mapping, cast
+
+from schemathesis.core.errors import InfiniteRecursiveReference
+from schemathesis.core.jsonschema.bundler import BundleError
+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
+from schemathesis.specs.openapi.stateful.dependencies.models import (
+    CanonicalizationCache,
+    Cardinality,
+    DefinitionSource,
+    ResourceDefinition,
+    ResourceMap,
+)
+from schemathesis.specs.openapi.stateful.dependencies.naming import from_path
+from schemathesis.specs.openapi.stateful.dependencies.schemas import (
+    ROOT_POINTER,
+    canonicalize,
+    try_unwrap_composition,
+    unwrap_schema,
+)
+
+if TYPE_CHECKING:
+    from schemathesis.core.compat import RefResolver
+    from schemathesis.schemas import APIOperation
+    from schemathesis.specs.openapi.adapter.responses import OpenApiResponse
+
+
+@dataclass
+class ExtractedResource:
+    """How a resource was extracted from a response."""
+
+    resource: ResourceDefinition
+    # Where in response body (JSON pointer)
+    pointer: str
+    # Is this a single resource or an array?
+    cardinality: Cardinality
+
+    __slots__ = ("resource", "pointer", "cardinality")
+
+
+def extract_resources_from_responses(
+    *,
+    operation: APIOperation,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> Iterator[tuple[OpenApiResponse, ExtractedResource]]:
+    """Extract resource definitions from operation's successful responses.
+
+    Processes each 2xx response, unwrapping pagination wrappers,
+    handling `allOf` / `oneOf` / `anyOf` composition, and determining cardinality.
+    Updates the global resource registry as resources are discovered.
+    """
+    for response in operation.responses.iter_successful_responses():
+        for extracted in iter_resources_from_response(
+            path=operation.path,
+            response=response,
+            resources=resources,
+            updated_resources=updated_resources,
+            resolver=resolver,
+            canonicalization_cache=canonicalization_cache,
+        ):
+            yield response, extracted
+
+
+def iter_resources_from_response(
+    *,
+    path: str,
+    response: OpenApiResponse,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> Iterator[ExtractedResource]:
+    schema = response.get_raw_schema()
+
+    if isinstance(schema, bool):
+        boolean_resource = _resource_from_boolean_schema(path=path, resources=resources)
+        if boolean_resource is not None:
+            yield boolean_resource
+        return None
+    elif not isinstance(schema, dict):
+        # Ignore invalid schemas
+        return None
+
+    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:
+        if parent_ref is not None and parent_ref in canonicalization_cache:
+            canonicalized = canonicalization_cache[parent_ref]
+        else:
+            try:
+                canonicalized = canonicalize(cast(dict, resolved), resolver)
+            except (InfiniteRecursiveReference, BundleError):
+                canonicalized = resolved
+            if parent_ref is not None:
+                canonicalization_cache[parent_ref] = canonicalized
+    else:
+        canonicalized = resolved
+
+    # Detect wrapper pattern and navigate to data
+    unwrapped = unwrap_schema(schema=canonicalized, path=path, parent_ref=parent_ref, resolver=resolver)
+
+    # Recover $ref lost during allOf canonicalization
+    recovered_ref = None
+    if unwrapped.pointer != ROOT_POINTER and "allOf" in resolved:
+        recovered_ref = _recover_ref_from_allof(
+            branches=resolved["allOf"],
+            pointer=unwrapped.pointer,
+            resolver=resolver,
+        )
+
+    # Extract resource and determine cardinality
+    result = _extract_resource_and_cardinality(
+        schema=unwrapped.schema,
+        path=path,
+        resources=resources,
+        updated_resources=updated_resources,
+        resolver=resolver,
+        parent_ref=recovered_ref or unwrapped.ref or parent_ref,
+    )
+
+    if result is not None:
+        resource, cardinality = result
+        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:
+    """Recover original $ref from allOf branches after canonicalization.
+
+    Canonicalization inlines all $refs, losing resource name information.
+    This searches original allOf branches to find which one defined the
+    property at the given pointer.
+    """
+    # Parse pointer segments (e.g., "/data" -> ["data"])
+    segments = [s for s in pointer.strip("/").split("/") if s]
+
+    # Search each branch for the property
+    for branch in branches:
+        _, resolved_branch = maybe_resolve(branch, resolver, "")
+        properties = resolved_branch.get("properties", {})
+
+        # Check if this branch defines the target property
+        if segments[-1] in properties:
+            # Navigate to property in original (unresolved) branch
+            original_properties = branch.get("properties", {})
+            if segments[-1] in original_properties:
+                prop_schema = original_properties[segments[-1]]
+                # Extract $ref from property or its items
+                return prop_schema.get("$ref") or prop_schema.get("items", {}).get("$ref")
+
+    return None
+
+
+def _resource_from_boolean_schema(*, path: str, resources: ResourceMap) -> ExtractedResource | None:
+    name = from_path(path)
+    if name is None:
+        return None
+    resource = resources.get(name)
+    if resource is None:
+        resource = ResourceDefinition.without_properties(name)
+        resources[name] = resource
+    # Do not update existing resource as if it is inferred, it will have at least one field
+    return ExtractedResource(resource=resource, cardinality=Cardinality.ONE, pointer=ROOT_POINTER)
+
+
+def _extract_resource_and_cardinality(
+    *,
+    schema: Mapping[str, Any],
+    path: str,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    parent_ref: str | None = None,
+) -> tuple[ResourceDefinition, Cardinality] | None:
+    """Extract resource from schema and determine cardinality."""
+    # Check if it's an array
+    if schema.get("type") == "array" or "items" in schema:
+        items = schema.get("items")
+        if not isinstance(items, dict):
+            return None
+
+        # Resolve items if it's a $ref
+        _, resolved_items = maybe_resolve(items, resolver, "")
+
+        # Extract resource from items
+        resource = _extract_resource_from_schema(
+            schema=resolved_items,
+            path=path,
+            resources=resources,
+            updated_resources=updated_resources,
+            resolver=resolver,
+            # Prefer items $ref for name
+            parent_ref=items.get("$ref") or parent_ref,
+        )
+
+        if resource is None:
+            return None
+
+        return resource, Cardinality.MANY
+
+    # Single object
+    resource = _extract_resource_from_schema(
+        schema=schema,
+        path=path,
+        resources=resources,
+        updated_resources=updated_resources,
+        resolver=resolver,
+        parent_ref=parent_ref,
+    )
+
+    if resource is None:
+        return None
+
+    return resource, Cardinality.ONE
+
+
+def _extract_resource_from_schema(
+    *,
+    schema: Mapping[str, Any],
+    path: str,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    parent_ref: str | None = None,
+) -> ResourceDefinition | None:
+    """Extract resource definition from a schema."""
+    resource_name: str | None = None
+
+    ref = schema.get("$ref")
+    if ref is not None:
+        resource_name = resource_name_from_ref(ref)
+    elif parent_ref is not None:
+        resource_name = resource_name_from_ref(parent_ref)
+    else:
+        resource_name = naming.from_path(path)
+
+    if resource_name is None:
+        return None
+
+    resource = resources.get(resource_name)
+
+    if resource is None or resource.source < DefinitionSource.SCHEMA_WITH_PROPERTIES:
+        _, resolved = maybe_resolve(schema, resolver, "")
+
+        properties = resolved.get("properties")
+        if properties:
+            fields = list(properties)
+            source = DefinitionSource.SCHEMA_WITH_PROPERTIES
+        else:
+            fields = []
+            source = DefinitionSource.SCHEMA_WITHOUT_PROPERTIES
+        if resource is not None:
+            if resource.source < source:
+                resource.source = source
+                resource.fields = fields
+                updated_resources.add(resource_name)
+        else:
+            resource = ResourceDefinition(name=resource_name, fields=fields, source=source)
+            resources[resource_name] = resource
+
+    return resource