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

schemathesis/service/serialization.py

@@ -1,184 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
-
-import attr
-
-from ..models import Response
-from ..runner import events
-from ..runner.serialization import SerializedCase, deduplicate_checks
-from ..utils import merge
-
-S = TypeVar("S", bound=events.ExecutionEvent)
-SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
-
-
-def serialize_initialized(event: events.Initialized) -> Optional[Dict[str, Any]]:
-    return {
-        "schema": event.schema,
-        "operations_count": event.operations_count,
-        "location": event.location or "",
-        "base_url": event.base_url,
-    }
-
-
-def serialize_before_execution(event: events.BeforeExecution) -> Optional[Dict[str, Any]]:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-    }
-
-
-def _serialize_case(case: SerializedCase) -> Dict[str, Any]:
-    return {
-        "verbose_name": case.verbose_name,
-        "path_template": case.path_template,
-        "path_parameters": stringify_path_parameters(case.path_parameters),
-        "query": prepare_query(case.query),
-        "cookies": case.cookies,
-        "media_type": case.media_type,
-    }
-
-
-def _serialize_response(response: Response) -> Dict[str, Any]:
-    return {
-        "status_code": response.status_code,
-        "headers": response.headers,
-        "body": response.body,
-        "encoding": response.encoding,
-        "elapsed": response.elapsed,
-    }
-
-
-def serialize_after_execution(event: events.AfterExecution) -> Optional[Dict[str, Any]]:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-        "result": {
-            "checks": [
-                {
-                    "name": check.name,
-                    "value": check.value,
-                    "request": {
-                        "method": check.request.method,
-                        "uri": check.request.uri,
-                        "body": check.request.body,
-                        "headers": check.request.headers,
-                    },
-                    "response": _serialize_response(check.response) if check.response is not None else None,
-                    "example": _serialize_case(check.example),
-                    "message": check.message,
-                    "context": attr.asdict(check.context) if check.context is not None else None,
-                    "history": [
-                        {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
-                        for entry in check.history
-                    ],
-                }
-                for check in deduplicate_checks(event.result.checks)
-            ],
-            "errors": [
-                {
-                    "exception": error.exception,
-                    "exception_with_traceback": error.exception_with_traceback,
-                    "example": None if error.example is None else _serialize_case(error.example),
-                }
-                for error in event.result.errors
-            ],
-        },
-    }
-
-
-def serialize_interrupted(_: events.Interrupted) -> Optional[Dict[str, Any]]:
-    return None
-
-
-def serialize_internal_error(event: events.InternalError) -> Optional[Dict[str, Any]]:
-    return {
-        "message": event.message,
-        "exception_type": event.exception_type,
-        "exception_with_traceback": event.exception_with_traceback,
-    }
-
-
-def serialize_finished(event: events.Finished) -> Optional[Dict[str, Any]]:
-    return {
-        "generic_errors": [
-            {
-                "exception": error.exception,
-                "exception_with_traceback": error.exception_with_traceback,
-                "title": error.title,
-            }
-            for error in event.generic_errors
-        ]
-    }
-
-
-SERIALIZER_MAP = {
-    events.Initialized: serialize_initialized,
-    events.BeforeExecution: serialize_before_execution,
-    events.AfterExecution: serialize_after_execution,
-    events.Interrupted: serialize_interrupted,
-    events.InternalError: serialize_internal_error,
-    events.Finished: serialize_finished,
-}
-
-
-def serialize_event(
-    event: events.ExecutionEvent,
-    *,
-    on_initialized: Optional[SerializeFunc] = None,
-    on_before_execution: Optional[SerializeFunc] = None,
-    on_after_execution: Optional[SerializeFunc] = None,
-    on_interrupted: Optional[SerializeFunc] = None,
-    on_internal_error: Optional[SerializeFunc] = None,
-    on_finished: Optional[SerializeFunc] = None,
-    extra: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Optional[Dict[str, Any]]]:
-    """Turn an event into JSON-serializable structure."""
-    # Due to https://github.com/python-attrs/attrs/issues/864 it is easier to implement filtration manually
-    # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
-    serializer = {
-        events.Initialized: on_initialized,
-        events.BeforeExecution: on_before_execution,
-        events.AfterExecution: on_after_execution,
-        events.Interrupted: on_interrupted,
-        events.InternalError: on_internal_error,
-        events.Finished: on_finished,
-    }.get(event.__class__)
-    if serializer is None:
-        serializer = cast(SerializeFunc, SERIALIZER_MAP[event.__class__])
-    data = serializer(event)
-    if extra is not None:
-        # If `extra` is present, then merge it with the serialized data. If serialized data is empty, then replace it
-        # with `extra` value
-        if data is None:
-            data = extra
-        else:
-            data = merge(data, extra)
-    # Externally tagged structure
-    return {event.__class__.__name__: data}
-
-
-def stringify_path_parameters(path_parameters: Optional[Dict[str, Any]]) -> Dict[str, str]:
-    """Cast all path parameter values to strings.
-
-    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
-    """
-    return {key: str(value) for key, value in (path_parameters or {}).items()}
-
-
-def prepare_query(query: Optional[Dict[str, Any]]) -> Dict[str, List[str]]:
-    """Convert all query values to list of strings.
-
-    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
-    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
-    """
-
-    def to_list_of_strings(value: Any) -> List[str]:
-        if isinstance(value, list):
-            return list(map(str, value))
-        if isinstance(value, str):
-            return [value]
-        return [str(value)]
-
-    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/service/worker.py

