schemathesis 4.0.0a2__py3-none-any.whl → 4.0.0a4__py3-none-any.whl

schemathesis/engine/phases/unit/__init__.py

@@ -123,7 +123,7 @@ def worker_task(*, events_queue: Queue, producer: TaskProducer, ctx: EngineConte
                 else:
                     error = result.err()
                     if error.method:
-                        label = f"{error.method.upper()} {error.full_path}"
+                        label = f"{error.method.upper()} {error.path}"
                         scenario_started = events.ScenarioStarted(
                             label=label, phase=PhaseName.UNIT_TESTING, suite_id=suite_id
                         )
@@ -149,12 +149,11 @@ def worker_task(*, events_queue: Queue, producer: TaskProducer, ctx: EngineConte
                             )
                         )
                     else:
-                        assert error.full_path is not None
                         events_queue.put(
                             events.NonFatalError(
                                 error=error,
                                 phase=PhaseName.UNIT_TESTING,
-                                label=error.full_path,
+                                label=error.path,
                                 related_to_operation=False,
                             )
                         )

schemathesis/engine/phases/unit/_executor.py

@@ -70,6 +70,19 @@ def run_test(
             error=error, phase=PhaseName.UNIT_TESTING, label=operation.label, related_to_operation=True
         )
 
+    def scenario_finished(status: Status) -> events.ScenarioFinished:
+        return events.ScenarioFinished(
+            id=scenario_started.id,
+            suite_id=suite_id,
+            phase=PhaseName.UNIT_TESTING,
+            label=operation.label,
+            recorder=recorder,
+            status=status,
+            elapsed_time=time.monotonic() - test_start_time,
+            skip_reason=skip_reason,
+            is_final=False,
+        )
+
     try:
         setup_hypothesis_database_key(test_function, operation)
         with catch_warnings(record=True) as warnings, ignore_hypothesis_output():
@@ -111,6 +124,7 @@ def run_test(
         status = Status.ERROR
         yield non_fatal_error(hypothesis.errors.Unsatisfiable("Failed to generate test cases for this API operation"))
     except KeyboardInterrupt:
+        yield scenario_finished(Status.INTERRUPTED)
         yield events.Interrupted(phase=PhaseName.UNIT_TESTING)
         return
     except AssertionError as exc:  # May come from `hypothesis-jsonschema` or `hypothesis`
@@ -131,7 +145,6 @@ def run_test(
                     exc,
                     path=operation.path,
                     method=operation.method,
-                    full_path=operation.schema.get_full_path(operation.path),
                 )
             )
     except HypothesisRefResolutionError:
