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

schemathesis/core/jsonschema/references.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Any
+
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
+
+
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove $ref from optional locations."""
+    if isinstance(schema, bool):
+        return set()
+
+    stack: list[JsonSchema] = [schema]
+
+    while stack:
+        current = stack.pop()
+        if not isinstance(current, dict):
+            continue
+
+        _sanitize_combinators(current)
+
+        _sanitize_properties(current)
+
+        if "items" in current:
+            _sanitize_items(current)
+
+        if "prefixItems" in current:
+            _sanitize_prefix_items(current)
+
+        if "additionalProperties" in current:
+            _sanitize_additional_properties(current)
+
+        if "additionalItems" in current:
+            _sanitize_additional_items(current)
+
+        for value in current.values():
+            if isinstance(value, dict):
+                stack.append(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        stack.append(item)
+
+    remaining: set[str] = set()
+    _collect_all_references(schema, remaining)
+    return remaining
+
+
+def _sanitize_combinators(schema: JsonSchemaObject) -> None:
+    """Sanitize anyOf/oneOf/allOf."""
+    for combinator_key in ("anyOf", "oneOf"):
+        variants = schema.get(combinator_key)
+        if not isinstance(variants, list):
+            continue
+
+        flattened = _flatten_combinator(variants, combinator_key)
+
+        cleaned = [variant for variant in flattened if not _has_ref(variant)]
+
+        # Only update if we have non-$ref variants
+        if cleaned:
+            # At least one alternative remains, which narrows the constraints
+            schema[combinator_key] = cleaned
+        elif not flattened:
+            schema.pop(combinator_key, None)
+
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list):
+        flattened = _flatten_combinator(all_of, "allOf")
+
+        cleaned = [variant for variant in flattened if not _is_empty(variant)]
+        if cleaned:
+            schema["allOf"] = cleaned
+        else:
+            schema.pop("allOf", None)
+
+
+def _flatten_combinator(variants: list, key: str) -> list:
+    """Flatten nested same-type combinators."""
+    result = []
+    for variant in variants:
+        if isinstance(variant, dict) and key in variant and isinstance(variant[key], list):
+            result.extend(variant[key])
+        else:
+            result.append(variant)
+    return result
+
+
+def _is_empty(schema: JsonSchema) -> bool:
+    """Check if schema accepts anything."""
+    if schema is True:
+        return True
+
+    if not isinstance(schema, dict):
+        return False
+
+    if not schema:
+        return True
+
+    # Only non-validating keywords
+    NON_VALIDATING = {
+        "$id",
+        "$schema",
+        "$defs",
+        "definitions",
+        "title",
+        "description",
+        "default",
+        "examples",
+        "example",
+        "$comment",
+        "deprecated",
+        "readOnly",
+        "writeOnly",
+    }
+
+    return all(key in NON_VALIDATING for key in schema.keys())
+
+
+def _sanitize_properties(schema: JsonSchemaObject) -> None:
+    """Remove OPTIONAL property schemas if they have $ref."""
+    if "properties" not in schema:
+        return
+
+    properties = schema["properties"]
+    if not isinstance(properties, dict):
+        return
+
+    required = schema.get("required", [])
+
+    for name, subschema in list(properties.items()):
+        if not _has_ref(subschema):
+            continue
+
+        if name not in required:
+            del properties[name]
+
+
+def _sanitize_items(schema: JsonSchemaObject) -> None:
+    """Convert to empty array ONLY if minItems allows it."""
+    items = schema["items"]
+
+    has_ref = False
+    if isinstance(items, dict):
+        has_ref = _has_ref(items)
+    elif isinstance(items, list):
+        has_ref = any(_has_ref(item) for item in items)
+
+    if not has_ref:
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _sanitize_prefix_items(schema: JsonSchemaObject) -> None:
+    """Same logic as items."""
+    prefix_items = schema["prefixItems"]
+
+    if not isinstance(prefix_items, list):
+        return
+
+    if not any(_has_ref(item) for item in prefix_items):
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
+    schema.pop("items", None)
+    schema.pop("prefixItems", None)
+    schema["maxItems"] = 0
+    schema["minItems"] = 0
+
+
+def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalProperties"]
+    if _has_ref(additional):
+        schema["additionalProperties"] = False
+
+
+def _sanitize_additional_items(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalItems"]
+    if _has_ref(additional):
+        schema["additionalItems"] = False
+
+
+def _has_ref(schema: Any) -> bool:
+    """Check if schema contains $ref at any level."""
+    if not isinstance(schema, dict):
+        return False
+
+    if "$ref" in schema:
+        return True
+    for value in schema.values():
+        if isinstance(value, dict):
+            if _has_ref(value):
+                return True
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict) and _has_ref(item):
+                    return True
+
+    return False
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Collect all remaining $ref."""
+    if isinstance(schema, dict):
+        ref = schema.get("$ref")
+        if isinstance(ref, str):
+            remaining.add(ref)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)

