schemathesis 4.3.11__py3-none-any.whl → 4.3.13__py3-none-any.whl

schemathesis/core/errors.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import enum
 import re
 import traceback
+from dataclasses import dataclass
+from textwrap import indent
 from types import TracebackType
 from typing import TYPE_CHECKING, Any, Callable, NoReturn
 
@@ -33,6 +35,60 @@ class SchemathesisError(Exception):
     """Base exception class for all Schemathesis errors."""
 
 
+class DefinitionKind(str, enum.Enum):
+    SCHEMA = "Schema Object"
+    SECURITY_SCHEME = "Security Scheme Object"
+    RESPONSES = "Responses Object"
+    PARAMETER = "Parameter Object"
+
+
+@dataclass
+class SchemaLocation:
+    kind: DefinitionKind
+    # Hint about where the definition is located
+    hint: str | None
+    # Open API spec version
+    version: str
+
+    __slots__ = ("kind", "hint", "version")
+
+    @classmethod
+    def response_schema(cls, version: str) -> SchemaLocation:
+        return cls(kind=DefinitionKind.SCHEMA, hint="in response definition", version=version)
+
+    @classmethod
+    def maybe_from_error_path(cls, path: list[str | int], version: str) -> SchemaLocation | None:
+        if len(path) == 3 and path[:2] == ["components", "securitySchemes"]:
+            return cls(kind=DefinitionKind.SECURITY_SCHEME, hint=f"definition for `{path[2]}`", version=version)
+        if len(path) == 3 and path[:2] == ["components", "schemas"]:
+            return cls(kind=DefinitionKind.SCHEMA, hint=f"definition for `{path[2]}`", version=version)
+        if len(path) == 4 and path[0] == "paths" and path[-1] == "responses":
+            return cls(kind=DefinitionKind.RESPONSES, hint=None, version=version)
+        if len(path) == 5 and path[0] == "paths" and path[3] == "parameters":
+            return cls(kind=DefinitionKind.PARAMETER, hint=f"at index {path[4]}", version=version)
+
+        return None
+
+    @property
+    def message(self) -> str:
+        message = f"Invalid {self.kind.value}"
+        if self.hint is not None:
+            message += f" {self.hint}"
+        else:
+            message += " definition"
+        return message
+
+    @property
+    def specification_url(self) -> str:
+        anchor = {
+            DefinitionKind.SCHEMA: "schema-object",
+            DefinitionKind.SECURITY_SCHEME: "security-scheme-object",
+            DefinitionKind.RESPONSES: "responses-object",
+            DefinitionKind.PARAMETER: "parameter-object",
+        }[self.kind]
+        return f"https://spec.openapis.org/oas/v{self.version}#{anchor}"
+
+
 class InvalidSchema(SchemathesisError):
     """Indicates errors in API schema validation or processing."""
 
@@ -56,9 +112,16 @@ class InvalidSchema(SchemathesisError):
 
     @classmethod
     def from_jsonschema_error(
-        cls, error: ValidationError | JsonSchemaError, path: str | None, method: str | None, config: OutputConfig
+        cls,
+        error: ValidationError | JsonSchemaError,
+        path: str | None,
+        method: str | None,
+        config: OutputConfig,
+        location: SchemaLocation | None = None,
     ) -> InvalidSchema:
-        if error.absolute_path:
+        if location is not None:
+            message = location.message
+        elif error.absolute_path:
             part = error.absolute_path[-1]
             if isinstance(part, int) and len(error.absolute_path) > 1:
                 parent = error.absolute_path[-2]
@@ -70,14 +133,18 @@ class InvalidSchema(SchemathesisError):
         error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
         instance = truncate_json(error.instance, config=config)
-        message += f"\n\nProblematic definition:\n{instance}"
+        message += f"\n\nProblematic definition:\n{indent(instance, '    ')}"
         message += "\n\nError details:\n    "
         # This default message contains the instance which we already printed
         if "is not valid under any of the given schemas" in error.message:
             message += "The provided definition doesn't match any of the expected formats or types."
         else:
             message += error.message
-        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        message += "\n\n"
+        if location is not None:
+            message += f"See: {location.specification_url}"
+        else:
+            message += SCHEMA_ERROR_SUGGESTION
         return cls(message, path=path, method=method)
 
     @classmethod
@@ -86,12 +153,14 @@ class InvalidSchema(SchemathesisError):
     ) -> InvalidSchema:
         notes = getattr(error, "__notes__", [])
         # Some exceptions don't have the actual reference in them, hence we add it manually via notes
-        pointer = f"'{notes[0]}'"
-        message = "Unresolvable JSON pointer in the schema"
+        reference = str(notes[0])
+        message = "Unresolvable reference in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
-        message += f"\n\nError details:\n    JSON pointer: {pointer}"
-        message += "\n    This typically means that the schema is referencing a component that doesn't exist."
-        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        message += f"\n\nError details:\n    Reference: {reference}"
+        if not reference.startswith(("http://", "https://", "#/")):
+            message += "\n    File reference could not be resolved. Check that the file exists."
+        elif reference.startswith(("#/components", "#/definitions")):
+            message += "\n    Component does not exist in the schema."
         return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
