proxy-mock 2.10.1__py3-none-any.whl

proxy_mock/client/client.py

@@ -0,0 +1,174 @@
+from http import HTTPMethod
+from typing import Any
+
+import msgpack
+from yarl import URL
+
+from proxy_mock.client.route import Route
+from proxy_mock.client.service_endpoints import Endpoints
+
+CONFIGURE_CONTENT_TYPE = "application/octet-stream"
+
+
+def _build_traffic_settings_payload(record_unknown_traffic: bool | None, max_items: int | None) -> dict:
+    """The endpoint accepts a partial update, so fields that were not supplied are left out."""
+    payload = {}
+    if record_unknown_traffic is not None:
+        payload["record_unknown_traffic"] = record_unknown_traffic
+    if max_items is not None:
+        payload["max_items"] = max_items
+    return payload
+
+
+class ProxyMock(Route):
+    def get_proxy_mock(self):
+        return super().execute_request_and_get_response_body(HTTPMethod.GET, Endpoints.PROXY_MOCK)
+
+    def _build_mock_request_data(
+        self,
+        path: str,
+        body: Any = None,
+        headers: dict | None = None,
+        status_code: int | None = None,
+        extra_info: dict | None = None,
+        proxy_host: str | None = None,
+        timeout: float | None = None,
+        rules: list[dict] | None = None,
+        methods: list[str] | None = None,
+        cache_time: int | None = None,
+        include_body_if_none: bool = True,
+        **kwargs,
+    ) -> dict:
+        mock_data = {}
+        if include_body_if_none or body is not None:
+            mock_data["body"] = body
+        if status_code is not None:
+            mock_data["status_code"] = status_code
+        if headers is not None:
+            mock_data["headers"] = headers
+
+        request_data = {"path": path}
+        if methods is not None:
+            request_data["methods"] = methods
+        if mock_data:
+            request_data["mock_data"] = mock_data
+        if extra_info is not None:
+            request_data["extra_info"] = extra_info
+        if proxy_host is not None:
+            request_data["proxy_host"] = proxy_host
+        if timeout is not None:
+            request_data["timeout"] = timeout
+        if rules is not None:
+            request_data["rules"] = rules
+        if cache_time is not None:
+            request_data["cache_time"] = cache_time
+
+        request_data.update(kwargs)
+        return request_data
+
+    def _send_configure(self, method: HTTPMethod, payload: dict):
+        return super().execute_request_and_get_response_body(
+            method=method,
+            route=Endpoints.CONFIGURE_MOCK,
+            data=msgpack.packb(payload),
+            headers={"Content-Type": CONFIGURE_CONTENT_TYPE},
+        )
+
+    def configure_mock(
+        self,
+        path: str,
+        body: Any = None,
+        headers: dict | None = None,
+        status_code: int | None = None,
+        extra_info: dict | None = None,
+        proxy_host: str | None = None,
+        timeout: float | None = None,
+        rules: list[dict] | None = None,
+        methods: list[str] | None = None,
+        cache_time: int | None = None,
+        **kwargs,
+    ):
+        payload = self._build_mock_request_data(
+            path=path,
+            body=body,
+            headers=headers,
+            status_code=status_code,
+            extra_info=extra_info,
+            proxy_host=proxy_host,
+            timeout=timeout,
+            rules=rules,
+            methods=methods,
+            cache_time=cache_time,
+            include_body_if_none=True,  # for configure the body may explicitly be None
+            **kwargs,
+        )
+        return self._send_configure(HTTPMethod.POST, payload)
+
+    def patch_mock(
+        self,
+        path: str,
+        body: Any = None,
+        headers: dict | None = None,
+        status_code: int | None = None,
+        extra_info: dict | None = None,
+        proxy_host: str | None = None,
+        timeout: float | None = None,
+        rules: list[dict] | None = None,
+        methods: list[str] | None = None,
+        cache_time: int | None = None,
+        **kwargs,
+    ):
+        payload = self._build_mock_request_data(
+            path=path,
+            body=body,
+            headers=headers,
+            status_code=status_code,
+            extra_info=extra_info,
+            proxy_host=proxy_host,
+            timeout=timeout,
+            rules=rules,
+            methods=methods,
+            cache_time=cache_time,
+            include_body_if_none=False,  # for patch we do not send a body unless one is given
+            **kwargs,
+        )
+        return self._send_configure(HTTPMethod.PATCH, payload)
+
+    def get_traffic(self, path: str | None = None, method: str | None = None, limit: int | None = None):
+        query_params = {
+            **({"path": path} if path else {}),
+            **({"method": method} if method else {}),
+            **({"limit": limit} if limit is not None else {}),
+        }
+        full_path = URL().with_path(Endpoints.TRAFFIC).with_query(query_params).human_repr()
+        return super().execute_request_and_get_response_body(HTTPMethod.GET, full_path)
+
+    def get_storage(self, path: str | None = None):
+        query_params = {**({"path": path} if path else {})}
+        full_path = URL().with_path(Endpoints.STORAGE).with_query(query_params).human_repr()
+        return super().execute_request_and_get_response_body(HTTPMethod.GET, full_path)
+
+    def clean_storage(self, path: str | None = None):
+        query_params = {**({"path": path} if path else {})}
+        full_path = URL().with_path(Endpoints.STORAGE_CLEAN).with_query(query_params).human_repr()
+        return super().execute_request_and_get_response_body(HTTPMethod.POST, full_path)
+
+    def delete_mock(self, path: str):
+        full_path = URL().with_path(Endpoints.STORAGE).with_query({"path": path}).human_repr()
+        return super().execute_request_and_get_response_body(HTTPMethod.DELETE, full_path)
+
+    def clean_traffic(self):
+        return super().execute_request_and_get_response_body(HTTPMethod.POST, Endpoints.TRAFFIC_CLEAN)
+
+    def get_traffic_settings(self):
+        return super().execute_request_and_get_response_body(HTTPMethod.GET, Endpoints.TRAFFIC_SETTINGS)
+
+    def set_traffic_settings(self, record_unknown_traffic: bool | None = None, max_items: int | None = None):
+        return super().execute_request_and_get_response_body(
+            HTTPMethod.POST,
+            Endpoints.TRAFFIC_SETTINGS,
+            json=_build_traffic_settings_payload(record_unknown_traffic, max_items),
+        )
+
+    def clean_cache(self):
+        return super().execute_request_and_get_response_body(HTTPMethod.POST, Endpoints.CACHE_CLEAN)

