Refactor Reference

Author: dbanty

openapi_python_client/openapi_parser/openapi.py

@@ -67,7 +67,7 @@ def parse_request_form_body(body: Dict[str, Any], /) -> Optional[Reference]:
         body_content = body["content"]
         form_body = body_content.get("application/x-www-form-urlencoded")
         if form_body:
-            return Reference(form_body["schema"]["$ref"])
+            return Reference.from_ref(form_body["schema"]["$ref"])
         return None
 
     @staticmethod
@@ -168,7 +168,7 @@ def from_dict(d: Dict[str, Any], /) -> Schema:
             if isinstance(p, (ListProperty, RefProperty, EnumProperty)) and p.reference:
                 relative_imports.add(import_string_from_reference(p.reference))
         schema = Schema(
-            reference=Reference(d["title"]),
+            reference=Reference.from_ref(d["title"]),
             required_properties=required_properties,
             optional_properties=optional_properties,
             relative_imports=relative_imports,

openapi_python_client/openapi_parser/properties.py

@@ -122,7 +122,7 @@ class EnumProperty(Property):
     reference: Reference = field(init=False)
 
     def __post_init__(self) -> None:
-        self.reference = Reference(self.name)
+        self.reference = Reference.from_ref(self.name)
         inverse_values = {v: k for k, v in self.values.items()}
         if self.default is not None:
             self.default = f"{self.reference.class_name}.{inverse_values[self.default]}"
@@ -203,7 +203,7 @@ def property_from_dict(name: str, required: bool, data: Dict[str, Any]) -> Prope
             default=data.get("default"),
         )
     if "$ref" in data:
-        return RefProperty(name=name, required=required, reference=Reference(data["$ref"]), default=None)
+        return RefProperty(name=name, required=required, reference=Reference.from_ref(data["$ref"]), default=None)
     if data["type"] == "string":
         if "format" not in data:
             return StringProperty(
@@ -220,7 +220,7 @@ def property_from_dict(name: str, required: bool, data: Dict[str, Any]) -> Prope
     elif data["type"] == "array":
         reference = None
         if "$ref" in data["items"]:
-            reference = Reference(data["items"]["$ref"])
+            reference = Reference.from_ref(data["items"]["$ref"])
         _type = None
         if "type" in data["items"]:
             _type = _openapi_types_to_python_type_strings[data["items"]["type"]]

openapi_python_client/openapi_parser/reference.py

@@ -1,10 +1,21 @@
+""" A Reference is ultimately a Class which will be in models, usually defined in a body input or return type """
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
 import stringcase
 
 
+@dataclass
 class Reference:
     """ A reference to a class which will be in models """
 
-    def __init__(self, ref: str):
-        ref_value = ref.split("/")[-1]  # get the #/schemas/blahblah part off
-        self.class_name: str = stringcase.pascalcase(ref_value)
-        self.module_name: str = stringcase.snakecase(ref_value)
+    class_name: str
+    module_name: str
+
+    @staticmethod
+    def from_ref(ref: str) -> Reference:
+        """ Get a Reference from the openapi #/schemas/blahblah string """
+        ref_value = ref.split("/")[-1]
+        return Reference(class_name=stringcase.pascalcase(ref_value), module_name=stringcase.snakecase(ref_value),)

openapi_python_client/openapi_parser/responses.py

@@ -95,11 +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, reference=Reference(schema_data["$ref"]),)
+        return RefResponse(status_code=status_code, reference=Reference.from_ref(schema_data["$ref"]),)
     if "type" not in schema_data:
         return Response(status_code=status_code)
     if schema_data["type"] == "array":
-        return ListRefResponse(status_code=status_code, reference=Reference(schema_data["items"]["$ref"]),)
+        return ListRefResponse(status_code=status_code, reference=Reference.from_ref(schema_data["items"]["$ref"]),)
     if schema_data["type"] == "string":
         return StringResponse(status_code=status_code)
     raise ValueError(f"Cannot parse response of type {schema_data['type']}")

tests/test_end_to_end/test_end_to_end.py

@@ -30,7 +30,9 @@ def test_end_to_end(capsys):
     gm_path = Path(__file__).parent / "golden-master"
     output_path = Path.cwd() / "my-test-api-client"
 
-    runner.invoke(app, ["generate", f"--path={openapi_path}"])
+    result = runner.invoke(app, ["generate", f"--path={openapi_path}"])
 
+    if result.exit_code != 0:
+        raise result.exception
     _compare_directories(gm_path, output_path)
     shutil.rmtree(output_path)

tests/test_openapi_parser/test_openapi.py

@@ -159,14 +159,14 @@ def test_from_dict(self, mocker):
         property_from_dict = mocker.patch(
             f"{MODULE_NAME}.property_from_dict", side_effect=[required_property, optional_property]
         )
-        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
         import_string_from_reference = mocker.patch(f"{MODULE_NAME}.import_string_from_reference")
 
         from openapi_python_client.openapi_parser.openapi import Schema
 
         result = Schema.from_dict(in_data)
 
