Updated generic resource and tests

Author: albertsola

mpt_api_client/http/models.py

@@ -37,16 +37,16 @@ def next_offset(self) -> int:
 
 @dataclass
 class Meta:
-    """Provides meta information about the pagination, ignored fields and the response."""
+    """Provides meta-information about the pagination, ignored fields and the response."""
 
+    response: Response
     pagination: Pagination = field(default_factory=Pagination)
     ignored: list[str] = field(default_factory=list)
-    response: Response | None = None
 
     @classmethod
     def from_response(cls, response: Response) -> Self:
         """Creates a meta object from response."""
-        meta_data = response.json().get("$meta")
+        meta_data = response.json().get("$meta", {})
         if not isinstance(meta_data, dict):
             raise TypeError("Response $meta must be a dict.")
 
@@ -57,30 +57,34 @@ def from_response(cls, response: Response) -> Self:
         )
 
 
-class GenericResource(Box):
+ResourceType = dict[str, Any] | None
+
+
+class GenericResource:
     """Provides a base resource to interact with api data using fluent interfaces."""
+    _data_key = "data"
+
+    def __init__(self, resource:  ResourceType = None, meta: Meta | None = None) -> None:
+        resource = resource or {}
+        self.meta: Meta | None = meta
+        self._resource: Box = Box(resource, camel_killer_box=True, default_box=False)
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.__post_init__()
+    def __getattr__(self, attribute: str) -> Box | Any:
+        """Returns the resource data."""
+        return self._resource.__getattr__(attribute)  # type: ignore[no-untyped-call]
 
-    def __post_init__(self) -> None:
-        """Initializes meta information."""
-        meta = self.get("$meta", None)  # type: ignore[no-untyped-call]
-        if meta:
-            self._meta = Meta(**meta)
+    def to_dict(self) -> dict[str, Any]:
+        """Returns the resource as a dictionary."""
+        return self._resource.to_dict()
 
     @classmethod
     def from_response(cls, response: Response) -> Self:
         """Creates a resource from a response.
 
         Expected a Response with json data with two keys: data and $meta.
         """
-        response_data = response.json().get("data")
+        response_data = response.json().get(cls._data_key)
         if not isinstance(response_data, dict):
             raise TypeError("Response data must be a dict.")
         meta = Meta.from_response(response)
-        meta.response = response
-        resource = cls(response_data)
-        resource._meta = meta
-        return resource
+        return cls(response_data, meta)

tests/http/models/test_genric_resource.py

@@ -1,4 +1,3 @@
-import re
 
 import pytest
 from httpx import Response
@@ -11,100 +10,56 @@ def meta_data():
     return {"pagination": {"limit": 10, "offset": 20, "total": 100}, "ignored": ["one"]}  # noqa: WPS226
 
 
-class TestGenericResource:  # noqa: WPS214
-    def test_generic_resource_empty(self):
-        resource = GenericResource()
-        with pytest.raises(AttributeError):
-            _ = resource._meta
+def test_generic_resource_empty():
+    resource = GenericResource()
+    assert resource.meta is None
+    assert resource.to_dict() == {}
 
-    def test_initialization_with_data(self):
-        resource = GenericResource(name="test", value=123)
 
-        assert resource.name == "test"
-        assert resource.value == 123
+def test_from_response(meta_data):
+    record_data = {"id": 1, "name": {"given": "Albert", "family": "Einstein"}}
+    response = Response(200, json={"data": record_data, "$meta": meta_data})
+    expected_meta = Meta.from_response(response)
 
-    def test_init(self, meta_data):
-        resource = {"$meta": meta_data, "key": "value"}  # noqa: WPS445 WPS517
-        init_one = GenericResource(resource)
-        init_two = GenericResource(**resource)
-        assert init_one == init_two
+    resource = GenericResource.from_response(response)
 
-    def test_generic_resource_meta_property_with_data(self, meta_data):
-        resource = GenericResource({"$meta": meta_data})
-        assert resource._meta == Meta(**meta_data)
+    assert resource.to_dict() == record_data
+    assert resource.meta == expected_meta
 
-    def test_generic_resource_box_functionality(self):
-        resource = GenericResource(id=1, name="test_resource", nested={"key": "value"})
 
-        assert resource.id == 1
-        assert resource.name == "test_resource"
-        assert resource.nested.key == "value"
+def test_attribute_access():
+    record_data = {"id": 1, "name": {"given": "Albert", "family": "Einstein"}}
+    meta = Meta.from_response(Response(200, json={"$meta": {}}))
+    resource = GenericResource(resource=record_data, meta=meta)
 
-    def test_with_both_meta_and_response(self, meta_data):
-        response = Response(200, json={})
-        meta_data["response"] = response
-        meta_object = Meta(**meta_data)
+    assert resource.meta == meta
 
-        resource = GenericResource(
-            data="test_data",
-            **{"$meta": meta_data},  # noqa: WPS445 WPS517
-        )
+    assert resource.id == 1
 
