[CDAPI-100]: Change to a Client Protocol with a pytest hook to add the nhsd-apim marker for remote tests

Author: nhsd-rebecca-flynn

pathology-api/tests/conftest.py

@@ -2,24 +2,22 @@
 
 import os
 from datetime import timedelta
-from typing import Literal, cast
+from typing import Literal, Protocol, cast
 
 import pytest
 import requests
 from dotenv import load_dotenv
 
 load_dotenv()
 
+_RequestMethod = Literal["GET", "POST"]
 
-class Client:
-    """A simple HTTP client for testing purposes."""
 
-    def __init__(self, lambda_url: str, timeout: timedelta = timedelta(seconds=1)):
-        self._lambda_url = lambda_url
-        self._timeout = timeout.total_seconds()
+class Client(Protocol):
+    """Protocol defining the interface for HTTP clients."""
 
     def send(
-        self, data: str, path: str, request_method: Literal["GET", "POST"]
+        self, data: str, path: str, request_method: _RequestMethod
     ) -> requests.Response:
         """
         Send a request to the APIs with some given parameters.
@@ -30,12 +28,10 @@ def send(
         Returns:
             Response object from the request
         """
-        return self._send(
-            data=data, path=path, include_payload=True, request_method=request_method
-        )
+        ...
 
     def send_without_payload(
-        self, path: str, request_method: Literal["GET", "POST"]
+        self, path: str, request_method: _RequestMethod
     ) -> requests.Response:
         """
         Send a request to the APIs without a payload.
@@ -45,6 +41,28 @@ def send_without_payload(
         Returns:
             Response object from the request
         """
+        ...
+
+
+class LocalClient:
+    """A simple HTTP client for testing purposes."""
+
+    def __init__(self, lambda_url: str, timeout: timedelta = timedelta(seconds=1)):
+        self._lambda_url = lambda_url
+        self._timeout = timeout.total_seconds()
+
+    def send(
+        self, data: str, path: str, request_method: _RequestMethod
+    ) -> requests.Response:
+
+        return self._send(
+            data=data, path=path, include_payload=True, request_method=request_method
+        )
+
+    def send_without_payload(
+        self, path: str, request_method: _RequestMethod
+    ) -> requests.Response:
+
         return self._send(
             data=None, path=path, include_payload=False, request_method=request_method
         )
@@ -54,43 +72,149 @@ def _send(
         data: str | None,
         path: str,
         include_payload: bool,
-        request_method: Literal["GET", "POST"],
+        request_method: _RequestMethod,
     ) -> requests.Response:
+        url = f"{self._lambda_url}/{path}"
         match request_method:
             case "POST":
                 return requests.post(
-                    f"{self._lambda_url}/{path}",
+                    url,
                     data=data if include_payload else None,
                     timeout=self._timeout,
                 )
             case "GET":
                 return requests.get(
-                    f"{self._lambda_url}/{path}",
-                    timeout=self._timeout,
+                    url,
                     data=data if include_payload else None,
+                    timeout=self._timeout,
                 )
 
 
-@pytest.fixture(scope="module")
-def client(base_url: str) -> Client:
-    """Create a test client for the application."""
-    return Client(lambda_url=base_url)
+class RemoteClient:
+    """HTTP client for remote testing."""
+
+    def __init__(
+        self,
+        api_url: str,
+        auth_headers: dict[str, str],
+        timeout: timedelta = timedelta(seconds=5),
+    ):
+        self._api_url = api_url
+        self._default_headers = auth_headers | {"Content-Type": "application/fhir+json"}
+        self._timeout = timeout.total_seconds()
+
+    def send(
+        self,
+        data: str,
+        path: str,
+        request_method: _RequestMethod,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
+
+        return self._send(
+            data=data,
+            path=path,
+            include_payload=True,
+            request_method=request_method,
+            headers=headers,
+        )
+
+    def send_without_payload(
+        self,
+        path: str,
+        request_method: _RequestMethod,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
 
+        return self._send(
+            data=None,
+            path=path,
+            include_payload=False,
+            request_method=request_method,
+            headers=headers,
+        )
 
-@pytest.fixture(scope="module")
+    def _send(
+        self,
+        data: str | None,
+        path: str,
+        include_payload: bool,
+        request_method: _RequestMethod,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
+        url = f"{self._api_url}/{path}"
+        merged_headers = self._default_headers | (headers or {})
+        match request_method:
+            case "POST":
+                return requests.post(
+                    url,
+                    data=data if include_payload else None,
+                    headers=merged_headers,
+                    timeout=self._timeout,
+                )
+            case "GET":
+                return requests.get(
+                    url,
+                    data=data if include_payload else None,
+                    headers=merged_headers,
+                    timeout=self._timeout,
+                )
+
+
+@pytest.fixture
 def base_url() -> str:
     """Retrieves the base URL of the currently deployed application."""
     return _fetch_env_variable("BASE_URL", str)
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def hostname() -> str:
     """Retrieves the hostname of the currently deployed application."""
     return _fetch_env_variable("HOST", str)
 
 
+@pytest.fixture
+def client(request: pytest.FixtureRequest, base_url: str) -> Client:
+    env = request.config.getoption("--env")
+
+    if env == "local":
+        return LocalClient(lambda_url=base_url)
+    elif env == "remote":
+        auth_headers = request.getfixturevalue("nhsd_apim_auth_headers")
+        proxy_url = request.getfixturevalue("nhsd_apim_proxy_url")
+        return RemoteClient(
+            api_url=proxy_url,
+            auth_headers=auth_headers,
+        )
+    else:
+        raise ValueError(f"Unknown env: {env}")
+
+
 def _fetch_env_variable[T](name: str, _: type[T]) -> T:
     value = os.getenv(name)
     if not value:
         raise ValueError(f"{name} environment variable is not set.")
     return cast("T", value)
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    parser.addoption(
+        "--env",
+        action="store",
+        default="local",
+        help="Environment to run tests against",
+    )
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    env = config.getoption("--env")
+
+    if env == "remote":
+        for item in items:
+            item.add_marker(
+                pytest.mark.nhsd_apim_authorization(
+                    access="application", level="level3"
+                )
+            )