schemathesis 3.35.1__py3-none-any.whl → 3.35.3__py3-none-any.whl

schemathesis/cli/context.py

@@ -4,7 +4,7 @@ import os
 import shutil
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Generator
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
@@ -60,11 +60,15 @@ class ExecutionContext:
     analysis: Result[AnalysisResult, Exception] | None = None
     output_config: OutputConfig = field(default_factory=OutputConfig)
     state_machine_sink: StateMachineSink | None = None
-    summary_lines: list[str] = field(default_factory=list)
+    initialization_lines: list[str | Generator[str, None, None]] = field(default_factory=list)
+    summary_lines: list[str | Generator[str, None, None]] = field(default_factory=list)
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:
         return self.show_trace
 
-    def add_summary_line(self, line: str) -> None:
+    def add_initialization_line(self, line: str | Generator[str, None, None]) -> None:
+        self.initialization_lines.append(line)
+
+    def add_summary_line(self, line: str | Generator[str, None, None]) -> None:
         self.summary_lines.append(line)

schemathesis/cli/output/default.py

@@ -7,6 +7,7 @@ import textwrap
 import time
 from importlib import metadata
 from queue import Queue
+from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
 import click
@@ -776,6 +777,8 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
+    if context.initialization_lines:
+        _print_lines(context.initialization_lines)
 
 
 def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
@@ -852,12 +855,20 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_statistic(context, event)
     if context.summary_lines:
         click.echo()
-        for line in context.summary_lines:
-            click.echo(line)
+        _print_lines(context.summary_lines)
     click.echo()
     display_summary(event)
 
 
+def _print_lines(lines: list[str | Generator[str, None, None]]) -> None:
+    for entry in lines:
+        if isinstance(entry, str):
+            click.echo(entry)
+        elif isinstance(entry, GeneratorType):
+            for line in entry:
+                click.echo(line)
+
+
 def handle_interrupted(context: ExecutionContext, event: events.Interrupted) -> None:
     click.echo()
     _handle_interrupted(context)

schemathesis/generation/coverage.py

@@ -201,12 +201,12 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                     seen.add(value)
                 elif key == "multipleOf":
                     yield from _negative_multiple_of(ctx, schema, value)
-                elif key == "minLength" and 0 < value < BUFFER_SIZE and "pattern" not in schema:
+                elif key == "minLength" and 0 < value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
                         yield NegativeValue(
                             ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
                         )
-                elif key == "maxLength" and value < BUFFER_SIZE and "pattern" not in schema:
+                elif key == "maxLength" and value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
                         yield NegativeValue(
                             ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
@@ -234,6 +234,17 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                         yield from cover_schema_iter(nctx, sub_schema)
 
 
+def _get_properties(schema: dict | bool) -> dict | bool:
+    if isinstance(schema, dict):
+        if "example" in schema:
+            return {"const": schema["example"]}
+        if "examples" in schema and schema["examples"]:
+            return {"enum": schema["examples"]}
+        if schema.get("type") == "object":
+            return _get_template_schema(schema, "object")
+    return schema
+
+
 def _get_template_schema(schema: dict, ty: str) -> dict:
     if ty == "object":
         properties = schema.get("properties")
@@ -242,10 +253,7 @@ def _get_template_schema(schema: dict, ty: str) -> dict:
                 **schema,
                 "required": list(properties),
                 "type": ty,
-                "properties": {
-                    k: _get_template_schema(v, "object") if isinstance(v, dict) and v.get("type") == "object" else v
-                    for k, v in properties.items()
-                },
+                "properties": {k: _get_properties(v) for k, v in properties.items()},
             }
     return {**schema, "type": ty}
 
@@ -255,14 +263,21 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     # Boundary and near boundary values
     min_length = schema.get("minLength")
     max_length = schema.get("maxLength")
-
-    if not min_length and not max_length:
+    example = schema.get("example")
+    examples = schema.get("examples")
+    if example or examples:
+        if example:
+            yield PositiveValue(example)
+        if examples:
+            for example in examples:
+                yield PositiveValue(example)
+    elif not min_length and not max_length:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
 
     seen = set()
 
-    if min_length is not None and min_length < BUFFER_SIZE and "pattern" not in schema:
+    if min_length is not None and min_length < BUFFER_SIZE:
         # Exactly the minimum length
         yield PositiveValue(ctx.generate_from_schema({**schema, "maxLength": min_length}))
         seen.add(min_length)
@@ -273,7 +288,7 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger}))
             seen.add(larger)
 
-    if max_length is not None and "pattern" not in schema:
+    if max_length is not None:
         # Exactly the maximum length
         if max_length < BUFFER_SIZE and max_length not in seen:
             yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": max_length}))
@@ -310,8 +325,16 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     if exclusive_maximum is not None:
         maximum = exclusive_maximum - 1
     multiple_of = schema.get("multipleOf")
