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

schemathesis/openapi/loaders.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import enum
+import json
+import re
+from os import PathLike
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any, Mapping
+
+from schemathesis.config import SchemathesisConfig
+from schemathesis.core import media_types
+from schemathesis.core.deserialization import deserialize_yaml
+from schemathesis.core.errors import LoaderError, LoaderErrorKind
+from schemathesis.core.loaders import load_from_url, prepare_request_kwargs, raise_for_status, require_relative_url
+from schemathesis.hooks import HookContext, dispatch
+from schemathesis.python import asgi, wsgi
+
+if TYPE_CHECKING:
+    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+
+def from_asgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from an ASGI application.
+
+    Args:
+        path: Relative URL path to the OpenAPI schema endpoint (e.g., "/openapi.json")
+        app: ASGI application instance
+        config: Custom configuration. If `None`, uses auto-discovered config
+        **kwargs: Additional request parameters passed to the ASGI test client
+
+    Example:
+        ```python
+        from fastapi import FastAPI
+        import schemathesis
+
+        app = FastAPI()
+        schema = schemathesis.openapi.from_asgi("/openapi.json", app)
+        ```
+
+    """
+    require_relative_url(path)
+    client = asgi.get_client(app)
+    response = load_from_url(client.get, url=path, **kwargs)
+    content_type = detect_content_type(headers=response.headers, path=path)
+    schema = load_content(response.text, content_type)
+    loaded = from_dict(schema=schema, config=config)
+    loaded.app = app
+    loaded.location = path
+    return loaded
+
+
+def from_wsgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from a WSGI application.
+
+    Args:
+        path: Relative URL path to the OpenAPI schema endpoint (e.g., "/openapi.json")
+        app: WSGI application instance
+        config: Custom configuration. If `None`, uses auto-discovered config
+        **kwargs: Additional request parameters passed to the WSGI test client
+
+    Example:
+        ```python
+        from flask import Flask
+        import schemathesis
+
+        app = Flask(__name__)
+        schema = schemathesis.openapi.from_wsgi("/openapi.json", app)
+        ```
+
+    """
+    require_relative_url(path)
+    prepare_request_kwargs(kwargs)
+    client = wsgi.get_client(app)
+    response = client.get(path=path, **kwargs)
+    raise_for_status(response)
+    content_type = detect_content_type(headers=response.headers, path=path)
+    schema = load_content(response.text, content_type)
+    loaded = from_dict(schema=schema, config=config)
+    loaded.app = app
+    loaded.location = path
+    return loaded
+
+
+def from_url(
+    url: str, *, config: SchemathesisConfig | None = None, wait_for_schema: float | None = None, **kwargs: Any
+) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from a URL.
+
+    Args:
+        url: Full URL to the OpenAPI schema
+        config: Custom configuration. If `None`, uses auto-discovered config
+        wait_for_schema: Maximum time in seconds to wait for schema availability
+        **kwargs: Additional parameters passed to `requests.get()` (headers, timeout, auth, etc.)
+
+    Example:
+        ```python
+        import schemathesis
+
+        # Basic usage
+        schema = schemathesis.openapi.from_url("https://api.example.com/openapi.json")
+
+        # With authentication and timeout
+        schema = schemathesis.openapi.from_url(
+            "https://api.example.com/openapi.json",
+            headers={"Authorization": "Bearer token"},
+            timeout=30,
+            wait_for_schema=10.0
+        )
+        ```
+
+    """
+    import requests
+
+    response = load_from_url(requests.get, url=url, wait_for_schema=wait_for_schema, **kwargs)
+    content_type = detect_content_type(headers=response.headers, path=url)
+    schema = load_content(response.text, content_type)
+    loaded = from_dict(schema=schema, config=config)
+    loaded.location = url
+    return loaded
+
+
+def from_path(
+    path: PathLike | str, *, config: SchemathesisConfig | None = None, encoding: str = "utf-8"
+) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from a filesystem path.
+
+    Args:
+        path: File path to the OpenAPI schema (supports JSON / YAML)
+        config: Custom configuration. If `None`, uses auto-discovered config
+        encoding: Text encoding for reading the file
+
+    Example:
+        ```python
+        import schemathesis
+
+        # Load from file
+        schema = schemathesis.openapi.from_path("./specs/openapi.yaml")
+
+        # With custom encoding
+        schema = schemathesis.openapi.from_path("./specs/openapi.json", encoding="cp1252")
+        ```
+
+    """
+    with open(path, encoding=encoding) as file:
+        content_type = detect_content_type(headers=None, path=str(path))
+        schema = load_content(file.read(), content_type)
+    loaded = from_dict(schema=schema, config=config)
+    loaded.location = Path(path).absolute().as_uri()
+    return loaded
+
+
+def from_file(file: IO[str] | str, *, config: SchemathesisConfig | None = None) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from a file-like object or string.
+
+    Args:
+        file: File-like object or raw string containing the OpenAPI schema
+        config: Custom configuration. If `None`, uses auto-discovered config
+
+    Example:
+        ```python
+        import schemathesis
+
+        # From string
+        schema_content = '{"openapi": "3.0.0", "info": {"title": "API"}}'
+        schema = schemathesis.openapi.from_file(schema_content)
+
+        # From file object
+        with open("openapi.yaml") as f:
+            schema = schemathesis.openapi.from_file(f)
+        ```
+
+    """
+    if isinstance(file, str):
+        data = file
+    else:
+        data = file.read()
+    try:
+        schema = json.loads(data)
+    except json.JSONDecodeError:
+        schema = _load_yaml(data)
+    return from_dict(schema, config=config)
+
+
+def from_dict(schema: dict[str, Any], *, config: SchemathesisConfig | None = None) -> BaseOpenAPISchema:
+    """Load OpenAPI schema from a dictionary.
+
+    Args:
+        schema: Dictionary containing the parsed OpenAPI schema
+        config: Custom configuration. If `None`, uses auto-discovered config
+
+    Example:
+        ```python
+        import schemathesis
+
+        schema_dict = {
+            "openapi": "3.0.0",
+            "info": {"title": "My API", "version": "1.0.0"},
+            "paths": {"/users": {"get": {"responses": {"200": {"description": "OK"}}}}}
+        }
+
+        schema = schemathesis.openapi.from_dict(schema_dict)
+        ```
+
+    """
+    from schemathesis.specs.openapi.schemas import OpenApi30, SwaggerV20
+
+    if not isinstance(schema, dict):
+        raise LoaderError(LoaderErrorKind.OPEN_API_INVALID_SCHEMA, SCHEMA_INVALID_ERROR)
+    hook_context = HookContext()
+    dispatch("before_load_schema", hook_context, schema)
+
+    if config is None:
+        config = SchemathesisConfig.discover()
+    project_config = config.projects.get(schema)
+
+    if "swagger" in schema:
+        instance = SwaggerV20(raw_schema=schema, config=project_config)
+    elif "openapi" in schema:
+        version = schema["openapi"]
+        if not OPENAPI_VERSION_RE.match(version):
+            raise LoaderError(
+                LoaderErrorKind.OPEN_API_UNSUPPORTED_VERSION,
+                f"The provided schema uses Open API {version}, which is currently not supported.",
+            )
+        instance = OpenApi30(raw_schema=schema, config=project_config)
+    else:
+        raise LoaderError(
+            LoaderErrorKind.OPEN_API_UNSPECIFIED_VERSION,
+            "Unable to determine the Open API version as it's not specified in the document.",
+        )
+    instance.filter_set = project_config.operations.filter_set_with(include=instance.filter_set)
+    dispatch("after_load_schema", hook_context, instance)
+    return instance
+
+
+class ContentType(enum.Enum):
+    """Known content types for schema files."""
+
+    JSON = enum.auto()
+    YAML = enum.auto()
+    UNKNOWN = enum.auto()
+
+
+def detect_content_type(*, headers: Mapping[str, str] | None = None, path: str | None = None) -> ContentType:
+    """Detect content type from various sources."""
+    if headers is not None and (content_type := _detect_from_headers(headers)) != ContentType.UNKNOWN:
+        return content_type
+    if path is not None and (content_type := _detect_from_path(path)) != ContentType.UNKNOWN:
+        return content_type
+    return ContentType.UNKNOWN
+
+
+def _detect_from_headers(headers: Mapping[str, str]) -> ContentType:
+    """Detect content type from HTTP headers."""
+    content_type = headers.get("Content-Type", "").lower()
+    try:
+        if content_type and media_types.is_json(content_type):
+            return ContentType.JSON
+        if content_type and media_types.is_yaml(content_type):
+            return ContentType.YAML
+    except ValueError:
+        pass
+    return ContentType.UNKNOWN
+
+
+def _detect_from_path(path: str) -> ContentType:
+    """Detect content type from file path."""
+    suffix = Path(path).suffix.lower()
+    if suffix == ".json":
+        return ContentType.JSON
+    if suffix in (".yaml", ".yml"):
+        return ContentType.YAML
+    return ContentType.UNKNOWN
+
+
+def load_content(content: str, content_type: ContentType) -> dict[str, Any]:
+    """Load content using appropriate parser."""
+    if content_type == ContentType.JSON:
+        return _load_json(content)
+    if content_type == ContentType.YAML:
+        return _load_yaml(content)
+    # If type is unknown, try JSON first, then YAML
+    try:
+        return _load_json(content)
+    except LoaderError:
+        return _load_yaml(content)
+
+
+def _load_json(content: str) -> dict[str, Any]:
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError as exc:
+        raise LoaderError(
+            LoaderErrorKind.SYNTAX_ERROR,
+            SCHEMA_SYNTAX_ERROR,
+            extras=[entry for entry in str(exc).splitlines() if entry],
+        ) from exc
+
+
+def _load_yaml(content: str) -> dict[str, Any]:
+    import yaml
+
+    try:
+        return deserialize_yaml(content)
+    except yaml.YAMLError as exc:
+        raise LoaderError(
+            LoaderErrorKind.SYNTAX_ERROR,
+            SCHEMA_SYNTAX_ERROR,
+            extras=[entry for entry in str(exc).splitlines() if entry],
+        ) from exc
+
+
+SCHEMA_INVALID_ERROR = "The provided API schema does not appear to be a valid OpenAPI schema"
+SCHEMA_SYNTAX_ERROR = "API schema does not appear syntactically valid"
+OPENAPI_VERSION_RE = re.compile(r"^3\.[01]\.[0-9](-.+)?$")

schemathesis/pytest/__init__.py

@@ -0,0 +1,5 @@
+from schemathesis.pytest.loaders import from_fixture
+
+__all__ = [
+    "from_fixture",
+]

schemathesis/pytest/control_flow.py

@@ -0,0 +1,7 @@
+from typing import NoReturn
+
+import pytest
+
+
+def fail_on_no_matches(node_id: str) -> NoReturn:  # type: ignore[misc]
+    pytest.fail(f"Test function {node_id} does not match any API operations and therefore has no effect")

schemathesis/pytest/lazy.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+from contextlib import nullcontext
+from dataclasses import dataclass
+from inspect import signature
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type
+
+import pytest
+from hypothesis.core import HypothesisHandle
+from pytest_subtests import SubTests
+
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.core.result import Ok, Result
+from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, RegexValue, is_deprecated
+from schemathesis.generation import overrides
+from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode, create_test
+from schemathesis.generation.hypothesis.given import (
+    GivenArgsMark,
+    GivenInput,
+    GivenKwargsMark,
+    given_proxy,
+    is_given_applied,
+    merge_given_args,
+    validate_given_args,
+)
+from schemathesis.pytest.control_flow import fail_on_no_matches
+from schemathesis.schemas import BaseSchema
+
+if TYPE_CHECKING:
+    import hypothesis
+    from _pytest.fixtures import FixtureRequest
+
+    from schemathesis.schemas import APIOperation
+
+
+def get_all_tests(
+    *,
+    schema: BaseSchema,
+    test_func: Callable,
+    settings: hypothesis.settings | None = None,
+    seed: int | None = None,
+    as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None,
+    given_kwargs: dict[str, GivenInput] | None = None,
+) -> Generator[Result[tuple[APIOperation, Callable], InvalidSchema], None, None]:
+    """Generate all operations and Hypothesis tests for them."""
+    for result in schema.get_all_operations():
+        if isinstance(result, Ok):
+            operation = result.ok()
+            if callable(as_strategy_kwargs):
+                _as_strategy_kwargs = as_strategy_kwargs(operation)
+            else:
+                _as_strategy_kwargs = {}
+
+            # Get modes from config for this operation
+            modes = []
+            phases = schema.config.phases_for(operation=operation)
+            if phases.examples.enabled:
+                modes.append(HypothesisTestMode.EXAMPLES)
+            if phases.fuzzing.enabled:
+                modes.append(HypothesisTestMode.FUZZING)
+            if phases.coverage.enabled:
+                modes.append(HypothesisTestMode.COVERAGE)
+
+            test = create_test(
+                operation=operation,
+                test_func=test_func,
+                config=HypothesisTestConfig(
+                    settings=settings or schema.config.get_hypothesis_settings(operation=operation),
+                    modes=modes,
+                    seed=seed,
+                    project=schema.config,
+                    as_strategy_kwargs=_as_strategy_kwargs,
+                    given_kwargs=given_kwargs or {},
+                ),
+            )
+            yield Ok((operation, test))
+        else:
+            yield result
+
+
+@dataclass
+class LazySchema:
+    fixture_name: str
+    filter_set: FilterSet
+
+    __slots__ = ("fixture_name", "filter_set")
+
+    def __init__(
+        self,
+        fixture_name: str,
+        filter_set: FilterSet | None = None,
+    ) -> None:
+        self.fixture_name = fixture_name
+        self.filter_set = filter_set or FilterSet()
+
+    def include(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+    ) -> LazySchema:
+        """Include only operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        filter_set.include(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.__class__(fixture_name=self.fixture_name, filter_set=filter_set)
+
+    def exclude(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+        deprecated: bool = False,
+    ) -> LazySchema:
+        """Exclude operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        if deprecated:
+            if func is None:
+                func = is_deprecated
+            else:
+                filter_set.exclude(is_deprecated)
+        filter_set.exclude(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.__class__(fixture_name=self.fixture_name, filter_set=filter_set)
+
+    def parametrize(self) -> Callable:
+        def wrapper(test_func: Callable) -> Callable:
+            if is_given_applied(test_func):
+                # The user wrapped the test function with `@schema.given`
+                # These args & kwargs go as extra to the underlying test generator
+                given_args = GivenArgsMark.get(test_func)
+                given_kwargs = GivenKwargsMark.get(test_func)
+                assert given_args is not None
+                assert given_kwargs is not None
+                test_function = validate_given_args(test_func, given_args, given_kwargs)
+                if test_function is not None:
+                    return test_function
+                given_kwargs = merge_given_args(test_func, given_args, given_kwargs)
+                del given_args
+            else:
+                given_kwargs = {}
+
+            def wrapped_test(*args: Any, request: FixtureRequest, **kwargs: Any) -> None:
+                """The actual test, which is executed by pytest."""
+                __tracebackhide__ = True
+
+                # Load all checks eagerly, so they are accessible inside the test function
+                from schemathesis.checks import load_all_checks
+
+                load_all_checks()
+
+                schema = get_schema(
+                    request=request,
+                    name=self.fixture_name,
+                    test_function=test_func,
+                    filter_set=self.filter_set,
+                )
+                # Check if test function is a method and inject self from request.instance
+                sig = signature(test_func)
+                if "self" in sig.parameters and request.instance is not None:
+                    fixtures = {"self": request.instance}
+                    fixtures.update(get_fixtures(test_func, request, given_kwargs))
+                else:
+                    fixtures = get_fixtures(test_func, request, given_kwargs)
+                # Changing the node id is required for better reporting - the method and path will appear there
+                node_id = request.node._nodeid
+                settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
+
+                def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
+                    as_strategy_kwargs: dict[str, Any] = {}
+
+                    auth = schema.config.auth_for(operation=_operation)
+                    if auth is not None:
+                        from requests.auth import _basic_auth_str
+
+                        as_strategy_kwargs["headers"] = {"Authorization": _basic_auth_str(*auth)}
+
+                    headers = schema.config.headers_for(operation=_operation)
+                    if headers:
+                        as_strategy_kwargs["headers"] = headers
+
+                    override = overrides.for_operation(config=schema.config, operation=_operation)
+                    for location, entry in override.items():
+                        if entry:
+                            as_strategy_kwargs[location.container_name] = entry
+
+                    return as_strategy_kwargs
+
+                tests = list(
+                    get_all_tests(
+                        schema=schema,
+                        test_func=test_func,
+                        settings=settings,
+                        as_strategy_kwargs=as_strategy_kwargs,
+                        given_kwargs=given_kwargs,
+                    )
+                )
+                if not tests:
+                    fail_on_no_matches(node_id)
+                request.session.testscollected += len(tests)
+                suspend_capture_ctx = _get_capturemanager(request)
+                subtests = SubTests(request.node.ihook, suspend_capture_ctx, request)
+                for result in tests:
+                    if isinstance(result, Ok):
+                        operation, sub_test = result.ok()
+                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.path}]"
+                        run_subtest(operation, fixtures, sub_test, subtests)
+                    else:
+                        _schema_error(subtests, result.err(), node_id)
+                subtests.item._nodeid = node_id
+
+            sig = signature(test_func)
+            if "self" in sig.parameters:
+                # For methods, wrap with staticmethod to prevent pytest from passing self
+                wrapped_test = staticmethod(wrapped_test)  # type: ignore[assignment]
+                wrapped_func = wrapped_test.__func__  # type: ignore[attr-defined]
+            else:
+                wrapped_func = wrapped_test
+
+            wrapped_func = pytest.mark.usefixtures(self.fixture_name)(wrapped_func)
+            _copy_marks(test_func, wrapped_func)
+
+            # Needed to prevent a failure when settings are applied to the test function
+            wrapped_func.is_hypothesis_test = True
+            wrapped_func.hypothesis = HypothesisHandle(test_func, wrapped_func, given_kwargs)
+
+            return wrapped_test if "self" in sig.parameters else wrapped_func
+
+        return wrapper
+
+    def given(self, *args: GivenInput, **kwargs: GivenInput) -> Callable:
+        return given_proxy(*args, **kwargs)
+
+
+def _copy_marks(source: Callable, target: Callable) -> None:
+    marks = getattr(source, "pytestmark", [])
+    # Pytest adds this attribute in `usefixtures`
+    target.pytestmark.extend(marks)  # type: ignore[attr-defined]
+
+
+def _get_capturemanager(request: FixtureRequest) -> Generator | Type[nullcontext]:
+    capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
+    if capturemanager is not None:
+        return capturemanager.global_and_fixture_disabled
+    return nullcontext
+
+
+def run_subtest(operation: APIOperation, fixtures: dict[str, Any], sub_test: Callable, subtests: SubTests) -> None:
+    """Run the given subtest with pytest fixtures."""
+    __tracebackhide__ = True
+
+    with subtests.test(label=operation.label):
+        sub_test(**fixtures)
+
+
+SEPARATOR = "\n===================="
+
+
+def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> None:
+    """Run a failing test, that will show the underlying problem."""
+    sub_test = error.as_failing_test_function()
+    kwargs = {"path": error.path}
+    if error.method:
+        kwargs["method"] = error.method.upper()
+    subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)
+    __tracebackhide__ = True
+    with subtests.test(**kwargs):
+        sub_test()
+
+
+def _get_partial_node_name(node_id: str, **kwargs: Any) -> str:
+    """Make a test node name for failing tests caused by schema errors."""
+    name = node_id
+    if "method" in kwargs:
+        name += f"[{kwargs['method']} {kwargs['path']}]"
+    else:
+        name += f"[{kwargs['path']}]"
+    return name
+
+
+def get_schema(*, request: FixtureRequest, name: str, filter_set: FilterSet, test_function: Callable) -> BaseSchema:
+    """Loads a schema from the fixture."""
+    schema = request.getfixturevalue(name)
+    if not isinstance(schema, BaseSchema):
+        raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
+
+    # Merge config-based operation filters with user-provided filters
+    # This ensures operations disabled in schemathesis.toml are respected
+    merged_filter_set = schema.config.operations.filter_set_with(include=filter_set)
+
+    return schema.clone(filter_set=merged_filter_set, test_function=test_function)
+
+
+def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Load fixtures, needed for the test function."""
+    sig = signature(func)
+    return {
+        name: request.getfixturevalue(name)
+        for name in sig.parameters
+        if name not in ("case", "self") and name not in given_kwargs
+    }