Updated generic resource and tests

Author: albertsola

mpt_api_client/http/models.py

@@ -1,6 +1,6 @@
 import math
 from dataclasses import dataclass, field
-from typing import Any, Self
+from typing import Any, ClassVar, Self, override
 
 from box import Box
 from httpx import Response
@@ -16,13 +16,15 @@ class Pagination:
 
     def has_next(self) -> bool:
         """Returns True if there is a next page."""
+        if self.limit == 0:
+            return False
         return self.offset + self.limit < self.total
 
     def num_page(self) -> int:
         """Returns the current page number."""
         if self.limit == 0:
             return 0
-        return (self.offset // self.limit) + 1
+        return self.offset // self.limit
 
     def total_pages(self) -> int:
         """Returns the total number of pages."""
@@ -37,16 +39,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 +59,45 @@ 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."""
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.__post_init__()
+    _data_key: ClassVar[str] = "data"
+    _safe_attributes: ClassVar[list[str]] = ["meta", "_resource"]
+
+    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 __getattr__(self, attribute: str) -> Box | Any:
+        """Returns the resource data."""
+        return self._resource.__getattr__(attribute)  # type: ignore[no-untyped-call]
+
+    @override
+    def __setattr__(self, attribute: str, attribute_value: Any) -> None:
+        """Sets the resource data."""
+        if attribute in self._safe_attributes:
+            object.__setattr__(self, attribute, attribute_value)
+            return
+
+        self._resource.__setattr__(attribute, attribute_value)  # 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_generic_resource_custom_key.py

@@ -0,0 +1,17 @@
+from httpx import Response
+
+from mpt_api_client.http.models import GenericResource
+
+
+class ChargeResourceMock(GenericResource):
+    _data_key = "charge"
+
+
+def test_custom_data_key():
+    record_data = {"id": 1, "amount": 100}
+    response = Response(200, json={"charge": record_data})
+
+    resource = ChargeResourceMock.from_response(response)
+
+    assert resource.id == 1
+    assert resource.amount == 100

tests/http/models/test_genric_resource.py

@@ -1,5 +1,3 @@
-import re
-
 import pytest
 from httpx import Response
 
@@ -11,100 +9,53 @@ 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_initialization_with_data(self):
-        resource = GenericResource(name="test", value=123)
-
-        assert resource.name == "test"
-        assert resource.value == 123
-
-    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
-
-    def test_generic_resource_meta_property_with_data(self, meta_data):
-        resource = GenericResource({"$meta": meta_data})
-        assert resource._meta == Meta(**meta_data)
-
-    def test_generic_resource_box_functionality(self):
-        resource = GenericResource(id=1, name="test_resource", nested={"key": "value"})
+def test_generic_resource_empty():
+    resource = GenericResource()
+    assert resource.meta is None
+    assert resource.to_dict() == {}
 
-        assert resource.id == 1
-        assert resource.name == "test_resource"
-        assert resource.nested.key == "value"
 
-    def test_with_both_meta_and_response(self, meta_data):
-        response = Response(200, json={})
-        meta_data["response"] = response
-        meta_object = Meta(**meta_data)
+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)
 
-        resource = GenericResource(
-            data="test_data",
-            **{"$meta": meta_data},  # noqa: WPS445 WPS517
-        )
+    resource = GenericResource.from_response(response)
 
-        assert resource.data == "test_data"
-        assert resource._meta == meta_object
+    assert resource.to_dict() == record_data
+    assert resource.meta == expected_meta
 
-    def test_dynamic_attribute_access(self):
-        resource = GenericResource()
 
-        resource.dynamic_field = "dynamic_value"
-        resource.nested_object = {"inner": "data"}
+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)
 
-        assert resource.dynamic_field == "dynamic_value"
-        assert resource.nested_object.inner == "data"
+    assert resource.meta == meta
 
+    assert resource.id == 1
 
-class TestGenericResourceFromResponse:
-    @pytest.fixture
-    def meta_data_single(self):
-        return {"ignored": ["one"]}  # noqa: WPS226
+    with pytest.raises(AttributeError, match=r"'Box' object has no attribute 'address'"):
+        resource.address  # noqa: B018
 
-    @pytest.fixture
-    def meta_data_two_resources(self):
-        return {"pagination": {"limit": 10, "offset": 0, "total": 2}, "ignored": ["one"]}  # noqa: WPS226
+    with pytest.raises(AttributeError, match=r"'Box' object has no attribute 'surname'"):
+        resource.name.surname  # noqa: B018
 
-    @pytest.fixture
-    def meta_data_multiple(self):
-        return {"ignored": ["one", "two"]}  # noqa: WPS226
+    assert resource.name.given == "Albert"
+    assert resource.name.to_dict() == record_data["name"]
 
-    @pytest.fixture
-    def single_resource_data(self):
-        return {"id": 1, "name": "test"}
 
-    @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})
+def test_attribute_setter():
+    record_data = {"id": 1, "name": {"given": "Albert", "family": "Einstein"}}
+    resource = GenericResource(resource=record_data)
 
-    @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,
-            },
-        )
+    resource.id = 2
+    assert resource.id == 2
 
-    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}))
+    resource.name.given = "John"
+    assert resource.name.given == "John"
 
-    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)
+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}))

tests/http/models/test_meta.py

@@ -4,44 +4,38 @@
 from mpt_api_client.http.models import Meta, Pagination
 
 
-class TestMeta:
+@pytest.fixture
+def responses_fixture():
+    response_data = {
+        "$meta": {
+            "ignored": ["ignored"],
+            "pagination": {"limit": 25, "offset": 50, "total": 300},
+        }
+    }
+    return Response(status_code=200, json=response_data)
 
-    @pytest.fixture
-    def responses_fixture(self):
-        response_data = {
-            "$meta": {
-                "ignored": ["ignored"],
-                "pagination": {"limit": 25, "offset": 50, "total": 300}
 
-            }
-        }
-        return Response(status_code=200, json=response_data)
+@pytest.fixture
+def invalid_response_fixture():
+    response_data = {"$meta": "invalid_meta"}
+    return Response(status_code=200, json=response_data)
 
-    @pytest.fixture
-    def invalid_response_fixture(self):
-        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(responses_fixture):
+    meta = Meta.from_response(responses_fixture)
+
+    assert isinstance(meta.pagination, Pagination)
+    assert meta.pagination == Pagination(limit=25, offset=50, total=300)
 
-    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
+def test_invalid_meta_from_response(invalid_response_fixture):
+    with pytest.raises(TypeError, match=r"Response \$meta must be a dict."):
+        Meta.from_response(invalid_response_fixture)
 
-    def test_invalid_meta_from_response(self, invalid_response_fixture):
-        with pytest.raises(TypeError):
-            Meta.from_response(invalid_response_fixture)
 
-    def test_meta_with_pagination_object(self):
-        pagination = Pagination(limit=10, offset=0, total=100)
-        meta = Meta(pagination=pagination)
+def test_meta_with_pagination_object():
+    response = Response(status_code=200, json={})
+    pagination = Pagination(limit=10, offset=0, total=100)
+    meta = Meta(response=response, pagination=pagination)
 
-        assert meta.pagination == Pagination(limit=10, offset=0, total=100)
+    assert meta.pagination == Pagination(limit=10, offset=0, total=100)