@@ -194,20 +207,10 @@ def run_test(
     if invalid_headers:
         status = Status.ERROR
         yield non_fatal_error(InvalidHeadersExample.from_headers(invalid_headers))
-    test_elapsed_time = time.monotonic() - test_start_time
     for error in deduplicate_errors(errors):
         yield non_fatal_error(error)
-    yield events.ScenarioFinished(
-        id=scenario_started.id,
-        suite_id=suite_id,
-        phase=PhaseName.UNIT_TESTING,
-        label=operation.label,
-        recorder=recorder,
-        status=status,
-        elapsed_time=test_elapsed_time,
-        skip_reason=skip_reason,
-        is_final=False,
-    )
+
+    yield scenario_finished(status)
 
 
 def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> None:

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
 
@@ -24,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
 
@@ -35,10 +33,9 @@ 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 = {}
@@ -96,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
-
-            # 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
+                    yield node.value
+                    # Recurse into children
+                    yield from traverse(case_id)
+
+        # 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."""

schemathesis/errors.py

@@ -1,18 +1,24 @@
 """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,
+    InvalidRateLimit,
+    InvalidRegexPattern,
+    InvalidRegexType,
+    InvalidSchema,
+    InvalidStateMachine,
+    InvalidTransition,
+    LoaderError,
+    NoLinksFound,
+    OperationNotFound,
+    SchemathesisError,
+    SerializationError,
+    SerializationNotPossible,
+    TransitionValidationError,
+    UnboundPrefix,
+)
 
 __all__ = [
     "IncorrectUsage",
@@ -22,10 +28,14 @@ __all__ = [
     "InvalidRegexPattern",
     "InvalidRegexType",
     "InvalidSchema",
+    "InvalidStateMachine",
+    "InvalidTransition",
     "LoaderError",
     "OperationNotFound",
+    "NoLinksFound",
     "SchemathesisError",
     "SerializationError",
     "SerializationNotPossible",
+    "TransitionValidationError",
     "UnboundPrefix",
 ]

schemathesis/filters.py

@@ -268,6 +268,8 @@ class FilterSet:
                 # To match anything the regex should match the expected value, hence passing them together is useless
                 raise IncorrectUsage(ERROR_EXPECTED_AND_REGEX)
             if expected is not None:
+                if attribute == "method":
+                    expected = _normalize_method(expected)
                 matchers.append(Matcher.for_value(attribute, expected))
             if regex is not None:
                 matchers.append(Matcher.for_regex(attribute, regex))
@@ -283,6 +285,12 @@ class FilterSet:
             self._excludes.add(filter_)
 
 
+def _normalize_method(value: FilterValue) -> FilterValue:
+    if isinstance(value, list):
+        return [item.upper() for item in value]
+    return value.upper()
+
+
 def attach_filter_chain(
     target: Callable,
     attribute: str,

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"]
@@ -433,7 +437,12 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
-                elif key == "additionalProperties" and not value and "pattern" not in schema:
+                elif (
+                    key == "additionalProperties"
+                    and not value
+                    and "pattern" not in schema
+                    and schema.get("type") in ["object", None]
+                ):
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield NegativeValue(
                         {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},
@@ -514,11 +523,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,7 @@ 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
@@ -22,16 +22,11 @@ if TYPE_CHECKING:
     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),
 )
 
@@ -73,6 +68,52 @@ class ExtractedParam:
     __slots__ = ("definition", "value")
 
 
+@dataclass
+class ExtractionFailure:
+    """Represents a failure to extract data from a transition."""
+
+    # e.g., "GetUser"
+    id: str
+    case_id: str
+    # e.g., "POST /users"
+    source: str
+    # e.g., "GET /users/{userId}"
+    target: str
+    # e.g., "userId"
+    parameter_name: str
+    # e.g., "$response.body#/id"
+    expression: str
+    # Previous test cases in the chain, from newest to oldest
+    # Stored as a case + response pair
+    history: list[tuple[Case, Response]]
+    # The actual response that caused the failure
+    response: Response
+    error: Exception | None
+
+    __slots__ = ("id", "case_id", "source", "target", "parameter_name", "expression", "history", "response", "error")
+
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, ExtractionFailure)
+        return (
+            self.source == other.source
+            and self.target == other.target
+            and self.id == other.id
+            and self.parameter_name == other.parameter_name
+            and self.expression == other.expression
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.source,
+                self.target,
+                self.id,
+                self.parameter_name,
+                self.expression,
+            )
+        )
+
+
 @dataclass
 class StepOutput:
     """Output from a single transition of a state machine."""
@@ -104,7 +145,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()
 
@@ -173,7 +218,7 @@ class APIStateMachine(RuleBasedStateMachine):
         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)
+        self.validate_response(response, input.case, **kwargs)
         return StepOutput(response, input.case)
 
     def before_call(self, case: Case) -> None:
@@ -267,7 +312,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return {}
 
     def validate_response(
-        self, response: Response, case: Case, additional_checks: list[CheckFunction] | None = None
+        self, response: Response, case: Case, additional_checks: list[CheckFunction] | None = None, **kwargs: Any
     ) -> None:
         """Validate an API response.
 
@@ -299,4 +344,4 @@ class APIStateMachine(RuleBasedStateMachine):
         all provided checks rather than only the first encountered exception.
         """
         __tracebackhide__ = True
-        case.validate_response(response, additional_checks=additional_checks)
+        case.validate_response(response, additional_checks=additional_checks, transport_kwargs=kwargs)

schemathesis/pytest/lazy.py

@@ -168,7 +168,7 @@ class LazySchema:
                 for result in tests:
                     if isinstance(result, Ok):
                         operation, sub_test = result.ok()
-                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.full_path}]"
+                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.path}]"
                         run_subtest(operation, fixtures, sub_test, subtests)
                     else:
                         _schema_error(subtests, result.err(), node_id)
@@ -236,8 +236,7 @@ SEPARATOR = "\n===================="
 def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> None:
     """Run a failing test, that will show the underlying problem."""
     sub_test = error.as_failing_test_function()
-    # `full_path` is always available in this case
-    kwargs = {"path": error.full_path}
+    kwargs = {"path": error.path}
     if error.method:
         kwargs["method"] = error.method.upper()
     subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)

schemathesis/pytest/plugin.py

@@ -149,11 +149,10 @@ class SchemathesisCase(PyCollector):
             error = result.err()
             funcobj = error.as_failing_test_function()
             name = self.name
-            # `full_path` is always available in this case
             if error.method:
-                name += f"[{error.method.upper()} {error.full_path}]"
+                name += f"[{error.method.upper()} {error.path}]"
             else:
-                name += f"[{error.full_path}]"
+                name += f"[{error.path}]"
 
         cls = self._get_class_parent()
         definition: FunctionDefinition = FunctionDefinition.from_parent(

schemathesis/schemas.py

@@ -619,7 +619,7 @@ class APIOperation(Generic[P]):
 
     def __post_init__(self) -> None:
         if self.label is None:
-            self.label = f"{self.method.upper()} {self.full_path}"  # type: ignore
+            self.label = f"{self.method.upper()} {self.path}"  # type: ignore
 
     @property
     def full_path(self) -> str: