schemathesis 4.0.0a1__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

schemathesis/engine/recorder.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import base64
 import time
-import uuid
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterator, cast
 
@@ -14,6 +13,8 @@ from schemathesis.generation.case import Case
 if TYPE_CHECKING:
     import requests
 
+    from schemathesis.generation.stateful.state_machine import Transition
+
 
 @dataclass
 class ScenarioRecorder:
@@ -22,7 +23,6 @@ class ScenarioRecorder:
     Records test cases, their hierarchy, API interactions, and results of checks performed during execution.
     """
 
-    id: uuid.UUID
     # Human-readable label
     label: str
 
@@ -33,18 +33,17 @@ class ScenarioRecorder:
     # Network interactions by test case ID
     interactions: dict[str, Interaction]
 
-    __slots__ = ("id", "label", "status", "roots", "cases", "checks", "interactions")
+    __slots__ = ("label", "status", "roots", "cases", "checks", "interactions")
 
     def __init__(self, *, label: str) -> None:
-        self.id = uuid.uuid4()
         self.label = label
         self.cases = {}
         self.checks = {}
         self.interactions = {}
 
-    def record_case(self, *, parent_id: str | None, case: Case) -> None:
+    def record_case(self, *, parent_id: str | None, transition: Transition | None, case: Case) -> None:
         """Record a test case and its relationship to a parent, if applicable."""
-        self.cases[case.id] = CaseNode(value=case, parent_id=parent_id)
+        self.cases[case.id] = CaseNode(value=case, parent_id=parent_id, transition=transition)
 
     def record_response(self, *, case_id: str, response: Response) -> None:
         """Record the API response for a given test case."""
@@ -94,30 +93,34 @@ class ScenarioRecorder:
         return None
 
     def find_related(self, *, case_id: str) -> Iterator[Case]:
-        """Iterate over all ancestors and their children for a given case."""
-        current_id = case_id
-        seen = {current_id}
+        """Iterate over all cases in the tree, starting from the root."""
+        seen = {case_id}
 
+        # First, find the root by going up
+        current_id = case_id
         while True:
             current_node = self.cases.get(current_id)
             if current_node is None or current_node.parent_id is None:
+                root_id = current_id
                 break
+            current_id = current_node.parent_id
 
-            # Get all children of the parent (siblings of the current case)
-            parent_id = current_node.parent_id
-            for case_id, maybe_child in self.cases.items():
-                # If this case has the same parent and we haven't seen it yet
-                if parent_id == maybe_child.parent_id and case_id not in seen:
+        # Then traverse the whole tree from root
+        def traverse(node_id: str) -> Iterator[Case]:
+            # Get all children
+            for case_id, node in self.cases.items():
+                if node.parent_id == node_id and case_id not in seen:
                     seen.add(case_id)
-                    yield maybe_child.value
+                    yield node.value
+                    # Recurse into children
+                    yield from traverse(case_id)
 
-            # Move up to the parent
-            current_id = parent_id
-            if current_id not in seen:
-                seen.add(current_id)
-                parent_node = self.cases.get(current_id)
-                if parent_node:
-                    yield parent_node.value
+        # Start traversal from root
+        root_node = self.cases.get(root_id)
+        if root_node and root_id not in seen:
+            seen.add(root_id)
+            yield root_node.value
+        yield from traverse(root_id)
 
     def find_response(self, *, case_id: str) -> Response | None:
         """Retrieve the API response for a given test case, if available."""
@@ -133,8 +136,11 @@ class CaseNode:
 
     value: Case
     parent_id: str | None
+    # Transition may be absent if `parent_id` is present for cases when a case is derived inside a check
+    # and outside of the implemented transition logic (e.g. Open API links)
+    transition: Transition | None
 
-    __slots__ = ("value", "parent_id")
+    __slots__ = ("value", "parent_id", "transition")
 
 
 @dataclass

schemathesis/errors.py

@@ -1,29 +1,35 @@
 """Public Schemathesis errors."""
 
-from schemathesis.core.errors import IncorrectUsage as IncorrectUsage
-from schemathesis.core.errors import InternalError as InternalError
-from schemathesis.core.errors import InvalidHeadersExample as InvalidHeadersExample
-from schemathesis.core.errors import InvalidRateLimit as InvalidRateLimit
-from schemathesis.core.errors import InvalidRegexPattern as InvalidRegexPattern
-from schemathesis.core.errors import InvalidRegexType as InvalidRegexType
-from schemathesis.core.errors import InvalidSchema as InvalidSchema
-from schemathesis.core.errors import LoaderError as LoaderError
-from schemathesis.core.errors import OperationNotFound as OperationNotFound
-from schemathesis.core.errors import SchemathesisError as SchemathesisError
-from schemathesis.core.errors import SerializationError as SerializationError
-from schemathesis.core.errors import SerializationNotPossible as SerializationNotPossible
-from schemathesis.core.errors import UnboundPrefix as UnboundPrefix
+from schemathesis.core.errors import (
+    IncorrectUsage,
+    InternalError,
+    InvalidHeadersExample,
+    InvalidLinkDefinition,
+    InvalidRateLimit,
+    InvalidRegexPattern,
+    InvalidRegexType,
+    InvalidSchema,
+    LoaderError,
+    NoLinksFound,
+    OperationNotFound,
+    SchemathesisError,
+    SerializationError,
+    SerializationNotPossible,
+    UnboundPrefix,
+)
 
 __all__ = [
     "IncorrectUsage",
     "InternalError",
     "InvalidHeadersExample",
+    "InvalidLinkDefinition",
     "InvalidRateLimit",
     "InvalidRegexPattern",
     "InvalidRegexType",
     "InvalidSchema",
     "LoaderError",
     "OperationNotFound",
+    "NoLinksFound",
     "SchemathesisError",
     "SerializationError",
     "SerializationNotPossible",

schemathesis/generation/coverage.py

@@ -194,6 +194,10 @@ class CoverageContext:
                 re.compile(pattern)
             except re.error:
                 raise Unsatisfiable from None
+            if "minLength" in schema or "maxLength" in schema:
+                min_length = schema.get("minLength")
+                max_length = schema.get("maxLength")
+                pattern = update_quantifier(pattern, min_length, max_length)
             return cached_draw(st.from_regex(pattern))
         if (keys == ["items", "type"] or keys == ["items", "minItems", "type"]) and isinstance(schema["items"], dict):
             items = schema["items"]
@@ -514,11 +518,7 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
     elif "pattern" in schema:
-        # Without merging `maxLength` & `minLength` into a regex it is problematic
-        # to generate a valid value as the unredlying machinery will resort to filtering
-        # and it is unlikely that it will generate a string of that length
         yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
-        return
 
     seen = set()
 

schemathesis/generation/hypothesis/builder.py

@@ -386,19 +386,22 @@ def _iter_coverage_cases(
             container = template["query"]
             for parameter in operation.query:
                 instant = Instant()
-                value = container[parameter.name]
-                yield operation.Case(
-                    **{**template, "query": {**container, parameter.name: [value, value]}},
-                    meta=CaseMetadata(
-                        generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
-                        components={},
-                        phase=PhaseInfo.coverage(
-                            description=f"Duplicate `{parameter.name}` query parameter",
-                            parameter=parameter.name,
-                            parameter_location="query",
+                # Could be absent if value schema can't be negated
+                # I.e. contains just `default` value without any other keywords
+                value = container.get(parameter.name, NOT_SET)
+                if value is not NOT_SET:
+                    yield operation.Case(
+                        **{**template, "query": {**container, parameter.name: [value, value]}},
+                        meta=CaseMetadata(
+                            generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
+                            components={},
+                            phase=PhaseInfo.coverage(
+                                description=f"Duplicate `{parameter.name}` query parameter",
+                                parameter=parameter.name,
+                                parameter_location="query",
+                            ),
                         ),
-                    ),
-                )
+                    )
         # Generate missing required parameters
         for parameter in operation.iter_parameters():
             if parameter.is_required and parameter.location != "path":

schemathesis/generation/stateful/state_machine.py

@@ -10,7 +10,8 @@ from hypothesis.errors import InvalidDefinition
 from hypothesis.stateful import RuleBasedStateMachine
 
 from schemathesis.checks import CheckFunction
-from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.errors import NoLinksFound
+from schemathesis.core.result import Result
 from schemathesis.core.transport import Response
 from schemathesis.generation.case import Case
 
@@ -18,30 +19,64 @@ if TYPE_CHECKING:
     import hypothesis
     from requests.structures import CaseInsensitiveDict
 
-    from schemathesis.schemas import APIOperation, BaseSchema
+    from schemathesis.schemas import BaseSchema
 
 
-NO_LINKS_ERROR_MESSAGE = (
-    "Stateful testing requires at least one OpenAPI link in the schema, but no links detected. "
-    "Please add OpenAPI links to enable stateful testing or use stateless tests instead. \n"
-    "See https://schemathesis.readthedocs.io/en/stable/stateful.html#how-to-specify-connections for more information."
-)
-
+DEFAULT_STATEFUL_STEP_COUNT = 6
 DEFAULT_STATE_MACHINE_SETTINGS = hypothesis.settings(
     phases=[hypothesis.Phase.generate],
     deadline=None,
-    stateful_step_count=6,
+    stateful_step_count=DEFAULT_STATEFUL_STEP_COUNT,
     suppress_health_check=list(hypothesis.HealthCheck),
 )
 
 
 @dataclass
-class StepResult:
+class StepInput:
+    """Input for a single state machine step."""
+
+    case: Case
+    transition: Transition | None  # None for initial steps
+
+    __slots__ = ("case", "transition")
+
+    @classmethod
+    def initial(cls, case: Case) -> StepInput:
+        return cls(case=case, transition=None)
+
+
+@dataclass
+class Transition:
+    """Data about transition execution."""
+
+    # ID of the transition (e.g. link name)
+    id: str
+    parent_id: str
+    parameters: dict[str, dict[str, ExtractedParam]]
+    request_body: ExtractedParam | None
+
+    __slots__ = ("id", "parent_id", "parameters", "request_body")
+
+
+@dataclass
+class ExtractedParam:
+    """Result of parameter extraction."""
+
+    definition: Any
+    value: Result[Any, Exception]
+
+    __slots__ = ("definition", "value")
+
+
+@dataclass
+class StepOutput:
     """Output from a single transition of a state machine."""
 
     response: Response
     case: Case
 
+    __slots__ = ("response", "case")
+
 
 def _normalize_name(name: str) -> str:
     return re.sub(r"\W|^(?=\d)", "_", name).replace("__", "_")
@@ -64,7 +99,11 @@ class APIStateMachine(RuleBasedStateMachine):
             super().__init__()  # type: ignore
         except InvalidDefinition as exc:
             if "defines no rules" in str(exc):
-                raise IncorrectUsage(NO_LINKS_ERROR_MESSAGE) from None
+                if not self.schema.statistic.links.total:
+                    message = "Schema contains no link definitions required for stateful testing"
+                else:
+                    message = "All link definitions required for stateful testing are excluded by filters"
+                raise NoLinksFound(message) from None
             raise
         self.setup()
 
@@ -89,10 +128,10 @@ class APIStateMachine(RuleBasedStateMachine):
         target = _normalize_name(target)
         return super()._new_name(target)  # type: ignore
 
-    def _get_target_for_result(self, result: StepResult) -> str | None:
+    def _get_target_for_result(self, result: StepOutput) -> str | None:
         raise NotImplementedError
 
-    def _add_result_to_targets(self, targets: tuple[str, ...], result: StepResult | None) -> None:
+    def _add_result_to_targets(self, targets: tuple[str, ...], result: StepOutput | None) -> None:
         if result is None:
             return
         target = self._get_target_for_result(result)
@@ -115,19 +154,11 @@ class APIStateMachine(RuleBasedStateMachine):
     # To provide the return type in the rendered documentation
     teardown.__doc__ = RuleBasedStateMachine.teardown.__doc__
 
-    def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
-        raise NotImplementedError
-
-    def _step(self, case: Case, previous: StepResult | None = None, link: Direction | None = None) -> StepResult | None:
-        # This method is a proxy that is used under the hood during the state machine initialization.
-        # The whole point of having it is to make it possible to override `step`; otherwise, custom "step" is ignored.
-        # It happens because, at the point of initialization, the final class is not yet created.
+    def _step(self, input: StepInput) -> StepOutput | None:
         __tracebackhide__ = True
-        if previous is not None and link is not None:
-            return self.step(case, (previous, link))
-        return self.step(case, None)
+        return self.step(input)
 
-    def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
+    def step(self, input: StepInput) -> StepOutput:
         """A single state machine step.
 
         :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
