schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/cli/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    import schemathesis.cli
+
+    schemathesis.cli.schemathesis()

schemathesis/cli/callbacks.py

@@ -2,33 +2,36 @@ from __future__ import annotations
 
 import codecs
 import enum
+import operator
 import os
 import re
 import traceback
 from contextlib import contextmanager
-from functools import partial
-from typing import Generator, TYPE_CHECKING, Callable
+from functools import partial, reduce
+from typing import TYPE_CHECKING, Callable, Generator
 from urllib.parse import urlparse
 
 import click
 
-from click.types import LazyFile  # type: ignore
-
 from .. import exceptions, experimental, throttling
 from ..code_samples import CodeSampleStyle
+from ..constants import TRUE_VALUES
 from ..exceptions import extract_nth_traceback
 from ..generation import DataGenerationMethod
-from ..constants import TRUE_VALUES, FALSE_VALUES
+from ..internal.transformation import convert_boolean_string as _convert_boolean_string
 from ..internal.validation import file_exists, is_filename, is_illegal_surrogate
 from ..loaders import load_app
 from ..service.hosts import get_temporary_hosts_file
+from ..stateful import Stateful
 from ..transports.headers import has_invalid_characters, is_latin_1_encodable
-from ..types import PathLike
+from .cassettes import CassetteFormat
 from .constants import DEFAULT_WORKERS
-from ..stateful import Stateful
 
 if TYPE_CHECKING:
     import hypothesis