@@ -1,39 +0,0 @@
-from queue import Queue
-
-from . import events
-from .client import ServiceClient
-from .constants import STOP_MARKER
-from .models import TestRun
-from .serialization import serialize_event
-
-
-def start(client: ServiceClient, test_run: TestRun, in_queue: Queue, out_queue: Queue) -> None:
-    """Initialize a new run and start consuming events."""
-    try:
-        consume_events(client, in_queue, test_run.run_id)
-        # Reached a terminal event or a stop marker.
-        # In the case of stop marker, it is still a successful result for the handler itself as the error happened in
-        # a different handler
-        out_queue.put(events.Completed(short_url=test_run.short_url))
-    except Exception as exc:
-        out_queue.put(events.Error(exc))
-
-
-def consume_events(client: ServiceClient, in_queue: Queue, run_id: str) -> None:
-    """Main working loop that sends data to Schemathesis.io."""
-    try:
-        while True:
-            event = in_queue.get()
-            if event is STOP_MARKER:
-                # It is an equivalent of an internal error in some other handler.
-                # In the happy path scenario, the worker will exit on any terminal event
-                client.finish_test_run(run_id)
-                break
-            data = serialize_event(event)
-            client.send_event(run_id, data)
-            if event.is_terminal:
-                break
-    except Exception:
-        # Internal error on our side, try to finish the test run
-        client.finish_test_run(run_id)
-        raise

schemathesis/specs/graphql/loaders.py