-
-    if not minimum and not maximum:
+    example = schema.get("example")
+    examples = schema.get("examples")
+
+    if example or examples:
+        if example:
+            yield PositiveValue(example)
+        if examples:
+            for example in examples:
+                yield PositiveValue(example)
+    elif not minimum and not maximum:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
 
@@ -357,7 +380,17 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
 
 def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator[GeneratedValue, None, None]:
     seen = set()
-    yield PositiveValue(template)
+    example = schema.get("example")
+    examples = schema.get("examples")
+
+    if example or examples:
+        if example:
+            yield PositiveValue(example)
+        if examples:
+            for example in examples:
+                yield PositiveValue(example)
+    else:
+        yield PositiveValue(template)
     seen.add(len(template))
 
     # Boundary and near-boundary sizes
@@ -390,7 +423,17 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 
 
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
-    yield PositiveValue(template)
+    example = schema.get("example")
+    examples = schema.get("examples")
+
+    if example or examples:
+        if example:
+            yield PositiveValue(example)
+        if examples:
+            for example in examples:
+                yield PositiveValue(example)
+    else:
+        yield PositiveValue(template)
     # Only required properties
     properties = schema.get("properties", {})
     if set(properties) != set(schema.get("required", {})):

schemathesis/models.py

@@ -71,6 +71,14 @@ if TYPE_CHECKING:
     from .transports.responses import GenericResponse, WSGIResponse
 
 
+@dataclass
+class TransitionId:
+    name: str
+    status_code: str
+
+    __slots__ = ("name", "status_code")
+
+
 @dataclass
 class CaseSource:
     """Data sources, used to generate a test case."""
@@ -79,6 +87,7 @@ class CaseSource:
     response: GenericResponse
     elapsed: float
     overrides_all_parameters: bool
+    transition_id: TransitionId
 
     def partial_deepcopy(self) -> CaseSource:
         return self.__class__(
@@ -86,6 +95,7 @@ class CaseSource:
             response=self.response,
             elapsed=self.elapsed,
             overrides_all_parameters=self.overrides_all_parameters,
+            transition_id=self.transition_id,
         )
 
 
@@ -214,9 +224,20 @@ class Case:
     def app(self) -> Any:
         return self.operation.app
 
-    def set_source(self, response: GenericResponse, case: Case, elapsed: float, overrides_all_parameters: bool) -> None:
+    def set_source(
+        self,
+        response: GenericResponse,
+        case: Case,
+        elapsed: float,
+        overrides_all_parameters: bool,
+        transition_id: TransitionId,
+    ) -> None:
         self.source = CaseSource(
-            case=case, response=response, elapsed=elapsed, overrides_all_parameters=overrides_all_parameters
+            case=case,
+            response=response,
+            elapsed=elapsed,
+            overrides_all_parameters=overrides_all_parameters,
+            transition_id=transition_id,
         )
 
     @property

schemathesis/runner/events.py

@@ -14,7 +14,7 @@ from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
-    from ..schemas import BaseSchema
+    from ..schemas import BaseSchema, Specification
     from ..service.models import AnalysisResult
     from ..stateful import events
     from . import probes
@@ -39,6 +39,7 @@ class Initialized(ExecutionEvent):
     """Runner is initialized, settings are prepared, requests session is ready."""
 
     schema: dict[str, Any]
+    specification: Specification
     # Total number of operations in the schema
     operations_count: int | None
     # Total number of links in the schema
@@ -48,6 +49,8 @@ class Initialized(ExecutionEvent):
     seed: int | None
     # The base URL against which the tests are running
     base_url: str
+    # The base path part of every operation
+    base_path: str
     # API schema specification name
     specification_name: str
     # Monotonic clock value when the test run started. Used to properly calculate run duration, since this clock
