proxy-mock 2.10.1__py3-none-any.whl

proxy_mock/__init__.py

@@ -0,0 +1,10 @@
+from importlib import metadata
+
+from proxy_mock.app import create_app
+
+try:
+    __version__ = metadata.version(__package__)
+except ModuleNotFoundError:
+    __version__ = ""
+
+__all__ = ["create_app"]

proxy_mock/any_catcher.py

@@ -0,0 +1,8 @@
+from proxy_mock.app import create_app
+
+app = create_app()
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run("any_catcher:app", port=5000, log_level="info", reload=True)

proxy_mock/api/deps.py

@@ -0,0 +1,5 @@
+from fastapi import Request
+
+
+def get_app(request: Request):
+    return request.app

proxy_mock/api/routes/configure.py

@@ -0,0 +1,50 @@
+import json
+from copy import deepcopy
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import ValidationError
+
+from proxy_mock.domain.constants import ParseError
+from proxy_mock.domain.models import ConfigureMockRequestSchema
+from proxy_mock.services.mock_service import mock_initialization, patch_mock_data, return_mock_data
+from proxy_mock.services.request_parser import parse_configure
+
+router = APIRouter()
+
+
+@router.post("/configure_mock")
+async def configure_mock(request: Request):
+    try:
+        parsed_data = await parse_configure(request)
+    except ParseError as err:
+        return JSONResponse({"success": False, "error": err.detail}, err.code)
+
+    try:
+        validate_data = ConfigureMockRequestSchema.model_validate(parsed_data).model_dump()
+    except ValidationError as err:
+        return JSONResponse({"success": False, "error": json.loads(err.json())}, 422)
+
+    response = await mock_initialization(request.app, validate_data)
+    return JSONResponse(response, 201)
+
+
+@router.patch("/configure_mock")
+async def patch_mock_configuration(request: Request):
+    try:
+        parsed_data = await parse_configure(request)
+    except ParseError as err:
+        return JSONResponse({"success": False, "error": err.detail}, err.code)
+
+    try:
+        validate_data = ConfigureMockRequestSchema.model_validate(parsed_data).model_dump(exclude_unset=True)
+    except ValidationError as err:
+        return JSONResponse({"success": False, "error": json.loads(err.json())}, 422)
+
+    saved_data = await return_mock_data(validate_data["path"])
+    if not saved_data:
+        return JSONResponse({"success": False, "error": f"There is no mock for {validate_data['path']}"}, 400)
+
+    mock_data = deepcopy(await patch_mock_data(saved_data, validate_data))
+    response = await mock_initialization(request.app, mock_data)
+    return JSONResponse(response, 200)

proxy_mock/api/routes/service.py

@@ -0,0 +1,24 @@
+import platform
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from proxy_mock.services.mock_service import count_mocks
+
+router = APIRouter()
+
+
+@router.get("/proxy_mock")
+async def get_proxy_mock(request: Request):
+    app = request.app
+    return JSONResponse(
+        {
+            "success": True,
+            "version": app.state.version,
+            "python_version": platform.python_version(),
+            "mocks_count": await count_mocks(),
+            "traffic_count": await app.state.traffic_store.count(),
+            "traffic_max_items": app.state.traffic_store.max_items,
+        },
+        200,
+    )

proxy_mock/api/routes/storage.py

