schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/cli/{cassettes.py → commands/run/handlers/cassettes.py}

@@ -1,31 +1,28 @@
 from __future__ import annotations
 
-import base64
+import datetime
 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, TYPE_CHECKING, Any, Callable, Generator, Iterator, cast
+from typing import IO, Callable, Iterator
 from urllib.parse import parse_qsl, urlparse
 
+import click
 import harfile
 
-from ..constants import SCHEMATHESIS_VERSION
-from ..runner import events
-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 schemathesis.cli.commands.run.context import ExecutionContext
+from schemathesis.cli.commands.run.handlers.base import EventHandler
+from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import Response
+from schemathesis.core.version import SCHEMATHESIS_VERSION
+from schemathesis.engine import Status, events
+from schemathesis.engine.recorder import CheckNode, Request, ScenarioRecorder
+from schemathesis.generation.meta import CoveragePhaseData
 
 # Wait until the worker terminates
 WRITER_WORKER_JOIN_TIMEOUT = 1
@@ -49,58 +46,39 @@ class CassetteFormat(str, enum.Enum):
 
 
 @dataclass
-class CassetteWriter(EventHandler):
-    """Write interactions in a YAML cassette.
+class CassetteConfig:
+    path: click.utils.LazyFile
+    format: CassetteFormat = CassetteFormat.VCR
+    preserve_exact_body_bytes: bool = False
+    sanitize_output: bool = True
 
-    A low-level interface is used to write data to YAML file during the test run and reduce the delay at
-    the end of the test run.
-    """
 
-    file_handle: click.utils.LazyFile
-    format: CassetteFormat
-    preserve_exact_body_bytes: bool
+@dataclass
+class CassetteWriter(EventHandler):
+    """Write network interactions to a cassette."""
+
+    config: CassetteConfig
     queue: Queue = field(default_factory=Queue)
     worker: threading.Thread = field(init=False)
 
     def __post_init__(self) -> None:
-        kwargs = {
-            "file_handle": self.file_handle,
-            "queue": self.queue,
-            "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
-        }
+        kwargs = {"config": self.config, "queue": self.queue}
         writer: Callable
-        if self.format == CassetteFormat.HAR:
+        if self.config.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(seed=event.seed))
-        elif isinstance(event, events.AfterExecution):
-            self.queue.put(
-                Process(
-                    correlation_id=event.correlation_id,
-                    thread_id=event.thread_id,
-                    interactions=event.result.interactions,
-                )
-            )
-        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 start(self, ctx: ExecutionContext) -> None:
+        self.queue.put(Initialize(seed=ctx.seed))
+
+    def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
+        if isinstance(event, events.ScenarioFinished):
+            self.queue.put(Process(recorder=event.recorder))
 
-    def shutdown(self) -> None:
+    def shutdown(self, ctx: ExecutionContext) -> None:
         self.queue.put(Finalize())
         self._stop_worker()
 
@@ -114,20 +92,24 @@ class Initialize:
 
     seed: int | None
 
+    __slots__ = ("seed",)
+
 
 @dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    correlation_id: str
-    thread_id: int
-    interactions: list[SerializedInteraction]
+    recorder: ScenarioRecorder
+
+    __slots__ = ("recorder",)
 
 
 @dataclass
 class Finalize:
     """The work is done and there will be no more messages to process."""
 
+    __slots__ = ()
+
 
 def get_command_representation() -> str:
     """Get how Schemathesis was run."""
@@ -138,7 +120,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+def vcr_writer(config: CassetteConfig, 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:
@@ -149,52 +131,61 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
         providing tags, anchors to have incremental writing, with primitive types it is much simpler.
     """
     current_id = 1
-    stream = file_handle.open()
+    stream = config.path.open()
 
     def format_header_values(values: list[str]) -> str:
         return "\n".join(f"      - {json.dumps(v)}" for v in values)
 
-    def format_headers(headers: dict[str, list[str]]) -> str:
-        return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
+    if config.sanitize_output:
+
+        def format_headers(headers: dict[str, list[str]]) -> str:
+            headers = deepclone(headers)
+            sanitize_value(headers)
+            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
+
+    else:
+
+        def format_headers(headers: dict[str, list[str]]) -> str:
+            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"{message!r}"
 
-    def format_checks(checks: list[SerializedCheck]) -> str:
+    def format_checks(checks: list[CheckNode]) -> str:
         if not checks:
-            return "  checks: []"
+            return "\n  checks: []"
         items = "\n".join(
-            f"    - name: '{check.name}'\n      status: '{check.value.name.upper()}'\n      message: {format_check_message(check.message)}"
+            f"    - name: '{check.name}'\n      status: '{check.status.name.upper()}'\n      message: {format_check_message(check.failure_info.failure.title if check.failure_info else None)}"
             for check in checks
         )
         return f"""
   checks:
 {items}"""
 
-    if preserve_exact_body_bytes:
+    if config.preserve_exact_body_bytes:
 
         def format_request_body(output: IO, request: Request) -> None:
-            if request.body is not None:
+            if request.encoded_body is not None:
                 output.write(
                     f"""
     body:
       encoding: 'utf-8'
-      base64_string: '{request.body}'"""
+      base64_string: '{request.encoded_body}'"""
                 )
 
         def format_response_body(output: IO, response: Response) -> None:
