schemathesis 4.1.4__py3-none-any.whl → 4.2.1__py3-none-any.whl

schemathesis/cli/commands/run/executor.py

@@ -105,7 +105,7 @@ def initialize_handlers(
         if report.enabled:
             path = config.reports.get_path(format)
             open_file(path)
-            handlers.append(CassetteWriter(format=format, path=path, config=config))
+            handlers.append(CassetteWriter(format=format, output=path, config=config))
 
     for custom_handler in CUSTOM_HANDLERS:
         handlers.append(custom_handler(*args, **params))

schemathesis/cli/commands/run/handlers/base.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from contextlib import contextmanager
+from io import StringIO
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any, Generator, Protocol, Union
 
 if TYPE_CHECKING:
     from schemathesis.cli.commands.run.context import ExecutionContext
@@ -16,3 +19,27 @@ class EventHandler:
     def start(self, ctx: ExecutionContext) -> None: ...
 
     def shutdown(self, ctx: ExecutionContext) -> None: ...
+
+
+class WritableText(Protocol):
+    """Protocol for text-writable file-like objects."""
+
+    def write(self, s: str) -> int: ...  # pragma: no cover
+    def flush(self) -> None: ...  # pragma: no cover
+
+
+TextOutput = Union[IO[str], StringIO, Path]
+
+
+@contextmanager
+def open_text_output(output: TextOutput) -> Generator[IO[str]]:
+    """Open a text output, handling both Path and file-like objects."""
+    if isinstance(output, Path):
+        f = open(output, "w", encoding="utf-8")
+        try:
+            yield f
+        finally:
+            f.close()
+    else:
+        # Assume it's already a file-like object
+        yield output  # type: ignore[misc]

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -6,7 +6,6 @@ import sys
 import threading
 from dataclasses import dataclass
 from http.cookies import SimpleCookie
-from pathlib import Path
 from queue import Queue
 from typing import IO, Callable, Iterator
 from urllib.parse import parse_qsl, urlparse
@@ -14,7 +13,7 @@ from urllib.parse import parse_qsl, urlparse
 import harfile
 
 from schemathesis.cli.commands.run.context import ExecutionContext
-from schemathesis.cli.commands.run.handlers.base import EventHandler
+from schemathesis.cli.commands.run.handlers.base import EventHandler, TextOutput, open_text_output
 from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisConfig
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
 from schemathesis.core.transforms import deepclone
@@ -33,27 +32,27 @@ class CassetteWriter(EventHandler):
     """Write network interactions to a cassette."""
 
     format: ReportFormat
-    path: Path
+    output: TextOutput
     config: ProjectConfig
     queue: Queue
     worker: threading.Thread
 
-    __slots__ = ("format", "path", "config", "queue", "worker")
+    __slots__ = ("format", "output", "config", "queue", "worker")
 
     def __init__(
         self,
         format: ReportFormat,
-        path: Path,
+        output: TextOutput,
         config: ProjectConfig,
         queue: Queue | None = None,
     ) -> None:
         self.format = format
-        self.path = path
+        self.output = output
         self.config = config
         self.queue = queue or Queue()
 
         kwargs = {
-            "path": self.path,
+            "output": self.output,
             "config": self.config,
             "queue": self.queue,
         }
@@ -119,103 +118,85 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def vcr_writer(path: Path, config: ProjectConfig, 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:
-      - It is much faster. The string-based approach gives only ~2.5% time overhead when `yaml.CDumper` has ~11.2%;
-      - Implementation complexity. We have a quite simple format where almost all values are strings, and it is much
-        simpler to implement it with string composition rather than with adjusting `yaml.Serializer` to emit explicit
-        types. Another point is that with `pyyaml` we need to emit events and handle some low-level details like
-        providing tags, anchors to have incremental writing, with primitive types it is much simpler.
-    """
+def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
+    """Write YAML to a file in an incremental manner."""
     current_id = 1
 
-    def format_header_values(values: list[str]) -> str:
-        return "\n".join(f"      - {json.dumps(v)}" for v in values)
+    def write_header_values(stream: IO, values: list[str]) -> None:
+        for v in values:
+            stream.write(f"      - {json.dumps(v)}\n")
 
     if config.output.sanitization.enabled:
-
-        def format_headers(headers: dict[str, list[str]]) -> str:
-            headers = deepclone(headers)
-            sanitize_value(headers, config=config.output.sanitization)
-            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
-
+        sanitization_keys = config.output.sanitization.keys_to_sanitize
+        sensitive_markers = config.output.sanitization.sensitive_markers
+        replacement = config.output.sanitization.replacement
+
+        def write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                lower_name = name.lower()
+                stream.write(f'      "{name}":\n')
+
+                # Sanitize inline if needed
+                if lower_name in sanitization_keys or any(marker in lower_name for marker in sensitive_markers):
+                    stream.write(f"      - {json.dumps(replacement)}\n")
+                else:
+                    write_header_values(stream, values)
     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 write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                stream.write(f'      "{name}":\n')
+                write_header_values(stream, values)
 
-    def format_check_message(message: str | None) -> str:
-        return "~" if message is None else f"{message!r}"
-
-    def format_checks(checks: list[CheckNode]) -> str:
+    def write_checks(stream: IO, checks: list[CheckNode]) -> None:
         if not checks:
-            return "\n  checks: []"
-        items = "\n".join(
-            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}"""
+            stream.write("\n  checks: []")
+            return
+
+        stream.write("\n  checks:\n")
+        for check in checks:
+            message = check.failure_info.failure.title if check.failure_info else None
+            message_str = "~" if message is None else repr(message)
+            stream.write(
+                f"    - name: '{check.name}'\n"
+                f"      status: '{check.status.name.upper()}'\n"
+                f"      message: {message_str}\n"
+            )
 
     if config.reports.preserve_bytes:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.encoded_body is not None:
-                output.write(
-                    f"""
-    body:
-      encoding: 'utf-8'
-      base64_string: '{request.encoded_body}'"""
-                )
+                stream.write(f"\n    body:\n      encoding: 'utf-8'\n      base64_string: '{request.encoded_body}'")
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.encoded_body is not None:
-                output.write(
-                    f"""    body:
-      encoding: '{response.encoding}'
-      base64_string: '{response.encoded_body}'"""
+                stream.write(
+                    f"    body:\n      encoding: '{response.encoding}'\n      base64_string: '{response.encoded_body}'"
                 )
-
     else:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.body is not None:
                 string = request.body.decode("utf8", "replace")
-                output.write(
-                    """
-    body:
-      encoding: 'utf-8'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write("\n    body:\n      encoding: 'utf-8'\n      string: ")
+                write_double_quoted(stream, string)
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.content is not None:
                 encoding = response.encoding or "utf8"
                 string = response.content.decode(encoding, "replace")
-                output.write(
-                    f"""    body:
-      encoding: '{encoding}'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write(f"    body:\n      encoding: '{encoding}'\n      string: ")
+                write_double_quoted(stream, string)
 
-    with open(path, "w", encoding="utf-8") as stream:
+    with open_text_output(output) as stream:
         while True:
             item = queue.get()
-            if isinstance(item, Initialize):
-                stream.write(
-                    f"""command: '{get_command_representation()}'
-recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
-seed: {item.seed}
-http_interactions:"""
-                )
-            elif isinstance(item, Process):
+            if isinstance(item, Process):
                 for case_id, interaction in item.recorder.interactions.items():
                     case = item.recorder.cases[case_id]
+
+                    # Determine status and checks
                     if interaction.response is not None:
                         if case_id in item.recorder.checks:
                             checks = item.recorder.checks[case_id]
@@ -225,101 +206,93 @@ http_interactions:"""
                                     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
-                    stream.write(
-                        f"""\n- id: '{case_id}'
-  status: '{status.name}'"""
-                    )
+
+                    # Write interaction header
+                    stream.write(f"\n- id: '{case_id}'\n  status: '{status.name}'")
+
+                    # Write metadata if present
                     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
+                        stream.write(
+                            f"\n  generation:\n"
+                            f"    time: {meta.generation.time}\n"
+                            f"    mode: {meta.generation.mode.value}\n"
+                            f"  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
+                            stream.write(f"\n    {kind.value}:\n      mode: '{info.mode.value}'")
+
+                        stream.write(f"\n  phase:\n    name: '{meta.phase.name.value}'\n    data: ")
+
                         if isinstance(meta.phase.data, CoveragePhaseData):
-                            stream.write("""
-      description: """)
+                            stream.write("\n      description: ")
                             write_double_quoted(stream, meta.phase.data.description)
-                            stream.write("""
-      location: """)
+                            stream.write("\n      location: ")
                             write_double_quoted(stream, meta.phase.data.location)
-                            stream.write("""
-      parameter: """)
+                            stream.write("\n      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: """)
+                            stream.write("\n      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  metadata: null")
 
+                    # Sanitize URL if needed
                     if config.output.sanitization.enabled:
                         uri = sanitize_url(interaction.request.uri, config=config.output.sanitization)
                     else:
                         uri = interaction.request.uri
+
                     recorded_at = datetime.datetime.fromtimestamp(
                         interaction.timestamp, datetime.timezone.utc
                     ).isoformat()
+
+                    stream.write(f"\n  recorded_at: '{recorded_at}'")
+                    write_checks(stream, checks)
                     stream.write(
-                        f"""
-  recorded_at: '{recorded_at}'{format_checks(checks)}
-  request:
-    uri: '{uri}'
-    method: '{interaction.request.method}'
-    headers:
-{format_headers(interaction.request.headers)}"""
+                        f"\n  request:\n    uri: '{uri}'\n    method: '{interaction.request.method}'\n    headers:\n"
                     )
-                    format_request_body(stream, interaction.request)
+                    write_headers(stream, interaction.request.headers)
+                    write_request_body(stream, interaction.request)
+
+                    # Write response
                     if interaction.response is not None:
                         stream.write(
-                            f"""
-  response:
-    status:
-      code: '{interaction.response.status_code}'
-      message: {json.dumps(interaction.response.message)}
-    elapsed: '{interaction.response.elapsed}'
-    headers:
-{format_headers(interaction.response.headers)}
-"""
-                        )
-                        format_response_body(stream, interaction.response)
-                        stream.write(
-                            f"""
-    http_version: '{interaction.response.http_version}'"""
+                            f"\n  response:\n"
+                            f"    status:\n"
+                            f"      code: '{interaction.response.status_code}'\n"
+                            f"      message: {json.dumps(interaction.response.message)}\n"
+                            f"    elapsed: '{interaction.response.elapsed}'\n"
+                            f"    headers:\n"
                         )
+                        write_headers(stream, interaction.response.headers)
+                        stream.write("\n")
+                        write_response_body(stream, interaction.response)
+                        stream.write(f"\n    http_version: '{interaction.response.http_version}'")
                     else:
-                        stream.write("""
-  response: null""")
+                        stream.write("\n  response: null")
+
                     current_id += 1
+            elif isinstance(item, Initialize):
+                stream.write(
+                    f"command: '{get_command_representation()}'\n"
+                    f"recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'\n"
+                    f"seed: {item.seed}\n"
+                    f"http_interactions:"
+                )
             else:
                 break
 
@@ -367,8 +340,8 @@ def write_double_quoted(stream: IO, text: str | None) -> None:
     stream.write('"')
 
 
-def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
-    with harfile.open(path) as har:
+def har_writer(output: TextOutput, config: SchemathesisConfig, queue: Queue) -> None:
+    with harfile.open(output) as har:
         while True:
             item = queue.get()
             if isinstance(item, Process):
@@ -454,7 +427,6 @@ def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
                     )
             elif isinstance(item, Finalize):
                 break
-    har.flush()
 
 
 HARFILE_NO_RESPONSE = harfile.Response(

schemathesis/cli/commands/run/handlers/junitxml.py

@@ -2,26 +2,25 @@ from __future__ import annotations
 
 import platform
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Iterable
 
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
-from schemathesis.cli.commands.run.handlers.base import EventHandler
+from schemathesis.cli.commands.run.handlers.base import EventHandler, TextOutput, open_text_output
 from schemathesis.core.failures import format_failures
 from schemathesis.engine import Status, events
 
 
 @dataclass
 class JunitXMLHandler(EventHandler):
-    path: Path
+    output: TextOutput
     test_cases: dict
 
     __slots__ = ("path", "test_cases")
 
-    def __init__(self, path: Path, test_cases: dict | None = None) -> None:
-        self.path = path
+    def __init__(self, output: TextOutput, test_cases: dict | None = None) -> None:
+        self.output = output
         self.test_cases = test_cases or {}
 
     def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
@@ -40,7 +39,7 @@ class JunitXMLHandler(EventHandler):
             test_suites = [
                 TestSuite("schemathesis", test_cases=list(self.test_cases.values()), hostname=platform.node())
             ]
-            with open(self.path, "w", encoding="utf-8") as fd:
+            with open_text_output(self.output) as fd:
                 to_xml_report_file(file_descriptor=fd, test_suites=test_suites, prettyprint=True, encoding="utf-8")
 
     def get_or_create_test_case(self, label: str) -> TestCase:

schemathesis/cli/commands/run/handlers/output.py

@@ -1053,6 +1053,8 @@ class OutputHandler(EventHandler):
             self._check_stateful_warnings(ctx, event)
 
     def _check_warnings(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
+        from schemathesis.core.compat import RefResolutionError
+
         statistic = aggregate_status_codes(event.recorder.interactions.values())
 
         if statistic.total == 0:
@@ -1060,7 +1062,11 @@ class OutputHandler(EventHandler):
 
         assert ctx.find_operation_by_label is not None
         assert event.label is not None
-        operation = ctx.find_operation_by_label(event.label)
+        try:
+            operation = ctx.find_operation_by_label(event.label)
+        except RefResolutionError:
+            # This error will be reported elsewhere anyway
+            return None
 
         warnings = self.config.warnings_for(operation=operation)
 

schemathesis/cli/ext/fs.py

@@ -12,5 +12,5 @@ def open_file(file: Path) -> None:
         raise click.BadParameter(f"'{file.name}': {exc.strerror}") from exc
     try:
         file.open("w", encoding="utf-8")
-    except OSError as exc:
+    except (OSError, ValueError) as exc:
         raise click.BadParameter(f"Could not open file {file.name}: {exc}") from exc

schemathesis/config/_diff_base.py

@@ -69,12 +69,14 @@ class DiffBase:
     @classmethod
     def from_hierarchy(cls, configs: list[T]) -> T:
         # This config will accumulate "merged" config options
+        if len(configs) == 1:
+            return configs[0]
         output = cls()
         for option in cls.__slots__:  # type: ignore
             if option.startswith("_"):
                 continue
             default = getattr(output, option)
-            if is_dataclass(default):
+            if hasattr(default, "__dataclass_fields__"):
                 # Sub-configs require merging of nested config options
                 sub_configs = [getattr(config, option) for config in configs]
                 merged = type(default).from_hierarchy(sub_configs)  # type: ignore[union-attr]

schemathesis/config/_operations.py

@@ -68,6 +68,8 @@ class OperationsConfig(DiffBase):
 
     def get_for_operation(self, operation: APIOperation) -> OperationConfig:
         configs = [config for config in self.operations if config._filter_set.applies_to(operation)]
+        if not configs:
+            return OperationConfig()
         return OperationConfig.from_hierarchy(configs)
 
     def create_filter_set(

schemathesis/config/_phases.py

@@ -17,7 +17,7 @@ class PhaseConfig(DiffBase):
     generation: GenerationConfig
     checks: ChecksConfig
 
-    __slots__ = ("enabled", "generation", "checks")
+    __slots__ = ("enabled", "generation", "checks", "_is_default")
 
     def __init__(
         self,
@@ -29,6 +29,7 @@ class PhaseConfig(DiffBase):
         self.enabled = enabled
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = enabled and generation is None and checks is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> PhaseConfig:
@@ -46,7 +47,7 @@ class ExamplesPhaseConfig(DiffBase):
     generation: GenerationConfig
     checks: ChecksConfig
 
-    __slots__ = ("enabled", "fill_missing", "generation", "checks")
+    __slots__ = ("enabled", "fill_missing", "generation", "checks", "_is_default")
 
     def __init__(
         self,
@@ -60,6 +61,7 @@ class ExamplesPhaseConfig(DiffBase):
         self.fill_missing = fill_missing
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = enabled and not fill_missing and generation is None and checks is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> ExamplesPhaseConfig:
@@ -79,7 +81,14 @@ class CoveragePhaseConfig(DiffBase):
     checks: ChecksConfig
     unexpected_methods: set[str]
 
-    __slots__ = ("enabled", "generate_duplicate_query_parameters", "generation", "checks", "unexpected_methods")
+    __slots__ = (
+        "enabled",
+        "generate_duplicate_query_parameters",
+        "generation",
+        "checks",
+        "unexpected_methods",
+        "_is_default",
+    )
 
     def __init__(
         self,
@@ -95,6 +104,13 @@ class CoveragePhaseConfig(DiffBase):
         self.unexpected_methods = unexpected_methods or DEFAULT_UNEXPECTED_METHODS
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = (
+            enabled
+            and not generate_duplicate_query_parameters
+            and generation is None
+            and checks is None
+            and unexpected_methods is None
+        )
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> CoveragePhaseConfig:
@@ -142,7 +158,7 @@ class StatefulPhaseConfig(DiffBase):
     max_steps: int
     inference: InferenceConfig
 
-    __slots__ = ("enabled", "generation", "checks", "max_steps", "inference")
+    __slots__ = ("enabled", "generation", "checks", "max_steps", "inference", "_is_default")
 
     def __init__(
         self,
@@ -158,6 +174,7 @@ class StatefulPhaseConfig(DiffBase):
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
         self.inference = inference or InferenceConfig()
+        self._is_default = enabled and generation is None and checks is None and max_steps is None and inference is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> StatefulPhaseConfig:

schemathesis/config/_projects.py

@@ -347,6 +347,8 @@ class ProjectConfig(DiffBase):
             for op in self.operations.operations:
                 if op._filter_set.applies_to(operation=operation):
                     configs.append(op.phases)
+        if not configs:
+            return self.phases
         configs.append(self.phases)
         return PhasesConfig.from_hierarchy(configs)
 
@@ -367,7 +369,10 @@ class ProjectConfig(DiffBase):
         if phase is not None:
             phases = self.phases_for(operation=operation)
             phase_config = phases.get_by_name(name=phase)
-            configs.append(phase_config.generation)
+            if not phase_config._is_default:
+                configs.append(phase_config.generation)
+        if not configs:
+            return self.generation
         configs.append(self.generation)
         return GenerationConfig.from_hierarchy(configs)
 
@@ -388,7 +393,10 @@ class ProjectConfig(DiffBase):
         if phase is not None:
             phases = self.phases_for(operation=operation)
             phase_config = phases.get_by_name(name=phase)
-            configs.append(phase_config.checks)
+            if not phase_config._is_default:
+                configs.append(phase_config.checks)
+        if not configs:
+            return self.checks
         configs.append(self.checks)
         return ChecksConfig.from_hierarchy(configs)