@@ -154,13 +223,13 @@ class InvalidStateMachine(SchemathesisError):
         for source, target_groups in by_source.items():
             for (target, status), transitions in target_groups.items():
                 for transition in transitions:
-                    result += f"\n\n  {_format_transition(source, status, transition.name, target)}\n"
+                    result += f"\n\n  {format_transition(source, status, transition.name, target)}\n"
                     for error in transition.errors:
                         result += f"\n     - {error.message}"
         return result
 
 
-def _format_transition(source: str, status: str, transition: str, target: str) -> str:
+def format_transition(source: str, status: str, transition: str, target: str) -> str:
     return f"{source} -> [{status}] {transition} -> {target}"
 
 

schemathesis/engine/phases/unit/_executor.py

@@ -25,6 +25,7 @@ from schemathesis.core.errors import (
     InvalidRegexType,
     InvalidSchema,
     MalformedMediaType,
+    SchemaLocation,
     SerializationNotPossible,
 )
 from schemathesis.core.failures import Failure, FailureGroup
@@ -198,6 +199,9 @@ def run_test(
                     path=operation.path,
                     method=operation.method,
                     config=ctx.config.output,
+                    location=SchemaLocation.maybe_from_error_path(
+                        list(exc.absolute_path), ctx.schema.specification.version
+                    ),
                 )
             )
     except InvalidArgument as exc:

schemathesis/generation/stateful/state_machine.py

@@ -37,16 +37,23 @@ class StepInput:
 
     case: Case
     transition: Transition | None  # None for initial steps
-    # Whether this transition was actually applied
+    # What parameters were actually applied
     # Data extraction failures can prevent it, as well as transitions can be skipped in some cases
     # to improve discovery of bugs triggered by non-stateful inputs during stateful testing
-    is_applied: bool
+    applied_parameters: list[str]
 
-    __slots__ = ("case", "transition", "is_applied")
+    __slots__ = ("case", "transition", "applied_parameters")
 
     @classmethod
     def initial(cls, case: Case) -> StepInput:
-        return cls(case=case, transition=None, is_applied=False)
+        return cls(case=case, transition=None, applied_parameters=[])
+
+    @property
+    def is_applied(self) -> bool:
+        # If the transition has no parameters or body, count it as applied
+        if self.transition is not None and not self.transition.parameters and self.transition.request_body is None:
+            return True
+        return bool(self.applied_parameters)
 
 
 @dataclass
@@ -69,8 +76,9 @@ class ExtractedParam:
 
     definition: Any
     value: Result[Any, Exception]
+    is_required: bool
 
-    __slots__ = ("definition", "value")
+    __slots__ = ("definition", "value", "is_required")
 
 
 @dataclass

schemathesis/specs/openapi/schemas.py

@@ -27,7 +27,13 @@ from requests.structures import CaseInsensitiveDict
 from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, Specification, deserialization, media_types
 from schemathesis.core.adapter import OperationParameter, ResponsesContainer
 from schemathesis.core.compat import RefResolutionError
-from schemathesis.core.errors import InfiniteRecursiveReference, InvalidSchema, OperationNotFound
+from schemathesis.core.errors import (
+    SCHEMA_ERROR_SUGGESTION,
+    InfiniteRecursiveReference,
+    InvalidSchema,
+    OperationNotFound,
+    SchemaLocation,
+)
 from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.core.transport import Response
@@ -61,7 +67,6 @@ if TYPE_CHECKING:
     from schemathesis.generation.stateful import APIStateMachine
 
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
-SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, RefResolutionError, InvalidSchema, InfiniteRecursiveReference)
 
 
@@ -317,9 +322,13 @@ class BaseOpenAPISchema(BaseSchema):
             self.validate()
         except jsonschema.ValidationError as exc:
             raise InvalidSchema.from_jsonschema_error(
-                exc, path=path, method=method, config=self.config.output
+                exc,
+                path=path,
+                method=method,
+                config=self.config.output,
+                location=SchemaLocation.maybe_from_error_path(list(exc.absolute_path), self.specification.version),
             ) from None
-        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method) from error
+        raise InvalidSchema(SCHEMA_ERROR_SUGGESTION, path=path, method=method) from error
 
     def validate(self) -> None:
         with suppress(TypeError):