-        Reference.assert_called_once_with(in_data["title"])
+        from_ref.assert_called_once_with(in_data["title"])
         property_from_dict.assert_has_calls(
             [
                 mocker.call(name="RequiredEnum", required=True, data=in_data["properties"]["RequiredEnum"]),
@@ -175,7 +175,7 @@ def test_from_dict(self, mocker):
         )
         import_string_from_reference.assert_called_once_with(required_property.reference)
         assert result == Schema(
-            reference=Reference(),
+            reference=from_ref(),
             required_properties=[required_property],
             optional_properties=[optional_property],
             relative_imports={import_string_from_reference()},
@@ -187,14 +187,14 @@ class TestEndpoint:
     def test_parse_request_form_body(self, mocker):
         ref = mocker.MagicMock()
         body = {"content": {"application/x-www-form-urlencoded": {"schema": {"$ref": ref}}}}
-        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
 
         from openapi_python_client.openapi_parser.openapi import Endpoint
 
         result = Endpoint.parse_request_form_body(body)
 
-        Reference.assert_called_once_with(ref)
-        assert result == Reference()
+        from_ref.assert_called_once_with(ref)
+        assert result == from_ref()
 
     def test_parse_request_form_body_no_data(self):
         body = {"content": {}}

tests/test_openapi_parser/test_properties.py

@@ -100,20 +100,20 @@ class TestEnumProperty:
     def test___post_init__(self, mocker):
         name = mocker.MagicMock()
         fake_reference = mocker.MagicMock(class_name="MyTestEnum")
-        Reference = mocker.patch(f"{MODULE_NAME}.Reference", return_value=fake_reference)
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref", return_value=fake_reference)
 
         from openapi_python_client.openapi_parser.properties import EnumProperty
 
         enum_property = EnumProperty(
             name=name, required=True, default="second", values={"FIRST": "first", "SECOND": "second"}
         )
 
-        Reference.assert_called_once_with(name)
+        from_ref.assert_called_once_with(name)
         assert enum_property.default == "MyTestEnum.SECOND"
 
     def test_get_type_string(self, mocker):
         fake_reference = mocker.MagicMock(class_name="MyTestEnum")
-        mocker.patch(f"{MODULE_NAME}.Reference", return_value=fake_reference)
+        mocker.patch(f"{MODULE_NAME}.Reference.from_ref", return_value=fake_reference)
 
         from openapi_python_client.openapi_parser.properties import EnumProperty
 
@@ -125,7 +125,7 @@ def test_get_type_string(self, mocker):
 
     def test_transform(self, mocker):
         name = mocker.MagicMock()
-        mocker.patch(f"{MODULE_NAME}.Reference")
+        mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
 
         from openapi_python_client.openapi_parser.properties import EnumProperty
 
@@ -135,7 +135,7 @@ def test_transform(self, mocker):
 
     def test_constructor_from_dict(self, mocker):
         fake_reference = mocker.MagicMock(class_name="MyTestEnum")
-        mocker.patch(f"{MODULE_NAME}.Reference", return_value=fake_reference)
+        mocker.patch(f"{MODULE_NAME}.Reference.from_ref", return_value=fake_reference)
 
         from openapi_python_client.openapi_parser.properties import EnumProperty
 
@@ -217,15 +217,15 @@ def test_property_from_dict_ref(self, mocker):
         data = {
             "$ref": mocker.MagicMock(),
         }
-        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
         RefProperty = mocker.patch(f"{MODULE_NAME}.RefProperty")
 
         from openapi_python_client.openapi_parser.properties import property_from_dict
 
         p = property_from_dict(name=name, required=required, data=data)
 
-        Reference.assert_called_once_with(data["$ref"])
-        RefProperty.assert_called_once_with(name=name, required=required, reference=Reference(), default=None)
+        from_ref.assert_called_once_with(data["$ref"])
+        RefProperty.assert_called_once_with(name=name, required=required, reference=from_ref(), default=None)
         assert p == RefProperty()
 
     def test_property_from_dict_string_no_format(self, mocker):
@@ -335,15 +335,15 @@ def test_property_from_dict_ref_array(self, mocker):
             "items": {"$ref": ref},
         }
         ListProperty = mocker.patch(f"{MODULE_NAME}.ListProperty")
-        Reference = mocker.patch(f"{MODULE_NAME}.Reference")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
 
         from openapi_python_client.openapi_parser.properties import property_from_dict
 
         p = property_from_dict(name=name, required=required, data=data)
 
-        Reference.assert_called_once_with(ref)
+        from_ref.assert_called_once_with(ref)
         ListProperty.assert_called_once_with(
-            name=name, required=required, default=None, type=None, reference=Reference()
+            name=name, required=required, default=None, type=None, reference=from_ref()
         )
         assert p == ListProperty()
 

tests/test_openapi_parser/test_reference.py

@@ -0,0 +1,7 @@
+def test_from_ref():
+    from openapi_python_client.openapi_parser.reference import Reference
+
+    r = Reference.from_ref("#/components/schemas/PingResponse")
+
+    assert r.class_name == "PingResponse"
+    assert r.module_name == "ping_response"

tests/test_openapi_parser/test_responses.py

@@ -84,14 +84,14 @@ 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")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
         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())
+        from_ref.assert_called_once_with(ref)
+        RefResponse.assert_called_once_with(status_code=status_code, reference=from_ref())
         assert response == RefResponse()
 
     def test_response_from_dict_empty(self, mocker):
@@ -109,14 +109,14 @@ 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")
+        from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
         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())
+        from_ref.assert_called_once_with(ref)
+        ListRefResponse.assert_called_once_with(status_code=status_code, reference=from_ref())
         assert response == ListRefResponse()
 
     def test_response_from_dict_string(self, mocker):