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

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/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/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):

schemathesis/specs/openapi/expressions/nodes.py

@@ -9,10 +9,10 @@ from typing import TYPE_CHECKING, Any, cast
 from requests.structures import CaseInsensitiveDict
 
 from schemathesis.core.transforms import UNRESOLVABLE, resolve_pointer
+from schemathesis.generation.stateful.state_machine import StepOutput
 from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
 if TYPE_CHECKING:
-    from .context import ExpressionContext
     from .extractors import Extractor
 
 
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         raise NotImplementedError
 
 
@@ -39,7 +39,7 @@ class String(Node):
 
     value: str
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -53,11 +53,11 @@ class String(Node):
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         import requests
 
-        base_url = context.case.operation.base_url or "http://127.0.0.1"
-        kwargs = REQUESTS_TRANSPORT.serialize_case(context.case, base_url=base_url)
+        base_url = output.case.operation.base_url or "http://127.0.0.1"
+        kwargs = REQUESTS_TRANSPORT.serialize_case(output.case, base_url=base_url)
         prepared = requests.Request(**kwargs).prepare()
         return cast(str, prepared.url)
 
@@ -66,16 +66,16 @@ class URL(Node):
 class Method(Node):
     """A node for `$method` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.operation.method.upper()
+    def evaluate(self, output: StepOutput) -> str:
+        return output.case.operation.method.upper()
 
 
 @dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return str(context.response.status_code)
+    def evaluate(self, output: StepOutput) -> str:
+        return str(output.response.status_code)
 
 
 @dataclass
@@ -86,11 +86,11 @@ class NonBodyRequest(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         container: dict | CaseInsensitiveDict = {
-            "query": context.case.query,
-            "path": context.case.path_parameters,
-            "header": context.case.headers,
+            "query": output.case.query,
+            "path": output.case.path_parameters,
+            "header": output.case.headers,
         }[self.location] or {}
         if self.location == "header":
             container = CaseInsensitiveDict(container)
@@ -108,8 +108,8 @@ class BodyRequest(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        document = context.case.body
+    def evaluate(self, output: StepOutput) -> Any:
+        document = output.case.body
         if self.pointer is None:
             return document
         resolved = resolve_pointer(document, self.pointer[1:])
@@ -125,8 +125,8 @@ class HeaderResponse(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        value = context.response.headers.get(self.parameter.lower())
+    def evaluate(self, output: StepOutput) -> str:
+        value = output.response.headers.get(self.parameter.lower())
         if value is None:
             return ""
         if self.extractor is not None:
@@ -140,8 +140,8 @@ class BodyResponse(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        document = context.response.json()
+    def evaluate(self, output: StepOutput) -> Any:
+        document = output.response.json()
         if self.pointer is None:
             # We need the parsed document - data will be serialized before sending to the application
             return document