schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a11__py3-none-any.whl

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

@@ -6,16 +6,16 @@ import sys
 import threading
 from dataclasses import dataclass, field
 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
 
 import harfile
-from click.utils import LazyFile
 
 from schemathesis.cli.commands.run.context import ExecutionContext
 from schemathesis.cli.commands.run.handlers.base import EventHandler
-from schemathesis.cli.commands.run.reports import ReportFormat
+from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisConfig
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import Response
@@ -33,17 +33,15 @@ class CassetteWriter(EventHandler):
     """Write network interactions to a cassette."""
 
     format: ReportFormat
-    path: LazyFile
-    sanitize_output: bool = True
-    preserve_bytes: bool = False
+    path: Path
+    config: ProjectConfig
     queue: Queue = field(default_factory=Queue)
     worker: threading.Thread = field(init=False)
 
     def __post_init__(self) -> None:
         kwargs = {
             "path": self.path,
-            "sanitize_output": self.sanitize_output,
-            "preserve_bytes": self.preserve_bytes,
+            "config": self.config,
             "queue": self.queue,
         }
         writer: Callable
@@ -55,7 +53,7 @@ class CassetteWriter(EventHandler):
         self.worker.start()
 
     def start(self, ctx: ExecutionContext) -> None:
-        self.queue.put(Initialize(seed=ctx.seed))
+        self.queue.put(Initialize(seed=ctx.config.seed))
 
     def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
         if isinstance(event, events.ScenarioFinished):
@@ -103,7 +101,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def vcr_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queue: Queue) -> None:
+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:
@@ -114,16 +112,15 @@ def vcr_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
         providing tags, anchors to have incremental writing, with primitive types it is much simpler.
     """
     current_id = 1
-    stream = path.open()
 
     def format_header_values(values: list[str]) -> str:
         return "\n".join(f"      - {json.dumps(v)}" for v in values)
 
-    if sanitize_output:
+    if config.output.sanitization.enabled:
 
         def format_headers(headers: dict[str, list[str]]) -> str:
             headers = deepclone(headers)
-            sanitize_value(headers)
+            sanitize_value(headers, config=config.output.sanitization)
             return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
 
     else:
@@ -145,7 +142,7 @@ def vcr_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
   checks:
 {items}"""
 
-    if preserve_bytes:
+    if config.reports.preserve_bytes:
 
         def format_request_body(output: IO, request: Request) -> None:
             if request.encoded_body is not None:
@@ -188,102 +185,105 @@ def vcr_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
                 )
                 write_double_quoted(output, string)
 
-    while True:
-        item = queue.get()
-        if isinstance(item, Initialize):
-            stream.write(
-                f"""command: '{get_command_representation()}'
+    with open(path, "w", encoding="utf-8") 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):
-            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
+                )
+            elif isinstance(item, Process):
+                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:
-                        # 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.ERROR
+                    # Body payloads are handled via separate `stream.write` calls to avoid some allocations
+                    stream.write(
+                        f"""\n- id: '{case_id}'
   status: '{status.name}'"""
-                )
-                meta = case.value.meta
-                if meta is not None:
-                    # Start metadata block
-                    stream.write(f"""
+                    )
+                    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"""
+                        # 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("""
+                        # 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("""
+                            write_double_quoted(stream, meta.phase.data.description)
+                            stream.write("""
       location: """)
-                        write_double_quoted(stream, meta.phase.data.location)
-                        stream.write("""
+                            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("""
+                            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)
+                            if meta.phase.data.parameter_location is not None:
+                                write_double_quoted(stream, meta.phase.data.parameter_location)
+                            else:
+                                stream.write("null")
                         else:
-                            stream.write("null")
+                            # Empty objects for these phases
+                            stream.write("{}")
                     else:
-                        # Empty objects for these phases
-                        stream.write("{}")
-                else:
-                    stream.write("null")
+                        stream.write("null")
 
