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

schemathesis/cli/callbacks.py

@@ -1,188 +0,0 @@
-import os
-import re
-from contextlib import contextmanager
-from typing import Dict, Generator, List, Optional, Tuple, Union
-from urllib.parse import urlparse
-
-import click
-import hypothesis
-from requests import PreparedRequest, RequestException
-
-from .. import utils
-from ..constants import CodeSampleStyle, DataGenerationMethod
-from ..stateful import Stateful
-from .constants import DEFAULT_WORKERS
-
-
-def validate_schema(ctx: click.core.Context, param: click.core.Parameter, raw_value: str) -> str:
-    if "app" not in ctx.params:
-        try:
-            netloc = urlparse(raw_value).netloc
-        except ValueError as exc:
-            raise click.UsageError("Invalid SCHEMA, must be a valid URL or file path.") from exc
-        if not netloc:
-            if "\x00" in raw_value or not utils.file_exists(raw_value):
-                raise click.UsageError("Invalid SCHEMA, must be a valid URL or file path.")
-            if "base_url" not in ctx.params and not ctx.params.get("dry_run", False):
-                raise click.UsageError('Missing argument, "--base-url" is required for SCHEMA specified by file.')
-        else:
-            _validate_url(raw_value)
-    return raw_value
-
-
-def _validate_url(value: str) -> None:
-    try:
-        PreparedRequest().prepare_url(value, {})  # type: ignore
-    except RequestException as exc:
-        raise click.UsageError("Invalid SCHEMA, must be a valid URL or file path.") from exc
-
-
-def validate_base_url(ctx: click.core.Context, param: click.core.Parameter, raw_value: str) -> str:
-    try:
-        netloc = urlparse(raw_value).netloc
-    except ValueError as exc:
-        raise click.UsageError("Invalid base URL") from exc
-    if raw_value and not netloc:
-        raise click.UsageError("Invalid base URL")
-    return raw_value
-
-
-APPLICATION_FORMAT_MESSAGE = (
-    "Can not import application from the given module!\n"
-    "The `--app` option value should be in format:\n\n    path:variable\n\n"
-    "where `path` is an importable path to a Python module,\n"
-    "and `variable` is a variable name inside that module."
-)
-
-
-def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]) -> Optional[str]:
-    if raw_value is None:
-        return raw_value
-    try:
-        utils.import_app(raw_value)
-        # String is returned instead of an app because it might be passed to a subprocess
-        # Since most app instances are not-transferable to another process, they are passed as strings and
-        # imported in a subprocess
-        return raw_value
-    except Exception as exc:
-        show_errors_tracebacks = ctx.params["show_errors_tracebacks"]
-        message = utils.format_exception(exc, show_errors_tracebacks).strip()
-        click.secho(f"{APPLICATION_FORMAT_MESSAGE}\n\nException:\n\n{message}", fg="red")
-        if not show_errors_tracebacks:
-            click.secho(
-                "\nAdd this option to your command line parameters to see full tracebacks: --show-errors-tracebacks",
-                fg="red",
-            )
-        raise click.exceptions.Exit(1)
-
-
-def validate_auth(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[Tuple[str, str]]:
-    if raw_value is not None:
-        with reraise_format_error(raw_value):
-            user, password = tuple(raw_value.split(":"))
-        if not user:
-            raise click.BadParameter("Username should not be empty")
-        if not utils.is_latin_1_encodable(user):
-            raise click.BadParameter("Username should be latin-1 encodable")
-        if not utils.is_latin_1_encodable(password):
-            raise click.BadParameter("Password should be latin-1 encodable")
-        return user, password
-    return None
-
-
-def validate_headers(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Tuple[str, ...]
-) -> Dict[str, str]:
-    headers = {}
-    for header in raw_value:
-        with reraise_format_error(header):
-            key, value = header.split(":", maxsplit=1)
-        value = value.lstrip()
-        key = key.strip()
-        if not key:
-            raise click.BadParameter("Header name should not be empty")
-        if not utils.is_latin_1_encodable(key):
-            raise click.BadParameter("Header name should be latin-1 encodable")
-        if not utils.is_latin_1_encodable(value):
-            raise click.BadParameter("Header value should be latin-1 encodable")
-        if utils.has_invalid_characters(key, value):
-            raise click.BadParameter("Invalid return character or leading space in header")
-        headers[key] = value
-    return headers
-
-
-def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_value: Tuple[str, ...]) -> Tuple[str, ...]:
-    for value in raw_value:
-        try:
-            re.compile(value)
-        except (re.error, OverflowError, RuntimeError) as exc:
-            raise click.BadParameter(f"Invalid regex: {exc.args[0]}")
-    return raw_value
-
-
-def validate_request_cert_key(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[str]:
-    if raw_value is not None and "request_cert" not in ctx.params:
-        raise click.UsageError('Missing argument, "--request-cert" should be specified as well.')
-    return raw_value
-
-
-def convert_verbosity(
-    ctx: click.core.Context, param: click.core.Parameter, value: Optional[str]
-) -> Optional[hypothesis.Verbosity]:
-    if value is None:
-        return value
-    return hypothesis.Verbosity[value]
-
-
-def convert_stateful(ctx: click.core.Context, param: click.core.Parameter, value: Optional[str]) -> Optional[Stateful]:
-    if value is None:
-        return value
-    return Stateful[value]
-
-
-def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:
-    return CodeSampleStyle.from_str(value)
-
-
-def convert_data_generation_method(
-    ctx: click.core.Context, param: click.core.Parameter, value: str
-) -> List[DataGenerationMethod]:
-    return [DataGenerationMethod[value]]
-
-
-def convert_request_tls_verify(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Union[str, bool]:
-    if value.lower() in ("y", "yes", "t", "true", "on", "1"):
-        return True
-    if value.lower() in ("n", "no", "f", "false", "off", "0"):
-        return False
-    return value
-
-
-@contextmanager
-def reraise_format_error(raw_value: str) -> Generator[None, None, None]:
-    try:
-        yield
-    except ValueError as exc:
-        raise click.BadParameter(f"Should be in KEY:VALUE format. Got: {raw_value}") from exc
-
-
-def get_workers_count() -> int:
-    """Detect the number of available CPUs for the current process, if possible.
-
-    Use ``DEFAULT_WORKERS`` if not possible to detect.
-    """
-    if hasattr(os, "sched_getaffinity"):
-        # In contrast with `os.cpu_count` this call respects limits on CPU resources on some Unix systems
-        return len(os.sched_getaffinity(0))
-    # Number of CPUs in the system, or 1 if undetermined
-    return os.cpu_count() or DEFAULT_WORKERS
-
-
-def convert_workers(ctx: click.core.Context, param: click.core.Parameter, value: str) -> int:
-    if value == "auto":
-        return get_workers_count()
-    return int(value)

schemathesis/cli/cassettes.py

@@ -1,253 +0,0 @@
-import base64
-import json
-import re
-import sys
-import threading
-from queue import Queue
-from typing import Any, Dict, Generator, Iterator, List, Optional, cast
-
-import attr
-import click
-import requests
-from requests.cookies import RequestsCookieJar
-from requests.structures import CaseInsensitiveDict
-
-from .. import constants
-from ..models import Request, Response
-from ..runner import events
-from ..runner.serialization import SerializedCheck, SerializedInteraction
-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
-    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, "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"):
-        return "<unknown entrypoint>"
-    args = " ".join(sys.argv[1:])
-    return f"schemathesis {args}"
-
-
-def worker(file_handle: click.utils.LazyFile, 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
-        )
-
-    def format_request_body(request: Request) -> str:
-        if request.body is not None:
-            return f"""    body:
-      encoding: 'utf-8'
-      base64_string: '{request.body}'"""
-        return ""
-
-    def format_response_body(response: Response) -> str:
-        if response.body is not None:
-            return f"""    body:
-      encoding: '{response.encoding}'
-      base64_string: '{response.body}'"""
-        return ""
-
-    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()
-                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(interaction.request)}
-  response:
-    status:
-      code: '{interaction.response.status_code}'
-      message: {json.dumps(interaction.response.message)}
-    headers:
-{format_headers(interaction.response.headers)}
-{format_response_body(interaction.response)}
-    http_version: '{interaction.response.http_version}'"""
-                )
-                current_id += 1
-        else:
-            break
-    file_handle.close()
-
-
-@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,
-) -> Generator[Replayed, None, None]:
-    """Replay saved interactions."""
-    session = requests.Session()
-    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:
-        encoded = data["body"]["base64_string"]
-        if encoded:
-            prepared.body = base64.b64decode(encoded)
-    # 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,36 +0,0 @@
-import os
-import shutil
-from queue import Queue
-from typing import List, Optional
-
-import attr
-
-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_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_file_name: 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,51 +0,0 @@
-from enum import Enum
-from typing import Any, List, Optional, 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 CSVOption(click.Choice):
-    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]:
-        items = [item for item in value.split(",") if item]
-        invalid_options = set(items) - set(self.choices)
-        if not invalid_options and items:
-            return [self.enum[item] for item in items]
-        # Sort to keep the error output consistent with the passed values
-        sorted_options = ", ".join(sorted(invalid_options, key=items.index))
-        available_options = ", ".join(self.choices)
-        self.fail(f"invalid choice(s): {sorted_options}. Choose from {available_options}")
-
-
-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 == "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