proxy_mock/client/route.py

@@ -0,0 +1,93 @@
+import json
+from typing import Any
+
+import requests
+
+
+class ProxyMockRequestError(Exception):
+    """Error while performing a request to the proxy-mock server."""
+
+
+class ProxyMockResponseError(Exception):
+    """HTTP error returned by the proxy-mock server."""
+
+
+class Route:
+    def __init__(self, host: str, timeout: float = 10.0) -> None:
+        self.host = host.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+
+    def _build_url(self, command: str) -> str:
+        command = command.strip("/")
+        return f"{self.host}/{command}"
+
+    def _request(
+        self,
+        method: str,
+        url: str,
+        params: dict[str, Any] | None = None,
+        data: bytes | str | None = None,
+        json_data: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs,
+    ) -> requests.Response:
+        try:
+            return self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                data=data,
+                json=json_data,
+                headers=headers,
+                timeout=kwargs.pop("timeout", self.timeout),
+                **kwargs,
+            )
+        except (requests.ConnectionError, requests.Timeout) as err:
+            raise ProxyMockRequestError(f"Proxy-mock request error:\n{err}") from err
+
+    @staticmethod
+    def _parse_response_body(response: requests.Response) -> dict | str | list | bytes | None:
+        if not response.content:
+            return None
+
+        content_type = response.headers.get("Content-Type", "")
+        try:
+            if "json" in content_type:
+                return response.json()
+            if "text" in content_type:
+                return response.text
+            return response.content
+        except json.JSONDecodeError:
+            return response.text
+
+    def execute_request(self, method: str, route: str, raise_for_status: bool = False, **kwargs) -> requests.Response:
+        url = self._build_url(route)
+
+        # Normalise the json argument: kwargs["json"] is accepted but passed to _request as json_data
+        json_payload = kwargs.pop("json", None)
+
+        response = self._request(method=method, url=url, json_data=json_payload, **kwargs)
+
+        if raise_for_status and response.status_code >= 400:
+            raise ProxyMockResponseError(f"Proxy-mock returned HTTP {response.status_code}: {response.text}")
+
+        return response
+
+    def execute_request_and_get_response_body(
+        self,
+        method: str,
+        route: str,
+        **kwargs,
+    ) -> dict | str | list | bytes | None:
+        response = self.execute_request(method=method, route=route, **kwargs)
+        return self._parse_response_body(response)
+
+    def close(self) -> None:
+        self.session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()