@@ -540,7 +549,11 @@ class BaseOpenAPISchema(BaseSchema):
             definition.validator.validate(data)
         except jsonschema.SchemaError as exc:
             raise InvalidSchema.from_jsonschema_error(
-                exc, path=operation.path, method=operation.method, config=self.config.output
+                exc,
+                path=operation.path,
+                method=operation.method,
+                config=self.config.output,
+                location=SchemaLocation.response_schema(self.specification.version),
             ) from exc
         except jsonschema.ValidationError as exc:
             failures.append(

schemathesis/specs/openapi/stateful/__init__.py

@@ -8,6 +8,7 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
+from schemathesis.core import NOT_SET
 from schemathesis.core.errors import InvalidStateMachine, InvalidTransition
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Ok
@@ -49,7 +50,7 @@ class OpenAPIStateMachine(APIStateMachine):
 # The proportion of negative tests generated for "root" transitions
 NEGATIVE_TEST_CASES_THRESHOLD = 10
 # How often some transition is skipped
-USE_TRANSITION_THRESHOLD = 85
+BASE_EXPLORATION_RATE = 0.15
 
 
 @dataclass
@@ -162,14 +163,12 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     for target in operations:
         if target.label in transitions.operations:
             incoming = transitions.operations[target.label].incoming
+            config = schema.config.generation_for(operation=target, phase="stateful")
             if incoming:
                 for link in incoming:
                     bundle_name = f"{link.source.label} -> {link.status_code}"
-                    name = _normalize_name(
-                        f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
-                    )
+                    name = _normalize_name(link.full_name)
                     assert name not in rules, name
-                    config = schema.config.generation_for(operation=target, phase="stateful")
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
@@ -181,7 +180,6 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                     )
             if target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
                 name = _normalize_name(f"RANDOM -> {target.label}")
-                config = schema.config.generation_for(operation=target, phase="stateful")
                 if len(config.modes) == 1:
                     case_strategy = target.as_strategy(generation_mode=config.modes[0], phase=TestPhase.STATEFUL)
                 else:
@@ -237,8 +235,8 @@ def classify_root_transitions(operations: list[APIOperation], transitions: ApiTr
 
 def is_likely_root_transition(operation: APIOperation) -> bool:
     """Check if operation is likely to succeed as a root transition."""
-    # POST operations with request bodies are likely to create resources
-    if operation.method == "post" and operation.body:
+    # POST operations are likely to create resources
+    if operation.method == "post":
         return True
 
     # GET operations without path parameters are likely to return lists
@@ -249,50 +247,97 @@ def is_likely_root_transition(operation: APIOperation) -> bool:
 
 
 def into_step_input(
-    target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
+    *, target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
 ) -> Callable[[StepOutput], st.SearchStrategy[StepInput]]:
+    """A single transition between API operations."""
+
     def builder(_output: StepOutput) -> st.SearchStrategy[StepInput]:
         @st.composite  # type: ignore[misc]
         def inner(draw: st.DrawFn, output: StepOutput) -> StepInput:
+            random = draw(st.randoms(use_true_random=True))
+
+            def biased_coin(p: float) -> bool:
+                return random.random() < p
+
+            # Extract transition data from previous operation's output
             transition = link.extract(output)
 
-            kwargs: dict[str, Any] = {
-                container: {
-                    name: extracted.value.ok()
-                    for name, extracted in data.items()
-                    if isinstance(extracted.value, Ok) and extracted.value.ok() not in (None, UNRESOLVABLE)
-                }
-                for container, data in transition.parameters.items()
-            }
+            overrides: dict[str, Any] = {}
+            applied_parameters = []
+            for container, data in transition.parameters.items():
+                overrides[container] = {}
+
+                for name, extracted in data.items():
+                    # Skip if extraction failed or returned unusable value
+                    if not isinstance(extracted.value, Ok) or extracted.value.ok() in (None, UNRESOLVABLE):
+                        continue
+
+                    param_key = f"{container}.{name}"
+
+                    # Calculate exploration rate based on parameter characteristics
+                    exploration_rate = BASE_EXPLORATION_RATE
+
+                    # Path parameters are critical for routing - use link values more often
+                    if container == "path_parameters":
+                        exploration_rate *= 0.5
+
+                    # Required parameters should follow links more often, optional ones explored more
+                    # Path params are always required, so they get both multipliers
+                    if extracted.is_required:
+                        exploration_rate *= 0.5
+                    else:
+                        # Explore optional parameters more to avoid only testing link-provided values
+                        exploration_rate *= 3.0
 
+                    if biased_coin(1 - exploration_rate):
+                        overrides[container][name] = extracted.value.ok()
+                        applied_parameters.append(param_key)
+
+            # Get the extracted body value
             if (
                 transition.request_body is not None
                 and isinstance(transition.request_body.value, Ok)
                 and transition.request_body.value.ok() is not UNRESOLVABLE
-                and not link.merge_body
-                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
             ):
-                kwargs["body"] = transition.request_body.value.ok()
-
-            is_applied = bool(kwargs)
+                request_body = transition.request_body.value.ok()
+            else:
+                request_body = NOT_SET
+
+            # Link suppose to replace the entire extracted body
+            if request_body is not NOT_SET and not link.merge_body and biased_coin(1 - BASE_EXPLORATION_RATE):
+                overrides["body"] = request_body
+                if isinstance(overrides["body"], dict):
+                    applied_parameters.extend(f"body.{field}" for field in overrides["body"])
+                else:
+                    applied_parameters.append("body")
 
             cases = st.one_of(
-                target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **kwargs) for mode in modes
+                [target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **overrides) for mode in modes]
             )
             case = draw(cases)