+    from click.types import LazyFile  # type: ignore[attr-defined]
+
+    from ..types import PathLike
 
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--hypothesis-derandomize` implies no database, so passing `--hypothesis-database` too is invalid."
@@ -338,13 +341,59 @@ def convert_experimental(
 
 
 def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return sum(value, [])
+    return reduce(operator.iadd, value, [])
+
+
+def convert_status_codes(
+    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+) -> list[str] | None:
+    if not value:
+        return value
+
+    invalid = []
+
+    for code in value:
+        if len(code) != 3:
+            invalid.append(code)
+            continue
+
+        if code[0] not in {"1", "2", "3", "4", "5"}:
+            invalid.append(code)
+            continue
+
+        upper_code = code.upper()
+
+        if "X" in upper_code:
+            if (
+                upper_code[1:] == "XX"
+                or (upper_code[1] == "X" and upper_code[2].isdigit())
+                or (upper_code[1].isdigit() and upper_code[2] == "X")
+            ):
+                continue
+            else:
+                invalid.append(code)
+                continue
+
+        if not code.isnumeric():
+            invalid.append(code)
+
+    if invalid:
+        raise click.UsageError(
+            f"Invalid status code(s): {', '.join(invalid)}. "
+            "Use valid 3-digit codes between 100 and 599, "
+            "or wildcards (e.g., 2XX, 2X0, 20X), where X is a wildcard digit."
+        )
+    return value
 
 
 def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:
     return CodeSampleStyle.from_str(value)
 
 
+def convert_cassette_format(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CassetteFormat:
+    return CassetteFormat.from_str(value)
+
+
 def convert_data_generation_method(
     ctx: click.core.Context, param: click.core.Parameter, value: str
 ) -> list[DataGenerationMethod]:
@@ -374,11 +423,7 @@ def convert_hosts_file(ctx: click.core.Context, param: click.core.Parameter, val
 
 
 def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> str | bool:
-    if value.lower() in TRUE_VALUES:
-        return True
-    if value.lower() in FALSE_VALUES:
-        return False
-    return value
+    return _convert_boolean_string(value)
 
 
 def convert_report(ctx: click.core.Context, param: click.core.Option, value: LazyFile) -> LazyFile:

schemathesis/cli/cassettes.py

@@ -1,30 +1,53 @@
 from __future__ import annotations
+
 import base64
+import enum
 import json
 import re
 import sys
 import threading
 from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
 from queue import Queue
-from typing import IO, Any, Generator, Iterator, cast, TYPE_CHECKING
+from typing import IO, TYPE_CHECKING, Any, Callable, Generator, Iterator, cast
+from urllib.parse import parse_qsl, urlparse
+
+import harfile
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
-from ..types import RequestCert
 from .handlers import EventHandler
 
 if TYPE_CHECKING:
     import click
     import requests
+
     from ..models import Request, Response
     from ..runner.serialization import SerializedCheck, SerializedInteraction
+    from ..types import RequestCert
     from .context import ExecutionContext
-    from ..generation import DataGenerationMethod
 
 # Wait until the worker terminates
 WRITER_WORKER_JOIN_TIMEOUT = 1
 
 
+class CassetteFormat(str, enum.Enum):
+    """Type of the cassette."""
+
+    VCR = "vcr"
+    HAR = "har"
+
+    @classmethod
+    def from_str(cls, value: str) -> CassetteFormat:
+        try:
+            return cls[value.upper()]
+        except KeyError:
+            available_formats = ", ".join(cls)
+            raise ValueError(
+                f"Invalid value for cassette format: {value}. Available formats: {available_formats}"
+            ) from None
+
+
 @dataclass
 class CassetteWriter(EventHandler):
     """Write interactions in a YAML cassette.
@@ -34,42 +57,47 @@ class CassetteWriter(EventHandler):
     """
 
     file_handle: click.utils.LazyFile
+    format: CassetteFormat
     preserve_exact_body_bytes: bool
     queue: Queue = field(default_factory=Queue)
     worker: threading.Thread = field(init=False)
 
     def __post_init__(self) -> None:
-        self.worker = threading.Thread(
-            target=worker,
-            kwargs={
-                "file_handle": self.file_handle,
-                "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
-                "queue": self.queue,
-            },
-        )
+        kwargs = {
+            "file_handle": self.file_handle,
+            "queue": self.queue,
+            "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
+        }
+        writer: Callable
+        if self.format == CassetteFormat.HAR:
+            writer = har_writer
+        else:
+            writer = vcr_writer
+        self.worker = threading.Thread(name="SchemathesisCassetteWriter", target=writer, kwargs=kwargs)
         self.worker.start()
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.Initialized):
             # In the beginning we write metadata and start `http_interactions` list
-            self.queue.put(Initialize())
-        if isinstance(event, events.AfterExecution):
-            # Seed is always present at this point, the original Optional[int] type is there because `TestResult`
-            # instance is created before `seed` is generated on the hypothesis side
-            seed = cast(int, event.result.seed)
+            self.queue.put(Initialize(seed=event.seed))
+        elif isinstance(event, events.AfterExecution):
             self.queue.put(
                 Process(
-                    seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
-                    # NOTE: For backward compatibility reasons AfterExecution stores a list of data generation methods
-                    # The list always contains one element - the method that was actually used for generation
-                    # This will change in the future
-                    data_generation_method=event.data_generation_method[0],
                     interactions=event.result.interactions,
                 )
             )
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.AfterStatefulExecution):
+            self.queue.put(
+                Process(
+                    # Correlation ID is not used in stateful testing
+                    correlation_id="",
+                    thread_id=event.thread_id,
+                    interactions=event.result.interactions,
+                )
+            )
+        elif isinstance(event, events.Finished):
             self.shutdown()
 
     def shutdown(self) -> None:
@@ -84,15 +112,15 @@ class CassetteWriter(EventHandler):
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
+    seed: int | None
+
 
 @dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int
     correlation_id: str
     thread_id: int
-    data_generation_method: DataGenerationMethod
     interactions: list[SerializedInteraction]
 
 
@@ -110,7 +138,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
     """Write YAML to a file in an incremental manner.
 
     This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
@@ -130,13 +158,18 @@ def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, q
         return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
 
     def format_check_message(message: str | None) -> str:
-        return "~" if message is None else f"{repr(message)}"
+        return "~" if message is None else f"{message!r}"
 
     def format_checks(checks: list[SerializedCheck]) -> str:
-        return "\n".join(
+        if not checks:
+            return "  checks: []"
+        items = "\n".join(
             f"    - name: '{check.name}'\n      status: '{check.value.name.upper()}'\n      message: {format_check_message(check.message)}"
             for check in checks
         )
+        return f"""
+  checks:
+{items}"""
 
     if preserve_exact_body_bytes:
 
@@ -181,9 +214,11 @@ def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, q
                 )
                 write_double_quoted(output, string)
 
+    seed = "null"
     while True:
         item = queue.get()
         if isinstance(item, Initialize):
+            seed = f"'{item.seed}'"
             stream.write(
                 f"""command: '{get_command_representation()}'
 recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
@@ -193,16 +228,45 @@ http_interactions:"""
             for interaction in item.interactions:
                 status = interaction.status.name.upper()
                 # Body payloads are handled via separate `stream.write` calls to avoid some allocations
+                phase = f"'{interaction.phase.value}'" if interaction.phase is not None else "null"
                 stream.write(
                     f"""\n- id: '{current_id}'
   status: '{status}'
-  seed: '{item.seed}'
+  seed: {seed}
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
-  data_generation_method: '{item.data_generation_method.value}'
-  elapsed: '{interaction.response.elapsed}'
+  data_generation_method: '{interaction.data_generation_method.value}'
+  meta:
+    description: """
+                )
+
+                if interaction.description is not None:
+                    write_double_quoted(stream, interaction.description)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    location: ")
+                if interaction.location is not None:
+                    write_double_quoted(stream, interaction.location)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    parameter: ")
+                if interaction.parameter is not None:
+                    write_double_quoted(stream, interaction.parameter)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    parameter_location: ")
+                if interaction.parameter_location is not None:
+                    write_double_quoted(stream, interaction.parameter_location)
+                else:
+                    stream.write("null")
+                stream.write(
+                    f"""
+  phase: {phase}
+  elapsed: '{interaction.response.elapsed if interaction.response else 0}'
   recorded_at: '{interaction.recorded_at}'
-  checks:
 {format_checks(interaction.checks)}
   request:
     uri: '{interaction.request.uri}'
@@ -211,8 +275,9 @@ http_interactions:"""
 {format_headers(interaction.request.headers)}"""
                 )
                 format_request_body(stream, interaction.request)
-                stream.write(
-                    f"""
+                if interaction.response is not None:
+                    stream.write(
+                        f"""
   response:
     status:
       code: '{interaction.response.status_code}'
@@ -220,12 +285,16 @@ http_interactions:"""
     headers:
 {format_headers(interaction.response.headers)}
 """
-                )
-                format_response_body(stream, interaction.response)
-                stream.write(
-                    f"""
+                    )
+                    format_response_body(stream, interaction.response)
+                    stream.write(
+                        f"""
     http_version: '{interaction.response.http_version}'"""
-                )
+                    )
+                else:
+                    stream.write("""
+  response: null
+""")
                 current_id += 1
         else:
             break
@@ -254,8 +323,8 @@ def write_double_quoted(stream: IO, text: str) -> None:
             ch = text[end]
         if (
             ch is None
-            or ch in '"\\\x85\u2028\u2029\uFEFF'
-            or not ("\x20" <= ch <= "\x7E" or ("\xA0" <= ch <= "\uD7FF" or "\uE000" <= ch <= "\uFFFD"))
+            or ch in '"\\\x85\u2028\u2029\ufeff'
+            or not ("\x20" <= ch <= "\x7e" or ("\xa0" <= ch <= "\ud7ff" or "\ue000" <= ch <= "\ufffd"))
         ):
             if start < end:
                 stream.write(text[start:end])
@@ -264,18 +333,135 @@ def write_double_quoted(stream: IO, text: str) -> None:
                 # Escape character
                 if ch in Emitter.ESCAPE_REPLACEMENTS:
                     data = "\\" + Emitter.ESCAPE_REPLACEMENTS[ch]
-                elif ch <= "\xFF":
-                    data = "\\x%02X" % ord(ch)
-                elif ch <= "\uFFFF":
-                    data = "\\u%04X" % ord(ch)
+                elif ch <= "\xff":
+                    data = f"\\x{ord(ch):02X}"
+                elif ch <= "\uffff":
+                    data = f"\\u{ord(ch):04X}"
                 else:
-                    data = "\\U%08X" % ord(ch)
+                    data = f"\\U{ord(ch):08X}"
                 stream.write(data)
                 start = end + 1
         end += 1
     stream.write('"')
 
 
+def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+    if preserve_exact_body_bytes:
+
+        def get_body(body: str) -> str:
+            return body
+    else:
+
+        def get_body(body: str) -> str:
+            return base64.b64decode(body).decode("utf-8", errors="replace")
+
+    with harfile.open(file_handle) as har:
+        while True:
+            item = queue.get()
+            if isinstance(item, Process):
+                for interaction in item.interactions:
+                    query_params = urlparse(interaction.request.uri).query
+                    if interaction.request.body is not None:
+                        post_data = harfile.PostData(
+                            mimeType=interaction.request.headers.get("Content-Type", [""])[0],
+                            text=get_body(interaction.request.body),
+                        )
+                    else:
+                        post_data = None
+                    if interaction.response is not None:
+                        content_type = interaction.response.headers.get("Content-Type", [""])[0]
+                        content = harfile.Content(
+                            size=interaction.response.body_size or 0,
+                            mimeType=content_type,
+                            text=get_body(interaction.response.body) if interaction.response.body is not None else None,
+                            encoding="base64"
+                            if interaction.response.body is not None and preserve_exact_body_bytes
+                            else None,
+                        )
+                        http_version = f"HTTP/{interaction.response.http_version}"
+                        response = harfile.Response(
+                            status=interaction.response.status_code,
+                            httpVersion=http_version,
+                            statusText=interaction.response.message,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.response.headers.items()
+                            ],
+                            cookies=_extract_cookies(interaction.response.headers.get("Set-Cookie", [])),
+                            content=content,
+                            headersSize=_headers_size(interaction.response.headers),
+                            bodySize=interaction.response.body_size or 0,
+                            redirectURL=interaction.response.headers.get("Location", [""])[0],
+                        )
+                        time = round(interaction.response.elapsed * 1000, 2)
+                    else:
+                        response = HARFILE_NO_RESPONSE
+                        time = 0
+                        http_version = ""
+
+                    har.add_entry(
+                        startedDateTime=interaction.recorded_at,
+                        time=time,
+                        request=harfile.Request(
+                            method=interaction.request.method.upper(),
+                            url=interaction.request.uri,
+                            httpVersion=http_version,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.request.headers.items()
+                            ],
+                            queryString=[
+                                harfile.Record(name=name, value=value)
+                                for name, value in parse_qsl(query_params, keep_blank_values=True)
+                            ],
+                            cookies=_extract_cookies(interaction.request.headers.get("Cookie", [])),
+                            headersSize=_headers_size(interaction.request.headers),
+                            bodySize=interaction.request.body_size or 0,
+                            postData=post_data,
+                        ),
+                        response=response,
+                        timings=harfile.Timings(send=0, wait=0, receive=time, blocked=0, dns=0, connect=0, ssl=0),
+                    )
+            elif isinstance(item, Finalize):
+                break
+
+
+HARFILE_NO_RESPONSE = harfile.Response(
+    status=0,
+    httpVersion="",
+    statusText="",
+    headers=[],
+    cookies=[],
+    content=harfile.Content(),
+)
+
+
+def _headers_size(headers: dict[str, list[str]]) -> int:
+    size = 0
+    for name, values in headers.items():
+        # 4 is for ": " and "\r\n"
+        size += len(name) + 4 + len(values[0])
+    return size
+
+
+def _extract_cookies(headers: list[str]) -> list[harfile.Cookie]:
+    return [cookie for items in headers for item in items for cookie in _cookie_to_har(item)]
+
+
+def _cookie_to_har(cookie: str) -> Iterator[harfile.Cookie]:
+    parsed = SimpleCookie(cookie)
+    for name, data in parsed.items():
+        yield harfile.Cookie(
+            name=name,
+            value=data.value,
+            path=data["path"] or None,
+            domain=data["domain"] or None,
+            expires=data["expires"] or None,
+            httpOnly=data["httponly"] or None,
+            secure=data["secure"] or None,
+        )
+
+
 @dataclass
 class Replayed:
     interaction: dict[str, Any]
@@ -351,9 +537,9 @@ def filter_cassette(
 
 def get_prepared_request(data: dict[str, Any]) -> requests.PreparedRequest:
     """Create a `requests.PreparedRequest` from a serialized one."""
-    from requests.structures import CaseInsensitiveDict
-    from requests.cookies import RequestsCookieJar
     import requests
+    from requests.cookies import RequestsCookieJar
+    from requests.structures import CaseInsensitiveDict
 
     prepared = requests.PreparedRequest()
     prepared.method = data["method"]

schemathesis/cli/constants.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
+
 from enum import IntEnum, unique
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import hypothesis
+
 MIN_WORKERS = 1
 DEFAULT_WORKERS = MIN_WORKERS
 MAX_WORKERS = 64
@@ -40,11 +42,15 @@ class HealthCheck(IntEnum):
     filter_too_much = 2
     too_slow = 3
     large_base_example = 7
+    all = 8
 
-    def as_hypothesis(self) -> hypothesis.HealthCheck:
+    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
         from hypothesis import HealthCheck
 
-        return HealthCheck[self.name]
+        if self.name == "all":
+            return list(HealthCheck)
+
+        return [HealthCheck[self.name]]
 
 
 @unique

schemathesis/cli/context.py

@@ -1,17 +1,25 @@
 from __future__ import annotations
-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
-from ..runner.serialization import SerializedTestResult
+from ..internal.output import OutputConfig
 
 if TYPE_CHECKING:
+    import os
+    from queue import Queue
+
     import hypothesis
 
+    from ..internal.result import Result
+    from ..runner.probes import ProbeRun
+    from ..runner.serialization import SerializedTestResult
+    from ..service.models import AnalysisResult
+    from ..stateful.sink import StateMachineSink
+
 
 @dataclass
 class ServiceReportContext:
@@ -49,7 +57,19 @@ class ExecutionContext:
     verbosity: int = 0
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     report: ServiceReportContext | FileReportContext | None = None
+    probes: list[ProbeRun] | None = None
+    analysis: Result[AnalysisResult, Exception] | None = None
+    output_config: OutputConfig = field(default_factory=OutputConfig)
+    state_machine_sink: StateMachineSink | None = None
+    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_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/debug.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
+
 import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-
 from .handlers import EventHandler
 
 if TYPE_CHECKING:
     from click.utils import LazyFile
+
     from ..runner import events
     from .context import ExecutionContext
 

schemathesis/cli/handlers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from ..runner import events
@@ -8,6 +8,9 @@ if TYPE_CHECKING:
 
 
 class EventHandler:
+    def __init__(self, *args: Any, **params: Any) -> None:
+        pass
+
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         raise NotImplementedError