schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/cli/output/short.py

@@ -1,59 +0,0 @@
-import click
-
-from ...runner import events
-from ...stateful import events as stateful_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.status.value)
-
-
-def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent) -> None:
-    if isinstance(event.data, stateful_events.RunStarted):
-        click.echo()
-    default.handle_stateful_event(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)
-        elif isinstance(event, events.BeforeProbing):
-            default.handle_before_probing(context, event)
-        elif isinstance(event, events.AfterProbing):
-            default.handle_after_probing(context, event)
-        elif isinstance(event, events.BeforeAnalysis):
-            default.handle_before_analysis(context, event)
-        elif isinstance(event, events.AfterAnalysis):
-            default.handle_after_analysis(context, event)
-        elif isinstance(event, events.BeforeExecution):
-            handle_before_execution(context, event)
-        elif isinstance(event, events.AfterExecution):
-            handle_after_execution(context, event)
-        elif isinstance(event, events.Finished):
-            if context.operations_count == context.operations_processed:
-                click.echo()
-            default.handle_finished(context, event)
-        elif isinstance(event, events.Interrupted):
-            default.handle_interrupted(context, event)
-        elif isinstance(event, events.InternalError):
-            default.handle_internal_error(context, event)
-        elif isinstance(event, events.StatefulEvent):
-            handle_stateful_event(context, event)
-        elif isinstance(event, events.AfterStatefulExecution):
-            default.handle_after_stateful_execution(context, event)

schemathesis/cli/reporting.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from itertools import groupby
-from typing import TYPE_CHECKING, Callable, Generator, Iterator
-
-import click
-
-from ..exceptions import RuntimeErrorType
-from ..runner.serialization import SerializedCheck, deduplicate_failures
-
-if TYPE_CHECKING:
-    from ..code_samples import CodeSampleStyle
-
-TEST_CASE_ID_TITLE = "Test Case ID"
-
-
-def group_by_case(
-    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
-) -> Generator[tuple[str, Iterator[SerializedCheck]], None, None]:
-    checks = deduplicate_failures(checks)
-    checks = sorted(checks, key=lambda c: _by_unique_key(c, code_sample_style))
-    for (sample, _, _), gen in groupby(checks, lambda c: _by_unique_key(c, code_sample_style)):
-        yield (sample, gen)
-
-
-def _by_unique_key(check: SerializedCheck, code_sample_style: CodeSampleStyle) -> tuple[str, int, str]:
-    return (
-        code_sample_style.generate(
-            method=check.example.method,
-            url=check.example.url,
-            body=check.example.deserialize_body(),
-            headers=check.example.headers,
-            verify=check.example.verify,
-            extra_headers=check.example.extra_headers,
-        ),
-        0 if not check.response else check.response.status_code,
-        "SCHEMATHESIS-INTERNAL-NO-RESPONSE"
-        if not check.response
-        else check.response.body or "SCHEMATHESIS-INTERNAL-EMPTY-BODY",
-    )
-
-
-def split_traceback(traceback: str) -> list[str]:
-    return [entry for entry in traceback.splitlines() if entry]
-
-
-def bold(option: str) -> str:
-    return click.style(option, bold=True)
-
-
-def get_runtime_error_suggestion(error_type: RuntimeErrorType, bold: Callable[[str], str] = bold) -> str | None:
-    DISABLE_SSL_SUGGESTION = f"Bypass SSL verification with {bold('`--request-tls-verify=false`')}."
-    DISABLE_SCHEMA_VALIDATION_SUGGESTION = (
-        f"Bypass validation using {bold('`--validate-schema=false`')}. Caution: May cause unexpected errors."
-    )
-
-    def _format_health_check_suggestion(label: str) -> str:
-        return f"Bypass this health check using {bold(f'`--hypothesis-suppress-health-check={label}`')}."
-
-    RUNTIME_ERROR_SUGGESTIONS = {
-        RuntimeErrorType.CONNECTION_SSL: DISABLE_SSL_SUGGESTION,
-        RuntimeErrorType.HYPOTHESIS_DEADLINE_EXCEEDED: (
-            f"Adjust the deadline using {bold('`--hypothesis-deadline=MILLIS`')} or "
-            f"disable with {bold('`--hypothesis-deadline=None`')}."
-        ),
-        RuntimeErrorType.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
-        RuntimeErrorType.SCHEMA_BODY_IN_GET_REQUEST: DISABLE_SCHEMA_VALIDATION_SUGGESTION,
-        RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
-        "For guidance, visit: https://docs.python.org/3/library/re.html",
-        RuntimeErrorType.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
-        "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/graphql.html#custom-scalars",
-        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE: _format_health_check_suggestion("data_too_large"),
-        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH: _format_health_check_suggestion("filter_too_much"),
-        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW: _format_health_check_suggestion("too_slow"),
-        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE: _format_health_check_suggestion(
-            "large_base_example"
-        ),
-    }
-    return RUNTIME_ERROR_SUGGESTIONS.get(error_type)

schemathesis/cli/sanitization.py

@@ -1,26 +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)
-        elif isinstance(event, events.AfterStatefulExecution):
-            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,151 +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
-
-if TYPE_CHECKING:
-    from requests.structures import CaseInsensitiveDict
-
-    from .types import Headers
-
-
-@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={body!r}"
-    if headers:
-        command += f", headers={headers!r}"
-    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,56 +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,16 +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 hypothesis import strategies as st
-
-    from ....specs import openapi
-
-    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 hypothesis import strategies as st
-
-    from ..models import Case
-
-
-def install() -> None:
-    warnings.warn(
-        "The `schemathesis.contrib.unique_data` hook is **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)