@@ -71,10 +74,12 @@ class Initialized(ExecutionEvent):
         """Computes all needed data from a schema instance."""
         return cls(
             schema=schema.raw_schema,
+            specification=schema.specification,
             operations_count=schema.operations_count if count_operations else None,
             links_count=schema.links_count if count_links else None,
             location=schema.location,
             base_url=schema.get_base_url(),
+            base_path=schema.base_path,
             start_time=start_time or time.monotonic(),
             started_at=started_at or current_datetime(),
             specification_name=schema.verbose_name,

schemathesis/runner/impl/core.py

@@ -306,13 +306,12 @@ class BaseRunner:
                 if isinstance(stateful_event, stateful_events.SuiteFinished):
                     if stateful_event.failures and status != Status.error:
                         status = Status.failure
-                    for failure in stateful_event.failures:
-                        result.checks.append(failure)
                 elif isinstance(stateful_event, stateful_events.RunStarted):
                     test_start_time = stateful_event.timestamp
                 elif isinstance(stateful_event, stateful_events.RunFinished):
                     test_elapsed_time = stateful_event.timestamp - cast(float, test_start_time)
                 elif isinstance(stateful_event, stateful_events.StepFinished):
+                    result.checks.extend(stateful_event.checks)
                     on_step_finished(stateful_event)
                 elif isinstance(stateful_event, stateful_events.Errored):
                     status = Status.error

schemathesis/runner/serialization.py

@@ -28,7 +28,7 @@ from ..exceptions import (
     make_unique_by_key,
 )
 from ..generation import DataGenerationMethod
-from ..models import Case, Check, Interaction, Request, Response, Status, TestPhase, TestResult
+from ..models import Case, Check, Interaction, Request, Response, Status, TestPhase, TestResult, TransitionId
 from ..transports import deserialize_payload, serialize_payload
 
 if TYPE_CHECKING:
@@ -52,7 +52,9 @@ class SerializedCase:
     method: str
     url: str
     path_template: str
+    full_path: str
     verbose_name: str
+    transition_id: TransitionId | None
     # Transport info
     verify: bool
     # Headers coming from sources outside data generation
@@ -78,7 +80,9 @@ class SerializedCase:
             method=case.method,
             url=request_data.url,
             path_template=case.path,
+            full_path=case.full_path,
             verbose_name=case.operation.verbose_name,
+            transition_id=case.source.transition_id if case.source is not None else None,
             verify=verify,
             extra_headers=request_data.headers,
         )
@@ -174,7 +178,11 @@ class SerializedCheck:
 
 
 def _get_headers(headers: dict[str, Any] | CaseInsensitiveDict) -> dict[str, str]:
-    return {key: value[0] for key, value in headers.items() if key not in get_excluded_headers()}
+    return {
+        key: value[0] if isinstance(value, list) else value
+        for key, value in headers.items()
+        if key not in get_excluded_headers()
+    }
 
 
 @dataclass

schemathesis/schemas.py

@@ -1,12 +1,3 @@
-"""Schema objects provide a convenient interface to raw schemas.
-
-Their responsibilities:
-  - Provide a unified way to work with different types of schemas
-  - Give all paths / methods combinations that are available directly from the schema;
-
-They give only static definitions of paths.
-"""
-
 from __future__ import annotations
 
 from collections.abc import Mapping
@@ -69,6 +60,7 @@ from .types import (
     NotSet,
     PathParameters,
     Query,
+    Specification,
 )
 from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
 
@@ -89,6 +81,7 @@ def get_full_path(base_path: str, path: str) -> str:
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
     transport: Transport
+    specification: Specification
     location: str | None = None
     base_url: str | None = None
     filter_set: FilterSet = field(default_factory=FilterSet)