schemathesis/core/jsonschema/types.py

@@ -0,0 +1,41 @@
+from typing import Any, Union
+
+JsonSchemaObject = dict[str, Any]
+JsonSchema = Union[JsonSchemaObject, bool]
+
+ANY_TYPE = ["null", "boolean", "number", "string", "array", "object"]
+ALL_TYPES = ["null", "boolean", "integer", "number", "string", "array", "object"]
+
+
+def get_type(schema: JsonSchema, *, _check_type: bool = False) -> list[str]:
+    if isinstance(schema, bool):
+        return ANY_TYPE
+    ty = schema.get("type", ANY_TYPE)
+    if isinstance(ty, str):
+        if _check_type and ty not in ALL_TYPES:
+            raise AssertionError(f"Unknown type: `{ty}`. Should be one of {', '.join(ALL_TYPES)}")
+        return [ty]
+    if ty is ANY_TYPE:
+        return list(ty)
+    return [t for t in ALL_TYPES if t in ty]
+
+
+def _get_type(schema: JsonSchema) -> list[str]:
+    # Special version to patch `hypothesis-jsonschema`
+    return get_type(schema, _check_type=True)
+
+
+def to_json_type_name(v: Any) -> str:
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "boolean"
+    if isinstance(v, dict):
+        return "object"
+    if isinstance(v, list):
+        return "array"
+    if isinstance(v, (int, float)):
+        return "number"
+    if isinstance(v, str):
+        return "string"
+    return type(v).__name__

schemathesis/core/lazy_import.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def lazy_import(module: str, name: str, imports: dict[str, Callable[[], Any]], _globals: dict[str, Any]) -> Any:
+    value = _globals.get(name)
+    if value is not None:
+        return value
+    loader = imports.get(name)
+    if loader is not None:
+        value = loader()
+        _globals[name] = value
+        return value
+    raise AttributeError(f"module {module!r} has no attribute {name!r}")

