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

schemathesis/cli/output/short.py

@@ -1,44 +0,0 @@
-import click
-
-from ...runner import events
-from ..context import ExecutionContext
-from ..handlers import EventHandler
-from . import default
-
-
-def handle_before_execution(context: ExecutionContext, event: events.BeforeExecution) -> None:
-    if event.recursion_level > 0:
-        context.operations_count += 1  # type: ignore
-
-
-def handle_after_execution(context: ExecutionContext, event: events.AfterExecution) -> None:
-    context.operations_processed += 1
-    context.results.append(event.result)
-    context.hypothesis_output.extend(event.hypothesis_output)
-    default.display_execution_result(context, event)
-
-
-class ShortOutputStyleHandler(EventHandler):
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        """Short output style shows single symbols in the progress bar.
-
-        Otherwise, identical to the default output style.
-        """
-        if isinstance(event, events.Initialized):
-            default.handle_initialized(context, event)
-        if isinstance(event, events.BeforeProbing):
-            default.handle_before_probing(context, event)
-        if isinstance(event, events.AfterProbing):
-            default.handle_after_probing(context, event)
-        if isinstance(event, events.BeforeExecution):
-            handle_before_execution(context, event)
-        if isinstance(event, events.AfterExecution):
-            handle_after_execution(context, event)
-        if isinstance(event, events.Finished):
-            if context.operations_count == context.operations_processed:
-                click.echo()
-            default.handle_finished(context, event)
-        if isinstance(event, events.Interrupted):
-            default.handle_interrupted(context, event)
-        if isinstance(event, events.InternalError):
-            default.handle_internal_error(context, event)

schemathesis/cli/sanitization.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from ..runner import events
-from ..sanitization import sanitize_serialized_check, sanitize_serialized_interaction
-from .handlers import EventHandler
-
-if TYPE_CHECKING:
-    from .context import ExecutionContext
-
-
-@dataclass
-class SanitizationHandler(EventHandler):
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        if isinstance(event, events.AfterExecution):
-            for check in event.result.checks:
-                sanitize_serialized_check(check)
-            for interaction in event.result.interactions:
-                sanitize_serialized_interaction(interaction)

schemathesis/code_samples.py

@@ -1,149 +0,0 @@
-from __future__ import annotations
-from enum import Enum
-from functools import lru_cache
-from shlex import quote
-from typing import TYPE_CHECKING
-
-from .constants import SCHEMATHESIS_TEST_CASE_HEADER
-from .types import Headers
-
-if TYPE_CHECKING:
-    from requests.structures import CaseInsensitiveDict
-
-
-@lru_cache
-def get_excluded_headers() -> CaseInsensitiveDict:
-    from requests.structures import CaseInsensitiveDict
-    from requests.utils import default_headers
-
-    # These headers are added automatically by Schemathesis or `requests`.
-    # Do not show them in code samples to make them more readable
-
-    return CaseInsensitiveDict(
-        {
-            "Content-Length": None,
-            "Transfer-Encoding": None,
-            SCHEMATHESIS_TEST_CASE_HEADER: None,
-            **default_headers(),
-        }
-    )
-
-
-class CodeSampleStyle(str, Enum):
-    """Controls the style of code samples for failure reproduction."""
-
-    python = "python"
-    curl = "curl"
-
-    @property
-    def verbose_name(self) -> str:
-        return {
-            self.curl: "cURL command",
-            self.python: "Python code",
-        }[self]
-
-    @classmethod
-    def default(cls) -> CodeSampleStyle:
-        return cls.curl
-
-    @classmethod
-    def from_str(cls, value: str) -> CodeSampleStyle:
-        try:
-            return cls[value]
-        except KeyError:
-            available_styles = ", ".join(cls)
-            raise ValueError(
-                f"Invalid value for code sample style: {value}. Available styles: {available_styles}"
-            ) from None
-
-    def generate(
-        self,
-        *,
-        method: str,
-        url: str,
-        body: str | bytes | None,
-        headers: Headers | None,
-        verify: bool,
-        extra_headers: Headers | None = None,
-    ) -> str:
-        """Generate a code snippet for making HTTP requests."""
-        handlers = {
-            self.curl: _generate_curl,
-            self.python: _generate_requests,
-        }
-        return handlers[self](
-            method=method, url=url, body=body, headers=_filter_headers(headers, extra_headers), verify=verify
-        )
-
-
-def _filter_headers(headers: Headers | None, extra: Headers | None = None) -> Headers:
-    headers = headers.copy() if headers else {}
-    if extra is not None:
-        for key, value in extra.items():
-            if key not in get_excluded_headers():
-                headers[key] = value
-    return headers
-
-
-def _generate_curl(
-    *,
-    method: str,
-    url: str,
-    body: str | bytes | None,
-    headers: Headers,
-    verify: bool,
-) -> str:
-    """Create a cURL command to reproduce an HTTP request."""
-    command = f"curl -X {method}"
-    for key, value in headers.items():
-        header = f"{key}: {value}"
-        command += f" -H {quote(header)}"
-    if body:
-        if isinstance(body, bytes):
-            body = body.decode("utf-8", errors="replace")
-        command += f" -d {quote(body)}"
-    if not verify:
-        command += " --insecure"
-    return f"{command} {quote(url)}"
-
-
-def _generate_requests(
-    *,
-    method: str,
-    url: str,
-    body: str | bytes | None,
-    headers: Headers,
-    verify: bool,
-) -> str:
-    """Create a Python code to reproduce an HTTP request."""
-    url = _escape_single_quotes(url)
-    command = f"requests.{method.lower()}('{url}'"
-    if body:
-        command += f", data={repr(body)}"
-    if headers:
-        command += f", headers={repr(headers)}"
-    if not verify:
-        command += ", verify=False"
-    command += ")"
-    return command
-
-
-def _escape_single_quotes(url: str) -> str:
-    """Escape single quotes in a string, so it is usable as in generated Python code.
-
-    The usual ``str.replace`` is not suitable as it may convert already escaped quotes to not-escaped.
-    """
-    result = []
-    escape = False
-    for char in url:
-        if escape:
-            result.append(char)
-            escape = False
-        elif char == "\\":
-            result.append(char)
-            escape = True
-        elif char == "'":
-            result.append("\\'")
-        else:
-            result.append(char)
-    return "".join(result)

