schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -1,246 +0,0 @@
-"""High-level API for creating Hypothesis tests."""
-from __future__ import annotations
-
-import asyncio
-import warnings
-from typing import Any, Callable, Generator, Mapping, Optional, Tuple
-
-import hypothesis
-from hypothesis import Phase
-from hypothesis import strategies as st
-from hypothesis.errors import HypothesisWarning, Unsatisfiable
-from hypothesis.internal.reflection import proxies
-from jsonschema.exceptions import SchemaError
-
-from .auths import get_auth_storage_from_test
-from .constants import DEFAULT_DEADLINE
-from .exceptions import OperationSchemaError, SerializationNotPossible
-from .generation import DataGenerationMethod, GenerationConfig
-from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher
-from .models import APIOperation, Case
-from .transports.content_types import parse_content_type
-from .transports.headers import has_invalid_characters, is_latin_1_encodable
-from .utils import GivenInput, combine_strategies
-
-
-def create_test(
-    *,
-    operation: APIOperation,
-    test: Callable,
-    settings: hypothesis.settings | None = None,
-    seed: int | None = None,
-    data_generation_methods: list[DataGenerationMethod],
-    generation_config: GenerationConfig | None = None,
-    as_strategy_kwargs: dict[str, Any] | None = None,
-    keep_async_fn: bool = False,
-    _given_args: tuple[GivenInput, ...] = (),
-    _given_kwargs: dict[str, GivenInput] | None = None,
-) -> Callable:
-    """Create a Hypothesis test."""
-    hook_dispatcher = getattr(test, "_schemathesis_hooks", None)
-    auth_storage = get_auth_storage_from_test(test)
-    strategies = []
-    skip_on_not_negated = len(data_generation_methods) == 1 and DataGenerationMethod.negative in data_generation_methods
-    for data_generation_method in data_generation_methods:
-        strategies.append(
-            operation.as_strategy(
-                hooks=hook_dispatcher,
-                auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
-                generation_config=generation_config,
-                skip_on_not_negated=skip_on_not_negated,
-                **(as_strategy_kwargs or {}),
-            )
-        )
-    strategy = combine_strategies(strategies)
-    _given_kwargs = (_given_kwargs or {}).copy()
-    _given_kwargs.setdefault("case", strategy)
-
-    # Each generated test should be a unique function. It is especially important for the case when Schemathesis runs
-    # tests in multiple threads because Hypothesis stores some internal attributes on function objects and re-writing
-    # them from different threads may lead to unpredictable side-effects.
-
-    @proxies(test)  # type: ignore
-    def test_function(*args: Any, **kwargs: Any) -> Any:
-        __tracebackhide__ = True
-        return test(*args, **kwargs)
-
-    wrapped_test = hypothesis.given(*_given_args, **_given_kwargs)(test_function)
-    if seed is not None:
-        wrapped_test = hypothesis.seed(seed)(wrapped_test)
-    if asyncio.iscoroutinefunction(test):
-        # `pytest-trio` expects a coroutine function
-        if keep_async_fn:
-            wrapped_test.hypothesis.inner_test = test  # type: ignore
-        else:
-            wrapped_test.hypothesis.inner_test = make_async_test(test)  # type: ignore
-    setup_default_deadline(wrapped_test)
-    if settings is not None:
-        wrapped_test = settings(wrapped_test)
-    existing_settings = _get_hypothesis_settings(wrapped_test)
-    if existing_settings is not None:
-        existing_settings = remove_explain_phase(existing_settings)
-        wrapped_test._hypothesis_internal_use_settings = existing_settings  # type: ignore
-        if Phase.explicit in existing_settings.phases:
-            wrapped_test = add_examples(wrapped_test, operation, hook_dispatcher=hook_dispatcher)
-    return wrapped_test
-
-
-def setup_default_deadline(wrapped_test: Callable) -> None:
-    # Quite hacky, but it is the simplest way to set up the default deadline value without affecting non-Schemathesis
-    # tests globally
-    existing_settings = _get_hypothesis_settings(wrapped_test)
-    if existing_settings is not None and existing_settings.deadline == hypothesis.settings.default.deadline:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", HypothesisWarning)
-            new_settings = hypothesis.settings(existing_settings, deadline=DEFAULT_DEADLINE)
-        wrapped_test._hypothesis_internal_use_settings = new_settings  # type: ignore
-
-
-def remove_explain_phase(settings: hypothesis.settings) -> hypothesis.settings:
-    # The "explain" phase is not supported
-    if Phase.explain in settings.phases:
-        phases = tuple(phase for phase in settings.phases if phase != Phase.explain)
-        return hypothesis.settings(settings, phases=phases)
-    return settings
-
-
-def _get_hypothesis_settings(test: Callable) -> hypothesis.settings | None:
-    return getattr(test, "_hypothesis_internal_use_settings", None)
-
-
-def make_async_test(test: Callable) -> Callable:
-    def async_run(*args: Any, **kwargs: Any) -> None:
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-        coro = test(*args, **kwargs)
-        future = asyncio.ensure_future(coro, loop=loop)
-        loop.run_until_complete(future)
-
-    return async_run
-
-
-def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: HookDispatcher | None = None) -> Callable:
-    """Add examples to the Hypothesis test, if they are specified in the schema."""
-    from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-
-    try:
-        examples: list[Case] = [get_single_example(strategy) for strategy in operation.get_strategies_from_examples()]
-    except (
-        OperationSchemaError,
-        HypothesisRefResolutionError,
-        Unsatisfiable,
-        SerializationNotPossible,
-        SchemaError,
-    ) as exc:
-        # Invalid schema:
-        # In this case, the user didn't pass `--validate-schema=false` and see an error in the output anyway,
-        # and no tests will be executed. For this reason, examples can be skipped
-        # Recursive references: This test will be skipped anyway
-        # Unsatisfiable:
-        # The underlying schema is not satisfiable and test will raise an error for the same reason.
-        # Skipping this exception here allows us to continue the testing process for other operations.
-        # Still, we allow running user-defined hooks
-        examples = []
-        if isinstance(exc, Unsatisfiable):
-            add_unsatisfied_example_mark(test, exc)
-        if isinstance(exc, SerializationNotPossible):
-            add_non_serializable_mark(test, exc)
-        if isinstance(exc, SchemaError):
-            add_invalid_regex_mark(test, exc)
-    context = HookContext(operation)  # context should be passed here instead
-    GLOBAL_HOOK_DISPATCHER.dispatch("before_add_examples", context, examples)
-    operation.schema.hooks.dispatch("before_add_examples", context, examples)
-    if hook_dispatcher:
-        hook_dispatcher.dispatch("before_add_examples", context, examples)
-    original_test = test
-    for example in examples:
-        if example.headers is not None:
-            invalid_headers = dict(find_invalid_headers(example.headers))
-            if invalid_headers:
-                add_invalid_example_header_mark(original_test, invalid_headers)
-                continue
-        if example.media_type is not None:
-            try:
-                media_type = parse_content_type(example.media_type)
-                if media_type == ("application", "x-www-form-urlencoded"):
-                    example.body = prepare_urlencoded(example.body)
-            except ValueError:
-                pass
-        test = hypothesis.example(case=example)(test)
-    return test
-
-
-def find_invalid_headers(headers: Mapping) -> Generator[Tuple[str, str], None, None]:
-    for name, value in headers.items():
-        if not is_latin_1_encodable(value) or has_invalid_characters(name, value):
-            yield name, value
-
-
-def prepare_urlencoded(data: Any) -> Any:
-    if isinstance(data, list):
-        output = []
-        for item in data:
-            if isinstance(item, dict):
-                for key, value in item.items():
-                    output.append((key, value))
-            else:
-                output.append(item)
-        return output
-    return data
-
-
-def add_unsatisfied_example_mark(test: Callable, exc: Unsatisfiable) -> None:
-    test._schemathesis_unsatisfied_example = exc  # type: ignore
-
-
-def has_unsatisfied_example_mark(test: Callable) -> bool:
-    return hasattr(test, "_schemathesis_unsatisfied_example")
-
-
-def add_non_serializable_mark(test: Callable, exc: SerializationNotPossible) -> None:
-    test._schemathesis_non_serializable = exc  # type: ignore
-
-
-def get_non_serializable_mark(test: Callable) -> Optional[SerializationNotPossible]:
-    return getattr(test, "_schemathesis_non_serializable", None)
-
-
-def get_invalid_regex_mark(test: Callable) -> Optional[SchemaError]:
-    return getattr(test, "_schemathesis_invalid_regex", None)
-
-
-def add_invalid_regex_mark(test: Callable, exc: SchemaError) -> None:
-    test._schemathesis_invalid_regex = exc  # type: ignore
-
-
-def get_invalid_example_headers_mark(test: Callable) -> Optional[dict[str, str]]:
-    return getattr(test, "_schemathesis_invalid_example_headers", None)
-
-
-def add_invalid_example_header_mark(test: Callable, headers: dict[str, str]) -> None:
-    test._schemathesis_invalid_example_headers = headers  # type: ignore
-
-
-def get_single_example(strategy: st.SearchStrategy[Case]) -> Case:
-    examples: list[Case] = []
-    add_single_example(strategy, examples)
-    return examples[0]
-
-
-def add_single_example(strategy: st.SearchStrategy[Case], examples: list[Case]) -> None:
-    @hypothesis.given(strategy)  # type: ignore
-    @hypothesis.settings(  # type: ignore
-        database=None,
-        max_examples=1,
-        deadline=None,
-        verbosity=hypothesis.Verbosity.quiet,
-        phases=(hypothesis.Phase.generate,),
-        suppress_health_check=list(hypothesis.HealthCheck),
-    )
-    def example_generating_inner_function(ex: Case) -> None:
-        examples.append(ex)
-
-    example_generating_inner_function()