-            if (
-                transition.request_body is not None
-                and isinstance(transition.request_body.value, Ok)
-                and transition.request_body.value.ok() is not UNRESOLVABLE
-                and link.merge_body
-                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
-            ):
-                new = transition.request_body.value.ok()
-                if isinstance(case.body, dict) and isinstance(new, dict):
-                    case.body = {**case.body, **new}
-                else:
-                    case.body = new
-                is_applied = True
+            if request_body is not NOT_SET and link.merge_body:
+                if isinstance(request_body, dict):
+                    selected_fields = {}
+
+                    for field_name, field_value in request_body.items():
+                        if field_value is UNRESOLVABLE:
+                            continue
+
+                        if biased_coin(1 - BASE_EXPLORATION_RATE):
+                            selected_fields[field_name] = field_value
+                            applied_parameters.append(f"body.{field_name}")
+
+                    if selected_fields:
+                        if isinstance(case.body, dict):
+                            case.body = {**case.body, **selected_fields}
+                        else:
+                            # Can't merge into non-dict, replace entirely
+                            case.body = selected_fields
+                elif biased_coin(1 - BASE_EXPLORATION_RATE):
+                    case.body = request_body
+                    applied_parameters.append("body")
+
+                # Re-validate generation mode after merging body
                 if case.meta and case.meta.generation.mode == GenerationMode.NEGATIVE:
                     # It is possible that the new body is now valid and the whole test case could be valid too
                     for alternative in case.operation.body:
@@ -304,7 +349,7 @@ def into_step_input(
                                 )
                                 if all(info.mode == GenerationMode.POSITIVE for info in case.meta.components.values()):
                                     case.meta.generation.mode = GenerationMode.POSITIVE
-            return StepInput(case=case, transition=transition, is_applied=is_applied)
+            return StepInput(case=case, transition=transition, applied_parameters=applied_parameters)
 
         return inner(output=_output)
 

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

@@ -10,7 +10,11 @@ from typing import TYPE_CHECKING, Any
 from schemathesis.core import NOT_SET
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.result import Ok
-from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
+from schemathesis.specs.openapi.stateful.dependencies.inputs import (
+    extract_inputs,
+    merge_related_resources,
+    update_input_field_bindings,
+)
 from schemathesis.specs.openapi.stateful.dependencies.models import (
     CanonicalizationCache,
     Cardinality,
@@ -25,6 +29,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     ResourceMap,
 )
 from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
+from schemathesis.specs.openapi.stateful.dependencies.resources import remove_unused_resources
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -88,6 +93,12 @@ def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
     for resource in updated_resources:
         update_input_field_bindings(resource, operations)
 
+    # Merge parameter-inferred resources with schema-defined ones
+    merge_related_resources(operations, resources)
+
+    # Clean up orphaned resources
+    remove_unused_resources(operations, resources)
+
     return DependencyGraph(operations=operations, resources=resources)
 
 

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

@@ -14,6 +14,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     DefinitionSource,
     InputSlot,
     OperationMap,
+    OutputSlot,
     ResourceDefinition,
     ResourceMap,
 )