schemathesis/core/loaders.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import http.client
+from typing import TYPE_CHECKING, Any, Callable, NoReturn
+
+from schemathesis.core.errors import LoaderError, LoaderErrorKind, get_request_error_extras, get_request_error_message
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT, USER_AGENT
+
+if TYPE_CHECKING:
+    import requests
+
+
+def prepare_request_kwargs(kwargs: dict[str, Any]) -> None:
+    """Prepare common request kwargs."""
+    headers = kwargs.setdefault("headers", {})
+    if "user-agent" not in {header.lower() for header in headers}:
+        kwargs["headers"]["User-Agent"] = USER_AGENT
+
+
+def handle_request_error(exc: requests.RequestException) -> NoReturn:
+    """Handle request-level errors."""
+    import requests
+
+    url = exc.request.url if exc.request is not None else None
+    if isinstance(exc, requests.exceptions.SSLError):
+        kind = LoaderErrorKind.CONNECTION_SSL
+    elif isinstance(exc, requests.exceptions.ConnectionError):
+        kind = LoaderErrorKind.CONNECTION_OTHER
+    else:
+        kind = LoaderErrorKind.NETWORK_OTHER
+    raise LoaderError(
+        message=get_request_error_message(exc),
+        kind=kind,
+        url=url,
+        extras=get_request_error_extras(exc),
+    ) from exc
+
+
+def raise_for_status(response: requests.Response) -> requests.Response:
+    """Handle response status codes."""
+    status_code = response.status_code
+    if status_code < 400:
+        return response
+
+    reason = http.client.responses.get(status_code, "Unknown")
+    if status_code >= 500:
+        message = f"Failed to load schema due to server error (HTTP {status_code} {reason})"
+        kind = LoaderErrorKind.HTTP_SERVER_ERROR
+    else:
+        message = f"Failed to load schema due to client error (HTTP {status_code} {reason})"
+        kind = (
+            LoaderErrorKind.HTTP_FORBIDDEN
+            if status_code == 403
+            else LoaderErrorKind.HTTP_NOT_FOUND
+            if status_code == 404
+            else LoaderErrorKind.HTTP_CLIENT_ERROR
+        )
+    raise LoaderError(message=message, kind=kind, url=response.request.url, extras=[])
+
+
+def make_request(func: Callable[..., requests.Response], url: str, **kwargs: Any) -> requests.Response:
+    """Make HTTP request with error handling."""
+    import requests
+
+    try:
+        response = func(url, **kwargs)
+        return raise_for_status(response)
+    except requests.RequestException as exc:
+        handle_request_error(exc)
+    except OSError as exc:
+        # Possible with certificate errors
+        raise LoaderError(message=str(exc), kind=LoaderErrorKind.INVALID_CERTIFICATE, url=url, extras=[]) from None
+
+
+WAIT_FOR_SCHEMA_INTERVAL = 0.05
+
+
+def load_from_url(
+    func: Callable[..., requests.Response],
+    *,
+    url: str,
+    wait_for_schema: float | None = None,
+    **kwargs: Any,
+) -> requests.Response:
+    """Load schema from URL with retries."""
+    import backoff
+    import requests
+
+    kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT)
+    prepare_request_kwargs(kwargs)
+
+    if wait_for_schema is not None:
+        func = backoff.on_exception(
+            backoff.constant,
+            requests.exceptions.ConnectionError,
+            max_time=wait_for_schema,
+            interval=WAIT_FOR_SCHEMA_INTERVAL,
+        )(func)
+
+    return make_request(func, url, **kwargs)
+
+
+def require_relative_url(url: str) -> None:
+    """Raise an error if the URL is not relative."""
+    # Deliberately simplistic approach
+    if "://" in url or url.startswith("//"):
+        raise ValueError("Schema path should be relative for WSGI/ASGI loaders")

schemathesis/core/marks.py

@@ -0,0 +1,66 @@
+"""A lightweight mechanism to attach Schemathesis-specific metadata to test functions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Generic, TypeVar
+
+from schemathesis.core import NOT_SET, NotSet
+
+METADATA_ATTR = "_schemathesis_metadata"
+
+
+@dataclass
+class SchemathesisMetadata:
+    """Container for all Schemathesis-specific data attached to test functions."""
+
+
+T = TypeVar("T")
+
+
+class Mark(Generic[T]):
+    """Access to specific attributes in SchemathesisMetadata."""
+
+    def __init__(
+        self, *, attr_name: str, default: T | Callable[[], T] | None = None, check: Callable[[T], bool] | None = None
+    ) -> None:
+        self.attr_name = attr_name
+        self._default = default
+        self._check = check
+
+    def _get_default(self) -> T | None:
+        if callable(self._default):
+            return self._default()
+        return self._default
+
+    def _check_value(self, value: T) -> bool:
+        if self._check is not None:
+            return self._check(value)
+        return True
+
+    def get(self, func: Callable) -> T | None:
+        """Get marker value if it's set."""
+        metadata = getattr(func, METADATA_ATTR, None)
+        if metadata is None:
+            return self._get_default()
+        value = getattr(metadata, self.attr_name, NOT_SET)
+        if value is NOT_SET:
+            return self._get_default()
+        assert not isinstance(value, NotSet)
+        if self._check_value(value):
+            return value
+        return self._get_default()
+
+    def set(self, func: Callable, value: T) -> None:
+        """Set marker value, creating metadata if needed."""
+        if not hasattr(func, METADATA_ATTR):
+            setattr(func, METADATA_ATTR, SchemathesisMetadata())
+        metadata = getattr(func, METADATA_ATTR)
+        setattr(metadata, self.attr_name, value)
+
+    def is_set(self, func: Callable) -> bool:
+        """Check if function has metadata with this marker set."""
+        metadata = getattr(func, METADATA_ATTR, None)
+        if metadata is None:
+            return False
+        return hasattr(metadata, self.attr_name)

