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

schemathesis/runner/impl/solo.py

@@ -1,85 +0,0 @@
-import threading
-from typing import Generator, Optional, Union
-
-import attr
-
-from ...models import TestResultSet
-from ...types import RequestCert
-from ...utils import get_requests_auth
-from .. import events
-from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SingleThreadRunner(BaseRunner):
-    """Fast runner that runs tests sequentially in the main thread."""
-
-    request_tls_verify: Union[bool, str] = attr.ib(default=True)  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib(default=None)  # pragma: no mutate
-
-    def _execute(
-        self, results: TestResultSet, stop_event: threading.Event
-    ) -> Generator[events.ExecutionEvent, None, None]:
-        for event in self._execute_impl(results):
-            yield event
-            if stop_event.is_set() or self._should_stop(event):
-                break
-
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
-        auth = get_requests_auth(self.auth, self.auth_type)
-        with get_session(auth) as session:
-            yield from self._run_tests(
-                self.schema.get_all_tests,
-                network_test,
-                self.hypothesis_settings,
-                self.seed,
-                checks=self.checks,
-                max_response_time=self.max_response_time,
-                targets=self.targets,
-                results=results,
-                session=session,
-                headers=self.headers,
-                request_timeout=self.request_timeout,
-                request_tls_verify=self.request_tls_verify,
-                request_cert=self.request_cert,
-                store_interactions=self.store_interactions,
-                dry_run=self.dry_run,
-            )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SingleThreadWSGIRunner(SingleThreadRunner):
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
-        yield from self._run_tests(
-            self.schema.get_all_tests,
-            wsgi_test,
-            self.hypothesis_settings,
-            self.seed,
-            checks=self.checks,
-            max_response_time=self.max_response_time,
-            targets=self.targets,
-            results=results,
-            auth=self.auth,
-            auth_type=self.auth_type,
-            headers=self.headers,
-            store_interactions=self.store_interactions,
-            dry_run=self.dry_run,
-        )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SingleThreadASGIRunner(SingleThreadRunner):
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
-        yield from self._run_tests(
-            self.schema.get_all_tests,
-            asgi_test,
-            self.hypothesis_settings,
-            self.seed,
-            checks=self.checks,
-            max_response_time=self.max_response_time,
-            targets=self.targets,
-            results=results,
-            headers=self.headers,
-            store_interactions=self.store_interactions,
-            dry_run=self.dry_run,
-        )

schemathesis/runner/impl/threadpool.py