proxy_mock/client/service_endpoints.py

@@ -0,0 +1,14 @@
+"""Routes of the proxy-mock API."""
+
+from enum import StrEnum
+
+
+class Endpoints(StrEnum):
+    PROXY_MOCK = "/proxy_mock"
+    CONFIGURE_MOCK = "/configure_mock"
+    STORAGE_CLEAN = "/storage/clean"
+    TRAFFIC_CLEAN = "/traffic/clean"
+    CACHE_CLEAN = "/cache/clean"
+    TRAFFIC = "/traffic"
+    TRAFFIC_SETTINGS = "/traffic/settings"
+    STORAGE = "/storage"

proxy_mock/core/logging.py

@@ -0,0 +1,16 @@
+import logging
+
+
+def configure_logger():
+    uvicorn_logger = logging.getLogger("uvicorn")
+    logger = uvicorn_logger.getChild("proxy_mock")
+
+    formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(message)s")
+    for handler in uvicorn_logger.handlers:
+        handler.setFormatter(formatter)
+
+    logger.setLevel(logging.DEBUG)
+    return logger
+
+
+app_logger = configure_logger()

proxy_mock/core/serializers.py

@@ -0,0 +1,32 @@
+import json
+from typing import Any
+
+
+def formatted_data(data: str | bytes):
+    if not data:
+        return None
+
+    if isinstance(data, str):
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            return data
+
+    if isinstance(data, bytes):
+        try:
+            return json.loads(data)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            # latin-1 decodes any byte sequence, so no further fallback is needed.
+            return data.decode("latin-1")
+
+    return data
+
+
+def convert_bytes_to_str(data: Any):
+    if isinstance(data, dict):
+        return {key: convert_bytes_to_str(value) for key, value in data.items()}
+    if isinstance(data, list):
+        return [convert_bytes_to_str(item) for item in data]
+    if isinstance(data, bytes):
+        return formatted_data(data)
+    return data

proxy_mock/core/settings.py

@@ -0,0 +1,50 @@
+import os
+import tomllib
+from importlib import metadata
+
+PACKAGE_NAME = "proxy_mock"
+
+RECORD_UNKNOWN_TRAFFIC_ENV = "PROXY_MOCK_RECORD_UNKNOWN_TRAFFIC"
+DEFAULT_RECORD_UNKNOWN_TRAFFIC = True
+
+_TRUE_VALUES = frozenset({"1", "true", "yes", "on"})
+_FALSE_VALUES = frozenset({"0", "false", "no", "off"})
+
+
+def record_unknown_traffic_default() -> bool:
+    """Whether to record requests that matched no mock (the 404 response) in traffic.
+
+    An unrecognised value falls back to the default, so a typo cannot silently change behaviour.
+    """
+    raw = os.getenv(RECORD_UNKNOWN_TRAFFIC_ENV, "").strip().lower()
+    if raw in _TRUE_VALUES:
+        return True
+    if raw in _FALSE_VALUES:
+        return False
+    return DEFAULT_RECORD_UNKNOWN_TRAFFIC
+
+
+def get_version_from_pyproject(logger) -> str:
+    # Dev checkout or Docker image: the working directory holds proxy_mock's own pyproject.toml.
+    # We check the project name so that another project's pyproject.toml is not picked up
+    # when proxy_mock is installed as a library.
+    try:
+        with open("pyproject.toml", "rb") as file:
+            pyproject_data = tomllib.load(file)
+        project = pyproject_data.get("project") or {}
+        if project.get("name") == PACKAGE_NAME:
+            version = project["version"]
+            logger.info(f"Proxy-Mock version is {version}")
+            return version
+    except (OSError, tomllib.TOMLDecodeError, KeyError):
+        pass
+
+    # Installed as a package: take the version from the distribution metadata
+    try:
+        version = metadata.version(PACKAGE_NAME)
+    except metadata.PackageNotFoundError:
+        logger.warning("Could not determine the proxy_mock version")
+        return "unknown"
+
+    logger.info(f"Proxy-Mock version is {version}")
+    return version

proxy_mock/core/time.py

@@ -0,0 +1,6 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+
+def now_msk_iso() -> str:
+    return datetime.now(ZoneInfo("Europe/Moscow")).isoformat()