-        assert resource.data == "test_data"
-        assert resource._meta == meta_object
+    with pytest.raises(AttributeError, match=r"'Box' object has no attribute 'address'"):
+        _ = resource.address  # noqa: WPS122
 
-    def test_dynamic_attribute_access(self):
-        resource = GenericResource()
+    with pytest.raises(AttributeError, match=r"'Box' object has no attribute 'surname'"):
+        _ = resource.name.surname  # noqa: WPS122
 
-        resource.dynamic_field = "dynamic_value"
-        resource.nested_object = {"inner": "data"}
+    assert resource.name.given == "Albert"
+    assert resource.name.to_dict() == record_data["name"]
 
-        assert resource.dynamic_field == "dynamic_value"
-        assert resource.nested_object.inner == "data"
 
+def test_wrong_data_type():
+    with pytest.raises(TypeError, match=r"Response data must be a dict."):
+        GenericResource.from_response(Response(200, json={"data": 1}))
 
-class TestGenericResourceFromResponse:
-    @pytest.fixture
-    def meta_data_single(self):
-        return {"ignored": ["one"]}  # noqa: WPS226
 
-    @pytest.fixture
-    def meta_data_two_resources(self):
-        return {"pagination": {"limit": 10, "offset": 0, "total": 2}, "ignored": ["one"]}  # noqa: WPS226
+class ChargeResourceMock(GenericResource):
+    _data_key = "charge"
 
-    @pytest.fixture
-    def meta_data_multiple(self):
-        return {"ignored": ["one", "two"]}  # noqa: WPS226
 
-    @pytest.fixture
-    def single_resource_data(self):
-        return {"id": 1, "name": "test"}
+def test_custom_data_key():
+    record_data = {"id": 1, "amount": 100}
+    response = Response(200, json={"charge": record_data})
 
-    @pytest.fixture
-    def single_resource_response(self, single_resource_data, meta_data_single):
-        return Response(200, json={"data": single_resource_data, "$meta": meta_data_single})
+    resource = ChargeResourceMock.from_response(response)
 
-    @pytest.fixture
-    def multiple_resource_response(self, single_resource_data, meta_data_two_resources):
-        return Response(
-            200,
-            json={
-                "data": [single_resource_data, single_resource_data],
-                "$meta": meta_data_two_resources,
-            },
-        )
-
-    def test_malformed_meta_response(self):
-        with pytest.raises(TypeError, match=re.escape("Response $meta must be a dict.")):
-            _resource = GenericResource.from_response(Response(200, json={"data": {}, "$meta": 4}))
-
-    def test_single_resource(self, single_resource_response):
-        resource = GenericResource.from_response(single_resource_response)
-        assert resource.id == 1
-        assert resource.name == "test"
-        assert isinstance(resource._meta, Meta)
-        assert resource._meta.response == single_resource_response
-
-    def test_two_resources(self, multiple_resource_response, single_resource_data):
-        with pytest.raises(TypeError, match=r"Response data must be a dict."):
-            _resource = GenericResource.from_response(multiple_resource_response)
+    assert resource.id == 1
+    assert resource.amount == 100

tests/http/models/test_meta.py

@@ -5,43 +5,34 @@
 
 
 class TestMeta:
-
     @pytest.fixture
     def responses_fixture(self):
         response_data = {
             "$meta": {
                 "ignored": ["ignored"],
-                "pagination": {"limit": 25, "offset": 50, "total": 300}
-
+                "pagination": {"limit": 25, "offset": 50, "total": 300},
             }
         }
         return Response(status_code=200, json=response_data)
 
     @pytest.fixture
     def invalid_response_fixture(self):
-        response_data = {
-            "$meta": "invalid_meta"
-        }
+        response_data = {"$meta": "invalid_meta"}
         return Response(status_code=200, json=response_data)
 
-    def test_meta_initialization_empty(self):
-        meta = Meta()
-        assert meta.pagination == Pagination(limit=0, offset=0, total=0)
-
     def test_meta_from_response(self, responses_fixture):
         meta = Meta.from_response(responses_fixture)
 
         assert isinstance(meta.pagination, Pagination)
-        assert meta.pagination.limit == 25
-        assert meta.pagination.offset == 50
-        assert meta.pagination.total == 300
+        assert meta.pagination == Pagination(limit=25, offset=50, total=300)
 
     def test_invalid_meta_from_response(self, invalid_response_fixture):
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=r"Response \$meta must be a dict."):
             Meta.from_response(invalid_response_fixture)
 
     def test_meta_with_pagination_object(self):
+        response = Response(status_code=200, json={})
         pagination = Pagination(limit=10, offset=0, total=100)
-        meta = Meta(pagination=pagination)
+        meta = Meta(response=response, pagination=pagination)
 
         assert meta.pagination == Pagination(limit=10, offset=0, total=100)