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

schemathesis/engine/phases/stateful/_executor.py

@@ -78,7 +78,6 @@ def execute_state_machine_loop(
             self._start_time = time.monotonic()
             self._scenario_id = scenario_started.id
             event_queue.put(scenario_started)
-            self.recorder = ScenarioRecorder(label="Stateful tests")
             self._check_ctx = engine.get_check_context(self.recorder)
 
         def get_call_kwargs(self, case: Case) -> dict[str, Any]:
@@ -100,12 +99,6 @@ def execute_state_machine_loop(
         def step(self, input: StepInput) -> StepOutput | None:
             # Checking the stop event once inside `step` is sufficient as it is called frequently
             # The idea is to stop the execution as soon as possible
-            if input.transition is not None:
-                self.recorder.record_case(
-                    parent_id=input.transition.parent_id, transition=input.transition, case=input.case
-                )
-            else:
-                self.recorder.record_case(parent_id=None, transition=None, case=input.case)
             if engine.has_to_stop:
                 raise KeyboardInterrupt
             try:
@@ -176,10 +169,7 @@ def execute_state_machine_loop(
             ctx.reset_scenario()
             super().teardown()
 
-    if config.execution.seed is not None:
-        InstrumentedStateMachine = hypothesis.seed(config.execution.seed)(_InstrumentedStateMachine)
-    else:
-        InstrumentedStateMachine = _InstrumentedStateMachine
+    seed = config.execution.seed
 
     while True:
         # This loop is running until no new failures are found in a single iteration
@@ -197,6 +187,13 @@ def execute_state_machine_loop(
             )
             break
         suite_status = Status.SUCCESS
+        if seed is not None:
+            InstrumentedStateMachine = hypothesis.seed(seed)(_InstrumentedStateMachine)
+            # Predictably change the seed to avoid re-running the same sequences if tests fail
+            # yet have reproducible results
+            seed += 1
+        else:
+            InstrumentedStateMachine = _InstrumentedStateMachine
         try:
             with catch_warnings(), ignore_hypothesis_output():  # type: ignore
                 InstrumentedStateMachine.run(settings=config.execution.hypothesis_settings)

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,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,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),
 )
 
@@ -104,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()
 

schemathesis/specs/openapi/checks.py

@@ -376,6 +376,10 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
         return True
 
+    # First, check if this is a 4XX response
+    if not (400 <= response.status_code < 500):
+        return None
+
     parent = ctx.find_parent(case_id=case.id)
     if parent is None:
         return None
@@ -383,6 +387,17 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
     if parent_response is None:
         return None
 
+    if not (
+        parent.operation.method.upper() == "POST"
+        and 200 <= parent_response.status_code < 400
+        and _is_prefix_operation(
+            ResourcePath(parent.path, parent.path_parameters or {}),
+            ResourcePath(case.path, case.path_parameters or {}),
+        )
+    ):
+        return None
+
+    # Check if all parameters come from links
     overrides = case._override
     overrides_all_parameters = True
     for parameter in case.operation.iter_parameters():
@@ -390,34 +405,42 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
         if parameter.name not in getattr(overrides, container, {}):
             overrides_all_parameters = False
             break
+    if not overrides_all_parameters:
+        return None
 
-    if (
-        # Response indicates a client error, even though all available parameters were taken from links
-        # and comes from a POST request. This case likely means that the POST request actually did not
-        # save the resource and it is not available for subsequent operations
-        400 <= response.status_code < 500
-        and parent.operation.method.upper() == "POST"
-        and 200 <= parent_response.status_code < 400
-        and overrides_all_parameters
-        and _is_prefix_operation(
-            ResourcePath(parent.path, parent.path_parameters or {}),
-            ResourcePath(case.path, case.path_parameters or {}),
-        )
-    ):
-        created_with = parent.operation.label
-        not_available_with = case.operation.label
-        reason = http.client.responses.get(response.status_code, "Unknown")
-        raise EnsureResourceAvailability(
-            operation=created_with,
-            message=(
-                f"The API returned `{response.status_code} {reason}` for a resource that was just created.\n\n"
-                f"Created with      : `{created_with}`\n"
-                f"Not available with: `{not_available_with}`"
-            ),
-            created_with=created_with,
-            not_available_with=not_available_with,
-        )
-    return None
+    # Look for any successful DELETE operations on this resource
+    for related_case in ctx.find_related(case_id=case.id):
+        related_response = ctx.find_response(case_id=related_case.id)
+        if (
+            related_case.operation.method.upper() == "DELETE"
+            and related_response is not None
+            and 200 <= related_response.status_code < 300
+            and _is_prefix_operation(
+                ResourcePath(related_case.path, related_case.path_parameters or {}),
+                ResourcePath(case.path, case.path_parameters or {}),
+            )
+        ):
+            # Resource was properly deleted, 404 is expected
+            return None
+
+    # If we got here:
+    # 1. Resource was created successfully
+    # 2. Current operation returned 4XX
+    # 3. All parameters come from links
+    # 4. No successful DELETE operations found
+    created_with = parent.operation.label
+    not_available_with = case.operation.label
+    reason = http.client.responses.get(response.status_code, "Unknown")
+    raise EnsureResourceAvailability(
+        operation=created_with,
+        message=(
+            f"The API returned `{response.status_code} {reason}` for a resource that was just created.\n\n"
+            f"Created with      : `{created_with}`\n"
+            f"Not available with: `{not_available_with}`"
+        ),
+        created_with=created_with,
+        not_available_with=not_available_with,
+    )
 
 
 class AuthKind(enum.Enum):

schemathesis/specs/openapi/links.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Generator, Literal, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Literal, Union, cast
 
 from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.errors import InvalidLinkDefinition, InvalidSchema, OperationNotFound
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
 from schemathesis.schemas import APIOperation
@@ -48,14 +49,27 @@ class OpenApiLink:
     __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
 
     def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
         self.name = name
         self.status_code = status_code
         self.source = source
+        assert isinstance(source.schema, BaseOpenAPISchema)
 
+        get_operation: Callable[[str], APIOperation]
         if "operationId" in definition:
-            self.target = source.schema.get_operation_by_id(definition["operationId"])  # type: ignore
+            operation_reference = definition["operationId"]
+            get_operation = source.schema.get_operation_by_id
         else:
-            self.target = source.schema.get_operation_by_reference(definition["operationRef"])  # type: ignore
+            operation_reference = definition["operationRef"]
+            get_operation = source.schema.get_operation_by_reference
+
+        try:
+            self.target = get_operation(operation_reference)
+        except OperationNotFound as exc:
+            raise InvalidLinkDefinition(
+                f"Link '{name}' references non-existent operation '{operation_reference}' from {status_code} response of '{source.label}'"
+            ) from exc
 
         extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
         self.parameters = self._normalize_parameters(definition.get("parameters", {}))
@@ -92,7 +106,7 @@ class OpenApiLink:
         for param in self.target.iter_parameters():
             if param.name == name:
                 return LOCATION_TO_CONTAINER[param.location]
-        raise ValueError(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
+        raise InvalidSchema(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
 
     def extract(self, output: StepOutput) -> Transition:
         return self._cached_extract(StepOutputWrapper(output))

schemathesis/specs/openapi/patterns.py

@@ -66,9 +66,177 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
             )
             + trailing_anchor
         )
+    elif (
+        len(parsed) > 3
+        and parsed[0][0] == ANCHOR
+        and parsed[-1][0] == ANCHOR
+        and all(op == LITERAL or op in REPEATS for op, _ in parsed[1:-1])
+    ):
+        return _handle_anchored_pattern(parsed, pattern, min_length, max_length)
     return pattern
 
 
+def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update regex pattern with multiple quantified patterns to satisfy length constraints."""
+    # Extract anchors
+    leading_anchor_length = _get_anchor_length(parsed[0][1])
+    trailing_anchor_length = _get_anchor_length(parsed[-1][1])
+    leading_anchor = pattern[:leading_anchor_length]
+    trailing_anchor = pattern[-trailing_anchor_length:]
+
+    pattern_parts = parsed[1:-1]
+
+    # Adjust length constraints by subtracting fixed literals length
+    fixed_length = sum(1 for op, _ in pattern_parts if op == LITERAL)
+    if min_length is not None:
+        min_length -= fixed_length
+        if min_length < 0:
+            return pattern
+    if max_length is not None:
+        max_length -= fixed_length
+        if max_length < 0:
+            return pattern
+
+    # Extract only min/max bounds from quantified parts
+    quantifier_bounds = [value[:2] for op, value in pattern_parts if op in REPEATS]
+
+    if not quantifier_bounds:
+        return pattern
+
+    length_distribution = _distribute_length_constraints(quantifier_bounds, min_length, max_length)
+    if not length_distribution:
+        return pattern
+
+    # Rebuild pattern with updated quantifiers
+    result = leading_anchor
+    current_position = leading_anchor_length
+    distribution_idx = 0
+
+    for op, value in pattern_parts:
+        if op == LITERAL:
+            if pattern[current_position] == "\\":
+                # Escaped value
+                current_position += 2
+                result += "\\"
+            else:
+                current_position += 1
+            result += chr(value)
+        else:
+            new_min, new_max = length_distribution[distribution_idx]
+            next_position = _find_quantified_end(pattern, current_position)
+            quantified_segment = pattern[current_position:next_position]
+            _, _, subpattern = value
+            new_value = (new_min, new_max, subpattern)
+
+            result += _update_quantifier(op, new_value, quantified_segment, new_min, new_max)
+            current_position = next_position
+            distribution_idx += 1
+
+    return result + trailing_anchor
+
+
+def _find_quantified_end(pattern: str, start: int) -> int:
+    """Find the end position of current quantified part."""
+    char_class_level = 0
+    group_level = 0
+
+    for i in range(start, len(pattern)):
+        char = pattern[i]
+
+        # Handle character class nesting
+        if char == "[":
+            char_class_level += 1
+        elif char == "]":
+            char_class_level -= 1
+
+        # Handle group nesting
+        elif char == "(":
+            group_level += 1
+        elif char == ")":
+            group_level -= 1
+
+        # Only process quantifiers when we're not inside any nested structure
+        elif char_class_level == 0 and group_level == 0:
+            if char in "*+?":
+                return i + 1
+            elif char == "{":
+                # Find matching }
+                while i < len(pattern) and pattern[i] != "}":
+                    i += 1
+                return i + 1
+
+    return len(pattern)
+
+
+def _distribute_length_constraints(
+    bounds: list[tuple[int, int]], min_length: int | None, max_length: int | None
+) -> list[tuple[int, int]] | None:
+    """Distribute length constraints among quantified pattern parts."""
+    # Handle exact length case with dynamic programming
+    if min_length == max_length:
+        assert min_length is not None
+        target = min_length
+        dp: dict[tuple[int, int], list[tuple[int, ...]] | None] = {}
+
+        def find_valid_combination(pos: int, remaining: int) -> list[tuple[int, ...]] | None:
+            if (pos, remaining) in dp:
+                return dp[(pos, remaining)]
+
+            if pos == len(bounds):
+                return [()] if remaining == 0 else None
+
+            max_len: int
+            min_len, max_len = bounds[pos]
+            if max_len == MAXREPEAT:
+                max_len = remaining + 1
+            else:
+                max_len += 1
+
+            # Try each possible length for current quantifier
+            for length in range(min_len, max_len):
+                rest = find_valid_combination(pos + 1, remaining - length)
+                if rest is not None:
+                    dp[(pos, remaining)] = [(length,) + r for r in rest]
+                    return dp[(pos, remaining)]
+
+            dp[(pos, remaining)] = None
+            return None
+
+        distribution = find_valid_combination(0, target)
+        if distribution:
+            return [(length, length) for length in distribution[0]]
+        return None
+
+    # Handle range case by distributing min/max bounds
+    result = []
+    remaining_min = min_length or 0
+    remaining_max = max_length or MAXREPEAT
+
+    for min_repeat, max_repeat in bounds:
+        if remaining_min > 0:
+            part_min = min(max_repeat, max(min_repeat, remaining_min))
+        else:
+            part_min = min_repeat
+
+        if remaining_max < MAXREPEAT:
+            part_max = min(max_repeat, remaining_max)
+        else:
+            part_max = max_repeat
+
+        if part_min > part_max:
+            return None
+
+        result.append((part_min, part_max))
+
+        remaining_min = max(0, remaining_min - part_min)
+        remaining_max -= part_max if part_max != MAXREPEAT else 0
+
+    if remaining_min > 0 or remaining_max < 0:
+        return None
+
+    return result
+
+
 def _get_anchor_length(node_type: int) -> int:
     """Determine the length of the anchor based on its type."""
     if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
@@ -93,13 +261,13 @@ def _handle_repeat_quantifier(
     min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
     if min_length > max_length:
         return pattern
-    return f"({_strip_quantifier(pattern)})" + _build_quantifier(min_length, max_length)
+    return f"({_strip_quantifier(pattern).strip(')(')})" + _build_quantifier(min_length, max_length)
 
 
 def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Handle literal or character class quantifiers."""
     min_length = 1 if min_length is None else max(min_length, 1)
-    return f"({pattern})" + _build_quantifier(min_length, max_length)
+    return f"({pattern.strip(')(')})" + _build_quantifier(min_length, max_length)
 
 
 def _build_quantifier(minimum: int | None, maximum: int | None) -> str: