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

schemathesis/generation/stateful/state_machine.py

@@ -11,6 +11,7 @@ from hypothesis.stateful import RuleBasedStateMachine
 
 from schemathesis.checks import CheckFunction
 from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.result import Result
 from schemathesis.core.transport import Response
 from schemathesis.generation.case import Case
 
@@ -18,7 +19,7 @@ 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 = (
@@ -36,12 +37,51 @@ DEFAULT_STATE_MACHINE_SETTINGS = hypothesis.settings(
 
 
 @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("__", "_")
@@ -89,10 +129,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 +155,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 +169,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 +300,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

schemathesis/openapi/checks.py

@@ -37,7 +37,6 @@ class UndefinedStatusCode(Failure):
         "allowed_status_codes",
         "message",
         "title",
-        "code",
         "case_id",
         "severity",
     )
@@ -51,7 +50,6 @@ class UndefinedStatusCode(Failure):
         allowed_status_codes: list[int],
         message: str,
         title: str = "Undocumented HTTP status code",
-        code: str = "undefined_status_code",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -60,7 +58,6 @@ class UndefinedStatusCode(Failure):
         self.allowed_status_codes = allowed_status_codes
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -72,7 +69,7 @@ class UndefinedStatusCode(Failure):
 class MissingHeaders(Failure):
     """Some required headers are missing."""
 
-    __slots__ = ("operation", "missing_headers", "message", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "missing_headers", "message", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -81,14 +78,12 @@ class MissingHeaders(Failure):
         missing_headers: list[str],
         message: str,
         title: str = "Missing required headers",
-        code: str = "missing_headers",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.missing_headers = missing_headers
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -105,7 +100,6 @@ class JsonSchemaError(Failure):
         "instance",
         "message",
         "title",
-        "code",
         "case_id",
         "severity",
     )
@@ -121,7 +115,6 @@ class JsonSchemaError(Failure):
         instance: None | bool | float | str | list | dict[str, Any],
         message: str,
         title: str = "Response violates schema",
-        code: str = "json_schema",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -132,7 +125,6 @@ class JsonSchemaError(Failure):
         self.instance = instance
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.HIGH
 
@@ -176,7 +168,7 @@ class JsonSchemaError(Failure):
 class MissingContentType(Failure):
     """Content type header is missing."""
 
-    __slots__ = ("operation", "media_types", "message", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "media_types", "message", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -185,14 +177,12 @@ class MissingContentType(Failure):
         media_types: list[str],
         message: str,
         title: str = "Missing Content-Type header",
-        code: str = "missing_content_type",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.media_types = media_types
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -204,7 +194,7 @@ class MissingContentType(Failure):
 class MalformedMediaType(Failure):
     """Media type name is malformed."""
 
-    __slots__ = ("operation", "actual", "defined", "message", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "actual", "defined", "message", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -214,7 +204,6 @@ class MalformedMediaType(Failure):
         defined: str,
         message: str,
         title: str = "Malformed media type",
-        code: str = "malformed_media_type",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -222,7 +211,6 @@ class MalformedMediaType(Failure):
         self.defined = defined
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -236,7 +224,6 @@ class UndefinedContentType(Failure):
         "defined_content_types",
         "message",
         "title",
-        "code",
         "case_id",
         "severity",
     )
@@ -249,7 +236,6 @@ class UndefinedContentType(Failure):
         defined_content_types: list[str],
         message: str,
         title: str = "Undocumented Content-Type",
-        code: str = "undefined_content_type",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -257,7 +243,6 @@ class UndefinedContentType(Failure):
         self.defined_content_types = defined_content_types
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -269,7 +254,7 @@ class UndefinedContentType(Failure):
 class UseAfterFree(Failure):
     """Resource was used after a successful DELETE operation on it."""
 
-    __slots__ = ("operation", "message", "free", "usage", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "message", "free", "usage", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -279,7 +264,6 @@ class UseAfterFree(Failure):
         free: str,
         usage: str,
         title: str = "Use after free",
-        code: str = "use_after_free",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -287,7 +271,6 @@ class UseAfterFree(Failure):
         self.free = free
         self.usage = usage
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.CRITICAL
 
@@ -299,7 +282,7 @@ class UseAfterFree(Failure):
 class EnsureResourceAvailability(Failure):
     """Resource is not available immediately after creation."""
 
-    __slots__ = ("operation", "message", "created_with", "not_available_with", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "message", "created_with", "not_available_with", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -309,7 +292,6 @@ class EnsureResourceAvailability(Failure):
         created_with: str,
         not_available_with: str,
         title: str = "Resource is not available after creation",
-        code: str = "ensure_resource_availability",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -317,7 +299,6 @@ class EnsureResourceAvailability(Failure):
         self.created_with = created_with
         self.not_available_with = not_available_with
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -329,7 +310,7 @@ class EnsureResourceAvailability(Failure):
 class IgnoredAuth(Failure):
     """The API operation does not check the specified authentication."""
 
-    __slots__ = ("operation", "message", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "message", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -337,13 +318,11 @@ class IgnoredAuth(Failure):
         operation: str,
         message: str,
         title: str = "Authentication declared but not enforced",
-        code: str = "ignored_auth",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.message = message
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.CRITICAL
 
@@ -355,7 +334,7 @@ class IgnoredAuth(Failure):
 class AcceptedNegativeData(Failure):
     """Response with negative data was accepted."""
 
-    __slots__ = ("operation", "message", "status_code", "allowed_statuses", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "message", "status_code", "allowed_statuses", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -365,7 +344,6 @@ class AcceptedNegativeData(Failure):
         status_code: int,
         allowed_statuses: list[str],
         title: str = "Accepted negative data",
-        code: str = "accepted_negative_data",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -373,7 +351,6 @@ class AcceptedNegativeData(Failure):
         self.status_code = status_code
         self.allowed_statuses = allowed_statuses
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 
@@ -385,7 +362,7 @@ class AcceptedNegativeData(Failure):
 class RejectedPositiveData(Failure):
     """Response with positive data was rejected."""
 
-    __slots__ = ("operation", "message", "status_code", "allowed_statuses", "title", "code", "case_id", "severity")
+    __slots__ = ("operation", "message", "status_code", "allowed_statuses", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -395,7 +372,6 @@ class RejectedPositiveData(Failure):
         status_code: int,
         allowed_statuses: list[str],
         title: str = "Rejected positive data",
-        code: str = "rejected_positive_data",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
@@ -403,7 +379,6 @@ class RejectedPositiveData(Failure):
         self.status_code = status_code
         self.allowed_statuses = allowed_statuses
         self.title = title
-        self.code = code
         self.case_id = case_id
         self.severity = Severity.MEDIUM
 

schemathesis/schemas.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from functools import lru_cache, partial
+from functools import cached_property, lru_cache, partial
 from itertools import chain
 from typing import (
     TYPE_CHECKING,
@@ -57,6 +57,34 @@ def get_full_path(base_path: str, path: str) -> str:
     return unquote(urljoin(base_path, quote(path.lstrip("/"))))
 
 
+@dataclass
+class FilteredCount:
+    """Count of total items and those passing filters."""
+
+    total: int
+    selected: int
+
+    __slots__ = ("total", "selected")
+
+    def __init__(self) -> None:
+        self.total = 0
+        self.selected = 0
+
+
+@dataclass
+class ApiStatistic:
+    """Statistics about API operations and links."""
+
+    operations: FilteredCount
+    links: FilteredCount
+
+    __slots__ = ("operations", "links")
+
+    def __init__(self) -> None:
+        self.operations = FilteredCount()
+        self.links = FilteredCount()
+
+
 @dataclass
 class ApiOperationsCount:
     """Statistics about API operations."""
@@ -84,7 +112,6 @@ class BaseSchema(Mapping):
     generation_config: GenerationConfig = field(default_factory=GenerationConfig)
     output_config: OutputConfig = field(default_factory=OutputConfig)
     rate_limiter: Limiter | None = None
-    _operations_count: ApiOperationsCount | None = None
 
     def __post_init__(self) -> None:
         self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
@@ -186,7 +213,7 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def __len__(self) -> int:
-        return self.count_operations().total
+        return self.statistic.operations.total
 
     def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
@@ -225,18 +252,11 @@ class BaseSchema(Mapping):
     def validate(self) -> None:
         raise NotImplementedError
 
-    def count_operations(self) -> ApiOperationsCount:
-        """Count total and selected operations."""
-        if self._operations_count is None:
-            self._operations_count = self._do_count_operations()
-        return self._operations_count
+    @cached_property
+    def statistic(self) -> ApiStatistic:
+        return self._measure_statistic()
 
-    def _do_count_operations(self) -> ApiOperationsCount:
-        """Implementation-specific counting logic."""
-        raise NotImplementedError
-
-    @property
-    def links_count(self) -> int:
+    def _measure_statistic(self) -> ApiStatistic:
         raise NotImplementedError
 
     def get_all_operations(

schemathesis/specs/graphql/schemas.py

@@ -24,9 +24,11 @@ from hypothesis import strategies as st
 from hypothesis_graphql import strategies as gql_st
 from requests.structures import CaseInsensitiveDict
 
+from schemathesis import auths
 from schemathesis.core import NOT_SET, NotSet, Specification
 from schemathesis.core.errors import InvalidSchema, OperationNotFound
 from schemathesis.core.result import Ok, Result
+from schemathesis.generation import GenerationConfig, GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import (
     CaseMetadata,
@@ -38,12 +40,16 @@ from schemathesis.generation.meta import (
     PhaseInfo,
     TestPhase,
 )
+from schemathesis.hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
+from schemathesis.schemas import (
+    APIOperation,
+    APIOperationMap,
+    ApiStatistic,
+    BaseSchema,
+    OperationDefinition,
+)
+from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 
-from ... import auths
-from ...generation import GenerationConfig, GenerationMode
-from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
-from ...schemas import APIOperation, APIOperationMap, ApiOperationsCount, BaseSchema, OperationDefinition
-from ..openapi.constants import LOCATION_TO_CONTAINER
 from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
@@ -140,8 +146,8 @@ class GraphQLSchema(BaseSchema):
     def _get_base_path(self) -> str:
         return cast(str, urlsplit(self.location).path)
 
-    def _do_count_operations(self) -> ApiOperationsCount:
-        counter = ApiOperationsCount()
+    def _measure_statistic(self) -> ApiStatistic:
+        statistic = ApiStatistic()
         raw_schema = self.raw_schema["__schema"]
         dummy_operation = APIOperation(
             base_url=self.get_base_url(),
@@ -159,16 +165,11 @@ class GraphQLSchema(BaseSchema):
                 for type_def in raw_schema.get("types", []):
                     if type_def["name"] == query_type_name:
                         for field in type_def["fields"]:
-                            counter.total += 1
+                            statistic.operations.total += 1
                             dummy_operation.label = f"{query_type_name}.{field['name']}"
                             if not self._should_skip(dummy_operation):
-                                counter.selected += 1
-        return counter
-
-    @property
-    def links_count(self) -> int:
-        # Links are not supported for GraphQL
-        return 0
+                                statistic.operations.selected += 1
+        return statistic
 
     def get_all_operations(
         self, generation_config: GenerationConfig | None = None

schemathesis/specs/openapi/expressions/__init__.py

@@ -8,42 +8,38 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from schemathesis.generation.stateful.state_machine import StepOutput
+
 from . import lexer, nodes, parser
-from .context import ExpressionContext
 
-__all__ = [
-    "lexer",
-    "nodes",
-    "parser",
-    "ExpressionContext",
-]
+__all__ = ["lexer", "nodes", "parser"]
 
 
-def evaluate(expr: Any, context: ExpressionContext, evaluate_nested: bool = False) -> Any:
+def evaluate(expr: Any, output: StepOutput, evaluate_nested: bool = False) -> Any:
     """Evaluate runtime expression in context."""
     if isinstance(expr, (dict, list)) and evaluate_nested:
-        return _evaluate_nested(expr, context)
+        return _evaluate_nested(expr, output)
     if not isinstance(expr, str):
         # Can be a non-string constant
         return expr
-    parts = [node.evaluate(context) for node in parser.parse(expr)]
+    parts = [node.evaluate(output) for node in parser.parse(expr)]
     if len(parts) == 1:
         return parts[0]  # keep the return type the same as the internal value type
     # otherwise, concatenate into a string
     return "".join(str(part) for part in parts if part is not None)
 
 
-def _evaluate_nested(expr: dict[str, Any] | list, context: ExpressionContext) -> Any:
+def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
     if isinstance(expr, dict):
         return {
-            _evaluate_object_key(key, context): evaluate(value, context, evaluate_nested=True)
+            _evaluate_object_key(key, output): evaluate(value, output, evaluate_nested=True)
             for key, value in expr.items()
         }
-    return [evaluate(item, context, evaluate_nested=True) for item in expr]
+    return [evaluate(item, output, evaluate_nested=True) for item in expr]
 
 
-def _evaluate_object_key(key: str, context: ExpressionContext) -> Any:
-    evaluated = evaluate(key, context)
+def _evaluate_object_key(key: str, output: StepOutput) -> Any:
+    evaluated = evaluate(key, output)
     if isinstance(evaluated, str):
         return evaluated
     if isinstance(evaluated, bool):