schemathesis/core/media_types.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Generator, Tuple
+
+from schemathesis.core.errors import MalformedMediaType
+
+YAML_MEDIA_TYPES: Tuple[str, ...] = (
+    "text/yaml",
+    "text/x-yaml",
+    "application/x-yaml",
+    "text/vnd.yaml",
+    "application/yaml",
+)
+
+
+def _parseparam(s: str) -> Generator[str]:
+    while s[:1] == ";":
+        s = s[1:]
+        end = s.find(";")
+        while end > 0 and (s.count('"', 0, end) - s.count('\\"', 0, end)) % 2:
+            end = s.find(";", end + 1)
+        if end < 0:
+            end = len(s)
+        f = s[:end]
+        yield f.strip()
+        s = s[end:]
+
+
+def _parse_header(line: str) -> tuple[str, dict]:
+    parts = _parseparam(";" + line)
+    key = parts.__next__()
+    pdict = {}
+    for p in parts:
+        i = p.find("=")
+        if i >= 0:
+            name = p[:i].strip().lower()
+            value = p[i + 1 :].strip()
+            if len(value) >= 2 and value[0] == value[-1] == '"':
+                value = value[1:-1]
+                value = value.replace("\\\\", "\\").replace('\\"', '"')
+            pdict[name] = value
+    return key, pdict
+
+
+@lru_cache
+def parse(media_type: str) -> tuple[str, str]:
+    """Parse Content Type and return main type and subtype."""
+    try:
+        media_type, _ = _parse_header(media_type)
+        main_type, sub_type = media_type.split("/", 1)
+    except ValueError as exc:
+        raise MalformedMediaType(f"Malformed media type: `{media_type}`") from exc
+    return main_type.lower(), sub_type.lower()
+
+
+def is_json(value: str) -> bool:
+    """Detect whether the content type is JSON-compatible.
+
+    For example - ``application/problem+json`` matches.
+    """
+    main, sub = parse(value)
+    return main == "application" and (sub == "json" or sub.endswith("+json"))
+
+
+def is_yaml(value: str) -> bool:
+    """Detect whether the content type is YAML-compatible."""
+    return value in YAML_MEDIA_TYPES
+
+
+def is_plain_text(value: str) -> bool:
+    """Detect variations of the ``text/plain`` media type."""
+    return parse(value) == ("text", "plain")
+
+
+def is_xml(value: str) -> bool:
+    """Detect variations of the ``application/xml`` media type."""
+    _, sub = parse(value)
+    return sub == "xml" or sub.endswith("+xml")

schemathesis/core/output/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from schemathesis.config import OutputConfig
+
+TRUNCATED = "// Output truncated..."
+
+
+def truncate_json(data: Any, *, config: OutputConfig, max_lines: int | None = None) -> str:
+    # Convert JSON to string with indentation
+    indent = 4
+    serialized = json.dumps(data, indent=indent)
+    if not config.truncation.enabled:
+        return serialized
+
+    max_lines = max_lines if max_lines is not None else config.truncation.max_lines
+    # Split string by lines
+    lines = [
+        line[: config.truncation.max_width - 3] + "..." if len(line) > config.truncation.max_width else line
+        for line in serialized.split("\n")
+    ]
+
+    if len(lines) <= max_lines:
+        return "\n".join(lines)
+
+    truncated_lines = lines[: max_lines - 1]
+    indentation = " " * indent
+    truncated_lines.append(f"{indentation}{TRUNCATED}")
+    truncated_lines.append(lines[-1])
+
+    return "\n".join(truncated_lines)
+
+
+def prepare_response_payload(payload: str, *, config: OutputConfig) -> str:
+    if payload.endswith("\r\n"):
+        payload = payload[:-2]
+    elif payload.endswith("\n"):
+        payload = payload[:-1]
+    if not config.truncation.enabled:
+        return payload
+    if len(payload) > config.truncation.max_payload_size:
+        payload = payload[: config.truncation.max_payload_size] + f" {TRUNCATED}"
+    return payload

