schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/cli/cassettes.py

@@ -1,351 +0,0 @@
-import base64
-import json
-import re
-import sys
-import threading
-from queue import Queue
-from typing import IO, Any, Dict, Generator, Iterator, List, Optional, cast
-
-import attr
-import click
-import requests
-from requests.cookies import RequestsCookieJar
-from requests.structures import CaseInsensitiveDict
-from yaml.emitter import Emitter
-
-from .. import constants
-from ..models import Request, Response
-from ..runner import events
-from ..runner.serialization import SerializedCheck, SerializedInteraction
-from ..types import RequestCert
-from .context import ExecutionContext
-from .handlers import EventHandler
-
-# Wait until the worker terminates
-WRITER_WORKER_JOIN_TIMEOUT = 1
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class CassetteWriter(EventHandler):
-    """Write interactions in a YAML cassette.
-
-    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 = attr.ib()  # pragma: no mutate
-    preserve_exact_body_bytes: bool = attr.ib()  # pragma: no mutate
-    queue: Queue = attr.ib(factory=Queue)  # pragma: no mutate
-    worker: threading.Thread = attr.ib(init=False)  # pragma: no mutate
-
-    def __attrs_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,
-            },
-        )
-        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(
-                Process(
-                    seed=seed,
-                    interactions=event.result.interactions,
-                )
-            )
-        if isinstance(event, events.Finished):
-            self.shutdown()
-
-    def shutdown(self) -> None:
-        self.queue.put(Finalize())
-        self._stop_worker()
-
-    def _stop_worker(self) -> None:
-        self.worker.join(WRITER_WORKER_JOIN_TIMEOUT)
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class Initialize:
-    """Start up, the first message to make preparations before proceeding the input data."""
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class Process:
-    """A new chunk of data should be processed."""
-
-    seed: int = attr.ib()  # pragma: no mutate
-    interactions: List[SerializedInteraction] = attr.ib()  # pragma: no mutate
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class Finalize:
-    """The work is done and there will be no more messages to process."""
-
-
-def get_command_representation() -> str:
-    """Get how Schemathesis was run."""
-    # It is supposed to be executed from Schemathesis CLI, not via Click's `command.invoke`
-    if not sys.argv[0].endswith(("schemathesis", "st")):
-        return "<unknown entrypoint>"
-    args = " ".join(sys.argv[1:])
-    return f"st {args}"
-
-
-def worker(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:
-      - 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 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 strings it is much simpler.
-    """
-    current_id = 1
-    stream = file_handle.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())
-
-    def format_check_message(message: Optional[str]) -> str:
-        return "~" if message is None else f"{repr(message)}"
-
-    def format_checks(checks: List[SerializedCheck]) -> str:
-        return "\n".join(
-            f"    - name: '{check.name}'\n      status: '{check.value.name.upper()}'\n      message: {format_check_message(check.message)}"
-            for check in checks
-        )
-
-    if preserve_exact_body_bytes:
-
-        def format_request_body(output: IO, request: Request) -> None:
-            if request.body is not None:
-                output.write(
-                    f"""    body:
-      encoding: 'utf-8'
-      base64_string: '{request.body}'"""
-                )
-
-        def format_response_body(output: IO, response: Response) -> None:
-            if response.body is not None:
-                output.write(
-                    f"""    body:
-      encoding: '{response.encoding}'
-      base64_string: '{response.body}'"""
-                )
-
-    else:
-
-        def format_request_body(output: IO, request: Request) -> None:
-            if request.body is not None:
-                string = _safe_decode(request.body, "utf8")
-                output.write(
-                    """    body:
-      encoding: 'utf-8'
-      string: """
-                )
-                write_double_quoted(output, string)
-
-        def format_response_body(output: IO, response: Response) -> None:
-            if response.body is not None:
-                encoding = response.encoding or "utf8"
-                string = _safe_decode(response.body, encoding)
-                output.write(
-                    f"""    body:
-      encoding: '{encoding}'
-      string: """
-                )
-                write_double_quoted(output, string)
-
-    while True:
-        item = queue.get()
-        if isinstance(item, Initialize):
-            stream.write(
-                f"""command: '{get_command_representation()}'
-recorded_with: 'Schemathesis {constants.__version__}'
-http_interactions:"""
-            )
-        elif isinstance(item, Process):
-            for interaction in item.interactions:
-                status = interaction.status.name.upper()
-                # Body payloads are handled via separate `stream.write` calls to avoid some allocations
-                stream.write(
-                    f"""\n- id: '{current_id}'
-  status: '{status}'
-  seed: '{item.seed}'
-  elapsed: '{interaction.response.elapsed}'
-  recorded_at: '{interaction.recorded_at}'
-  checks:
-{format_checks(interaction.checks)}
-  request:
-    uri: '{interaction.request.uri}'
-    method: '{interaction.request.method}'
-    headers:
-{format_headers(interaction.request.headers)}
-"""
-                )
-                format_request_body(stream, interaction.request)
-                stream.write(
-                    f"""
-  response:
-    status:
-      code: '{interaction.response.status_code}'
-      message: {json.dumps(interaction.response.message)}
-    headers:
-{format_headers(interaction.response.headers)}
-"""
-                )
-                format_response_body(stream, interaction.response)
-                stream.write(
-                    f"""
-    http_version: '{interaction.response.http_version}'"""
-                )
-                current_id += 1
-        else:
-            break
-    file_handle.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:
-    """Writes a valid YAML string enclosed in double quotes."""
-    # Adapted from `yaml.Emitter.write_double_quoted`:
-    #   - Doesn't split the string, therefore doesn't track the current column
-    #   - Doesn't encode the input
-    #   - Allows Unicode unconditionally
-    stream.write('"')
-    start = end = 0
-    length = len(text)
-    while end <= length:
-        ch = None
-        if end < length:
-            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"))
-        ):
-            if start < end:
-                stream.write(text[start:end])
-                start = end
-            if ch is not 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)
-                else:
-                    data = "\\U%08X" % ord(ch)
-                stream.write(data)
-                start = end + 1
-        end += 1
-    stream.write('"')
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class Replayed:
-    interaction: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    response: requests.Response = attr.ib()  # pragma: no mutate
-
-
-def replay(
-    cassette: Dict[str, Any],
-    id_: Optional[str] = None,
-    status: Optional[str] = None,
-    uri: Optional[str] = None,
-    method: Optional[str] = None,
-    request_tls_verify: bool = True,
-    request_cert: Optional[RequestCert] = None,
-) -> Generator[Replayed, None, None]:
-    """Replay saved interactions."""
-    session = requests.Session()
-    session.verify = request_tls_verify
-    session.cert = request_cert
-    for interaction in filter_cassette(cassette["http_interactions"], id_, status, uri, method):
-        request = get_prepared_request(interaction["request"])
-        response = session.send(request)  # type: ignore
-        yield Replayed(interaction, response)
-
-
-def filter_cassette(
-    interactions: List[Dict[str, Any]],
-    id_: Optional[str] = None,
-    status: Optional[str] = None,
-    uri: Optional[str] = None,
-    method: Optional[str] = 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."""
-    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

schemathesis/cli/context.py

@@ -1,38 +0,0 @@
-import os
-import shutil
-from queue import Queue
-from typing import List, Optional
-
-import attr
-import hypothesis
-
-from ..constants import CodeSampleStyle
-from ..runner.serialization import SerializedTestResult
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ServiceContext:
-    url: str = attr.ib()  # pragma: no mutate
-    queue: Queue = attr.ib()  # pragma: no mutate
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ExecutionContext:
-    """Storage for the current context of the execution."""
-
-    hypothesis_settings: hypothesis.settings = attr.ib()  # pragma: no mutate
-    hypothesis_output: List[str] = attr.ib(factory=list)  # pragma: no mutate
-    workers_num: int = attr.ib(default=1)  # pragma: no mutate
-    show_errors_tracebacks: bool = attr.ib(default=False)  # pragma: no mutate
-    validate_schema: bool = attr.ib(default=True)  # pragma: no mutate
-    operations_processed: int = attr.ib(default=0)  # pragma: no mutate
-    # It is set in runtime, from a `Initialized` event
-    operations_count: Optional[int] = attr.ib(default=None)  # pragma: no mutate
-    current_line_length: int = attr.ib(default=0)  # pragma: no mutate
-    terminal_size: os.terminal_size = attr.ib(factory=shutil.get_terminal_size)  # pragma: no mutate
-    results: List[SerializedTestResult] = attr.ib(factory=list)  # pragma: no mutate
-    cassette_path: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    junit_xml_file: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    verbosity: int = attr.ib(default=0)  # pragma: no mutate
-    code_sample_style: CodeSampleStyle = attr.ib(default=CodeSampleStyle.default())  # pragma: no mutate
-    service: Optional[ServiceContext] = attr.ib(default=None)  # pragma: no mutate

schemathesis/cli/debug.py

@@ -1,21 +0,0 @@
-import json
-
-import attr
-from click.utils import LazyFile
-
-from ..runner import events
-from .handlers import EventHandler, ExecutionContext
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class DebugOutputHandler(EventHandler):
-    file_handle: LazyFile = attr.ib()  # pragma: no mutate
-
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        stream = self.file_handle.open()
-        data = event.asdict()
-        stream.write(json.dumps(data))
-        stream.write("\n")
-
-    def shutdown(self) -> None:
-        self.file_handle.close()

schemathesis/cli/handlers.py

@@ -1,11 +0,0 @@
-from ..runner import events
-from .context import ExecutionContext
-
-
-class EventHandler:
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        raise NotImplementedError
-
-    def shutdown(self) -> None:
-        # Do nothing by default
-        pass

schemathesis/cli/junitxml.py

@@ -1,41 +0,0 @@
-import platform
-from typing import List, Optional
-
-import attr
-from click.utils import LazyFile
-from junit_xml import TestCase, TestSuite, to_xml_report_file
-
-from ..models import Status
-from ..runner import events
-from ..runner.serialization import deduplicate_failures
-from .handlers import EventHandler, ExecutionContext
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class JunitXMLHandler(EventHandler):
-    file_handle: LazyFile = attr.ib()  # pragma: no mutate
-    test_cases: List = attr.ib(factory=list)  # pragma: no mutate
-    start_time: Optional[float] = attr.ib(default=None)  # pragma: no mutate
-
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        if isinstance(event, events.Initialized):
-            self.start_time = event.start_time
-        if isinstance(event, events.AfterExecution):
-            test_case = TestCase(
-                f"{event.result.method} {event.result.path}",
-                elapsed_sec=event.elapsed_time,
-                allow_multiple_subelements=True,
-            )
-            if event.status == Status.failure:
-                checks = deduplicate_failures(event.result.checks)
-                for idx, check in enumerate(checks, 1):
-                    # `check.message` is always not empty for events with `failure` status
-                    test_case.add_failure_info(message=f"{idx}. {check.message}")
-            if event.status == Status.error:
-                test_case.add_error_info(
-                    message=event.result.errors[-1].exception, output=event.result.errors[-1].exception_with_traceback
-                )
-            self.test_cases.append(test_case)
-        if isinstance(event, events.Finished):
-            test_suites = [TestSuite("schemathesis", test_cases=self.test_cases, hostname=platform.node())]
-            to_xml_report_file(file_descriptor=self.file_handle, test_suites=test_suites, prettyprint=True)

schemathesis/cli/options.py

@@ -1,70 +0,0 @@
-from enum import Enum
-from typing import Any, List, NoReturn, Optional, Set, Tuple, Type, Union
-
-import click
-
-from ..types import NotSet
-
-
-class CustomHelpMessageChoice(click.Choice):
-    """Allows you to customize how choices are displayed in the help message."""
-
-    def __init__(self, *args: Any, choices_repr: str, **kwargs: Any):
-        super().__init__(*args, **kwargs)
-        self.choices_repr = choices_repr
-
-    def get_metavar(self, param: click.Parameter) -> str:
-        return self.choices_repr
-
-
-class BaseCsvChoice(click.Choice):
-    def parse_value(self, value: str) -> Tuple[List[str], Set[str]]:
-        selected = [item for item in value.split(",") if item]
-        invalid_options = set(selected) - set(self.choices)
-        return selected, invalid_options
-
-    def fail_on_invalid_options(self, invalid_options: Set[str], selected: List[str]) -> NoReturn:
-        # Sort to keep the error output consistent with the passed values
-        sorted_options = ", ".join(sorted(invalid_options, key=selected.index))
-        available_options = ", ".join(self.choices)
-        self.fail(f"invalid choice(s): {sorted_options}. Choose from {available_options}")
-
-
-class CsvEnumChoice(BaseCsvChoice):
-    def __init__(self, choices: Type[Enum]):
-        self.enum = choices
-        super().__init__(tuple(choices.__members__))
-
-    def convert(  # type: ignore[return]
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> List[Enum]:
-        selected, invalid_options = self.parse_value(value)
-        if not invalid_options and selected:
-            return [self.enum[item] for item in selected]
-        self.fail_on_invalid_options(invalid_options, selected)
-
-
-class CsvChoice(BaseCsvChoice):
-    def convert(
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> List[str]:
-        selected, invalid_options = self.parse_value(value)
-        if not invalid_options and selected:
-            return selected
-        self.fail_on_invalid_options(invalid_options, selected)
-
-
-not_set = NotSet()
-
-
-class OptionalInt(click.types.IntRange):
-    def convert(  # type: ignore
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> Union[int, NotSet]:
-        if value.lower() == "none":
-            return not_set
-        try:
-            int(value)
-            return super().convert(value, param, ctx)
-        except ValueError:
-            self.fail("%s is not a valid integer or None" % value, param, ctx)

schemathesis/cli/output/__init__.py

@@ -1 +0,0 @@
-from . import default, short