@@ -0,0 +1,51 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from proxy_mock.core.serializers import convert_bytes_to_str
+from proxy_mock.services.mock_service import (
+    cleanup_storage,
+    delete_mock_data,
+    remove_runtime_routes,
+    return_mock_data,
+    return_storage,
+)
+
+router = APIRouter()
+
+
+@router.get("/storage")
+async def get_storage(request: Request):
+    path = request.query_params.get("path")
+    data = await return_mock_data(path) if path else await return_storage()
+    return JSONResponse({"success": True, "data": convert_bytes_to_str(data)}, 200)
+
+
+@router.delete("/storage")
+async def delete_storage(request: Request):
+    """Delete mocks. Without `path` all of them; with `path` only that one (`404` if missing)."""
+    path = request.query_params.get("path")
+
+    if not path:
+        result = await cleanup_storage(request.app)
+        return JSONResponse({"success": result, "data": convert_bytes_to_str(await return_storage())}, 200)
+
+    remove_runtime_routes(request.app, path)
+    deleted = await delete_mock_data(path)
+    if not deleted:
+        return JSONResponse({"success": False, "error": f"No mock found for {path}"}, 404)
+
+    return JSONResponse({"success": True, "data": convert_bytes_to_str(await return_storage())}, 200)
+
+
+@router.post("/storage/clean")
+async def clean_storage(request: Request):
+    """Deprecated alias for deleting mocks. The RESTful variant is `DELETE /storage`."""
+    path = request.query_params.get("path")
+
+    if path:
+        remove_runtime_routes(request.app, path)
+        result = await delete_mock_data(path)
+    else:
+        result = await cleanup_storage(request.app)
+
+    return JSONResponse({"success": result, "data": convert_bytes_to_str(await return_storage())}, 200)

proxy_mock/api/routes/traffic.py

@@ -0,0 +1,79 @@
+import json
+
+from aiocache import Cache
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import ValidationError
+
+from proxy_mock.domain.models import TrafficSettingsSchema
+
+router = APIRouter()
+
+
+def _traffic_settings(request: Request) -> dict:
+    return {
+        "record_unknown_traffic": request.app.state.record_unknown_traffic,
+        "max_items": request.app.state.traffic_store.max_items,
+    }
+
+
+@router.get("/traffic")
+async def get_traffic(request: Request):
+    path = request.query_params.get("path")
+    method = request.query_params.get("method")
+    limit_raw = request.query_params.get("limit")
+    limit = int(limit_raw) if limit_raw and limit_raw.isdigit() else None
+
+    data = await request.app.state.traffic_store.list(path=path, method=method, limit=limit)
+    return JSONResponse({"success": True, "count": len(data), "data": data}, 200)
+
+
+@router.post("/traffic/clean")
+async def clean_traffic(request: Request):
+    await request.app.state.traffic_store.clear()
+    return JSONResponse({"success": True, "data": []}, 200)
+
+
+@router.get("/traffic/settings")
+async def get_traffic_settings(request: Request):
+    return JSONResponse({"success": True, "data": _traffic_settings(request)}, 200)
+
+
+@router.post("/traffic/settings")
+async def set_traffic_settings(request: Request):
+    """Traffic recording settings, changeable without restarting the service.
+
+    The update is partial: only the supplied fields are applied.
+    """
+    try:
+        payload = await request.json()
+    except ValueError:
+        return JSONResponse({"success": False, "error": "The request body must be valid JSON"}, 400)
+
+    try:
+        settings = TrafficSettingsSchema.model_validate(payload)
+    except ValidationError as err:
+        return JSONResponse({"success": False, "error": json.loads(err.json())}, 422)
+
+    changes = settings.model_dump(exclude_unset=True, exclude_none=True)
+    if not changes:
+        return JSONResponse(
+            {"success": False, "error": "Provide at least one field: record_unknown_traffic, max_items"}, 422
+        )
+
+    if "record_unknown_traffic" in changes:
+        request.app.state.record_unknown_traffic = changes["record_unknown_traffic"]
+
+    if "max_items" in changes:
+        await request.app.state.traffic_store.set_max_items(changes["max_items"])
+
+    request.app.logger.info(f"Traffic settings updated: {changes}")
+
+    return JSONResponse({"success": True, "data": _traffic_settings(request)}, 200)
+
+
+@router.post("/cache/clean")
+async def clean_cache(request: Request):
+    await request.app.state.cache.close()
+    request.app.state.cache = Cache(Cache.MEMORY, namespace="mocks")
+    return JSONResponse({"success": True}, 200)

proxy_mock/api/schemas.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class SuccessResponse(BaseModel):
+    success: bool = True
+
+
+class ErrorResponse(BaseModel):
+    success: bool = False
+    error: str | dict | list

proxy_mock/app/__init__.py