schemathesis/constants.py

@@ -1,55 +0,0 @@
-from importlib import metadata
-from .types import NotSet
-
-try:
-    SCHEMATHESIS_VERSION = metadata.version(__package__)
-except metadata.PackageNotFoundError:
-    # Local run without installation
-    SCHEMATHESIS_VERSION = "dev"
-
-NOT_SET = NotSet()
-USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
-SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
-HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
-DISCORD_LINK = "https://discord.gg/R9ASRAmHnA"
-GITHUB_APP_LINK = "https://github.com/apps/schemathesis"
-# Maximum test running time
-DEFAULT_DEADLINE = 15000
-DEFAULT_RESPONSE_TIMEOUT = 10000
-DEFAULT_STATEFUL_RECURSION_LIMIT = 5
-HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
-RECURSIVE_REFERENCE_ERROR_MESSAGE = (
-    "Currently, Schemathesis can't generate data for this operation due to "
-    "recursive references in the operation definition. See more information in "
-    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
-)
-GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE = (
-    "Unsupported test setup. Tests using `@schema.given` cannot be combined with explicit schema examples in the same "
-    "function. Separate these tests into distinct functions to avoid conflicts."
-)
-SERIALIZERS_SUGGESTION_MESSAGE = (
-    "You can register your own serializer with `schemathesis.serializer` "
-    "and Schemathesis will be able to make API calls with this media type. \n"
-    "See https://schemathesis.readthedocs.io/en/stable/how.html#payload-serialization for more information."
-)
-NO_LINKS_ERROR_MESSAGE = (
-    "Stateful testing requires at least one OpenAPI link in the schema, but no links detected. "
-    "Please add OpenAPI links to enable stateful testing or use stateless tests instead. \n"
-    "See https://schemathesis.readthedocs.io/en/stable/stateful.html#how-to-specify-connections for more information."
-)
-EXTENSIONS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/extending.html"
-ISSUE_TRACKER_URL = (
-    "https://github.com/schemathesis/schemathesis/issues/new?"
-    "labels=Status%3A%20Needs%20Triage%2C+Type%3A+Bug&template=bug_report.md&title=%5BBUG%5D"
-)
-FLAKY_FAILURE_MESSAGE = "[FLAKY] Schemathesis was not able to reliably reproduce this failure"
-BOM_MARK = "\ufeff"
-WAIT_FOR_SCHEMA_INTERVAL = 0.05
-HOOKS_MODULE_ENV_VAR = "SCHEMATHESIS_HOOKS"
-API_NAME_ENV_VAR = "SCHEMATHESIS_API_NAME"
-BASE_URL_ENV_VAR = "SCHEMATHESIS_BASE_URL"
-WAIT_FOR_SCHEMA_ENV_VAR = "SCHEMATHESIS_WAIT_FOR_SCHEMA"
-REPORT_SUGGESTION_ENV_VAR = "SCHEMATHESIS_REPORT_SUGGESTION"
-
-TRUE_VALUES = ("y", "yes", "t", "true", "on", "1")
-FALSE_VALUES = ("n", "no", "f", "false", "off", "0")

schemathesis/contrib/openapi/formats/__init__.py

@@ -1,9 +0,0 @@
-from . import uuid
-
-
-def install() -> None:
-    uuid.install()
-
-
-def uninstall() -> None:
-    uuid.uninstall()

schemathesis/contrib/openapi/formats/uuid.py

@@ -1,15 +0,0 @@
-# Open API 2.0 / 3.0 do not include `uuid` in the list of built-in formats, hence it lives in `contrib`.
-FORMAT_NAME = "uuid"
-
-
-def install() -> None:
-    from ....specs import openapi
-    from hypothesis import strategies as st
-
-    openapi.format(FORMAT_NAME, st.uuids().map(str))
-
-
-def uninstall() -> None:
-    from ....specs import openapi
-
-    openapi.unregister_string_format("uuid")

schemathesis/contrib/unique_data.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING
-
-from ..hooks import HookContext, register, unregister
-
-if TYPE_CHECKING:
-    from ..models import Case
-    from hypothesis import strategies as st
-
-
-def install() -> None:
-    warnings.warn(
-        "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-        "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-        "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-        "This leads to cryptic error messages about external state and flaky test runs, "
-        "therefore it will be removed in Schemathesis 4.0",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    register(before_generate_case)
-
-
-def uninstall() -> None:
-    unregister(before_generate_case)
-
-
-def before_generate_case(context: HookContext, strategy: st.SearchStrategy[Case]) -> st.SearchStrategy[Case]:
-    seen = set()
-
-    def is_not_seen(case: Case) -> bool:
-        # Calculate hash just once as it is costly
-        hashed = hash(case)
-        if hashed not in seen:
-            seen.add(hashed)
-            return True
-        return False
-
-    return strategy.filter(is_not_seen)