@@ -39,7 +40,7 @@ def extract_inputs(
     creating placeholder resources if not yet discovered from their schemas.
     """
     known_dependencies = set()
-    for param in operation.path_parameters:
+    for param in operation.iter_parameters():
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
             parameter_location=param.location,
@@ -310,3 +311,118 @@ def update_input_field_bindings(resource_name: str, operations: OperationMap) ->
             )
             if new_field is not None:
                 input_slot.resource_field = new_field
+
+
+def merge_related_resources(operations: OperationMap, resources: ResourceMap) -> None:
+    """Merge parameter-inferred resources with schema-defined resources from related operations."""
+    candidates = find_producer_consumer_candidates(operations)
+
+    for producer_name, consumer_name in candidates:
+        producer = operations[producer_name]
+        consumer = operations[consumer_name]
+
+        # Try to upgrade each input slot
+        for input_slot in consumer.inputs:
+            result = try_merge_input_resource(input_slot, producer.outputs, resources)
+
+            if result is not None:
+                new_resource_name, new_field_name = result
+                # Update input slot to use the better resource definition
+                input_slot.resource = resources[new_resource_name]
+                input_slot.resource_field = new_field_name
+
+
+def try_merge_input_resource(
+    input_slot: InputSlot,
+    producer_outputs: list[OutputSlot],
+    resources: ResourceMap,
+) -> tuple[str, str] | None:
+    """Try to upgrade an input's resource to a producer's resource."""
+    consumer_resource = input_slot.resource
+
+    # Only upgrade parameter-inferred resources (low confidence)
+    if consumer_resource.source != DefinitionSource.PARAMETER_INFERENCE:
+        return None
+
+    # Try each producer output
+    for output in producer_outputs:
+        producer_resource = resources[output.resource.name]
+
+        # Only merge to schema-defined resources (high confidence)
+        if producer_resource.source != DefinitionSource.SCHEMA_WITH_PROPERTIES:
+            continue
+
+        # Try to match the input parameter to producer's fields
+        param_name = input_slot.parameter_name
+        if not isinstance(param_name, str):
+            continue
+
+        for resource_name in (input_slot.resource.name, producer_resource.name):
+            matched_field = naming.find_matching_field(
+                parameter=param_name,
+                resource=resource_name,
+                fields=producer_resource.fields,
+            )
+
+            if matched_field is not None:
+                return (producer_resource.name, matched_field)
+
+    return None
+
+
+def find_producer_consumer_candidates(operations: OperationMap) -> list[tuple[str, str]]:
+    """Find operation pairs that might produce/consume the same resource via REST patterns."""
+    candidates = []
+
+    # Group by base path to reduce comparisons
+    paths: dict[str, list[str]] = {}
+    for name, node in operations.items():
+        base = _extract_base_path(node.path)
+        paths.setdefault(base, []).append(name)
+
+    # Within each path group, find POST/PUT → GET/DELETE/PATCH patterns
+    for names in paths.values():
+        for producer_name in names:
+            producer = operations[producer_name]
+            # Producer must create/update and return data
+            if producer.method not in ("post", "put") or not producer.outputs:
+                continue
+
+            for consumer_name in names:
+                consumer = operations[consumer_name]
+                # Consumer must have path parameters
+                if not consumer.inputs:
+                    continue
+                # Paths must be related (collection + item pattern)
+                if _is_collection_item_pattern(producer.path, consumer.path):
+                    candidates.append((producer_name, consumer_name))
+
+    return candidates
+
+
+def _extract_base_path(path: str) -> str:
+    """Extract collection path: /blog/posts/{id} -> /blog/posts."""
+    parts = [p for p in path.split("/") if not p.startswith("{")]
+    return "/".join(parts).rstrip("/")
+
+
+def _is_collection_item_pattern(collection_path: str, item_path: str) -> bool:
+    """Check if paths follow REST collection/item pattern."""
+    # /blog/posts + /blog/posts/{postId}
+    normalized_collection = collection_path.rstrip("/")
+    normalized_item = item_path.rstrip("/")
+
+    # Must start with collection path
+    if not normalized_item.startswith(normalized_collection + "/"):
+        return False
+
+    # Extract the segment after collection path
+    remainder = normalized_item[len(normalized_collection) + 1 :]
+
+    # Must be a single path parameter: {paramName} with no slashes
+    return (
+        remainder.startswith("{")
+        and remainder.endswith("}")
+        and len(remainder) > 2  # Not empty {}
+        and "/" not in remainder
+    )

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

@@ -394,13 +394,13 @@ def find_matching_field(*, parameter: str, resource: str, fields: list[str]) ->
             return field
 
     # Extract parameter components
-    parameter_prefix, param_suffix = _split_parameter_name(parameter)
+    parameter_prefix, parameter_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)
+        suffix_normalized = _normalize_for_matching(parameter_suffix)
 
         for field in fields:
             field_normalized = _normalize_for_matching(field)
@@ -409,8 +409,8 @@ def find_matching_field(*, parameter: str, resource: str, fields: list[str]) ->
 
     # 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)
+    if not parameter_prefix and parameter_suffix:
+        expected_field_normalized = resource_normalized + _normalize_for_matching(parameter_suffix)
 
         for field in fields:
             field_normalized = _normalize_for_matching(field)
@@ -433,7 +433,7 @@ def _normalize_for_matching(text: str) -> str:
     return text.lower().replace("_", "").replace("-", "")
 
 
-def _split_parameter_name(param_name: str) -> tuple[str, str]:
+def _split_parameter_name(parameter_name: str) -> tuple[str, str]:
     """Split parameter into (prefix, suffix) components.
 
     Examples:
@@ -444,13 +444,16 @@ def _split_parameter_name(param_name: str) -> tuple[str, str]:
         "channel_id" -> ("channel", "_id")
 
     """
-    if param_name.endswith("Id") and len(param_name) > 2:
-        return (param_name[:-2], "Id")
+    if parameter_name.endswith("Id") and len(parameter_name) > 2:
+        return (parameter_name[:-2], "Id")
 
-    if param_name.endswith("_id") and len(param_name) > 3:
-        return (param_name[:-3], "_id")
+    if parameter_name.endswith("_id") and len(parameter_name) > 3:
+        return (parameter_name[:-3], "_id")
 
-    return ("", param_name)
+    if parameter_name.endswith("_guid") and len(parameter_name) > 5:
+        return (parameter_name[:-5], "_guid")
+
+    return ("", parameter_name)
 
 
 def strip_affixes(name: str, prefixes: list[str], suffixes: list[str]) -> str:

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

@@ -13,6 +13,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     CanonicalizationCache,
     Cardinality,
     DefinitionSource,
+    OperationMap,
     ResourceDefinition,
     ResourceMap,
     extend_pointer,
@@ -293,7 +294,13 @@ def _extract_resource_from_schema(
         properties = resolved.get("properties")
         if properties:
             fields = sorted(properties)
-            types = {field: set(get_type(subschema)) for field, subschema in properties.items()}
+            types = {}
+            for field, subschema in properties.items():
+                if isinstance(subschema, dict):
+                    _, resolved_subschema = maybe_resolve(subschema, resolver, "")
+                else:
+                    resolved_subschema = subschema
+                types[field] = set(get_type(cast(dict, resolved_subschema)))
             source = DefinitionSource.SCHEMA_WITH_PROPERTIES
         else:
             fields = []
@@ -310,3 +317,18 @@ def _extract_resource_from_schema(
             resources[resource_name] = resource
 
     return resource
+
+
+def remove_unused_resources(operations: OperationMap, resources: ResourceMap) -> None:
+    """Remove resources that aren't referenced by any operation."""
+    # Collect all resource names currently in use
+    used_resources = set()
+    for operation in operations.values():
+        for input_slot in operation.inputs:
+            used_resources.add(input_slot.resource.name)
+        for output_slot in operation.outputs:
+            used_resources.add(output_slot.resource.name)
+
+    unused = set(resources.keys()) - used_resources
+    for resource_name in unused:
+        del resources[resource_name]

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

@@ -232,30 +232,38 @@ def unwrap_schema(
         _, resolved = maybe_resolve(array_schema, resolver, "")
         pointer = f"/{encode_pointer(array_field)}"
 
+        uses_parent_ref = False
         # 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)
+                external_tag = _detect_externally_tagged_pattern(resolved_items, path, parent_ref)
                 if external_tag:
-                    nested_properties = resolved_items["properties"][external_tag]
+                    external_tag_, uses_parent_ref = external_tag
+                    nested_properties = resolved_items["properties"][external_tag_]
                     _, resolved = maybe_resolve(nested_properties, resolver, "")
-                    pointer += f"/{encode_pointer(external_tag)}"
+                    pointer += f"/{encode_pointer(external_tag_)}"
 
+        ref = parent_ref if uses_parent_ref else array_schema.get("$ref")
         return UnwrappedSchema(pointer=pointer, schema=resolved, ref=array_schema.get("$ref"))
 
     # External tag
-    external_tag = _detect_externally_tagged_pattern(schema, path)
+    external_tag = _detect_externally_tagged_pattern(schema, path, parent_ref)
     if external_tag:
-        tagged_schema = properties[external_tag]
+        external_tag_, uses_parent_ref = external_tag
+        tagged_schema = properties[external_tag_]
         _, resolved_tagged = maybe_resolve(tagged_schema, resolver, "")
 
         resolved = try_unwrap_all_of(resolved_tagged)
-        ref = resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
+        ref = (
+            parent_ref
+            if uses_parent_ref
+            else resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
+        )
 
         _, resolved = maybe_resolve(resolved, resolver, "")
-        return UnwrappedSchema(pointer=f"/{encode_pointer(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"))
@@ -391,7 +399,9 @@ def _is_pagination_wrapper(
     return None
 
 
-def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> str | None:
+def _detect_externally_tagged_pattern(
+    schema: Mapping[str, Any], path: str, parent_ref: str | None
+) -> tuple[str, bool] | None:
     """Detect externally tagged resource pattern.
 
     Pattern: {ResourceName: [...]} or {resourceName: [...]}
@@ -420,12 +430,18 @@ def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> s
         # `data_request`
         naming.to_snake_case(resource_name),
     }
+    parent_names = set()
+    if parent_ref is not None:
+        maybe_resource_name = resource_name_from_ref(parent_ref)
+        parent_names.add(naming.to_plural(maybe_resource_name.lower()))
+        parent_names.add(naming.to_snake_case(maybe_resource_name))
+        possible_names = possible_names.union(parent_names)
 
     for name, subschema in properties.items():
         if name.lower() not in possible_names:
             continue
 
         if isinstance(subschema, dict) and "object" in get_type(subschema):
-            return name
+            return name, name.lower() in parent_names
 
     return None

schemathesis/specs/openapi/stateful/links.py

@@ -5,7 +5,7 @@ from functools import lru_cache
 from typing import Any, Callable
 
 from schemathesis.core import NOT_SET, NotSet
-from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
+from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError, format_transition
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
@@ -23,8 +23,9 @@ class NormalizedParameter:
     name: str
     expression: str
     container_name: str
+    is_required: bool
 
-    __slots__ = ("location", "name", "expression", "container_name")
+    __slots__ = ("location", "name", "expression", "container_name", "is_required")
 
 
 @dataclass(repr=False)
@@ -93,6 +94,10 @@ class OpenApiLink:
 
         self._cached_extract = lru_cache(8)(self._extract_impl)
 
+    @property
+    def full_name(self) -> str:
+        return format_transition(self.source.label, self.status_code, self.name, self.target.label)
+
     def _normalize_parameters(
         self, parameters: dict[str, str], errors: list[TransitionValidationError]
     ) -> list[NormalizedParameter]:
@@ -131,15 +136,21 @@ class OpenApiLink:
                 except Exception as exc:
                     errors.append(TransitionValidationError(str(exc)))
 
+            is_required = False
             if hasattr(self, "target"):
                 try:
                     container_name = self._get_parameter_container(location, name)
                 except TransitionValidationError as exc:
                     errors.append(exc)
                     continue
+
+                for param in self.target.iter_parameters():
+                    if param.name == name:
+                        is_required = param.is_required
+                        break
             else:
                 continue
-            result.append(NormalizedParameter(location, name, expression, container_name))
+            result.append(NormalizedParameter(location, name, expression, container_name, is_required=is_required))
         return result
 
     def _get_parameter_container(self, location: ParameterLocation | None, name: str) -> str:
@@ -158,7 +169,7 @@ class OpenApiLink:
     def _extract_impl(self, wrapper: StepOutputWrapper) -> Transition:
         output = wrapper.output
         return Transition(
-            id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
+            id=self.full_name,
             parent_id=output.case.id,
             is_inferred=self.is_inferred,
             parameters=self.extract_parameters(output),
@@ -178,7 +189,9 @@ class OpenApiLink:
                 value = Ok(expressions.evaluate(parameter.expression, output))
             except Exception as exc:
                 value = Err(exc)
-            container[parameter.name] = ExtractedParam(definition=parameter.expression, value=value)
+            container[parameter.name] = ExtractedParam(
+                definition=parameter.expression, value=value, is_required=parameter.is_required
+            )
         return extracted
 
     def extract_body(self, output: StepOutput) -> ExtractedParam | None:
@@ -188,7 +201,7 @@ class OpenApiLink:
                 value = Ok(expressions.evaluate(self.body, output, evaluate_nested=True))
             except Exception as exc:
                 value = Err(exc)
-            return ExtractedParam(definition=self.body, value=value)
+            return ExtractedParam(definition=self.body, value=value, is_required=True)
         return None
 
 

{schemathesis-4.3.11.dist-info → schemathesis-4.3.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.11
+Version: 4.3.13
 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.11.dist-info → schemathesis-4.3.13.dist-info}/RECORD

@@ -52,7 +52,7 @@ schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1
 schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
 schemathesis/core/curl.py,sha256=jrPL9KpNHteyJ6A1oxJRSkL5bfuBeuPs3xh9Z_ml2cE,1892
 schemathesis/core/deserialization.py,sha256=qjXUPaz_mc1OSgXzTUSkC8tuVR8wgVQtb9g3CcAF6D0,2951
-schemathesis/core/errors.py,sha256=KlcDlsxg9sHKdo-NtFDluhk1iwQbSHdpDGykf8CxOKY,17357
+schemathesis/core/errors.py,sha256=sr23WgbD-52n5fmC-QBn2suzNUbsB1okvXIs_L5EyR0,19918
 schemathesis/core/failures.py,sha256=yFpAxWdEnm0Ri8z8RqRI9H7vcLH5ztOeSIi4m4SGx5g,8996
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/hooks.py,sha256=qhbkkRSf8URJ4LKv2wmKRINKpquUOgxQzWBHKWRWo3Q,475
@@ -89,7 +89,7 @@ schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuU
 schemathesis/engine/phases/stateful/_executor.py,sha256=yRpUJqKLTKMVRy7hEXPwmI23CtgGIprz341lCJwvTrU,15613
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
 schemathesis/engine/phases/unit/__init__.py,sha256=9dDcxyj887pktnE9YDIPNaR-vc7iqKQWIrFr77SbUTQ,8786
-schemathesis/engine/phases/unit/_executor.py,sha256=YDibV3lkC2UMHLvh1FSmnlaQ-SJS-R0MU2qEF4NBbf0,17235
+schemathesis/engine/phases/unit/_executor.py,sha256=4wr7POpPfeI7_Mx6i2pk2efyK1FxKGjXdMwi_MURTDU,17427
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=SLMw6zkzmeiZdaIij8_0tjTF70BrMlRSWREaqWii0uM,12508
@@ -104,7 +104,7 @@ schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8E
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
 schemathesis/generation/stateful/__init__.py,sha256=s7jiJEnguIj44IsRyMi8afs-8yjIUuBbzW58bH5CHjs,1042
-schemathesis/generation/stateful/state_machine.py,sha256=25kkYImw5byNwuTtt97aNE3kTHAF8rZ-p3ax_bmd3JI,9135
+schemathesis/generation/stateful/state_machine.py,sha256=CiVtpBEeotpNOUkYO3vJLKRe89gdT1kjguZ88vbfqs0,9500
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
@@ -137,7 +137,7 @@ schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
 schemathesis/specs/openapi/references.py,sha256=AW1laU23BkiRf0EEFM538vyVFLXycGUiucGVV461le0,1927
-schemathesis/specs/openapi/schemas.py,sha256=uTxwggtWi5dWjuKlSDs0DthlNNfcRvSJtrND-PaTkrg,33758
+schemathesis/specs/openapi/schemas.py,sha256=ONFB8kMBrryZL_tKHWvxnBjyUHoHh_MAUqxjuVDc78c,34034
 schemathesis/specs/openapi/serialization.py,sha256=RPNdadne5wdhsGmjSvgKLRF58wpzpRx3wura8PsHM3o,12152
 schemathesis/specs/openapi/utils.py,sha256=XkOJT8qD-6uhq-Tmwxk_xYku1Gy5F9pKL3ldNg_DRZw,522
 schemathesis/specs/openapi/adapter/__init__.py,sha256=YEovBgLjnXd3WGPMJXq0KbSGHezkRlEv4dNRO7_evfk,249
@@ -159,17 +159,17 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=B78vps314fJOMZwlPdv7vUHo7
 schemathesis/specs/openapi/negative/mutations.py,sha256=9U352xJsdZBR-Zfy1V7_X3a5i91LIUS9Zqotrzp3BLA,21000
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
-schemathesis/specs/openapi/stateful/__init__.py,sha256=EkGiy1ksv0lH7IDBfR6Bdo1D9kaT5dLIJUwoz-p7hkw,16594
+schemathesis/specs/openapi/stateful/__init__.py,sha256=RpGqyjKShp2X94obaHnCR9TO6Qt_ZAarlB-awlyMzUY,18654
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
 schemathesis/specs/openapi/stateful/inference.py,sha256=B99jSTDVi2yKxU7-raIb91xpacOrr0nZkEZY5Ej3eCY,9783
-schemathesis/specs/openapi/stateful/links.py,sha256=SSA66mU50FFBz7e6sA37CfL-Vt0OY3gont72oFSvZYU,8163
-schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=0JM-FrY6Awv6gl-qDHaaK7pXbt_GKutBKPyIaph8apA,7842
-schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=PSactImp4OqsYMHUl2gB2pgvUlZCCKJRJKeaalclFzU,11511
+schemathesis/specs/openapi/stateful/links.py,sha256=TEZ7wudPdRdP-pg5XNIgYbual_9n2arBKnS2n8SxiaU,8629
+schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=9FWF7tiP7GaOwapRFIYjsu16LxkosKCzBvzjkSTCsjU,8183
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=sQydINThS6vp9-OnTKCb_unoVP4m3Ho-0xTG0K7ps8Q,15915
 schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=Kl482Hwq2M8lYAdqGmf_8Yje3voSj1WLDUIujRUDWDQ,12286
-schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=NnXEFY1W3i18jEEYGgC_8oLoE7YOxdXgcMYtZvLj10w,12920
+schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=GoO_Tw04u_7ix6qsAzMDoJooXZqIRAIV8sLphL4mGnw,13084
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
-schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=p58XoADpMKFAun0Bx_rul-kiUlfA9PXjxHJ97dT2tBE,11202
-schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=RaG1BJH4D7-o5Qs2rIRQvS8ERntMUEs2I5jXUFaKMRo,14147
+schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=eUWE26ZixPtSuHl7laF2asS_-6qklQRhyQlk7e99hlc,12087
+schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=TKM6hEuyLm5NB-jQeEbIXF7GZF-7mqYLq3OsTBRDpws,14878
 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
@@ -178,8 +178,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.11.dist-info/METADATA,sha256=yx5kZtdpuluVpHR7jIERaQlKLfLpYa7h__hOuJMAyyU,8566
-schemathesis-4.3.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.11.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.11.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.11.dist-info/RECORD,,
+schemathesis-4.3.13.dist-info/METADATA,sha256=n-G9iaIj5lgmV9oro_G7FL4f2tAeI9xOXaLe95r6WnA,8566
+schemathesis-4.3.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.13.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.13.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.13.dist-info/RECORD,,