proxy_mock/domain/__init__.py

@@ -0,0 +1,20 @@
+from proxy_mock.domain.constants import ConfigureContentTypes, ParseError
+from proxy_mock.domain.models import (
+    ConfigureMockRequestSchema,
+    InputRequestSchema,
+    MockDataSchema,
+    MockPathSchema,
+    MockRulesSchema,
+    RulesInputDataSchema,
+)
+
+__all__ = [
+    "MockDataSchema",
+    "RulesInputDataSchema",
+    "MockRulesSchema",
+    "MockPathSchema",
+    "ConfigureMockRequestSchema",
+    "InputRequestSchema",
+    "ConfigureContentTypes",
+    "ParseError",
+]

proxy_mock/domain/constants.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class ConfigureContentTypes(str, Enum):
+    JSON = "application/json"
+    BINARY = "application/octet-stream"
+
+    @classmethod
+    def array(cls) -> list[str]:
+        return [item.value for item in cls]
+
+
+class ParseError(Exception):
+    def __init__(self, detail: str, code: int):
+        self.detail = detail
+        self.code = code

proxy_mock/domain/models.py

@@ -0,0 +1,94 @@
+import time
+from http import HTTPMethod
+
+from pydantic import BaseModel, Field, field_serializer, field_validator
+from yarl import URL
+
+
+class MockDataSchema(BaseModel):
+    body: dict | str | bytes | list | None = Field(None)
+    status_code: int = Field(200)
+    headers: dict | None = Field(None)
+
+    @field_serializer("headers")
+    def serialize_headers(self, headers: dict) -> dict:
+        return {str(key): str(value) for key, value in headers.items()} if headers else {}
+
+
+class RulesInputDataSchema(BaseModel):
+    methods: list[HTTPMethod] | None = Field(None)
+    body: dict | bytes | None = Field(None)
+    headers: dict | None = Field(None)
+    query: dict | None = Field(None)
+    proxy_host: str | None = Field(None)
+    timeout: float | None = Field(None)
+
+    @field_serializer("headers")
+    def serialize_headers(self, headers: dict) -> dict:
+        return {str(key).lower(): str(value) for key, value in headers.items()} if headers else {}
+
+    @field_serializer("query")
+    def serialize_query(self, query: dict) -> dict:
+        return {str(key): str(value) for key, value in query.items()} if query else {}
+
+    @field_validator("proxy_host")
+    def check_proxy_host(cls, value):
+        if value and not URL(value).is_absolute():
+            raise ValueError("Parameter 'proxy_host' must be an absolute URL")
+        return value
+
+
+class MockRulesSchema(BaseModel):
+    input_data: RulesInputDataSchema | dict = Field(RulesInputDataSchema().model_dump())
+    output_data: MockDataSchema | dict = Field(MockDataSchema().model_dump())
+    extra_info: dict | None = Field(None)
+    priority: int = Field(0)
+    timestamp: float = Field(default_factory=lambda: time.time())
+
+
+class MockPathSchema(BaseModel):
+    methods: list[HTTPMethod] | None = Field(None)
+    mock_data: MockDataSchema | dict = Field(MockDataSchema().model_dump())
+    extra_info: dict | None = Field(None)
+    proxy_host: str | None = Field(None)
+    timeout: float | None = Field(None)
+    rules: list[MockRulesSchema] | None = Field(None)
+    cache_time: int | None = Field(None)
+
+
+class ConfigureMockRequestSchema(MockPathSchema):
+    path: str = Field(...)
+
+    @field_validator("proxy_host")
+    def check_proxy_host(cls, value):
+        if value and not URL(value).is_absolute():
+            raise ValueError("Parameter 'proxy_host' must be an absolute URL")
+        return value
+
+    @field_serializer("path")
+    def serialize_path(self, path: str):
+        path = path.split("?")[0]
+        path = path.replace(" ", "")
+        return f"/{path}" if path and path[0] != "/" else path
+
+    @field_serializer("methods")
+    def serialize_methods(self, methods: list[str]):
+        if not methods:
+            return [m.value for m in HTTPMethod]
+        return methods
+
+
+class TrafficSettingsSchema(BaseModel):
+    """Partial update: only the explicitly supplied fields are applied."""
+
+    record_unknown_traffic: bool | None = Field(None)
+    max_items: int | None = Field(None, gt=0)
+
+
+class InputRequestSchema(BaseModel):
+    request_method: str = Field(...)
+    request_body: dict | list | str | None = Field(None)
+    request_headers: dict | None = Field(None)
+    request_path: str | None = Field(None)
+    request_query: dict | None = Field(None)
+    extra_info: dict | None = Field(None)