-                if sanitize_output:
-                    uri = sanitize_url(interaction.request.uri)
-                else:
-                    uri = interaction.request.uri
-                recorded_at = datetime.datetime.fromtimestamp(interaction.timestamp, datetime.timezone.utc).isoformat()
-                stream.write(
-                    f"""
+                    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"""
   recorded_at: '{recorded_at}'{format_checks(checks)}
   request:
     uri: '{uri}'
     method: '{interaction.request.method}'
     headers:
 {format_headers(interaction.request.headers)}"""
-                )
-                format_request_body(stream, interaction.request)
-                if interaction.response is not None:
-                    stream.write(
-                        f"""
+                    )
+                    format_request_body(stream, interaction.request)
+                    if interaction.response is not None:
+                        stream.write(
+                            f"""
   response:
     status:
       code: '{interaction.response.status_code}'
@@ -292,19 +292,18 @@ 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("""
+                        )
+                    else:
+                        stream.write("""
   response: null""")
-                current_id += 1
-        else:
-            break
-    path.close()
+                    current_id += 1
+            else:
+                break
 
 
 def write_double_quoted(stream: IO, text: str | None) -> None:
@@ -350,14 +349,14 @@ def write_double_quoted(stream: IO, text: str | None) -> None:
     stream.write('"')
 
 
-def har_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queue: Queue) -> None:
+def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
     with harfile.open(path) as har:
         while True:
             item = queue.get()
             if isinstance(item, Process):
                 for interaction in item.recorder.interactions.values():
-                    if sanitize_output:
-                        uri = sanitize_url(interaction.request.uri)
+                    if config.output.sanitization.enabled:
+                        uri = sanitize_url(interaction.request.uri, config=config.output.sanitization)
                     else:
                         uri = interaction.request.uri
                     query_params = urlparse(uri).query
@@ -365,7 +364,7 @@ def har_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
                         post_data = harfile.PostData(
                             mimeType=interaction.request.headers.get("Content-Type", [""])[0],
                             text=interaction.request.encoded_body
-                            if preserve_bytes
+                            if config.reports.preserve_bytes
                             else interaction.request.body.decode("utf-8", "replace"),
                         )
                     else:
@@ -376,16 +375,18 @@ def har_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
                             size=interaction.response.body_size or 0,
                             mimeType=content_type,
                             text=interaction.response.encoded_body
-                            if preserve_bytes
+                            if config.reports.preserve_bytes
                             else interaction.response.content.decode("utf-8", "replace")
                             if interaction.response.content is not None
                             else None,
-                            encoding="base64" if interaction.response.content is not None and preserve_bytes else None,
+                            encoding="base64"
+                            if interaction.response.content is not None and config.reports.preserve_bytes
+                            else None,
                         )
                         http_version = f"HTTP/{interaction.response.http_version}"
-                        if sanitize_output:
+                        if config.output.sanitization.enabled:
                             headers = deepclone(interaction.response.headers)
