Add tests for responses

#3

Author: dbanty

openapi_python_client/openapi_parser/responses.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Any, Dict, Literal, TypedDict, Union, cast
+from typing import Any, Dict, Literal, TypedDict, Union
 
 from .reference import Reference
 
@@ -11,7 +11,6 @@ class Response:
     """ Describes a single response for an endpoint """
 
     status_code: int
-    content_type: ContentType
 
     def return_string(self) -> str:
         """ How this Response should be represented as a return type """
@@ -65,13 +64,6 @@ def constructor(self) -> str:
         return "response.text"
 
 
-@dataclass
-class EmptyResponse(Response):
-    """ Response has no payload """
-
-    pass
-
-
 _openapi_types_to_python_type_strings = {
     "string": "str",
     "number": "float",
@@ -103,15 +95,11 @@ def response_from_dict(*, status_code: int, data: _ResponseDict) -> Response:
     schema_data = data["content"][content_type]["schema"]
 
     if "$ref" in schema_data:
-        return RefResponse(
-            status_code=status_code, content_type=content_type, reference=Reference(schema_data["$ref"]),
-        )
+        return RefResponse(status_code=status_code, reference=Reference(schema_data["$ref"]),)
     if "type" not in schema_data:
-        return EmptyResponse(status_code=status_code, content_type=content_type,)
+        return Response(status_code=status_code)
     if schema_data["type"] == "array":
-        return ListRefResponse(
-            status_code=status_code, content_type=content_type, reference=Reference(schema_data["items"]["$ref"]),
-        )
+        return ListRefResponse(status_code=status_code, reference=Reference(schema_data["items"]["$ref"]),)
     if schema_data["type"] == "string":
-        return StringResponse(status_code=status_code, content_type=content_type)
+        return StringResponse(status_code=status_code)
     raise ValueError(f"Cannot parse response of type {schema_data['type']}")

tests/test_openapi_parser/test_openapi.py

@@ -296,8 +296,8 @@ def test__add_responses(self, mocker):
         )
         ref_1 = Reference(ref="ref_1")
         ref_2 = Reference(ref="ref_2")
-        response_1 = RefResponse(status_code=200, content_type="application/json", reference=ref_1)
-        response_2 = RefResponse(status_code=404, content_type="application/json", reference=ref_2)
+        response_1 = RefResponse(status_code=200, reference=ref_1)
+        response_2 = RefResponse(status_code=404, reference=ref_2)
         response_from_dict = mocker.patch(f"{MODULE_NAME}.response_from_dict", side_effect=[response_1, response_2])
         import_string_from_reference = mocker.patch(
             f"{MODULE_NAME}.import_string_from_reference", side_effect=["import_1", "import_2"]

tests/test_openapi_parser/test_responses.py

@@ -0,0 +1,121 @@
+import pytest
+
+MODULE_NAME = "openapi_python_client.openapi_parser.responses"
+
+
+class TestResponse:
+    def test_return_string(self):
+        from openapi_python_client.openapi_parser.responses import Response
+
+        r = Response(200)
+
+        assert r.return_string() == "None"
+
+    def test_constructor(self):
+        from openapi_python_client.openapi_parser.responses import Response
+
+        r = Response(200)
+
+        assert r.constructor() == "None"
+
+
+class TestListRefResponse:
+    def test_return_string(self, mocker):
+        from openapi_python_client.openapi_parser.responses import ListRefResponse
+
+        r = ListRefResponse(200, reference=mocker.MagicMock(class_name="SuperCoolClass"))
+
+        assert r.return_string() == "List[SuperCoolClass]"
+
+    def test_constructor(self, mocker):
+        from openapi_python_client.openapi_parser.responses import ListRefResponse
+
+        r = ListRefResponse(200, reference=mocker.MagicMock(class_name="SuperCoolClass"))
+
+        assert r.constructor() == "[SuperCoolClass.from_dict(item) for item in response.json()]"
+
+
+class TestStringResponse:
+    def test_return_string(self):
+        from openapi_python_client.openapi_parser.responses import StringResponse
+
+        r = StringResponse(200)
+
+        assert r.return_string() == "str"
+
+    def test_constructor(self):
+        from openapi_python_client.openapi_parser.responses import StringResponse
+
+        r = StringResponse(200)
+
+        assert r.constructor() == "response.text"
+
+
+class TestResponseFromDict:
+    def test_response_from_dict_no_content(self):
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        with pytest.raises(ValueError):
+            response_from_dict(status_code=200, data={})
+
+    def test_response_from_dict_unsupported_content_type(self):
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        with pytest.raises(ValueError):
+            response_from_dict(status_code=200, data={"content": {"not/real": {}}})
+
+    def test_response_from_dict_ref(self, mocker):
+        ref = mocker.MagicMock()
+        status_code = mocker.MagicMock(autospec=int)
+        data = {"content": {"application/json": {"schema": {"$ref": ref}}}}
+        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        RefResponse = mocker.patch(f"{MODULE_NAME}.RefResponse")
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        response = response_from_dict(status_code=status_code, data=data)
+
+        Reference.assert_called_once_with(ref)
+        RefResponse.assert_called_once_with(status_code=status_code, reference=Reference())
+        assert response == RefResponse()
+
+    def test_response_from_dict_empty(self, mocker):
+        status_code = mocker.MagicMock(autospec=int)
+        data = {"content": {"application/json": {"schema": {}}}}
+        Response = mocker.patch(f"{MODULE_NAME}.Response")
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        response = response_from_dict(status_code=status_code, data=data)
+
+        Response.assert_called_once_with(status_code=status_code)
+        assert response == Response()
+
+    def test_response_from_dict_array(self, mocker):
+        ref = mocker.MagicMock()
+        status_code = mocker.MagicMock(autospec=int)
+        data = {"content": {"application/json": {"schema": {"type": "array", "items": {"$ref": ref}}}}}
+        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        ListRefResponse = mocker.patch(f"{MODULE_NAME}.ListRefResponse")
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        response = response_from_dict(status_code=status_code, data=data)
+
+        Reference.assert_called_once_with(ref)
+        ListRefResponse.assert_called_once_with(status_code=status_code, reference=Reference())
+        assert response == ListRefResponse()
+
+    def test_response_from_dict_string(self, mocker):
+        status_code = mocker.MagicMock(autospec=int)
+        data = {"content": {"text/html": {"schema": {"type": "string"}}}}
+        StringResponse = mocker.patch(f"{MODULE_NAME}.StringResponse")
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        response = response_from_dict(status_code=status_code, data=data)
+
+        StringResponse.assert_called_once_with(status_code=status_code)
+        assert response == StringResponse()
+
+    def test_response_from_dict_unsupported_type(self):
+        from openapi_python_client.openapi_parser.responses import response_from_dict
+
+        with pytest.raises(ValueError):
+            response_from_dict(status_code=200, data={"content": {"application/json": {"schema": {"type": "blah"}}}})