Merge remote-tracking branch 'origin/0.7.x' into 0.8.0

# Conflicts:
#	packages/core/minos-microservice-aggregate/minos/aggregate/__init__.py
#	packages/core/minos-microservice-aggregate/minos/aggregate/testing/snapshots/repositories/testcases.py
#	packages/core/minos-microservice-aggregate/poetry.lock
#	packages/core/minos-microservice-aggregate/pyproject.toml
#	packages/core/minos-microservice-common/minos/common/__init__.py
#	packages/core/minos-microservice-common/pyproject.toml
#	packages/core/minos-microservice-networks/minos/networks/__init__.py
#	packages/core/minos-microservice-networks/poetry.lock
#	packages/core/minos-microservice-networks/pyproject.toml
#	packages/plugins/minos-database-aiopg/minos/plugins/aiopg/__init__.py
#	packages/plugins/minos-database-aiopg/poetry.lock
#	packages/plugins/minos-database-aiopg/pyproject.toml

Author: Sergio García Prado

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

@@ -146,6 +146,11 @@ def _evaluate(self, value: Model) -> bool:
         return self._get_field(value) in self.parameter
 
 
+class _ContainsCondition(_SimpleCondition):
+    def _evaluate(self, value: Model) -> bool:
+        return self.parameter in self._get_field(value)
+
+
 class _LikeCondition(_SimpleCondition):
     def _evaluate(self, value: Model) -> bool:
         return bool(self._pattern.fullmatch(self._get_field(value)))
@@ -205,6 +210,7 @@ class Condition:
     EQUAL = _EqualCondition
     NOT_EQUAL = _NotEqualCondition
     IN = _InCondition
+    CONTAINS = _ContainsCondition
     LIKE = _LikeCondition
 
 

packages/core/minos-microservice-aggregate/minos/aggregate/testing/snapshots/repositories/testcases.py

@@ -52,6 +52,16 @@ class SnapshotRepositoryTestCase(MinosTestCase, ABC):
 
     snapshot_repository: SnapshotRepository
 
+    class NumbersList(Entity):
+        """For testing purposes"""
+
+        numbers: list[int]
+
+    class Number(Entity):
+        """For testing purposes"""
+
+        value: int
+
     class Owner(Entity):
         """For testing purposes"""
 
@@ -380,6 +390,52 @@ async def test_find_by_uuid(self):
         ]
         self.assertEqual(expected, observed)
 
+    async def test_find_contains(self):
+        a = FieldDiffContainer([FieldDiff("numbers", list[int], [1, 2, 3])])
+        b = FieldDiffContainer([FieldDiff("numbers", list[int], [4, 5, 6])])
+        c = FieldDiffContainer([FieldDiff("numbers", list[int], [3, 8, 9])])
+        await self.delta_repository.create(
+            DeltaEntry(name=self.NumbersList.classname, data=a.avro_bytes, uuid=self.uuid_1)
+        )
+        await self.delta_repository.create(
+            DeltaEntry(name=self.NumbersList.classname, data=b.avro_bytes, uuid=self.uuid_2)
+        )
+        await self.delta_repository.create(
+            DeltaEntry(name=self.NumbersList.classname, data=c.avro_bytes, uuid=self.uuid_3)
+        )
+        await self.synchronize()
+
+        condition = Condition.CONTAINS("numbers", 3)
+
+        iterable = self.snapshot_repository.find(self.NumbersList, condition, ordering=Ordering.ASC("updated_at"))
+        observed = [v async for v in iterable]
+
+        expected = [
+            await self.snapshot_repository.get(self.NumbersList, self.uuid_1),
+            await self.snapshot_repository.get(self.NumbersList, self.uuid_3),
+        ]
+        self.assertEqual(expected, observed)
+
+    async def test_find_equal(self):
+        a = FieldDiffContainer([FieldDiff("value", int, 1)])
+        b = FieldDiffContainer([FieldDiff("value", int, 2)])
+        c = FieldDiffContainer([FieldDiff("value", int, 1)])
+        await self.delta_repository.create(DeltaEntry(name=self.Number.classname, data=a.avro_bytes, uuid=self.uuid_1))
+        await self.delta_repository.create(DeltaEntry(name=self.Number.classname, data=b.avro_bytes, uuid=self.uuid_2))
+        await self.delta_repository.create(DeltaEntry(name=self.Number.classname, data=c.avro_bytes, uuid=self.uuid_3))
+        await self.synchronize()
+
+        condition = Condition.EQUAL("value", 1)
+
+        iterable = self.snapshot_repository.find(self.Number, condition, ordering=Ordering.ASC("updated_at"))
+        observed = [v async for v in iterable]
+
+        expected = [
+            await self.snapshot_repository.get(self.Number, self.uuid_1),
+            await self.snapshot_repository.get(self.Number, self.uuid_3),
+        ]
+        self.assertEqual(expected, observed)
+
     async def test_find_with_transaction(self):
         await self.populate_and_synchronize()
         condition = Condition.IN("uuid", [self.uuid_2, self.uuid_3])

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

