eyeriss-plugin-sdk 0.1.0__tar.gz

eyeriss_plugin_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: eyeriss-plugin-sdk
+Version: 0.1.0
+Summary: Eyeriss API Gateway Plugin SDK for Python
+Author-email: Eyeriss <dev@eyeriss.io>
+License: MIT
+Project-URL: Homepage, https://github.com/eyeriss/eyeriss-sdk
+Project-URL: Documentation, https://docs.eyeriss.io/plugins/sdk
+Project-URL: Repository, https://github.com/eyeriss/eyeriss-sdk
+Keywords: eyeriss,api-gateway,plugin,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.10

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk/__init__.py

@@ -0,0 +1,36 @@
+"""
+Eyeriss Plugin SDK for Python
+
+Provides the base class and data types for building Python plugins
+for the Eyeriss API Gateway.
+
+Usage:
+    from eyeriss_plugin_sdk import EyerissPlugin
+    from eyeriss_plugin_sdk.types import PluginContext, PluginResult, ErrorResponse
+
+    class Plugin(EyerissPlugin):
+        @property
+        def plugin_id(self) -> str:
+            return "my-plugin"
+
+        async def pre_request(self, context: PluginContext) -> PluginResult:
+            return PluginResult(proceed=True)
+"""
+
+from eyeriss_plugin_sdk.plugin import EyerissPlugin
+from eyeriss_plugin_sdk.types import (
+    ErrorResponse,
+    PluginContext,
+    PluginResult,
+    SerializedRequest,
+)
+
+__all__ = [
+    "EyerissPlugin",
+    "ErrorResponse",
+    "PluginContext",
+    "PluginResult",
+    "SerializedRequest",
+]
+
+__version__ = "0.1.0"

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk/plugin.py

@@ -0,0 +1,105 @@
+"""
+EyerissPlugin Abstract Base Class
+
+Base class for all Python plugins in the Eyeriss Gateway. Plugin authors
+subclass this and implement the hooks they need. Default implementations
+return proceed=True so plugins only need to override hooks they care about.
+"""
+
+from abc import ABC, abstractmethod
+
+from eyeriss_plugin_sdk.types import PluginContext, PluginResult
+
+
+class EyerissPlugin(ABC):
+    """
+    Base class for all Python plugins in the Eyeriss Gateway.
+
+    Plugin authors must:
+    1. Subclass this class
+    2. Implement the `plugin_id` property (must match manifest.json id)
+    3. Override one or more hook methods
+
+    Example:
+        class Plugin(EyerissPlugin):
+            @property
+            def plugin_id(self) -> str:
+                return "my-custom-plugin"
+
+            async def pre_request(self, context: PluginContext) -> PluginResult:
+                return PluginResult(
+                    proceed=True,
+                    modified_headers={"X-Plugin-Processed": "true"},
+                )
+    """
+
+    @property
+    @abstractmethod
+    def plugin_id(self) -> str:
+        """Unique plugin identifier (must match manifest.json 'id' field)."""
+        ...
+
+    async def pre_request(self, context: PluginContext) -> PluginResult:
+        """
+        Called after auth/RBAC pass, before proxying to backend.
+
+        Return PluginResult with proceed=False to block the request.
+        Return modified_headers to add/override outbound headers.
+        Return modified_body to replace the request body.
+
+        Default: proceed without modification.
+        """
+        return PluginResult(proceed=True)
+
+    async def post_response(self, context: PluginContext) -> PluginResult:
+        """
+        Called after backend response, before returning to client.
+
+        Return modified_headers to add/override response headers.
+        Return modified_body to replace the response body.
+        proceed=False is ignored for post_response (response already received).
+
+        Default: pass-through without modification.
+        """
+        return PluginResult(proceed=True)
+
+    async def on_error(self, context: PluginContext, error_info: dict) -> None:
+        """
+        Called on gateway error (auth failure, 5xx, timeout, etc.).
+
+        Observational only — return value is ignored. Cannot modify the
+        error response. Use for logging, alerting, or metrics.
+
+        Default: no-op.
+        """
+        pass
+
+    async def initialize(self) -> None:
+        """
+        Called once when the plugin is loaded at gateway startup.
+        Override for setup tasks (initialize state, validate config, etc.).
+
+        Default: no-op.
+        """
+        pass
+
+    async def configure(self, config: dict) -> None:
+        """
+        Called after initialize() with the plugin's configuration.
+
+        Override to apply settings from the admin UI / database config.
+        Use this instead of reading environment variables directly so
+        that configuration changes via the UI take effect immediately.
+
+        Default: no-op.
+        """
+        pass
+
+    async def cleanup(self) -> None:
+        """
+        Called when the plugin is unloaded (gateway shutdown or plugin removal).
+        Override for cleanup tasks (close connections, flush buffers, etc.).
+
+        Default: no-op.
+        """
+        pass

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk/types.py