@@ -0,0 +1,3 @@
+from proxy_mock.app.factory import create_app
+
+__all__ = ["create_app"]

proxy_mock/app/factory.py

@@ -0,0 +1,97 @@
+import os
+from contextlib import asynccontextmanager
+
+import httpx2
+from aiocache import Cache
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from proxy_mock.api.routes.configure import router as configure_router
+from proxy_mock.api.routes.service import router as service_router
+from proxy_mock.api.routes.storage import router as storage_router
+from proxy_mock.api.routes.traffic import router as traffic_router
+from proxy_mock.core.logging import app_logger
+from proxy_mock.core.settings import get_version_from_pyproject, record_unknown_traffic_default
+from proxy_mock.repositories.traffic_store import TrafficStore
+from proxy_mock.services.traffic_service import new_traffic_data
+from proxy_mock.utils import log_request
+
+
+def _proxy_timeout() -> float:
+    raw = os.getenv("PROXY_MOCK_PROXY_TIMEOUT", "").strip()
+    try:
+        value = float(raw)
+        return value if value > 0 else 30.0
+    except ValueError:
+        return 30.0
+
+
+@asynccontextmanager
+async def app_lifespan(app: FastAPI):
+    app.state.http_client = httpx2.AsyncClient(timeout=httpx2.Timeout(_proxy_timeout()))
+    try:
+        yield
+    finally:
+        await app.state.http_client.aclose()
+
+
+class ProxyMockApp(FastAPI):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("lifespan", app_lifespan)
+        super().__init__(*args, **kwargs)
+
+        self.state.cache = Cache(Cache.MEMORY, namespace="mocks")
+        self.state.traffic_store = TrafficStore()
+        # Toggled at runtime via POST /traffic/settings, so it lives in state rather than in a module constant.
+        self.state.record_unknown_traffic = record_unknown_traffic_default()
+        self.logger = app_logger
+
+
+def create_app() -> ProxyMockApp:
+    app = ProxyMockApp(title="Proxy Mock")
+    app.state.version = get_version_from_pyproject(app.logger)
+
+    app.include_router(service_router)
+    app.include_router(configure_router)
+    app.include_router(storage_router)
+    app.include_router(traffic_router)
+
+    @app.middleware("http")
+    @log_request
+    async def request_middleware(request: Request, call_next):
+        return await call_next(request)
+
+    @app.exception_handler(404)
+    async def custom_404_handler(request: Request, exc):
+        app.logger.warning(f"No mock found for {request.url.path}")
+        if app.state.record_unknown_traffic:
+            try:
+                await new_traffic_data(app, request, {"status_code": 404})
+            except Exception as err:  # recording traffic must not break the 404 response
+                app.logger.error(f"Failed to record traffic for the 404: {err}")
+        return JSONResponse({"error": f"No mock found for {request.url.path}"}, 404)
+
+    app.logger.info(f"Service routes: {sorted(collect_service_paths(app))}")
+
+    return app
+
+
+def collect_service_paths(app: FastAPI) -> set[str]:
+    """Paths of the service endpoints.
+
+    Since the FastAPI upgrade, routes added by include_router are nested in _IncludedRouter
+    and have no top-level ``path`` attribute of their own, so we read them from original_router.
+    """
+    paths: set[str] = set()
+    for route in app.routes:
+        original_router = getattr(route, "original_router", None)
+        if original_router is not None:
+            for inner in getattr(original_router, "routes", []):
+                inner_path = getattr(inner, "path", None)
+                if inner_path:
+                    paths.add(inner_path)
+        else:
+            route_path = getattr(route, "path", None)
+            if route_path:
+                paths.add(route_path)
+    return paths

proxy_mock/client/__init__.py

@@ -0,0 +1,4 @@
+from proxy_mock.client.async_client import AsyncProxyMock
+from proxy_mock.client.client import ProxyMock
+
+__all__ = ["ProxyMock", "AsyncProxyMock"]

proxy_mock/client/async_client.py

