Client uses content-type from response to format output

Author: olliesilvester

src/daq_config_server/app.py

@@ -51,15 +51,14 @@ def get_configuration(
         match accept:
             case AcceptedFileTypes.JSON:
                 with file_path.open("r", encoding="utf-8") as f:
-                    content = json.load(f)
-                json_response = JSONResponse(
+                    content = json.loads(f.read())
+                return JSONResponse(
                     content=content,
                 )
-                return json_response
             case AcceptedFileTypes.PLAIN_TEXT:
                 with file_path.open("r", encoding="utf-8") as f:
                     content = f.read()
-                Response(content=content, media_type=accept)
+                return Response(content=content, media_type=accept)
     except Exception as e:
         LOGGER.warning(
             f"Failed to convert {file_name} to {accept} and caught \

src/daq_config_server/client.py

@@ -1,14 +1,24 @@
+import json
+from enum import StrEnum
 from logging import Logger, getLogger
 from typing import Any, TypeVar
 
 import requests
 
+from daq_config_server.app import AcceptedFileTypes
+
 from .constants import ENDPOINTS
 
 T = TypeVar("T")
 BlParamDType = str | int | float | bool
 
 
+class RequestedResponseFormats(StrEnum):
+    DICT = AcceptedFileTypes.JSON  # Tries to convert to dict using json.loads()
+    DECODED_STRING = AcceptedFileTypes.PLAIN_TEXT  # Use utf-8 decoding in response
+    RAW_BYTE_STRING = AcceptedFileTypes.RAW_BYTES  # Use raw bytes in response
+
+
 class ConfigServer:
     def __init__(self, url: str, log: Logger | None = None) -> None:
         self._url = url.rstrip("/")
@@ -17,13 +27,35 @@ def __init__(self, url: str, log: Logger | None = None) -> None:
     def _get(
         self,
         endpoint: str,
+        headers: dict,
         item: str | None = None,
     ):
-        r = requests.get(self._url + endpoint + (f"/{item}" if item else ""))
-        return r.json()
-
-    def read_unformatted_file(self, file_path: str) -> Any:
-        # After https://github.com/DiamondLightSource/daq-config-server/issues/67, we
-        # can get specific formats, and then have better typing on
-        # return values
-        return self._get(ENDPOINTS.CONFIG, file_path)
+        r = requests.get(
+            self._url + endpoint + (f"/{item}" if item else ""), headers=headers
+        )
+
+        content_type = r.headers["content-type"].split(";")[0].strip()
+
+        try:
+            match content_type:
+                case AcceptedFileTypes.JSON:
+                    content = json.loads(r.content)
+                case AcceptedFileTypes.PLAIN_TEXT:
+                    content = r.text
+                case _:
+                    content = r.content
+        except Exception:
+            # TODO warn here
+            content = r.content
+
+        return content
+
+    def get_file_contents(
+        self,
+        file_path: str,
+        requested_response_format: RequestedResponseFormats = (
+            RequestedResponseFormats.DECODED_STRING
+        ),
+    ) -> Any:
+        headers = {"Accept": requested_response_format}
+        return self._get(ENDPOINTS.CONFIG, headers, file_path)

tests/system_tests/test_client.py

@@ -1,6 +1,8 @@
+import json
+
 import pytest
 
-from daq_config_server.client import ConfigServer
+from daq_config_server.client import ConfigServer, RequestedResponseFormats
 from tests.constants import TEST_DATA_DIR
 
 SERVER_ADDRESS = "http://0.0.0.0:8555"
@@ -21,11 +23,59 @@ def server():
 
 
 @pytest.mark.requires_local_server
-def test_read_unformatted_file(server: ConfigServer):
+def test_read_unformatted_file_as_plain_text(server: ConfigServer):
     file_path = f"{TEST_DATA_DIR}/beamline_parameters.txt"
     with open(file_path) as f:
         expected_response = f.read()
+
+    assert (
+        server.get_file_contents(
+            file_path,
+        )
+        == expected_response
+    )
+
+
+@pytest.mark.requires_local_server
+def test_read_file_as_bytes(server: ConfigServer):
+    file_path = f"{TEST_DATA_DIR}/beamline_parameters.txt"
+    with open(file_path, "rb") as f:
+        expected_response = f.read()
+
+    assert (
+        server.get_file_contents(
+            file_path,
+            requested_response_format=RequestedResponseFormats.RAW_BYTE_STRING,
+        )
+        == expected_response
+    )
+
+
+@pytest.mark.requires_local_server
+def test_read_good_json_as_dict(server: ConfigServer):
+    file_path = f"{TEST_DATA_DIR}/test_good_json.json"
+    with open(file_path) as f:
+        expected_response = json.loads(f.read())
+
+    assert (
+        server.get_file_contents(
+            file_path,
+            requested_response_format=RequestedResponseFormats.DICT,
+        )
+        == expected_response
+    )
+
+
+@pytest.mark.requires_local_server
+def test_bad_json_read_as_bytes(server: ConfigServer):
+    file_path = f"{TEST_DATA_DIR}/test_bad_json"
+    with open(file_path, "rb") as f:
+        expected_response = f.read()
+
     assert (
-        server.read_unformatted_file(f"{TEST_DATA_DIR}/beamline_parameters.txt")
+        server.get_file_contents(
+            file_path,
+            requested_response_format=RequestedResponseFormats.DICT,
+        )
         == expected_response
     )

tests/unit_tests/test_client.py

@@ -3,16 +3,19 @@
 from fastapi import status
 from httpx import Response
 
-from daq_config_server.client import ConfigServer
+from daq_config_server.client import ConfigServer, RequestedResponseFormats
 from daq_config_server.constants import ENDPOINTS
 
 
 # More useful tests for the client are in tests/system_tests
 @patch("daq_config_server.client.requests.get")
-def test_read_unformatted_file(mock_request: MagicMock):
+def test_get_file_contents(mock_request: MagicMock):
     mock_request.return_value = Response(status_code=status.HTTP_200_OK, json="test")
     file_path = "test"
     url = "url"
     server = ConfigServer(url)
-    server.read_unformatted_file(file_path)
-    mock_request.assert_called_once_with(url + ENDPOINTS.CONFIG + "/" + file_path)
+    server.get_file_contents(file_path)
+    mock_request.assert_called_once_with(
+        url + ENDPOINTS.CONFIG + "/" + file_path,
+        headers={"Accept": RequestedResponseFormats.DECODED_STRING},
+    )