@@ -0,0 +1,168 @@
+"""
+Eyeriss Plugin SDK — Data Types
+
+Serializable data types for plugin hook arguments and return values.
+All types are fully JSON-serializable for WASM compatibility.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SerializedRequest:
+    """
+    Serialized representation of an HTTP request for plugin consumption.
+    Body is size-limited to prevent memory issues with large uploads.
+    """
+    method: str
+    path: str
+    headers: dict  # {header_name: value} — lowercase keys
+    query_params: dict  # {param_name: value}
+    content_type: str = ""
+    body: Optional[bytes] = None
+
+    def to_dict(self) -> dict:
+        """Serialize to a JSON-compatible dict (body as base64)."""
+        import base64
+        d = {
+            "method": self.method,
+            "path": self.path,
+            "headers": self.headers,
+            "query_params": self.query_params,
+            "content_type": self.content_type,
+        }
+        if self.body is not None:
+            d["body"] = base64.b64encode(self.body).decode("ascii")
+            d["body_encoding"] = "base64"
+        else:
+            d["body"] = None
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "SerializedRequest":
+        """Deserialize from a JSON-compatible dict."""
+        import base64
+        body = None
+        if d.get("body") is not None:
+            if d.get("body_encoding") == "base64":
+                body = base64.b64decode(d["body"])
+            elif isinstance(d["body"], bytes):
+                body = d["body"]
+            else:
+                body = d["body"].encode("utf-8")
+        return cls(
+            method=d["method"],
+            path=d["path"],
+            headers=d.get("headers", {}),
+            query_params=d.get("query_params", {}),
+            content_type=d.get("content_type", ""),
+            body=body,
+        )
+
+
+@dataclass
+class ErrorResponse:
+    """Error response returned by a plugin when blocking a request."""
+    status_code: int
+    body: dict
+    headers: Optional[dict] = None
+
+    def to_dict(self) -> dict:
+        d = {"status_code": self.status_code, "body": self.body}
+        if self.headers:
+            d["headers"] = self.headers
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ErrorResponse":
+        return cls(
+            status_code=d["status_code"],
+            body=d["body"],
+            headers=d.get("headers"),
+        )
+
+
+@dataclass
+class PluginResult:
+    """
+    Result returned by a plugin hook execution.
+
+    - proceed=True: request continues to next plugin or to backend
+    - proceed=False: request is blocked; error_response is returned to client
+    - modified_headers: headers to merge into outbound request (pre_request)
+      or response (post_response)
+    - modified_body: replacement body bytes, or None to keep original
+    """
+    proceed: bool = True
+    modified_headers: Optional[dict] = None
+    modified_body: Optional[bytes] = None
+    error_response: Optional[ErrorResponse] = None
+
+    def to_dict(self) -> dict:
+        import base64
+        d = {"proceed": self.proceed}
+        if self.modified_headers is not None:
+            d["modified_headers"] = self.modified_headers
+        if self.modified_body is not None:
+            d["modified_body"] = base64.b64encode(self.modified_body).decode("ascii")
+            d["modified_body_encoding"] = "base64"
+        if self.error_response is not None:
+            d["error_response"] = self.error_response.to_dict()
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "PluginResult":
+        import base64
+        modified_body = None
+        if d.get("modified_body") is not None:
+            if d.get("modified_body_encoding") == "base64":
+                modified_body = base64.b64decode(d["modified_body"])
+            elif isinstance(d["modified_body"], bytes):
+                modified_body = d["modified_body"]
+        error_response = None
+        if d.get("error_response"):
+            error_response = ErrorResponse.from_dict(d["error_response"])
+        return cls(
+            proceed=d.get("proceed", True),
+            modified_headers=d.get("modified_headers"),
+            modified_body=modified_body,
+            error_response=error_response,
+        )
+
+
+@dataclass
+class PluginContext:
+    """
+    Context passed to plugin hooks.
+
+    Contains serialized request data and auth information. Must be fully
+    JSON-serializable for WASM compatibility.
+    """
+    request: SerializedRequest
+    application_id: int
+    endpoint_id: int
+    auth_result: dict
+    request_id: str
+    client_ip: str
+
+    def to_dict(self) -> dict:
+        return {
+            "request": self.request.to_dict(),
+            "application_id": self.application_id,
+            "endpoint_id": self.endpoint_id,
+            "auth_result": self.auth_result,
+            "request_id": self.request_id,
+            "client_ip": self.client_ip,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "PluginContext":
+        return cls(
+            request=SerializedRequest.from_dict(d["request"]),
+            application_id=d["application_id"],
+            endpoint_id=d["endpoint_id"],
+            auth_result=d.get("auth_result", {}),
+            request_id=d["request_id"],
+            client_ip=d["client_ip"],
+        )

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: eyeriss-plugin-sdk
+Version: 0.1.0
+Summary: Eyeriss API Gateway Plugin SDK for Python
+Author-email: Eyeriss <dev@eyeriss.io>
+License: MIT
+Project-URL: Homepage, https://github.com/eyeriss/eyeriss-sdk
+Project-URL: Documentation, https://docs.eyeriss.io/plugins/sdk
+Project-URL: Repository, https://github.com/eyeriss/eyeriss-sdk
+Keywords: eyeriss,api-gateway,plugin,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.10

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+eyeriss_plugin_sdk/__init__.py
+eyeriss_plugin_sdk/plugin.py
+eyeriss_plugin_sdk/types.py
+eyeriss_plugin_sdk.egg-info/PKG-INFO
+eyeriss_plugin_sdk.egg-info/SOURCES.txt
+eyeriss_plugin_sdk.egg-info/dependency_links.txt
+eyeriss_plugin_sdk.egg-info/top_level.txt
+tests/test_plugin.py
+tests/test_types.py

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eyeriss_plugin_sdk-0.1.0/eyeriss_plugin_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+eyeriss_plugin_sdk

eyeriss_plugin_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eyeriss-plugin-sdk"
+version = "0.1.0"
+description = "Eyeriss API Gateway Plugin SDK for Python"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    { name = "Eyeriss", email = "dev@eyeriss.io" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: System :: Networking",
+    "Typing :: Typed",
+]
+keywords = ["eyeriss", "api-gateway", "plugin", "sdk"]
+
+[project.urls]
+Homepage = "https://github.com/eyeriss/eyeriss-sdk"
+Documentation = "https://docs.eyeriss.io/plugins/sdk"
+Repository = "https://github.com/eyeriss/eyeriss-sdk"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["eyeriss_plugin_sdk*"]

eyeriss_plugin_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eyeriss_plugin_sdk-0.1.0/tests/test_plugin.py

@@ -0,0 +1,83 @@
+"""Tests for eyeriss_plugin_sdk.plugin — EyerissPlugin ABC."""
+
+import pytest
+
+from eyeriss_plugin_sdk import EyerissPlugin
+from eyeriss_plugin_sdk.types import PluginContext, PluginResult, SerializedRequest
+
+
+def _make_context():
+    return PluginContext(
+        request=SerializedRequest(
+            method="GET", path="/test",
+            headers={}, query_params={},
+        ),
+        application_id=1, endpoint_id=1,
+        auth_result={}, request_id="test-id",
+        client_ip="127.0.0.1",
+    )
+
+
+class _MinimalPlugin(EyerissPlugin):
+    @property
+    def plugin_id(self) -> str:
+        return "test-minimal-plugin"
+
+
+class TestEyerissPluginABC:
+
+    def test_cannot_instantiate_directly(self):
+        with pytest.raises(TypeError):
+            EyerissPlugin()
+
+    def test_must_implement_plugin_id(self):
+        class Incomplete(EyerissPlugin):
+            pass
+
+        with pytest.raises(TypeError):
+            Incomplete()
+
+    def test_minimal_subclass_instantiates(self):
+        plugin = _MinimalPlugin()
+        assert plugin.plugin_id == "test-minimal-plugin"
+
+
+class TestDefaultHooks:
+
+    @pytest.mark.asyncio
+    async def test_pre_request_returns_proceed(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.pre_request(_make_context())
+        assert isinstance(result, PluginResult)
+        assert result.proceed is True
+
+    @pytest.mark.asyncio
+    async def test_post_response_returns_proceed(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.post_response(_make_context())
+        assert isinstance(result, PluginResult)
+        assert result.proceed is True
+
+    @pytest.mark.asyncio
+    async def test_on_error_returns_none(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.on_error(_make_context(), {"error": "timeout"})
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_initialize_returns_none(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.initialize()
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_configure_returns_none(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.configure({"key": "value"})
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_cleanup_returns_none(self):
+        plugin = _MinimalPlugin()
+        result = await plugin.cleanup()
+        assert result is None

eyeriss_plugin_sdk-0.1.0/tests/test_types.py

@@ -0,0 +1,316 @@
+"""Tests for eyeriss_plugin_sdk.types — serialization, deserialization, roundtrips."""
+
+import base64
+
+from eyeriss_plugin_sdk.types import (
+    ErrorResponse,
+    PluginContext,
+    PluginResult,
+    SerializedRequest,
+)
+
+
+# ---------------------------------------------------------------------------
+# SerializedRequest
+# ---------------------------------------------------------------------------
+
+class TestSerializedRequest:
+
+    def test_to_dict_with_body(self):
+        req = SerializedRequest(
+            method="POST", path="/api/v1/data",
+            headers={"content-type": "application/json"},
+            query_params={"page": "1"},
+            content_type="application/json",
+            body=b'{"key": "value"}',
+        )
+        d = req.to_dict()
+        assert d["method"] == "POST"
+        assert d["path"] == "/api/v1/data"
+        assert d["headers"] == {"content-type": "application/json"}
+        assert d["query_params"] == {"page": "1"}
+        assert d["content_type"] == "application/json"
+        assert d["body_encoding"] == "base64"
+        assert base64.b64decode(d["body"]) == b'{"key": "value"}'
+
+    def test_to_dict_without_body(self):
+        req = SerializedRequest(
+            method="GET", path="/healthz",
+            headers={}, query_params={},
+        )
+        d = req.to_dict()
+        assert d["body"] is None
+        assert "body_encoding" not in d
+
+    def test_from_dict_base64_body(self):
+        encoded = base64.b64encode(b"hello").decode("ascii")
+        d = {
+            "method": "PUT", "path": "/items/1",
+            "headers": {}, "query_params": {},
+            "body": encoded, "body_encoding": "base64",
+        }
+        req = SerializedRequest.from_dict(d)
+        assert req.body == b"hello"
+
+    def test_from_dict_string_body(self):
+        d = {
+            "method": "POST", "path": "/data",
+            "headers": {}, "query_params": {},
+            "body": "plain text",
+        }
+        req = SerializedRequest.from_dict(d)
+        assert req.body == b"plain text"
+
+    def test_from_dict_bytes_body(self):
+        d = {
+            "method": "POST", "path": "/data",
+            "headers": {}, "query_params": {},
+            "body": b"raw bytes",
+        }
+        req = SerializedRequest.from_dict(d)
+        assert req.body == b"raw bytes"
+
+    def test_from_dict_none_body(self):
+        d = {
+            "method": "GET", "path": "/",
+            "headers": {}, "query_params": {},
+            "body": None,
+        }
+        req = SerializedRequest.from_dict(d)
+        assert req.body is None
+
+    def test_from_dict_missing_optional_fields(self):
+        d = {"method": "GET", "path": "/test"}
+        req = SerializedRequest.from_dict(d)
+        assert req.headers == {}
+        assert req.query_params == {}
+        assert req.content_type == ""
+        assert req.body is None
+
+    def test_roundtrip(self):
+        original = SerializedRequest(
+            method="PATCH", path="/users/42",
+            headers={"authorization": "Bearer tok"},
+            query_params={"fields": "name,email"},
+            content_type="application/json",
+            body=b'{"name": "Alice"}',
+        )
+        restored = SerializedRequest.from_dict(original.to_dict())
+        assert restored.method == original.method
+        assert restored.path == original.path
+        assert restored.headers == original.headers
+        assert restored.query_params == original.query_params
+        assert restored.content_type == original.content_type
+        assert restored.body == original.body
+
+    def test_roundtrip_no_body(self):
+        original = SerializedRequest(
+            method="DELETE", path="/items/7",
+            headers={}, query_params={},
+        )
+        restored = SerializedRequest.from_dict(original.to_dict())
+        assert restored.body is None
+
+    def test_defaults(self):
+        req = SerializedRequest(method="GET", path="/", headers={}, query_params={})
+        assert req.content_type == ""
+        assert req.body is None
+
+
+# ---------------------------------------------------------------------------
+# ErrorResponse
+# ---------------------------------------------------------------------------
+
+class TestErrorResponse:
+
+    def test_to_dict_without_headers(self):
+        err = ErrorResponse(status_code=403, body={"error": "forbidden"})
+        d = err.to_dict()
+        assert d == {"status_code": 403, "body": {"error": "forbidden"}}
+        assert "headers" not in d
+
+    def test_to_dict_with_headers(self):
+        err = ErrorResponse(
+            status_code=429, body={"error": "rate limited"},
+            headers={"Retry-After": "60"},
+        )
+        d = err.to_dict()
+        assert d["headers"] == {"Retry-After": "60"}
+
+    def test_from_dict(self):
+        d = {"status_code": 500, "body": {"error": "internal"}, "headers": {"X-Req-Id": "abc"}}
+        err = ErrorResponse.from_dict(d)
+        assert err.status_code == 500
+        assert err.body == {"error": "internal"}
+        assert err.headers == {"X-Req-Id": "abc"}
+
+    def test_from_dict_no_headers(self):
+        d = {"status_code": 401, "body": {"error": "unauthorized"}}
+        err = ErrorResponse.from_dict(d)
+        assert err.headers is None
+
+    def test_roundtrip(self):
+        original = ErrorResponse(status_code=422, body={"detail": "invalid"}, headers={"X-Error": "yes"})
+        restored = ErrorResponse.from_dict(original.to_dict())
+        assert restored.status_code == original.status_code
+        assert restored.body == original.body
+        assert restored.headers == original.headers
+
+
+# ---------------------------------------------------------------------------
+# PluginResult
+# ---------------------------------------------------------------------------
+
+class TestPluginResult:
+
+    def test_defaults(self):
+        result = PluginResult()
+        assert result.proceed is True
+        assert result.modified_headers is None
+        assert result.modified_body is None
+        assert result.error_response is None
+
+    def test_to_dict_minimal(self):
+        result = PluginResult()
+        assert result.to_dict() == {"proceed": True}
+
+    def test_to_dict_with_headers(self):
+        result = PluginResult(modified_headers={"X-Custom": "val"})
+        d = result.to_dict()
+        assert d["modified_headers"] == {"X-Custom": "val"}
+
+    def test_to_dict_with_body(self):
+        result = PluginResult(modified_body=b"new body")
+        d = result.to_dict()
+        assert d["modified_body_encoding"] == "base64"
+        assert base64.b64decode(d["modified_body"]) == b"new body"
+
+    def test_to_dict_with_error_response(self):
+        err = ErrorResponse(status_code=403, body={"msg": "blocked"})
+        result = PluginResult(proceed=False, error_response=err)
+        d = result.to_dict()
+        assert d["proceed"] is False
+        assert d["error_response"]["status_code"] == 403
+
+    def test_from_dict_minimal(self):
+        result = PluginResult.from_dict({"proceed": True})
+        assert result.proceed is True
+        assert result.modified_body is None
+        assert result.error_response is None
+
+    def test_from_dict_defaults_proceed_true(self):
+        result = PluginResult.from_dict({})
+        assert result.proceed is True
+
+    def test_from_dict_with_body(self):
+        encoded = base64.b64encode(b"modified").decode("ascii")
+        result = PluginResult.from_dict({
+            "proceed": True,
+            "modified_body": encoded,
+            "modified_body_encoding": "base64",
+        })
+        assert result.modified_body == b"modified"
+
+    def test_from_dict_with_raw_bytes_body(self):
+        result = PluginResult.from_dict({
+            "proceed": True,
+            "modified_body": b"raw",
+        })
+        assert result.modified_body == b"raw"
+
+    def test_from_dict_with_error_response(self):
+        result = PluginResult.from_dict({
+            "proceed": False,
+            "error_response": {"status_code": 429, "body": {"error": "throttled"}},
+        })
+        assert result.proceed is False
+        assert result.error_response.status_code == 429
+
+    def test_roundtrip_full(self):
+        err = ErrorResponse(status_code=503, body={"error": "unavailable"}, headers={"Retry-After": "30"})
+        original = PluginResult(
+            proceed=False,
+            modified_headers={"X-Plugin": "test"},
+            modified_body=b"replacement",
+            error_response=err,
+        )
+        restored = PluginResult.from_dict(original.to_dict())
+        assert restored.proceed == original.proceed
+        assert restored.modified_headers == original.modified_headers
+        assert restored.modified_body == original.modified_body
+        assert restored.error_response.status_code == original.error_response.status_code
+        assert restored.error_response.body == original.error_response.body
+        assert restored.error_response.headers == original.error_response.headers
+
+
+# ---------------------------------------------------------------------------
+# PluginContext
+# ---------------------------------------------------------------------------
+
+class TestPluginContext:
+
+    def _make_request(self):
+        return SerializedRequest(
+            method="POST", path="/api/test",
+            headers={"content-type": "application/json"},
+            query_params={"q": "search"},
+            content_type="application/json",
+            body=b'{"data": 1}',
+        )
+
+    def test_to_dict(self):
+        ctx = PluginContext(
+            request=self._make_request(),
+            application_id=10, endpoint_id=20,
+            auth_result={"user_id": "u1", "role": "admin"},
+            request_id="req-abc-123",
+            client_ip="192.168.1.100",
+        )
+        d = ctx.to_dict()
+        assert d["application_id"] == 10
+        assert d["endpoint_id"] == 20
+        assert d["auth_result"]["user_id"] == "u1"
+        assert d["request_id"] == "req-abc-123"
+        assert d["client_ip"] == "192.168.1.100"
+        assert d["request"]["method"] == "POST"
+
+    def test_from_dict(self):
+        req_dict = self._make_request().to_dict()
+        d = {
+            "request": req_dict,
+            "application_id": 5, "endpoint_id": 15,
+            "auth_result": {"authenticated": True},
+            "request_id": "req-xyz",
+            "client_ip": "10.0.0.1",
+        }
+        ctx = PluginContext.from_dict(d)
+        assert ctx.application_id == 5
+        assert ctx.request.method == "POST"
+        assert ctx.request.body == b'{"data": 1}'
+
+    def test_from_dict_default_auth_result(self):
+        req_dict = self._make_request().to_dict()
+        d = {
+            "request": req_dict,
+            "application_id": 1, "endpoint_id": 2,
+            "request_id": "r1", "client_ip": "0.0.0.0",
+        }
+        ctx = PluginContext.from_dict(d)
+        assert ctx.auth_result == {}
+
+    def test_roundtrip(self):
+        original = PluginContext(
+            request=self._make_request(),
+            application_id=42, endpoint_id=99,
+            auth_result={"scope": "read:all"},
+            request_id="roundtrip-id",
+            client_ip="203.0.113.50",
+        )
+        restored = PluginContext.from_dict(original.to_dict())
+        assert restored.application_id == original.application_id
+        assert restored.endpoint_id == original.endpoint_id
+        assert restored.auth_result == original.auth_result
+        assert restored.request_id == original.request_id
+        assert restored.client_ip == original.client_ip
+        assert restored.request.method == original.request.method
+        assert restored.request.body == original.request.body