refactor: migrate mocket.plugins.pook_mock_engine to use mocket.http

Author: betaboon

mocket/plugins/pook_mock_engine.py

@@ -1,83 +1,105 @@
-try:
-    from pook.engine import MockEngine
-except ModuleNotFoundError:
-    MockEngine = object
+from __future__ import annotations
+
+from typing import Any, Sequence
 
 from mocket.core.mocket import Mocket
-from mocket.mockhttp import Entry, Response
+from mocket.http import MocketHttpEntry, MocketHttpMethod, MocketHttpResponse
+
+try:
+    from pook import Engine as PookEngine
+    from pook import Mock as PookMock
+    from pook import MockEngine as PookMockEngine
+    from pook import Request as PookRequest
+    from pook.interceptors.base import BaseInterceptor as PookBaseInterceptor
+except ModuleNotFoundError:
+    PookEngine = object
+    PookMock = object
+    PookMockEngine = object
+    PookRequest = object
+    PookBaseInterceptor = object
 
 
-class MocketPookEntry(Entry):
+class MocketPookEntry(MocketHttpEntry):
     pook_request = None
     pook_engine = None
 
-    def can_handle(self, data):
-        can_handle = super().can_handle(data)
-
-        if can_handle:
-            self.pook_engine.match(self.pook_request)
-        return can_handle
-
-    @classmethod
-    def single_register(
-        cls,
-        method,
-        uri,
-        body="",
-        status=200,
-        headers=None,
-        match_querystring=True,
-        exception=None,
-    ):
-        entry = cls(
-            uri,
-            method,
-            [Response(body=body, status=status, headers=headers)],
+    def __init__(
+        self,
+        method: MocketHttpMethod,
+        uri: str,
+        responses: Sequence[MocketHttpResponse | Exception],
+        pook_engine: PookEngine,
+        pook_request: PookRequest,
+        match_querystring: bool = True,
+        add_trailing_slash: bool = True,
+    ) -> None:
+        super().__init__(
+            method=method,
+            uri=uri,
+            responses=responses,
             match_querystring=match_querystring,
+            add_trailing_slash=add_trailing_slash,
         )
-        Mocket.register(entry)
-        return entry
-
-
-class MocketEngine(MockEngine):
-    def __init__(self, engine):
-        def mocket_mock_fun(*args, **kwargs):
-            mock = self.pook_mock_fun(*args, **kwargs)
+        self._pook_engine = pook_engine
+        self._pook_request = pook_request
 
-            request = mock._request
-            method = request.method
-            url = request.rawurl
-
-            response = mock._response
-            body = response._body
-            status = response._status
-            headers = response._headers
+    def can_handle(self, data: bytes) -> bool:
+        can_handle = super().can_handle(data)
 
-            entry = MocketPookEntry.single_register(method, url, body, status, headers)
-            entry.pook_engine = self.engine
-            entry.pook_request = request
+        if can_handle:
+            self._pook_engine.match(self._pook_request)
+        return can_handle
 
-            return mock
 
-        from pook.interceptors.base import BaseInterceptor
+class MocketInterceptor(PookBaseInterceptor):  # type: ignore[misc]
+    @staticmethod
+    def activate() -> None:
+        Mocket.disable()
+        Mocket.enable()
 
-        class MocketInterceptor(BaseInterceptor):
-            @staticmethod
-            def activate():
-                Mocket.disable()
-                Mocket.enable()
+    @staticmethod
+    def disable() -> None:
+        Mocket.disable()
 
-            @staticmethod
-            def disable():
-                Mocket.disable()
 
+class MocketEngine(PookMockEngine):  # type: ignore[misc]
+    def __init__(self, engine: PookEngine) -> None:
         # Store plugins engine
         self.engine = engine
         # Store HTTP client interceptors
-        self.interceptors = []
+        self.interceptors: list[PookBaseInterceptor] = []
         # Self-register MocketInterceptor
         self.add_interceptor(MocketInterceptor)
 
         # mocking pook.mock()
         self.pook_mock_fun = self.engine.mock
-        self.engine.mock = mocket_mock_fun
+        self.engine.mock = self.mocket_mock_fun
+
+    def mocket_mock_fun(self, *args: Any, **kwargs: Any) -> PookMock:
+        mock = self.pook_mock_fun(*args, **kwargs)
+
+        request = mock._request
+        method = request.method
+        url = request.rawurl
+
+        response = mock._response
+        body = response._body
+        status = response._status
+        headers = response._headers
+
+        entry = MocketPookEntry(
+            method=method,
+            uri=url,
+            responses=[
+                MocketHttpResponse(
+                    status_code=status,
+                    headers=headers,
+                    body=body,
+                )
+            ],
+            pook_engine=self.engine,
+            pook_request=request,
+        )
+        Mocket.register(entry)
+
+        return mock