@@ -0,0 +1,237 @@
+from http import HTTPMethod
+from typing import Any
+
+import httpx2
+import msgpack
+from yarl import URL
+
+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 AsyncProxyMockRequestError(Exception):
+    """Error while performing an async request to the proxy-mock server."""
+
+
+class AsyncProxyMockResponseError(Exception):
+    """HTTP error returned by the proxy-mock server."""
+
+
+class AsyncProxyMock:
+    def __init__(self, host: str, timeout: float = 10.0) -> None:
+        self.host = host.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx2.AsyncClient(base_url=self.host, timeout=timeout)
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.aclose()
+
+    @staticmethod
+    def _parse_response_body(response: httpx2.Response) -> dict | str | list | bytes | None:
+        if not response.content:
+            return None
+
+        content_type = response.headers.get("Content-Type", "")
+        if "json" in content_type:
+            try:
+                return response.json()
+            except Exception:
+                return response.text
+        if "text" in content_type:
+            return response.text
+        return response.content
+
+    async def execute_request(
+        self,
+        method: str | HTTPMethod,
+        route: str,
+        raise_for_status: bool = False,
+        **kwargs,
+    ) -> httpx2.Response:
+        try:
+            response = await self._client.request(method=str(method), url=route, **kwargs)
+        except (httpx2.ConnectError, httpx2.TimeoutException) as err:
+            raise AsyncProxyMockRequestError(f"Proxy-mock request error:\n{err}") from err
+
+        if raise_for_status and response.status_code >= 400:
+            raise AsyncProxyMockResponseError(f"Proxy-mock returned HTTP {response.status_code}: {response.text}")
+        return response
+
+    async def execute_request_and_get_response_body(
+        self,
+        method: str | HTTPMethod,
+        route: str,
+        json: dict | None = None,
+        **kwargs,
+    ) -> dict | str | list | bytes | None:
+        response = await self.execute_request(method=method, route=route, json=json, **kwargs)
+        return self._parse_response_body(response)
+
+    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
+
+    async def _send_configure(self, method: HTTPMethod, payload: dict):
+        return await self.execute_request_and_get_response_body(
+            method=method,
+            route=Endpoints.CONFIGURE_MOCK,
+            content=msgpack.packb(payload),
+            headers={"Content-Type": CONFIGURE_CONTENT_TYPE},
+        )
+
+    async def get_proxy_mock(self):
+        return await self.execute_request_and_get_response_body(HTTPMethod.GET, Endpoints.PROXY_MOCK)
+
+    async 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,
+            **kwargs,
+        )
+        return await self._send_configure(HTTPMethod.POST, payload)
+
+    async 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,
+            **kwargs,
+        )
+        return await self._send_configure(HTTPMethod.PATCH, payload)
+
+    async 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 await self.execute_request_and_get_response_body(HTTPMethod.GET, full_path)
+
+    async 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 await self.execute_request_and_get_response_body(HTTPMethod.GET, full_path)
+
+    async 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 await self.execute_request_and_get_response_body(HTTPMethod.POST, full_path)
+
+    async def delete_mock(self, path: str):
+        full_path = URL().with_path(Endpoints.STORAGE).with_query({"path": path}).human_repr()
+        return await self.execute_request_and_get_response_body(HTTPMethod.DELETE, full_path)
+
+    async def clean_traffic(self):
+        return await self.execute_request_and_get_response_body(HTTPMethod.POST, Endpoints.TRAFFIC_CLEAN)
+
+    async def get_traffic_settings(self):
+        return await self.execute_request_and_get_response_body(HTTPMethod.GET, Endpoints.TRAFFIC_SETTINGS)
+
+    async def set_traffic_settings(self, record_unknown_traffic: bool | None = None, max_items: int | None = None):
+        return await self.execute_request_and_get_response_body(
+            HTTPMethod.POST,
+            Endpoints.TRAFFIC_SETTINGS,
+            json=_build_traffic_settings_payload(record_unknown_traffic, max_items),
+        )
+
+    async def clean_cache(self):
+        return await self.execute_request_and_get_response_body(HTTPMethod.POST, Endpoints.CACHE_CLEAN)