-                            sanitize_value(headers)
+                            sanitize_value(headers, config=config.output.sanitization)
                         else:
                             headers = interaction.response.headers
                         response = harfile.Response(
@@ -405,9 +406,9 @@ def har_writer(path: LazyFile, sanitize_output: bool, preserve_bytes: bool, queu
                         time = 0
                         http_version = ""
 
-                    if sanitize_output:
+                    if config.output.sanitization.enabled:
                         headers = deepclone(interaction.request.headers)
-                        sanitize_value(headers)
+                        sanitize_value(headers, config=config.output.sanitization)
                     else:
                         headers = interaction.request.headers
                     started_datetime = datetime.datetime.fromtimestamp(

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

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import platform
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Iterable
 
-from click.utils import LazyFile
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
@@ -15,7 +15,7 @@ from schemathesis.engine import Status, events
 
 @dataclass
 class JunitXMLHandler(EventHandler):
-    file_handle: LazyFile
+    path: Path
     test_cases: dict = field(default_factory=dict)
 
     def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
@@ -34,7 +34,8 @@ class JunitXMLHandler(EventHandler):
             test_suites = [
                 TestSuite("schemathesis", test_cases=list(self.test_cases.values()), hostname=platform.node())
             ]
-            to_xml_report_file(file_descriptor=self.file_handle, test_suites=test_suites, prettyprint=True)
+            with open(self.path, "w") as fd:
+                to_xml_report_file(file_descriptor=fd, test_suites=test_suites, prettyprint=True)
 
     def get_or_create_test_case(self, label: str) -> TestCase:
         return self.test_cases.setdefault(label, TestCase(label, elapsed_sec=0.0, allow_multiple_subelements=True))
@@ -47,7 +48,7 @@ def add_failure(test_case: TestCase, checks: Iterable[GroupedFailures], context:
             response=group.response,
             failures=group.failures,
             curl=group.code_sample,
-            config=context.output_config,
+            config=context.config.output,
         )
         for idx, group in enumerate(checks, 1)
     ]

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

@@ -13,21 +13,19 @@ import click
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
 from schemathesis.cli.commands.run.events import LoadingFinished, LoadingStarted
 from schemathesis.cli.commands.run.handlers.base import EventHandler
-from schemathesis.cli.commands.run.reports import ReportConfig, ReportFormat
 from schemathesis.cli.constants import ISSUE_TRACKER_URL
 from schemathesis.cli.core import get_terminal_width
+from schemathesis.config import ProjectConfig, ReportFormat
 from schemathesis.core.errors import LoaderError, LoaderErrorKind, format_exception, split_traceback
 from schemathesis.core.failures import MessageBlock, Severity, format_failures
 from schemathesis.core.output import prepare_response_payload
 from schemathesis.core.result import Err, Ok
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.engine import Status, events
-from schemathesis.engine.config import EngineConfig
 from schemathesis.engine.errors import EngineErrorInfo
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.phases.probes import ProbeOutcome
 from schemathesis.engine.recorder import Interaction, ScenarioRecorder
-from schemathesis.experimental import GLOBAL_EXPERIMENTS
 from schemathesis.generation.modes import GenerationMode
 from schemathesis.schemas import ApiStatistic
 
@@ -100,7 +98,7 @@ def display_failures_for_single_test(ctx: ExecutionContext, label: str, checks:
                 failures=group.failures,
                 curl=group.code_sample,
                 formatter=failure_formatter,
-                config=ctx.output_config,
+                config=ctx.config.output,
             )
         )
         click.echo()
@@ -770,12 +768,7 @@ def format_duration(duration_ms: int) -> str:
 
 @dataclass
 class OutputHandler(EventHandler):
-    workers_num: int
-    # Seed can be absent in the deterministic mode
-    seed: int | None
-    rate_limit: str | None
-    wait_for_schema: float | None
-    engine_config: EngineConfig
+    config: ProjectConfig
 
     loading_manager: LoadingProgressManager | None = None
     probing_manager: ProbingProgressManager | None = None
@@ -784,7 +777,6 @@ class OutputHandler(EventHandler):
 
     statistic: ApiStatistic | None = None
     skip_reasons: list[str] = field(default_factory=list)
-    report_config: ReportConfig | None = None
     warnings: WarningData = field(default_factory=WarningData)
     errors: set[events.NonFatalError] = field(default_factory=set)
     phases: dict[PhaseName, tuple[Status, PhaseSkipReason | None]] = field(
@@ -836,6 +828,8 @@ class OutputHandler(EventHandler):
         from rich.style import Style
         from rich.table import Table
 
+        self.config = event.config
+
         assert self.loading_manager is not None
         self.loading_manager.stop()
 
@@ -1068,7 +1062,7 @@ class OutputHandler(EventHandler):
 
         if (
             event.status == Status.SUCCESS
-            and GenerationMode.POSITIVE in self.engine_config.execution.generation.modes
+            and GenerationMode.POSITIVE in self.config.generation_for(operation=None, phase=event.phase.name).modes
             and all_positive_are_rejected(event.recorder)
             and statistic.should_warn_about_only_4xx()
         ):
@@ -1097,6 +1091,7 @@ class OutputHandler(EventHandler):
             )
             self.console.print(message)
             self.console.print()
+            self.probing_manager = None
 
     def _on_fatal_error(self, ctx: ExecutionContext, event: events.FatalError) -> None:
         from rich.padding import Padding
@@ -1116,7 +1111,9 @@ class OutputHandler(EventHandler):
                     self.console.print(Padding(Text(extra), (0, 0, 0, 5)))
                 self.console.print()
 
-            if not (event.exception.kind == LoaderErrorKind.CONNECTION_OTHER and self.wait_for_schema is not None):
+            if not (
+                event.exception.kind == LoaderErrorKind.CONNECTION_OTHER and self.config.wait_for_schema is not None
+            ):
                 suggestion = LOADER_ERROR_SUGGESTIONS.get(event.exception.kind)
                 if suggestion is not None:
                     click.echo(_style(f"{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
@@ -1134,7 +1131,7 @@ class OutputHandler(EventHandler):
         if not (
             isinstance(event.exception, LoaderError)
             and event.exception.kind == LoaderErrorKind.CONNECTION_OTHER
-            and self.wait_for_schema is not None
+            and self.config.wait_for_schema is not None
         ):
             click.echo(_style(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
 
@@ -1195,25 +1192,6 @@ class OutputHandler(EventHandler):
             click.echo(_style("Check base URL or adjust data generation settings", fg="yellow"))
             click.echo()
 
-    def display_experiments(self) -> None:
-        display_section_name("EXPERIMENTS")
-
-        click.echo()
-        for experiment in sorted(GLOBAL_EXPERIMENTS.enabled, key=lambda e: e.name):
-            click.echo(_style(f"🧪 {experiment.name}: ", bold=True), nl=False)
-            click.echo(_style(experiment.description))
-            click.echo(_style(f"   Feedback: {experiment.discussion_url}"))
-            click.echo()
-
-        click.echo(
-            _style(
-                "Your feedback is crucial for experimental features. "
-                "Please visit the provided URL(s) to share your thoughts.",
-                dim=True,
-            )
-        )
-        click.echo()
-
     def display_stateful_failures(self, ctx: ExecutionContext) -> None:
         display_section_name("Stateful tests")
 
@@ -1255,7 +1233,7 @@ class OutputHandler(EventHandler):
                     click.echo(f"\n{indent}<EMPTY>")
                 else:
                     try:
-                        payload = prepare_response_payload(response.text, config=ctx.output_config)
+                        payload = prepare_response_payload(response.text, config=ctx.config.output)
                         click.echo(textwrap.indent(f"\n{payload}", prefix=indent))
                     except UnicodeDecodeError:
                         click.echo(f"\n{indent}<BINARY>")
@@ -1410,24 +1388,27 @@ class OutputHandler(EventHandler):
         display_section_name(message, fg=color)
 
     def display_reports(self) -> None:
-        if self.report_config is not None:
-            reports = [
-                (format.value.upper(), self.report_config.get_path(format).name)
-                for format in ReportFormat
-                if format in self.report_config.formats
-            ]
-
+        reports = self.config.reports
+        if reports.vcr.enabled or reports.har.enabled or reports.junit.enabled:
             click.echo(_style("Reports:", bold=True))
-            for report_type, path in reports:
-                click.echo(_style(f"  - {report_type}: {path}"))
+            for format, report in (
+                (ReportFormat.JUNIT, reports.junit),
+                (ReportFormat.VCR, reports.vcr),
+                (ReportFormat.HAR, reports.har),
+            ):
+                if report.enabled:
+                    path = reports.get_path(format)
+                    click.echo(_style(f"  - {format.value.upper()}: {path}"))
             click.echo()
 
     def display_seed(self) -> None:
         click.echo(_style("Seed: ", bold=True), nl=False)
-        if self.seed is None:
+        # Deterministic mode can be applied to a subset of tests, but we only care if it is enabled everywhere
+        # If not everywhere, then the seed matter and should be displayed
+        if self.config.seed is None or self.config.generation.deterministic:
             click.echo("not used in the deterministic mode")
         else:
-            click.echo(str(self.seed))
+            click.echo(str(self.config.seed))
         click.echo()
 
     def _on_engine_finished(self, ctx: ExecutionContext, event: events.EngineFinished) -> None:
@@ -1450,8 +1431,6 @@ class OutputHandler(EventHandler):
         display_failures(ctx)
         if self.warnings.missing_auth or self.warnings.only_4xx_responses:
             self.display_warnings()
-        if GLOBAL_EXPERIMENTS.enabled:
-            self.display_experiments()
         if ctx.statistic.extraction_failures:
             self.display_stateful_failures(ctx)
         display_section_name("SUMMARY")