proxy_mock/repositories/mock_storage.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import asyncio
+from copy import deepcopy
+
+from proxy_mock.domain.models import MockDataSchema, MockPathSchema
+
+
+def _normalize_path(path: str) -> str:
+    path = (path or "").split("?")[0].strip()
+    if not path.startswith("/"):
+        path = "/" + path
+    if path != "/" and path.endswith("/"):
+        path = path.rstrip("/")
+    return path
+
+
+class MockStorage:
+    def __init__(self) -> None:
+        self._storage: dict[str, dict] = {}
+        self._lock = asyncio.Lock()
+
+    async def set_mock_data(
+        self,
+        path: str,
+        methods: list[str],
+        mock_data: dict,
+        extra_info: dict,
+        proxy_host: str | None,
+        timeout: float,
+        rules: list[dict],
+        cache_time: int,
+    ) -> dict:
+        normalized_path = _normalize_path(path)
+
+        payload = MockPathSchema(
+            methods=methods,
+            mock_data=MockDataSchema(**mock_data).model_dump(),
+            extra_info=extra_info,
+            proxy_host=proxy_host,
+            timeout=timeout,
+            rules=rules,
+            cache_time=cache_time,
+        ).model_dump()
+        payload["path"] = normalized_path
+
+        async with self._lock:
+            self._storage[normalized_path] = payload
+            return deepcopy(payload)
+
+    async def get_mock_data(self, path: str) -> dict | None:
+        normalized_path = _normalize_path(path)
+        async with self._lock:
+            data = self._storage.get(normalized_path)
+            return deepcopy(data) if data else None
+
+    async def get_storage(self) -> dict:
+        async with self._lock:
+            return deepcopy(self._storage)
+
+    async def count(self) -> int:
+        async with self._lock:
+            return len(self._storage)
+
+    async def clean_storage(self) -> bool:
+        async with self._lock:
+            self._storage.clear()
+        return True
+
+    async def delete_mock_data(self, path: str) -> bool:
+        normalized_path = _normalize_path(path)
+        async with self._lock:
+            return self._storage.pop(normalized_path, None) is not None
+
+
+mock_storage = MockStorage()

proxy_mock/repositories/traffic_store.py

@@ -0,0 +1,69 @@
+import asyncio
+import os
+from collections import deque
+from copy import deepcopy
+from typing import Any
+
+DEFAULT_TRAFFIC_MAX = 1000
+
+
+def _default_max_items() -> int:
+    raw = os.getenv("PROXY_MOCK_TRAFFIC_MAX", "").strip()
+    if raw.isdigit() and int(raw) > 0:
+        return int(raw)
+    return DEFAULT_TRAFFIC_MAX
+
+
+class TrafficStore:
+    def __init__(self, max_items: int | None = None):
+        self._data = deque(maxlen=max_items or _default_max_items())
+        self._lock = asyncio.Lock()
+
+    @property
+    def max_items(self) -> int:
+        return self._data.maxlen
+
+    async def set_max_items(self, value: int) -> None:
+        """Change the storage limit. Excess records are dropped, the most recent ones are kept."""
+        async with self._lock:
+            if value != self._data.maxlen:
+                self._data = deque(self._data, maxlen=value)
+
+    async def count(self) -> int:
+        async with self._lock:
+            return len(self._data)
+
+    async def add(self, item: dict[str, Any]) -> None:
+        async with self._lock:
+            self._data.append(item)
+
+    async def patch_last(self, patch: dict[str, Any]) -> None:
+        async with self._lock:
+            if not self._data:
+                return
+            last = dict(self._data[-1])
+            last.update(patch)
+            self._data[-1] = last
+
+    async def list(
+        self,
+        path: str | None = None,
+        method: str | None = None,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        async with self._lock:
+            items = list(self._data)
+
+        if path:
+            items = [x for x in items if x.get("request_path") == path]
+        if method:
+            method_u = method.upper()
+            items = [x for x in items if str(x.get("request_method", "")).upper() == method_u]
+        if limit is not None:
+            items = items[-limit:]
+
+        return deepcopy(items)
+
+    async def clear(self) -> None:
+        async with self._lock:
+            self._data.clear()