schemathesis/_override.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
-
-from .exceptions import UsageError
-from .parameters import ParameterSet
-from .types import GenericTest
-
-if TYPE_CHECKING:
-    from .models import APIOperation
-
-
-@dataclass
-class CaseOverride:
-    """Overrides for various parts of a test case."""
-
-    query: dict[str, str]
-    headers: dict[str, str]
-    cookies: dict[str, str]
-    path_parameters: dict[str, str]
-
-    def for_operation(self, operation: APIOperation) -> dict[str, dict[str, str]]:
-        return {
-            "query": (_for_parameters(self.query, operation.query)),
-            "headers": (_for_parameters(self.headers, operation.headers)),
-            "cookies": (_for_parameters(self.cookies, operation.cookies)),
-            "path_parameters": (_for_parameters(self.path_parameters, operation.path_parameters)),
-        }
-
-
-def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[str, str]:
-    output = {}
-    for param in defined:
-        if param.name in overridden:
-            output[param.name] = overridden[param.name]
-    return output
-
-
-def get_override_from_mark(test: GenericTest) -> Optional[CaseOverride]:
-    return getattr(test, "_schemathesis_override", None)
-
-
-def set_override_mark(test: GenericTest, override: CaseOverride) -> None:
-    test._schemathesis_override = override  # type: ignore[attr-defined]
-
-
-def check_no_override_mark(test: GenericTest) -> None:
-    if hasattr(test, "_schemathesis_override"):
-        raise UsageError(f"`{test.__name__}` has already been decorated with `override`.")