-            if response.body is not None:
+            if response.encoded_body is not None:
                 output.write(
                     f"""    body:
       encoding: '{response.encoding}'
-      base64_string: '{response.body}'"""
+      base64_string: '{response.encoded_body}'"""
                 )
 
     else:
 
         def format_request_body(output: IO, request: Request) -> None:
             if request.body is not None:
-                string = _safe_decode(request.body, "utf8")
+                string = request.body.decode("utf8", "replace")
                 output.write(
                     """
     body:
@@ -204,9 +195,9 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                 write_double_quoted(output, string)
 
         def format_response_body(output: IO, response: Response) -> None:
-            if response.body is not None:
+            if response.content is not None:
                 encoding = response.encoding or "utf8"
-                string = _safe_decode(response.body, encoding)
+                string = response.content.decode(encoding, "replace")
                 output.write(
                     f"""    body:
       encoding: '{encoding}'
@@ -214,62 +205,94 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                 )
                 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}'
+seed: {item.seed}
 http_interactions:"""
             )
         elif isinstance(item, Process):
-            for interaction in item.interactions:
-                status = interaction.status.name.upper()
+            for case_id, interaction in item.recorder.interactions.items():
+                case = item.recorder.cases[case_id]
+                if interaction.response is not None:
+                    if case_id in item.recorder.checks:
+                        checks = item.recorder.checks[case_id]
+                        status = Status.SUCCESS
+                        for check in checks:
+                            if check.status == Status.FAILURE:
+                                status = check.status
+                                break
+                    else:
+                        # NOTE: Checks recording could be skipped if Schemathesis start skipping just
+                        # discovered failures in order to get past them and potentially discover more failures
+                        checks = []
+                        status = Status.SKIP
+                else:
+                    checks = []
+                    status = Status.ERROR
                 # 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: {seed}
-  thread_id: {item.thread_id}
-  correlation_id: '{item.correlation_id}'
-  data_generation_method: '{interaction.data_generation_method.value}'
-  meta:
-    description: """
+                    f"""\n- id: '{case_id}'
+  status: '{status.name}'"""
                 )
-
-                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)
+                meta = case.value.meta
+                if meta is not None:
+                    # Start metadata block
+                    stream.write(f"""
+  generation:
+    time: {meta.generation.time}
+    mode: {meta.generation.mode.value}
+  components:""")
+
+                    # Write components
+                    for kind, info in meta.components.items():
+                        stream.write(f"""
+    {kind.value}:
+      mode: '{info.mode.value}'""")
+                    # Write phase info
+                    stream.write("\n  phase:")
+                    stream.write(f"\n    name: '{meta.phase.name.value}'")
+                    stream.write("\n    data: ")
+
+                    # Write phase-specific data
+                    if isinstance(meta.phase.data, CoveragePhaseData):
+                        stream.write("""
+      description: """)
+                        write_double_quoted(stream, meta.phase.data.description)
+                        stream.write("""
+      location: """)
+                        write_double_quoted(stream, meta.phase.data.location)
+                        stream.write("""
+      parameter: """)
+                        if meta.phase.data.parameter is not None:
+                            write_double_quoted(stream, meta.phase.data.parameter)
+                        else:
+                            stream.write("null")
+                        stream.write("""
+      parameter_location: """)
+                        if meta.phase.data.parameter_location is not None:
+                            write_double_quoted(stream, meta.phase.data.parameter_location)
+                        else:
+                            stream.write("null")
+                    else:
+                        # Empty objects for these phases
+                        stream.write("{}")
                 else:
                     stream.write("null")
 
-                stream.write("\n    parameter_location: ")
-                if interaction.parameter_location is not None:
-                    write_double_quoted(stream, interaction.parameter_location)
+                if config.sanitize_output:
+                    uri = sanitize_url(interaction.request.uri)
                 else:
-                    stream.write("null")
+                    uri = interaction.request.uri
+                recorded_at = datetime.datetime.fromtimestamp(interaction.timestamp, datetime.timezone.utc).isoformat()
                 stream.write(
                     f"""
-  phase: {phase}
-  elapsed: '{interaction.response.elapsed if interaction.response else 0}'
-  recorded_at: '{interaction.recorded_at}'
-{format_checks(interaction.checks)}
+  recorded_at: '{recorded_at}'{format_checks(checks)}
   request:
-    uri: '{interaction.request.uri}'
+    uri: '{uri}'
     method: '{interaction.request.method}'
     headers:
 {format_headers(interaction.request.headers)}"""
@@ -282,6 +305,7 @@ http_interactions:"""
     status:
       code: '{interaction.response.status_code}'
       message: {json.dumps(interaction.response.message)}
+    elapsed: '{interaction.response.elapsed}'
     headers:
 {format_headers(interaction.response.headers)}
 """
@@ -293,23 +317,21 @@ http_interactions:"""
                     )
                 else:
                     stream.write("""
-  response: null
-""")
+  response: null""")
                 current_id += 1
         else:
             break
-    file_handle.close()
-
+    config.path.close()
 
-def _safe_decode(value: str, encoding: str) -> str:
-    """Decode base64-encoded body bytes as a string."""
-    return base64.b64decode(value).decode(encoding, "replace")
 
-
-def write_double_quoted(stream: IO, text: str) -> None:
+def write_double_quoted(stream: IO, text: str | None) -> None:
     """Writes a valid YAML string enclosed in double quotes."""
     from yaml.emitter import Emitter
 
+    if text is None:
+        stream.write("null")
+        return
+
     # Adapted from `yaml.Emitter.write_double_quoted`:
     #   - Doesn't split the string, therefore doesn't track the current column
     #   - Doesn't encode the input
@@ -345,26 +367,23 @@ def write_double_quoted(stream: IO, text: str) -> None:
     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:
+def har_writer(config: CassetteConfig, queue: Queue) -> None:
+    with harfile.open(config.path) as har:
         while True:
             item = queue.get()
             if isinstance(item, Process):
-                for interaction in item.interactions:
-                    query_params = urlparse(interaction.request.uri).query
+                for interaction in item.recorder.interactions.values():
+                    if config.sanitize_output:
+                        uri = sanitize_url(interaction.request.uri)
+                    else:
+                        uri = interaction.request.uri
+                    query_params = urlparse(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),
+                            text=interaction.request.encoded_body
+                            if config.preserve_exact_body_bytes
+                            else interaction.request.body.decode("utf-8", "replace"),
                         )
                     else:
                         post_data = None
@@ -373,25 +392,31 @@ def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                         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,
+                            text=interaction.response.encoded_body
+                            if config.preserve_exact_body_bytes
+                            else interaction.response.content.decode("utf-8", "replace")
+                            if interaction.response.content is not None
+                            else None,
                             encoding="base64"
-                            if interaction.response.body is not None and preserve_exact_body_bytes
+                            if interaction.response.content is not None and config.preserve_exact_body_bytes
                             else None,
                         )
                         http_version = f"HTTP/{interaction.response.http_version}"
+                        if config.sanitize_output:
+                            headers = deepclone(interaction.response.headers)
+                            sanitize_value(headers)
+                        else:
+                            headers = interaction.response.headers
                         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", [])),
+                            headers=[harfile.Record(name=name, value=values[0]) for name, values in headers.items()],
+                            cookies=_extract_cookies(headers.get("Set-Cookie", [])),
                             content=content,
-                            headersSize=_headers_size(interaction.response.headers),
+                            headersSize=_headers_size(headers),
                             bodySize=interaction.response.body_size or 0,
-                            redirectURL=interaction.response.headers.get("Location", [""])[0],
+                            redirectURL=headers.get("Location", [""])[0],
                         )
                         time = round(interaction.response.elapsed * 1000, 2)
                     else:
@@ -399,23 +424,28 @@ def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                         time = 0
                         http_version = ""
 
+                    if config.sanitize_output:
+                        headers = deepclone(interaction.request.headers)
+                        sanitize_value(headers)
+                    else:
+                        headers = interaction.request.headers
+                    started_datetime = datetime.datetime.fromtimestamp(
+                        interaction.timestamp, datetime.timezone.utc
+                    ).isoformat()
                     har.add_entry(
-                        startedDateTime=interaction.recorded_at,
+                        startedDateTime=started_datetime,
                         time=time,
                         request=harfile.Request(
                             method=interaction.request.method.upper(),
-                            url=interaction.request.uri,
+                            url=uri,
                             httpVersion=http_version,
-                            headers=[
-                                harfile.Record(name=name, value=values[0])
-                                for name, values in interaction.request.headers.items()
-                            ],
+                            headers=[harfile.Record(name=name, value=values[0]) for name, values in 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),
+                            cookies=_extract_cookies(headers.get("Cookie", [])),
+                            headersSize=_headers_size(headers),
                             bodySize=interaction.request.body_size or 0,
                             postData=post_data,
                         ),
@@ -460,102 +490,3 @@ def _cookie_to_har(cookie: str) -> Iterator[harfile.Cookie]:
             httpOnly=data["httponly"] or None,
             secure=data["secure"] or None,
         )
-
-
-@dataclass
-class Replayed:
-    interaction: dict[str, Any]
-    response: requests.Response
-
-
-def replay(
-    cassette: dict[str, Any],
-    id_: str | None = None,
-    status: str | None = None,
-    uri: str | None = None,
-    method: str | None = None,
-    request_tls_verify: bool = True,
-    request_cert: RequestCert | None = None,
-    request_proxy: str | None = None,
-) -> Generator[Replayed, None, None]:
-    """Replay saved interactions."""
-    import requests
-
-    session = requests.Session()
-    session.verify = request_tls_verify
-    session.cert = request_cert
-    kwargs = {}
-    if request_proxy is not None:
-        kwargs["proxies"] = {"all": request_proxy}
-    for interaction in filter_cassette(cassette["http_interactions"], id_, status, uri, method):
-        request = get_prepared_request(interaction["request"])
-        response = session.send(request, **kwargs)  # type: ignore
-        yield Replayed(interaction, response)
-
-
-def filter_cassette(
-    interactions: list[dict[str, Any]],
-    id_: str | None = None,
-    status: str | None = None,
-    uri: str | None = None,
-    method: str | None = None,
-) -> Iterator[dict[str, Any]]:
-    filters = []
-
-    def id_filter(item: dict[str, Any]) -> bool:
-        return item["id"] == id_
-
-    def status_filter(item: dict[str, Any]) -> bool:
-        status_ = cast(str, status)
-        return item["status"].upper() == status_.upper()
-
-    def uri_filter(item: dict[str, Any]) -> bool:
-        uri_ = cast(str, uri)
-        return bool(re.search(uri_, item["request"]["uri"]))
-
-    def method_filter(item: dict[str, Any]) -> bool:
-        method_ = cast(str, method)
-        return bool(re.search(method_, item["request"]["method"]))
-
-    if id_ is not None:
-        filters.append(id_filter)
-
-    if status is not None:
-        filters.append(status_filter)
-
-    if uri is not None:
-        filters.append(uri_filter)
-
-    if method is not None:
-        filters.append(method_filter)
-
-    def is_match(interaction: dict[str, Any]) -> bool:
-        return all(filter_(interaction) for filter_ in filters)
-
-    return filter(is_match, interactions)
-
-
-def get_prepared_request(data: dict[str, Any]) -> requests.PreparedRequest:
-    """Create a `requests.PreparedRequest` from a serialized one."""
-    import requests
-    from requests.cookies import RequestsCookieJar
-    from requests.structures import CaseInsensitiveDict
-
-    prepared = requests.PreparedRequest()
-    prepared.method = data["method"]
-    prepared.url = data["uri"]
-    prepared._cookies = RequestsCookieJar()  # type: ignore
-    if "body" in data:
-        body = data["body"]
-        if "base64_string" in body:
-            content = body["base64_string"]
-            if content:
-                prepared.body = base64.b64decode(content)
-        else:
-            content = body["string"]
-            if content:
-                prepared.body = content.encode("utf8")
-    # There is always 1 value in a request
-    headers = [(key, value[0]) for key, value in data["headers"].items()]
-    prepared.headers = CaseInsensitiveDict(headers)
-    return prepared