@@ -1,215 +0,0 @@
-import pathlib
-from typing import IO, Any, Callable, Dict, Optional, Union, cast
-
-import graphql
-import requests
-from graphql import ExecutionResult
-from starlette.applications import Starlette
-from starlette.testclient import TestClient as ASGIClient
-from werkzeug import Client
-from yarl import URL
-
-from ...constants import DEFAULT_DATA_GENERATION_METHODS, CodeSampleStyle
-from ...exceptions import HTTPError
-from ...hooks import HookContext, dispatch
-from ...types import DataGenerationMethodInput, PathLike
-from ...utils import WSGIResponse, prepare_data_generation_methods, require_relative_url, setup_headers
-from .schemas import GraphQLSchema
-
-INTROSPECTION_QUERY = graphql.get_introspection_query()
-INTROSPECTION_QUERY_AST = graphql.parse(INTROSPECTION_QUERY)
-
-
-def from_path(
-    path: PathLike,
-    *,
-    app: Any = None,
-    base_url: Optional[str] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    encoding: str = "utf8",
-) -> GraphQLSchema:
-    """Load GraphQL schema via a file from an OS path.
-
-    :param path: A path to the schema file.
-    :param encoding: The name of the encoding used to decode the file.
-    """
-    with open(path, encoding=encoding) as fd:
-        return from_file(
-            fd,
-            app=app,
-            base_url=base_url,
-            data_generation_methods=data_generation_methods,
-            code_sample_style=code_sample_style,
-            location=pathlib.Path(path).absolute().as_uri(),
-        )
-
-
-def from_url(
-    url: str,
-    *,
-    app: Any = None,
-    base_url: Optional[str] = None,
-    port: Optional[int] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from the network.
-
-    :param url: Schema URL.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :param Optional[int] port: An optional port if you don't want to pass the ``base_url`` parameter, but only to change
-                               port in ``url``.
-    :param app: A WSGI app instance.
-    :return: GraphQLSchema
-    """
-    setup_headers(kwargs)
-    kwargs.setdefault("json", {"query": INTROSPECTION_QUERY})
-    if not base_url and port:
-        base_url = str(URL(url).with_port(port))
-    response = requests.post(url, **kwargs)
-    HTTPError.raise_for_status(response)
-    decoded = response.json()
-    return from_dict(
-        raw_schema=decoded["data"],
-        location=url,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-    )
-
-
-def from_file(
-    file: Union[IO[str], str],
-    *,
-    app: Any = None,
-    base_url: Optional[str] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    location: Optional[str] = None,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a file descriptor or a string.
-
-    :param file: Could be a file descriptor, string or bytes.
-    """
-    if isinstance(file, str):
-        data = file
-    else:
-        data = file.read()
-    document = graphql.build_schema(data)
-    result = graphql.execute(document, INTROSPECTION_QUERY_AST)
-    # TYPES: We don't pass `is_awaitable` above, therefore `result` is of the `ExecutionResult` type
-    result = cast(ExecutionResult, result)
-    # TYPES:
-    #  - `document` is a valid schema, because otherwise `build_schema` will rise an error;
-    #  - `INTROSPECTION_QUERY` is a valid query - it is known upfront;
-    # Therefore the execution result is always valid at this point and `result.data` is not `None`
-    raw_schema = cast(Dict[str, Any], result.data)
-    return from_dict(
-        raw_schema,
-        app=app,
-        base_url=base_url,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-        location=location,
-    )
-
-
-def from_dict(
-    raw_schema: Dict[str, Any],
-    *,
-    app: Any = None,
-    base_url: Optional[str] = None,
-    location: Optional[str] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a Python dictionary.
-
-    :param dict raw_schema: A schema to load.
-    :param Optional[str] location: Optional schema location. Either a full URL or a filesystem path.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :param app: A WSGI app instance.
-    :return: GraphQLSchema
-    """
-    _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
-    dispatch("before_load_schema", HookContext(), raw_schema)
-    return GraphQLSchema(
-        raw_schema,
-        location=location,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=prepare_data_generation_methods(data_generation_methods),
-        code_sample_style=_code_sample_style,
-    )  # type: ignore
-
-
-def from_wsgi(
-    schema_path: str,
-    app: Any,
-    *,
-    base_url: Optional[str] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a WSGI app.
-
-    :param str schema_path: An in-app relative URL to the schema.
-    :param app: A WSGI app instance.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :return: GraphQLSchema
-    """
-    require_relative_url(schema_path)
-    setup_headers(kwargs)
-    kwargs.setdefault("json", {"query": INTROSPECTION_QUERY})
-    client = Client(app, WSGIResponse)
-    response = client.post(schema_path, **kwargs)
-    HTTPError.check_response(response, schema_path)
-    return from_dict(
-        raw_schema=response.json["data"],
-        location=schema_path,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-    )
-
-
-def from_asgi(
-    schema_path: str,
-    app: Any,
-    *,
-    base_url: Optional[str] = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from an ASGI app.
-
-    :param str schema_path: An in-app relative URL to the schema.
-    :param app: An ASGI app instance.
-    :param Optional[str] base_url: Base URL to send requests to.
-    """
-    require_relative_url(schema_path)
-    setup_headers(kwargs)
-    kwargs.setdefault("json", {"query": INTROSPECTION_QUERY})
-    client = ASGIClient(app)
-    response = client.post(schema_path, **kwargs)
-    HTTPError.check_response(response, schema_path)
-    return from_dict(
-        response.json()["data"],
-        location=schema_path,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-    )
-
-
-def get_loader_for_app(app: Any) -> Callable:
-    if isinstance(app, Starlette):
-        return from_asgi
-    return from_wsgi

schemathesis/specs/openapi/constants.py

@@ -1,7 +0,0 @@
-LOCATION_TO_CONTAINER = {
-    "path": "path_parameters",
-    "query": "query",
-    "header": "headers",
-    "cookie": "cookies",
-    "body": "body",
-}

schemathesis/specs/openapi/expressions/context.py

@@ -1,12 +0,0 @@
-import attr
-
-from ....models import Case
-from ....utils import GenericResponse
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ExpressionContext:
-    """Context in what an expression are evaluated."""
-
-    response: GenericResponse = attr.ib()  # pragma: no mutate
-    case: Case = attr.ib()  # pragma: no mutate

schemathesis/specs/openapi/expressions/pointers.py

@@ -1,29 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-
-
-def resolve(document: Any, pointer: str) -> Optional[Union[Dict, List, str, int, float]]:
-    """Implementation is adapted from Rust's `serde-json` crate.
-
-    Ref: https://github.com/serde-rs/json/blob/master/src/value/mod.rs#L751
-    """
-    if not pointer:
-        return document
-    if not pointer.startswith("/"):
-        return None
-
-    def replace(value: str) -> str:
-        return value.replace("~1", "/").replace("~0", "~")
-
-    tokens = map(replace, pointer.split("/")[1:])
-    target = document
-    for token in tokens:
-        if isinstance(target, dict):
-            target = target.get(token)
-        elif isinstance(target, list):
-            try:
-                target = target[int(token)]
-            except IndexError:
-                return None
-        else:
-            return None
-    return target

schemathesis/specs/openapi/filters.py

@@ -1,44 +0,0 @@
-import re
-from typing import List, Optional
-
-from ...types import Filter
-from ...utils import force_tuple
-
-
-def should_skip_method(method: str, pattern: Optional[Filter]) -> bool:
-    if pattern is None:
-        return False
-    patterns = force_tuple(pattern)
-    return method.upper() not in map(str.upper, patterns)
-
-
-def should_skip_endpoint(endpoint: str, pattern: Optional[Filter]) -> bool:
-    if pattern is None:
-        return False
-    return not _match_any_pattern(endpoint, pattern)
-
-
-def should_skip_by_tag(tags: Optional[List[str]], pattern: Optional[Filter]) -> bool:
-    if pattern is None:
-        return False
-    if not tags:
-        return True
-    patterns = force_tuple(pattern)
-    return not any(re.search(item, tag) for item in patterns for tag in tags)
-
-
-def should_skip_by_operation_id(operation_id: Optional[str], pattern: Optional[Filter]) -> bool:
-    if pattern is None:
-        return False
-    if not operation_id:
-        return True
-    return not _match_any_pattern(operation_id, pattern)
-
-
-def should_skip_deprecated(is_deprecated: bool, skip_deprecated_operations: bool) -> bool:
-    return skip_deprecated_operations and is_deprecated
-
-
-def _match_any_pattern(target: str, pattern: Filter) -> bool:
-    patterns = force_tuple(pattern)
-    return any(re.search(item, target) for item in patterns)