schemathesis/cli/cassettes.py

@@ -1,375 +0,0 @@
-from __future__ import annotations
-import base64
-import json
-import re
-import sys
-import threading
-from dataclasses import dataclass, field
-from queue import Queue
-from typing import IO, Any, Generator, Iterator, cast, TYPE_CHECKING
-
-from ..constants import SCHEMATHESIS_VERSION
-from ..runner import events
-from ..types import RequestCert
-from .handlers import EventHandler
-
-if TYPE_CHECKING:
-    import click
-    import requests
-    from ..models import Request, Response
-    from ..runner.serialization import SerializedCheck, SerializedInteraction
-    from .context import ExecutionContext
-    from ..generation import DataGenerationMethod
-
-# Wait until the worker terminates
-WRITER_WORKER_JOIN_TIMEOUT = 1
-
-
-@dataclass
-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
-    preserve_exact_body_bytes: bool
-    queue: Queue = field(default_factory=Queue)
-    worker: threading.Thread = field(init=False)
-
-    def __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,
-                    correlation_id=event.correlation_id,
-                    thread_id=event.thread_id,
-                    # NOTE: For backward compatibility reasons AfterExecution stores a list of data generation methods
-                    # The list always contains one element - the method that was actually used for generation
-                    # This will change in the future
-                    data_generation_method=event.data_generation_method[0],
-                    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)
-
-
-@dataclass
-class Initialize:
-    """Start up, the first message to make preparations before proceeding the input data."""
-
-
-@dataclass
-class Process:
-    """A new chunk of data should be processed."""
-
-    seed: int
-    correlation_id: str
-    thread_id: int
-    data_generation_method: DataGenerationMethod
-    interactions: list[SerializedInteraction]
-
-
-@dataclass
-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 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.
-    """
-    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: str | None) -> 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 {SCHEMATHESIS_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}'
-  thread_id: {item.thread_id}
-  correlation_id: '{item.correlation_id}'
-  data_generation_method: '{item.data_generation_method.value}'
-  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."""
-    from yaml.emitter import Emitter
-
-    # 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('"')
-
-
-@dataclass
-class Replayed:
-    interaction: dict[str, Any]
-    response: requests.Response
-
-
-def replay(
-    cassette: dict[str, Any],
-    id_: str | None = None,
-    status: str | None = None,
-    uri: str | None = None,
-    method: str | None = None,
-    request_tls_verify: bool = True,
-    request_cert: RequestCert | None = None,
-    request_proxy: str | None = None,
-) -> Generator[Replayed, None, None]:
-    """Replay saved interactions."""
-    import requests
-
-    session = requests.Session()
-    session.verify = request_tls_verify
-    session.cert = request_cert
-    kwargs = {}
-    if request_proxy is not None:
-        kwargs["proxies"] = {"all": request_proxy}
-    for interaction in filter_cassette(cassette["http_interactions"], id_, status, uri, method):
-        request = get_prepared_request(interaction["request"])
-        response = session.send(request, **kwargs)  # type: ignore
-        yield Replayed(interaction, response)
-
-
-def filter_cassette(
-    interactions: list[dict[str, Any]],
-    id_: str | None = None,
-    status: str | None = None,
-    uri: str | None = None,
-    method: str | None = None,
-) -> Iterator[dict[str, Any]]:
-    filters = []
-
-    def id_filter(item: dict[str, Any]) -> bool:
-        return item["id"] == id_
-
-    def status_filter(item: dict[str, Any]) -> bool:
-        status_ = cast(str, status)
-        return item["status"].upper() == status_.upper()
-
-    def uri_filter(item: dict[str, Any]) -> bool:
-        uri_ = cast(str, uri)
-        return bool(re.search(uri_, item["request"]["uri"]))
-
-    def method_filter(item: dict[str, Any]) -> bool:
-        method_ = cast(str, method)
-        return bool(re.search(method_, item["request"]["method"]))
-
-    if id_ is not None:
-        filters.append(id_filter)
-
-    if status is not None:
-        filters.append(status_filter)
-
-    if uri is not None:
-        filters.append(uri_filter)
-
-    if method is not None:
-        filters.append(method_filter)
-
-    def is_match(interaction: dict[str, Any]) -> bool:
-        return all(filter_(interaction) for filter_ in filters)
-
-    return filter(is_match, interactions)
-
-
-def get_prepared_request(data: dict[str, Any]) -> requests.PreparedRequest:
-    """Create a `requests.PreparedRequest` from a serialized one."""
-    from requests.structures import CaseInsensitiveDict
-    from requests.cookies import RequestsCookieJar
-    import requests
-
-    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