@@ -408,6 +401,7 @@ class BaseSchema(Mapping):
 
         return self.__class__(
             self.raw_schema,
+            specification=self.specification,
             location=self.location,
             base_url=base_url,  # type: ignore
             app=app,

schemathesis/specs/graphql/loaders.py

@@ -21,7 +21,7 @@ from ...internal.validation import require_relative_url
 from ...loaders import load_schema_from_url
 from ...throttling import build_limiter
 from ...transports.headers import setup_default_headers
-from ...types import PathLike
+from ...types import PathLike, Specification
 
 if TYPE_CHECKING:
     from graphql import DocumentNode
@@ -254,6 +254,7 @@ def from_dict(
         rate_limiter = build_limiter(rate_limit)
     instance = GraphQLSchema(
         raw_schema,
+        specification=Specification.GRAPHQL,
         location=location,
         base_url=base_url,
         app=app,

schemathesis/specs/openapi/links.py

@@ -14,7 +14,7 @@ from jsonschema import RefResolver
 
 from ...constants import NOT_SET
 from ...internal.copy import fast_deepcopy
-from ...models import APIOperation, Case
+from ...models import APIOperation, Case, TransitionId
 from ...parameters import ParameterSet
 from ...stateful import ParsedData, StatefulTest, UnresolvableLink
 from ...stateful.state_machine import Direction
@@ -226,7 +226,16 @@ class OpenAPILink(Direction):
                 if parameter.name not in overrides.get(parameter.location, []):
                     overrides_all_parameters = False
                     break
-        case.set_source(context.response, context.case, elapsed, overrides_all_parameters)
+        case.set_source(
+            context.response,
+            context.case,
+            elapsed,
+            overrides_all_parameters,
+            transition_id=TransitionId(
+                name=self.name,
+                status_code=self.status_code,
+            ),
+        )
 
     def set_parameters(
         self, case: Case, context: expressions.ExpressionContext

schemathesis/specs/openapi/loaders.py

@@ -26,7 +26,7 @@ from ...loaders import load_schema_from_url, load_yaml
 from ...throttling import build_limiter
 from ...transports.content_types import is_json_media_type, is_yaml_media_type
 from ...transports.headers import setup_default_headers
-from ...types import Filter, NotSet, PathLike
+from ...types import Filter, NotSet, PathLike, Specification
 from . import definitions, validation
 
 if TYPE_CHECKING:
@@ -349,6 +349,7 @@ def from_dict(
         _maybe_validate_schema(raw_schema, definitions.SWAGGER_20_VALIDATOR, validate_schema)
         instance = SwaggerV20(
             raw_schema,
+            specification=Specification.OPENAPI,
             app=app,
             base_url=base_url,
             filter_set=filter_set,
@@ -388,6 +389,7 @@ def from_dict(
         _maybe_validate_schema(raw_schema, validator, validate_schema)
         instance = OpenApi30(
             raw_schema,
+            specification=Specification.OPENAPI,
             app=app,
             base_url=base_url,
             filter_set=filter_set,

schemathesis/specs/openapi/parameters.py

@@ -48,11 +48,20 @@ class OpenAPIParameter(Parameter):
 
     @property
     def is_header(self) -> bool:
-        raise NotImplementedError
+        return self.location in ("header", "cookie")
 
     def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
         """Convert parameter's definition to JSON Schema."""
+        # JSON Schema allows `examples` as an array
+        if self.examples_field in self.definition:
+            examples = [
+                example["value"] for example in self.definition[self.examples_field].values() if "value" in example
+            ]
+        else:
+            examples = None
         schema = self.from_open_api_to_json_schema(operation, self.definition)
+        if examples is not None:
+            schema["examples"] = examples
         return self.transform_keywords(schema)
 
     def transform_keywords(self, schema: dict[str, Any]) -> dict[str, Any]:
@@ -117,12 +126,10 @@ class OpenAPI20Parameter(OpenAPIParameter):
         "uniqueItems",
         "enum",
         "multipleOf",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location == "header"
-
 
 @dataclass(eq=False)
 class OpenAPI30Parameter(OpenAPIParameter):
@@ -163,12 +170,10 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "properties",
         "additionalProperties",
         "format",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location in ("header", "cookie")
-
     def from_open_api_to_json_schema(self, operation: APIOperation, open_api_schema: dict[str, Any]) -> dict[str, Any]:
         open_api_schema = get_parameter_schema(operation, open_api_schema)
         return super().from_open_api_to_json_schema(operation, open_api_schema)
@@ -217,6 +222,8 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
         "allOf",
         "properties",
         "additionalProperties",
+        "example",
+        "examples",
     )
     # NOTE. For Open API 2.0 bodies, we still give `x-example` precedence over the schema-level `example` field to keep
     # the precedence rules consistent.

schemathesis/stateful/context.py

@@ -48,6 +48,8 @@ class RunnerContext:
     current_response: GenericResponse | None = None
     # Total number of failures
     failures_count: int = 0
+    # The total number of completed test scenario
+    completed_scenarios: int = 0
     # Metrics collector for targeted testing
     metric_collector: TargetMetricCollector = field(default_factory=lambda: TargetMetricCollector(targets=[]))
 
@@ -64,6 +66,7 @@ class RunnerContext:
         return events.ScenarioStatus.REJECTED
 
     def reset_scenario(self) -> None:
+        self.completed_scenarios += 1
         self.current_step_status = None
         self.current_response = None
 

schemathesis/stateful/runner.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Type
 import hypothesis
 import requests
 from hypothesis.control import current_build_context
-from hypothesis.errors import Flaky
+from hypothesis.errors import Flaky, Unsatisfiable
 from hypothesis.stateful import Rule
 
 from ..exceptions import CheckFailed
@@ -265,6 +265,13 @@ def _execute_state_machine_loop(
             ctx.mark_current_suite_as_seen_in_run()
             continue
         except Exception as exc:
+            if isinstance(exc, Unsatisfiable) and ctx.completed_scenarios > 0:
+                # Sometimes Hypothesis randomly gives up on generating some complex cases. However, if we know that
+                # values are possible to generate based on the previous observations, we retry the generation
+                if ctx.completed_scenarios >= config.hypothesis_settings.max_examples:
+                    # Avoid infinite restarts
+                    break
+                continue
             # Any other exception is an inner error and the test run should be stopped
             suite_status = events.SuiteStatus.ERROR
             event_queue.put(events.Errored(exception=exc))

schemathesis/types.py

@@ -1,3 +1,4 @@
+import enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Set, Tuple, Union
 
@@ -34,3 +35,10 @@ Hook = Union[
 RawAuth = Tuple[str, str]
 # Generic test with any arguments and no return
 GenericTest = Callable[..., None]
+
+
+class Specification(str, enum.Enum):
+    """Specification of the given schema."""
+
+    OPENAPI = "openapi"
+    GRAPHQL = "graphql"