schemathesis/core/output/sanitization.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from collections.abc import MutableMapping, MutableSequence
+from typing import Any
+from urllib.parse import parse_qs, urlencode, urlsplit, urlunsplit
+
+from schemathesis.config import SanitizationConfig
+
+
+def sanitize_value(item: Any, *, config: SanitizationConfig) -> None:
+    """Sanitize sensitive values within a given item.
+
+    This function is recursive and will sanitize sensitive data within nested
+    dictionaries and lists as well.
+    """
+    if isinstance(item, MutableMapping):
+        for key in list(item.keys()):
+            lower_key = key.lower()
+            if lower_key in config.keys_to_sanitize or any(marker in lower_key for marker in config.sensitive_markers):
+                if isinstance(item[key], list):
+                    item[key] = [config.replacement]
+                else:
+                    item[key] = config.replacement
+        for value in item.values():
+            if isinstance(value, (MutableMapping, MutableSequence)):
+                sanitize_value(value, config=config)
+    elif isinstance(item, MutableSequence):
+        for value in item:
+            if isinstance(value, (MutableMapping, MutableSequence)):
+                sanitize_value(value, config=config)
+
+
+def sanitize_url(url: str, *, config: SanitizationConfig) -> str:
+    """Sanitize sensitive parts of a given URL.
+
+    This function will sanitize the authority and query parameters in the URL.
+    """
+    parsed = urlsplit(url)
+
+    # Sanitize authority
+    netloc_parts = parsed.netloc.split("@")
+    if len(netloc_parts) > 1:
+        netloc = f"{config.replacement}@{netloc_parts[-1]}"
+    else:
+        netloc = parsed.netloc
+
+    # Sanitize query parameters
+    query = parse_qs(parsed.query, keep_blank_values=True)
+    sanitize_value(query, config=config)
+    sanitized_query = urlencode(query, doseq=True)
+
+    # Reconstruct the URL
+    sanitized_url_parts = parsed._replace(netloc=netloc, query=sanitized_query)
+    return urlunsplit(sanitized_url_parts)

schemathesis/core/parameters.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+LOCATION_TO_CONTAINER = {
+    "path": "path_parameters",
+    "query": "query",
+    "header": "headers",
+    "cookie": "cookies",
+    "body": "body",
+}
+
+
+class ParameterLocation(str, Enum):
+    """API parameter location."""
+
+    QUERY = "query"
+    HEADER = "header"
+    PATH = "path"
+    COOKIE = "cookie"
+    BODY = "body"
+    UNKNOWN = None
+
+    @property
+    def container_name(self) -> str:
+        return {
+            "path": "path_parameters",
+            "query": "query",
+            "header": "headers",
+            "cookie": "cookies",
+            "body": "body",
+        }[self]
+
+    @property
+    def is_in_header(self) -> bool:
+        return self in HEADER_LOCATIONS
+
+
+HEADER_LOCATIONS = frozenset([ParameterLocation.HEADER, ParameterLocation.COOKIE])
+
+CONTAINER_TO_LOCATION = {
+    "path_parameters": ParameterLocation.PATH,
+    "query": ParameterLocation.QUERY,
+    "headers": ParameterLocation.HEADER,
+    "cookies": ParameterLocation.COOKIE,
+    "body": ParameterLocation.BODY,
+}