@@ -21,6 +21,10 @@ class _Text(DeclarativeModel):
     value: str
 
 
+class _ListInt(DeclarativeModel):
+    value: list[int]
+
+
 class TestCondition(unittest.TestCase):
     def test_hash(self):
         self.assertIsInstance(hash(Condition.EQUAL("value", 3)), int)
@@ -126,6 +130,13 @@ def test_condition_in(self):
         self.assertFalse(condition.evaluate(_Number(42)))
         self.assertTrue(condition.evaluate(_Number(56)))
 
+    def test_condition_contains(self):
+        condition = Condition.CONTAINS("value", 1)
+        self.assertEqual("_ContainsCondition('value', 1)", repr(condition))
+
+        self.assertFalse(condition.evaluate(_ListInt([42, 3, -5])))
+        self.assertTrue(condition.evaluate(_ListInt([1, 2, 3])))
+
     def test_condition_like(self):
         condition = Condition.LIKE("value", "a%[^ou]")
         self.assertEqual("_LikeCondition('value', 'a%[^ou]')", repr(condition))

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_snapshots/test_repositories/test_database.py

@@ -330,6 +330,44 @@ async def test_find_by_uuid(self):
             ):
                 await super().test_find_by_uuid()
 
+    async def test_find_contains(self):
+        entities = [
+            SnapshotRepositoryTestCase.NumbersList([1, 2, 3], uuid=self.uuid_2),
+            SnapshotRepositoryTestCase.NumbersList([3, 8, 9], uuid=self.uuid_3),
+        ]
+        with patch.object(DatabaseClient, "fetch_one", return_value=(9999,)):
+            with patch.object(
+                DatabaseClient,
+                "fetch_all",
+                side_effect=[
+                    FakeAsyncIterator(
+                        [tuple(SnapshotEntry.from_entity(entity).as_raw().values()) for entity in entities]
+                    ),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_entity(entities[0]).as_raw().values())]),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_entity(entities[1]).as_raw().values())]),
+                ],
+            ):
+                await super().test_find_contains()
+
+    async def test_find_equal(self):
+        entities = [
+            SnapshotRepositoryTestCase.Number(1, uuid=self.uuid_2),
+            SnapshotRepositoryTestCase.Number(1, uuid=self.uuid_3),
+        ]
+        with patch.object(DatabaseClient, "fetch_one", return_value=(9999,)):
+            with patch.object(
+                DatabaseClient,
+                "fetch_all",
+                side_effect=[
+                    FakeAsyncIterator(
+                        [tuple(SnapshotEntry.from_entity(entity).as_raw().values()) for entity in entities]
+                    ),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_entity(entities[0]).as_raw().values())]),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_entity(entities[1]).as_raw().values())]),
+                ],
+            ):
+                await super().test_find_equal()
+
     async def test_find_with_transaction(self):
         entities = [
             SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_2, version=4),