#219 - Improve getitem - getattr relationship

packages/core/minos-microservice-aggregate/minos/aggregate/entities/refs/models.py

@@ -56,13 +56,27 @@ def __init__(self, data: Union[MT, UUID], *args, broker_pool: BrokerClientPool =
 
         self._broker_pool = broker_pool
 
+    def __setitem__(self, key: str, value: Any) -> None:
+        try:
+            return super().__setitem__(key, value)
+        except KeyError:
+            self.data[key] = value
+
+    def __getitem__(self, item: str) -> Any:
+        try:
+            return super().__getitem__(item)
+        except KeyError as exc:
+            if item == "data":
+                raise exc
+            return self.data[item]
+
     def __getattr__(self, item: str) -> Any:
         try:
             return super().__getattr__(item)
         except AttributeError as exc:
-            if item != "data":
-                return getattr(self.data, item)
-            raise exc
+            if item == "data":
+                raise exc
+            return getattr(self.data, item)
 
     @property
     def int(self) -> int:

packages/core/minos-microservice-aggregate/minos/aggregate/events/fields.py

@@ -93,10 +93,10 @@ def __init__(
 
         self._mapper = _build_mapper(self._fields)
 
-    def __getattr__(self, item: str) -> Any:
+    def __getitem__(self, item: str) -> Any:
         try:
-            return super().__getattr__(item)
-        except AttributeError as exc:
+            return super().__getitem__(item)
+        except KeyError as exc:
             try:
                 return self.get_one(item)
             except Exception:

packages/core/minos-microservice-aggregate/minos/aggregate/events/models.py

@@ -65,10 +65,10 @@ def simplified_name(self) -> str:
     def __lt__(self, other: Any) -> bool:
         return isinstance(other, type(self)) and self.version < other.version
 
-    def __getattr__(self, item: str) -> Any:
+    def __getitem__(self, item: str) -> Any:
         try:
-            return super().__getattr__(item)
-        except AttributeError as exc:
+            return super().__getitem__(item)
+        except KeyError as exc:
             if item != "fields_diff":
                 try:
                     return self.get_field(item)

packages/core/minos-microservice-aggregate/minos/aggregate/value_objects.py

@@ -23,11 +23,8 @@
 class ValueObject(DeclarativeModel):
     """Value Object class."""
 
-    def __setattr__(self, key: str, value: Any):
-        if key.startswith("_"):
-            super().__setattr__(key, value)
-        else:
-            raise ValueObjectException("modification of an immutable value object not allowed")
+    def __setitem__(self, key: str, value: Any) -> None:
+        raise ValueObjectException("modification of an immutable value object not allowed")
 
 
 T = TypeVar("T", bound=Model)

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_entities/test_refs/test_models.py

@@ -73,17 +73,36 @@ def test_model_uuid(self):
 
         self.assertEqual(uuid, value.uuid)
 
-    def test_model_attribute(self):
+    def test_model_getattr(self):
         value = Ref(Bar(uuid4(), 1))
 
         self.assertEqual(1, value.age)
 
-    def test_model_attribute_raises(self):
+    def test_model_getattr_raises(self):
         value = Ref(Bar(uuid4(), 1))
 
         with self.assertRaises(AttributeError):
             value.year
 
+    def test_model_setattr(self):
+        value = Ref(Bar(uuid4(), 1))
+
+        value.age = 2
+
+        self.assertEqual(2, value.data.age)
+
+    def test_model_getitem(self):
+        value = Ref(Bar(uuid4(), 1))
+
+        self.assertEqual(1, value["age"])
+
+    def test_model_setitem(self):
+        value = Ref(Bar(uuid4(), 1))
+
+        value["age"] = 2
+
+        self.assertEqual(2, value.data.age)
+
     def test_fields(self):
         value = Ref(Bar(uuid4(), 1))
 

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_value_objects.py

@@ -19,14 +19,14 @@ class _Location(ValueObject):
 
 class TestValueObject(TestCase):
     def setUp(self) -> None:
-        self.value_object = _Location(street="street name")
+        self.value = _Location(street="street name")
 
     def test_instantiate(self):
-        self.assertEqual("street name", self.value_object.street)
+        self.assertEqual("street name", self.value.street)
 
     def test_raise_when_accessed(self):
         with self.assertRaises(ValueObjectException):
-            self.value_object.street = "this assignment must raise"
+            self.value["street"] = "this assignment must raise"
 
 
 class TestValueObjectSet(TestCase):

packages/core/minos-microservice-common/minos/common/model/abc.py

@@ -225,29 +225,30 @@ def fields(self) -> dict[str, Field]:
 
     def __setitem__(self, key: str, value: Any) -> None:
         try:
-            setattr(self, key, value)
-        except AttributeError as exc:
-            raise KeyError(str(exc))
+            self._fields[key].value = value
+        except KeyError:
+            raise KeyError(f"{type(self).__name__!r} does not contain the {key!r} field")
 
     def __getitem__(self, item: str) -> Any:
         try:
-            return getattr(self, item)
-        except AttributeError as exc:
-            raise KeyError(str(exc))
+            return self._fields[item].value
+        except KeyError:
+            raise KeyError(f"{type(self).__name__!r} does not contain the {item!r} field.")
 
     def __setattr__(self, key: str, value: Any) -> None:
-        if key.startswith("_"):
+        if key.startswith("_") or key in dir(self):
             object.__setattr__(self, key, value)
-        elif key in self._fields:
-            self._fields[key].value = value
         else:
-            raise AttributeError(f"{type(self).__name__!r} does not contain the {key!r} field")
+            try:
+                self[key] = value
+            except KeyError as exc:
+                raise AttributeError(str(exc))
 
     def __getattr__(self, item: str) -> Any:
-        if item != "_fields" and item in self._fields:
-            return self._fields[item].value
-        else:
-            raise AttributeError(f"{type(self).__name__!r} does not contain the {item!r} field.")
+        try:
+            return self[item]
+        except KeyError as exc:
+            raise AttributeError(str(exc))
 
     # noinspection PyMethodParameters
     @property_or_classproperty

packages/core/minos-microservice-common/tests/model_classes.py

@@ -160,6 +160,12 @@ class GenericUser(DeclarativeModel, Generic[T]):
     username: T
 
 
+class ReservedWordUser(DeclarativeModel, Generic[T]):
+    """For testing purposes."""
+
+    items: str
+
+
 class Auth(DeclarativeModel):
     """For testing purposes."""
 

packages/core/minos-microservice-common/tests/test_common/test_model/test_declarative/test_common.py

@@ -1,5 +1,6 @@
 import unittest
 from typing import (
+    Callable,
     Optional,
 )
 
@@ -18,6 +19,7 @@
     CustomerFailDict,
     CustomerFailList,
     GenericUser,
+    ReservedWordUser,
     ShoppingList,
     T,
     User,
@@ -51,6 +53,10 @@ def test_getattr(self):
         self.assertEqual("Doe", model.surname)
         self.assertEqual("John", model.name)
 
+    def test_getattr_reserved_word(self):
+        model = ReservedWordUser("foo")
+        self.assertIsInstance(model.items, Callable)
+
     def test_setattr(self):
         expected = Customer(1234, name="John", surname="Doe")
 
@@ -60,6 +66,12 @@ def test_setattr(self):
 
         self.assertEqual(expected, observed)
 
+    def test_setattr_reserved_word(self):
+        model = ReservedWordUser("foo")
+        model.items = "bar"
+        self.assertEqual("bar", model.items)
+        self.assertNotEqual("bar", model.fields["items"].value)
+
     def test_setattr_raises(self):
         model = Customer(123)
         with self.assertRaises(AttributeError):
@@ -76,6 +88,10 @@ def test_getitem(self):
         self.assertEqual("Doe", model["surname"])
         self.assertEqual("John", model["name"])
 
+    def test_getitem_reserved_word(self):
+        model = ReservedWordUser("foo")
+        self.assertEqual("foo", model["items"])
+
     def test_getitem_raises(self):
         model = Customer(1234)
         with self.assertRaises(KeyError):
@@ -90,6 +106,11 @@ def test_setitem(self):
 
         self.assertEqual(expected, observed)
 
+    def test_setitem_reserved_word(self):
+        model = ReservedWordUser("foo")
+        model["items"] = "bar"
+        self.assertEqual("bar", model.fields["items"].value)
+
     def test_setitem_raises(self):
         model = Customer(1234)
         with self.assertRaises(KeyError):

packages/core/minos-microservice-saga/minos/saga/context.py

@@ -25,22 +25,23 @@ def __init__(self, **kwargs):
 
         super().__init__(fields=fields)
 
-    def __setattr__(self, key: str, value: Any) -> None:
+    def __setitem__(self, key: str, value: Any) -> None:
         try:
-            super().__setattr__(key, value)
-        except AttributeError:
+            super().__setitem__(key, value)
+        except KeyError:
             self._fields[key] = Field(key, Any, value)
 
     def __delitem__(self, item: str) -> None:
         try:
-            return delattr(self, item)
-        except AttributeError as exc:
-            raise KeyError(exc)
+            del self._fields[item]
+        except KeyError:
+            raise KeyError(f"{type(self).__name__!r} does not contain the {item!r} field")
 
     def __delattr__(self, item: str) -> None:
-        if item.startswith("_"):
+        if item.startswith("_") or item in dir(self):
             super().__delattr__(item)
-        elif item in self._fields:
-            del self._fields[item]
         else:
-            raise AttributeError(f"{type(self).__name__!r} does not contain the {item!r} field")
+            try:
+                self[item]
+            except KeyError as exc:
+                raise AttributeError(str(exc))

packages/core/minos-microservice-saga/tests/test_saga/test_context.py

@@ -33,11 +33,24 @@ def test_setter(self):
         self.assertEqual("two", context.two)
         self.assertEqual(Foo("three"), context.three)
 
+    def test_setter_reserved_word(self):
+        context = SagaContext()
+        context.items = "bar"
+        self.assertEqual("bar", context.items)
+        self.assertNotIn("bar", context.fields)
+
     def test_deleter(self):
         context = SagaContext(one=1)
         del context.one
         self.assertEqual(SagaContext(), SagaContext())
 
+    def test_deleter_reserved_word(self):
+        context = SagaContext()
+        context["items"] = "foo"
+        with self.assertRaises(AttributeError):
+            del context.items
+        self.assertEqual("foo", context.fields["items"].value)
+
     def test_deleter_raises(self):
         with self.assertRaises(AttributeError):
             del SagaContext()._name
@@ -62,6 +75,11 @@ def test_item_setter(self):
         context["three"] = Foo("three")
         self.assertEqual(SagaContext(one=1, two="two", three=Foo("three")), context)
 
+    def test_item_setter_reserved_word(self):
+        context = SagaContext()
+        context["items"] = "bar"
+        self.assertEqual("bar", context.fields["items"].value)
+
     def test_item_getter(self):
         context = SagaContext(one=1, two="two", three=Foo("three"))
         self.assertEqual(1, context["one"])