@@ -137,15 +168,12 @@ class APIStateMachine(RuleBasedStateMachine):
         It is the most high-level point to extend the testing process. You probably don't need it in most cases.
         """
         __tracebackhide__ = True
-        if previous is not None:
-            result, direction = previous
-            case = self.transform(result, direction, case)
-        self.before_call(case)
-        kwargs = self.get_call_kwargs(case)
-        response = self.call(case, **kwargs)
-        self.after_call(response, case)
-        self.validate_response(response, case)
-        return self.store_result(response, case)
+        self.before_call(input.case)
+        kwargs = self.get_call_kwargs(input.case)
+        response = self.call(input.case, **kwargs)
+        self.after_call(response, input.case)
+        self.validate_response(response, input.case)
+        return StepOutput(response, input.case)
 
     def before_call(self, case: Case) -> None:
         """Hook method for modifying the case data before making a request.
@@ -271,15 +299,3 @@ class APIStateMachine(RuleBasedStateMachine):
         """
         __tracebackhide__ = True
         case.validate_response(response, additional_checks=additional_checks)
-
-    def store_result(self, response: Response, case: Case) -> StepResult:
-        return StepResult(response, case)
-
-
-class Direction:
-    name: str
-    status_code: str
-    operation: APIOperation
-
-    def set_data(self, case: Case, **kwargs: Any) -> None:
-        raise NotImplementedError

schemathesis/graphql/checks.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 class UnexpectedGraphQLResponse(Failure):
     """GraphQL response is not a JSON object."""
 
-    __slots__ = ("operation", "type_name", "title", "message", "code", "case_id", "severity")
+    __slots__ = ("operation", "type_name", "title", "message", "case_id", "severity")
 
     def __init__(
         self,
@@ -20,14 +20,12 @@ class UnexpectedGraphQLResponse(Failure):
         type_name: str,
         title: str = "Unexpected GraphQL Response",
         message: str,
-        code: str = "graphql_unexpected_response",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.type_name = type_name
         self.title = title
         self.message = message
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -39,7 +37,7 @@ class UnexpectedGraphQLResponse(Failure):
 class GraphQLClientError(Failure):
     """GraphQL query has not been executed."""
 
-    __slots__ = ("operation", "errors", "title", "message", "code", "case_id", "_unique_key_cache", "severity")
+    __slots__ = ("operation", "errors", "title", "message", "case_id", "_unique_key_cache", "severity")
 
     def __init__(
         self,
@@ -48,14 +46,12 @@ class GraphQLClientError(Failure):
         message: str,
         errors: list[GraphQLFormattedError],
         title: str = "GraphQL client error",
-        code: str = "graphql_client_error",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.errors = errors
         self.title = title
         self.message = message
-        self.code = code
         self.case_id = case_id
         self._unique_key_cache: str | None = None
         self.severity = Severity.MEDIUM
@@ -70,7 +66,7 @@ class GraphQLClientError(Failure):
 class GraphQLServerError(Failure):
     """GraphQL response indicates at least one server error."""
 
-    __slots__ = ("operation", "errors", "title", "message", "code", "case_id", "_unique_key_cache", "severity")
+    __slots__ = ("operation", "errors", "title", "message", "case_id", "_unique_key_cache", "severity")
 
     def __init__(
         self,
@@ -79,14 +75,12 @@ class GraphQLServerError(Failure):
         message: str,
         errors: list[GraphQLFormattedError],
         title: str = "GraphQL server error",
-        code: str = "graphql_server_error",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.errors = errors
         self.title = title
         self.message = message
-        self.code = code
         self.case_id = case_id
         self._unique_key_cache: str | None = None
         self.severity = Severity.CRITICAL