@@ -1,367 +0,0 @@
-import ctypes
-import queue
-import threading
-import time
-from queue import Queue
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Union, cast
-
-import attr
-import hypothesis
-
-from ..._hypothesis import create_test
-from ...models import CheckFunction, TestResultSet
-from ...stateful import Feedback, Stateful
-from ...targets import Target
-from ...types import RawAuth, RequestCert
-from ...utils import Ok, capture_hypothesis_output, get_requests_auth
-from .. import events
-from .core import BaseRunner, asgi_test, get_session, handle_schema_error, network_test, run_test, wsgi_test
-
-
-def _run_task(
-    test_template: Callable,
-    tasks_queue: Queue,
-    events_queue: Queue,
-    generator_done: threading.Event,
-    checks: Iterable[CheckFunction],
-    targets: Iterable[Target],
-    settings: hypothesis.settings,
-    seed: Optional[int],
-    results: TestResultSet,
-    stateful: Optional[Stateful],
-    stateful_recursion_limit: int,
-    **kwargs: Any,
-) -> None:
-    def _run_tests(maker: Callable, recursion_level: int = 0) -> None:
-        if recursion_level > stateful_recursion_limit:
-            return
-        for _result, _data_generation_method in maker(test_template, settings, seed):
-            # `result` is always `Ok` here
-            _operation, test = _result.ok()
-            feedback = Feedback(stateful, _operation)
-            for _event in run_test(
-                _operation,
-                test,
-                checks,
-                data_generation_method,
-                targets,
-                results,
-                recursion_level=recursion_level,
-                feedback=feedback,
-                **kwargs,
-            ):
-                events_queue.put(_event)
-            _run_tests(feedback.get_stateful_tests, recursion_level + 1)
-
-    with capture_hypothesis_output():
-        while True:
-            try:
-                result, data_generation_method = tasks_queue.get(timeout=0.001)
-            except queue.Empty:
-                # The queue is empty & there will be no more tasks
-                if generator_done.is_set():
-                    break
-                # If there is a possibility for new tasks - try again
-                continue
-            if isinstance(result, Ok):
-                operation = result.ok()
-                test_function = create_test(
-                    operation=operation,
-                    test=test_template,
-                    settings=settings,
-                    seed=seed,
-                    data_generation_method=data_generation_method,
-                )
-                items = (
-                    Ok((operation, test_function)),
-                    data_generation_method,
-                )
-                # This lambda ignores the input arguments to support the same interface for
-                # `feedback.get_stateful_tests`
-                _run_tests(lambda *_: (items,))
-            else:
-                for event in handle_schema_error(result.err(), results, data_generation_method, 0):
-                    events_queue.put(event)
-
-
-def thread_task(
-    tasks_queue: Queue,
-    events_queue: Queue,
-    generator_done: threading.Event,
-    checks: Iterable[CheckFunction],
-    targets: Iterable[Target],
-    settings: hypothesis.settings,
-    auth: Optional[RawAuth],
-    auth_type: Optional[str],
-    headers: Optional[Dict[str, Any]],
-    seed: Optional[int],
-    results: TestResultSet,
-    stateful: Optional[Stateful],
-    stateful_recursion_limit: int,
-    kwargs: Any,
-) -> None:
-    """A single task, that threads do.
-
-    Pretty similar to the default one-thread flow, but includes communication with the main thread via the events queue.
-    """
-    prepared_auth = get_requests_auth(auth, auth_type)
-    with get_session(prepared_auth) as session:
-        _run_task(
-            network_test,
-            tasks_queue,
-            events_queue,
-            generator_done,
-            checks,
-            targets,
-            settings,
-            seed,
-            results,
-            stateful=stateful,
-            stateful_recursion_limit=stateful_recursion_limit,
-            session=session,
-            headers=headers,
-            **kwargs,
-        )
-
-
-def wsgi_thread_task(
-    tasks_queue: Queue,
-    events_queue: Queue,
-    generator_done: threading.Event,
-    checks: Iterable[CheckFunction],
-    targets: Iterable[Target],
-    settings: hypothesis.settings,
-    seed: Optional[int],
-    results: TestResultSet,
-    stateful: Optional[Stateful],
-    stateful_recursion_limit: int,
-    kwargs: Any,
-) -> None:
-    _run_task(
-        wsgi_test,
-        tasks_queue,
-        events_queue,
-        generator_done,
-        checks,
-        targets,
-        settings,
-        seed,
-        results,
-        stateful=stateful,
-        stateful_recursion_limit=stateful_recursion_limit,
-        **kwargs,
-    )
-
-
-def asgi_thread_task(
-    tasks_queue: Queue,
-    events_queue: Queue,
-    generator_done: threading.Event,
-    checks: Iterable[CheckFunction],
-    targets: Iterable[Target],
-    settings: hypothesis.settings,
-    headers: Optional[Dict[str, Any]],
-    seed: Optional[int],
-    results: TestResultSet,
-    stateful: Optional[Stateful],
-    stateful_recursion_limit: int,
-    kwargs: Any,
-) -> None:
-    _run_task(
-        asgi_test,
-        tasks_queue,
-        events_queue,
-        generator_done,
-        checks,
-        targets,
-        settings,
-        seed,
-        results,
-        stateful=stateful,
-        stateful_recursion_limit=stateful_recursion_limit,
-        headers=headers,
-        **kwargs,
-    )
-
-
-def stop_worker(thread_id: int) -> None:
-    """Raise an error in a thread, so it is possible to asynchronously stop thread execution."""
-    ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread_id), ctypes.py_object(SystemExit))
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ThreadPoolRunner(BaseRunner):
-    """Spread different tests among multiple worker threads."""
-
-    workers_num: int = attr.ib(default=2)  # pragma: no mutate
-    request_tls_verify: Union[bool, str] = attr.ib(default=True)  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib(default=None)  # pragma: no mutate
-
-    def _execute(
-        self, results: TestResultSet, stop_event: threading.Event
-    ) -> Generator[events.ExecutionEvent, None, None]:
-        """All events come from a queue where different workers push their events."""
-        # Instead of generating all tests at once, we do it when there is a free worker to pick it up
-        # This is extremely important for memory consumption when testing large schemas
-        # IMPLEMENTATION NOTE:
-        # It would be better to have a separate producer thread and communicate via threading events.
-        # Though it is a bit more complex, so the current solution is suboptimal in terms of resources utilization,
-        # but good enough and easy enough to implement.
-        tasks_generator = (
-            (operation, data_generation_method)
-            for operation in self.schema.get_all_operations()
-            for data_generation_method in self.schema.data_generation_methods
-        )
-        generator_done = threading.Event()
-        tasks_queue: Queue = Queue()
-        # Add at least `workers_num` tasks first, so all workers are busy
-        for _ in range(self.workers_num):
-            try:
-                # SAFETY: Workers didn't start yet, direct modification is OK
-                tasks_queue.queue.append(next(tasks_generator))
-            except StopIteration:
-                generator_done.set()
-                break
-        # Events are pushed by workers via a separate queue
-        events_queue: Queue = Queue()
-        workers = self._init_workers(tasks_queue, events_queue, results, generator_done)
-
-        def stop_workers() -> None:
-            for worker in workers:
-                # workers are initialized at this point and `worker.ident` is set with an integer value
-                ident = cast(int, worker.ident)
-                stop_worker(ident)
-                worker.join()
-
-        is_finished = False
-        try:
-            while not is_finished:
-                # Sleep is needed for performance reasons
-                # each call to `is_alive` of an alive worker waits for a lock
-                # iterations without waiting are too frequent, and a lot of time will be spent on waiting for this locks
-                time.sleep(0.001)
-                is_finished = all(not worker.is_alive() for worker in workers)
-                while not events_queue.empty():
-                    event = events_queue.get()
-                    if stop_event.is_set() or isinstance(event, events.Interrupted) or self._should_stop(event):
-                        # We could still have events in the queue, but ignore them to keep the logic simple
-                        # for now, could be improved in the future to show more info in such corner cases
-                        stop_workers()
-                        is_finished = True
-                        if stop_event.is_set():
-                            # Discard the event. The invariant is: the next event after `stream.stop()` is `Finished`
-                            break
-                    yield event
-                    # When we know that there are more tasks, put another task to the queue.
-                    # The worker might not actually finish the current one yet, but we put the new one now, so
-                    # the worker can immediately pick it up when the current one is done
-                    if isinstance(event, events.BeforeExecution) and not generator_done.is_set():
-                        try:
-                            tasks_queue.put(next(tasks_generator))
-                        except StopIteration:
-                            generator_done.set()
-        except KeyboardInterrupt:
-            stop_workers()
-            yield events.Interrupted()
-
-    def _init_workers(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> List[threading.Thread]:
-        """Initialize & start workers that will execute tests."""
-        workers = [
-            threading.Thread(
-                target=self._get_task(),
-                kwargs=self._get_worker_kwargs(tasks_queue, events_queue, results, generator_done),
-                name=f"schemathesis_{num}",
-            )
-            for num in range(self.workers_num)
-        ]
-        for worker in workers:
-            worker.start()
-        return workers
-
-    def _get_task(self) -> Callable:
-        return thread_task
-
-    def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
-        return {
-            "tasks_queue": tasks_queue,
-            "events_queue": events_queue,
-            "generator_done": generator_done,
-            "checks": self.checks,
-            "targets": self.targets,
-            "settings": self.hypothesis_settings,
-            "auth": self.auth,
-            "auth_type": self.auth_type,
-            "headers": self.headers,
-            "seed": self.seed,
-            "results": results,
-            "stateful": self.stateful,
-            "stateful_recursion_limit": self.stateful_recursion_limit,
-            "kwargs": {
-                "request_timeout": self.request_timeout,
-                "request_tls_verify": self.request_tls_verify,
-                "request_cert": self.request_cert,
-                "store_interactions": self.store_interactions,
-                "max_response_time": self.max_response_time,
-                "dry_run": self.dry_run,
-            },
-        }
-
-
-class ThreadPoolWSGIRunner(ThreadPoolRunner):
-    def _get_task(self) -> Callable:
-        return wsgi_thread_task
-
-    def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
-        return {
-            "tasks_queue": tasks_queue,
-            "events_queue": events_queue,
-            "generator_done": generator_done,
-            "checks": self.checks,
-            "targets": self.targets,
-            "settings": self.hypothesis_settings,
-            "seed": self.seed,
-            "results": results,
-            "stateful": self.stateful,
-            "stateful_recursion_limit": self.stateful_recursion_limit,
-            "kwargs": {
-                "auth": self.auth,
-                "auth_type": self.auth_type,
-                "headers": self.headers,
-                "store_interactions": self.store_interactions,
-                "max_response_time": self.max_response_time,
-                "dry_run": self.dry_run,
-            },
-        }
-
-
-class ThreadPoolASGIRunner(ThreadPoolRunner):
-    def _get_task(self) -> Callable:
-        return asgi_thread_task
-
-    def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
-        return {
-            "tasks_queue": tasks_queue,
-            "events_queue": events_queue,
-            "generator_done": generator_done,
-            "checks": self.checks,
-            "targets": self.targets,
-            "settings": self.hypothesis_settings,
-            "headers": self.headers,
-            "seed": self.seed,
-            "results": results,
-            "stateful": self.stateful,
-            "stateful_recursion_limit": self.stateful_recursion_limit,
-            "kwargs": {
-                "store_interactions": self.store_interactions,
-                "max_response_time": self.max_response_time,
-                "dry_run": self.dry_run,
-            },
-        }

schemathesis/runner/serialization.py

@@ -1,206 +0,0 @@
-"""Transformation from Schemathesis-specific data structures to ones that can be serialized and sent over network.
-
-They all consist of primitive types and don't have references to schemas, app, etc.
-"""
-import logging
-from typing import Any, Dict, Generator, List, Optional, Set, Tuple
-
-import attr
-import requests
-
-from ..exceptions import FailureContext, InternalError, make_unique_by_key
-from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
-from ..utils import WSGIResponse, format_exception
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedCase:
-    text_lines: List[str] = attr.ib()  # pragma: no mutate
-    requests_code: str = attr.ib()
-    curl_code: str = attr.ib()
-    path_template: str = attr.ib()
-    path_parameters: Optional[Dict[str, Any]] = attr.ib()
-    query: Optional[Dict[str, Any]] = attr.ib()
-    cookies: Optional[Dict[str, Any]] = attr.ib()
-    verbose_name: str = attr.ib()
-    media_type: Optional[str] = attr.ib()
-
-    @classmethod
-    def from_case(cls, case: Case, headers: Optional[Dict[str, Any]]) -> "SerializedCase":
-        return cls(
-            text_lines=case.as_text_lines(headers),
-            requests_code=case.get_code_to_reproduce(headers),
-            curl_code=case.as_curl_command(headers),
-            path_template=case.path,
-            path_parameters=case.path_parameters,
-            query=case.query,
-            cookies=case.cookies,
-            verbose_name=case.operation.verbose_name,
-            media_type=case.media_type,
-        )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedCheck:
-    # Check name
-    name: str = attr.ib()  # pragma: no mutate
-    # Check result
-    value: Status = attr.ib()  # pragma: no mutate
-    request: Request = attr.ib()  # pragma: no mutate
-    response: Optional[Response] = attr.ib()  # pragma: no mutate
-    # Generated example
-    example: SerializedCase = attr.ib()  # pragma: no mutate
-    message: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    # Failure-specific context
-    context: Optional[FailureContext] = attr.ib(default=None)  # pragma: no mutate
-    # Cases & responses that were made before this one
-    history: List["SerializedHistoryEntry"] = attr.ib(factory=list)  # pragma: no mutate
-
-    @classmethod
-    def from_check(cls, check: Check) -> "SerializedCheck":
-        if check.response is not None:
-            request = Request.from_prepared_request(check.response.request)
-        elif check.request is not None:
-            # Response is not available, but it is not an error (only time-out behaves this way at the moment)
-            request = Request.from_prepared_request(check.request)
-        else:
-            raise InternalError("Can not find request data")
-
-        response: Optional[Response]
-        if isinstance(check.response, requests.Response):
-            response = Response.from_requests(check.response)
-        elif isinstance(check.response, WSGIResponse):
-            response = Response.from_wsgi(check.response, check.elapsed)
-        else:
-            response = None
-        headers = {key: value[0] for key, value in request.headers.items()}
-        history = []
-        case = check.example
-        while case.source is not None:
-            if isinstance(case.source.response, requests.Response):
-                history_response = Response.from_requests(case.source.response)
-            else:
-                history_response = Response.from_wsgi(case.source.response, case.source.elapsed)
-            entry = SerializedHistoryEntry(
-                case=SerializedCase.from_case(case.source.case, headers), response=history_response
-            )
-            history.append(entry)
-            case = case.source.case
-        return cls(
-            name=check.name,
-            value=check.value,
-            example=SerializedCase.from_case(check.example, headers),
-            message=check.message,
-            request=request,
-            response=response,
-            context=check.context,
-            history=history,
-        )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedHistoryEntry:
-    case: SerializedCase = attr.ib()
-    response: Response = attr.ib()
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedError:
-    exception: str = attr.ib()  # pragma: no mutate
-    exception_with_traceback: str = attr.ib()  # pragma: no mutate
-    example: Optional[SerializedCase] = attr.ib()  # pragma: no mutate
-    title: Optional[str] = attr.ib()  # pragma: no mutate
-
-    @classmethod
-    def from_error(
-        cls, exception: Exception, case: Optional[Case], headers: Optional[Dict[str, Any]], title: Optional[str] = None
-    ) -> "SerializedError":
-        return cls(
-            exception=format_exception(exception),
-            exception_with_traceback=format_exception(exception, True),
-            example=SerializedCase.from_case(case, headers) if case else None,
-            title=title,
-        )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedInteraction:
-    request: Request = attr.ib()  # pragma: no mutate
-    response: Response = attr.ib()  # pragma: no mutate
-    checks: List[SerializedCheck] = attr.ib()  # pragma: no mutate
-    status: Status = attr.ib()  # pragma: no mutate
-    recorded_at: str = attr.ib()  # pragma: no mutate
-
-    @classmethod
-    def from_interaction(cls, interaction: Interaction) -> "SerializedInteraction":
-        return cls(
-            request=interaction.request,
-            response=interaction.response,
-            checks=[SerializedCheck.from_check(check) for check in interaction.checks],
-            status=interaction.status,
-            recorded_at=interaction.recorded_at,
-        )
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializedTestResult:
-    method: str = attr.ib()  # pragma: no mutate
-    path: str = attr.ib()  # pragma: no mutate
-    verbose_name: str = attr.ib()  # pragma: no mutate
-    has_failures: bool = attr.ib()  # pragma: no mutate
-    has_errors: bool = attr.ib()  # pragma: no mutate
-    has_logs: bool = attr.ib()  # pragma: no mutate
-    is_errored: bool = attr.ib()  # pragma: no mutate
-    is_flaky: bool = attr.ib()  # pragma: no mutate
-    is_skipped: bool = attr.ib()  # pragma: no mutate
-    seed: Optional[int] = attr.ib()  # pragma: no mutate
-    data_generation_method: str = attr.ib()  # pragma: no mutate
-    checks: List[SerializedCheck] = attr.ib()  # pragma: no mutate
-    logs: List[str] = attr.ib()  # pragma: no mutate
-    errors: List[SerializedError] = attr.ib()  # pragma: no mutate
-    interactions: List[SerializedInteraction] = attr.ib()  # pragma: no mutate
-
-    @classmethod
-    def from_test_result(cls, result: TestResult) -> "SerializedTestResult":
-        formatter = logging.Formatter("[%(asctime)s] %(levelname)s in %(module)s: %(message)s")
-        return cls(
-            method=result.method,
-            path=result.path,
-            verbose_name=result.verbose_name,
-            has_failures=result.has_failures,
-            has_errors=result.has_errors,
-            has_logs=result.has_logs,
-            is_errored=result.is_errored,
-            is_flaky=result.is_flaky,
-            is_skipped=result.is_skipped,
-            seed=result.seed,
-            data_generation_method=result.data_generation_method.as_short_name(),
-            checks=[SerializedCheck.from_check(check) for check in result.checks],
-            logs=[formatter.format(record) for record in result.logs],
-            errors=[SerializedError.from_error(*error, headers=result.overridden_headers) for error in result.errors],
-            interactions=[SerializedInteraction.from_interaction(interaction) for interaction in result.interactions],
-        )
-
-
-def deduplicate_failures(checks: List[SerializedCheck]) -> List[SerializedCheck]:
-    """Return only unique checks that should be displayed in the output."""
-    seen: Set[Tuple[Optional[str], ...]] = set()
-    unique_checks = []
-    for check in reversed(checks):
-        # There are also could be checks that didn't fail
-        if check.value == Status.failure:
-            key = make_unique_by_key(check.name, check.message, check.context)
-            if key not in seen:
-                unique_checks.append(check)
-                seen.add(key)
-    return unique_checks
-
-
-def deduplicate_checks(checks: List[SerializedCheck]) -> Generator[SerializedCheck, None, None]:
-    """Return only unique checks outcomes."""
-    seen: Set[Tuple[Optional[str], ...]] = set()
-    for check in reversed(checks):
-        key = make_unique_by_key(check.name, check.message, check.context)
-        if key not in seen:
-            yield check
-            seen.add(key)