ISSUE #471

* Fix bug related with `Conditions.CONTAINS` and `aiopg`
* Fix minor bugs.

Author: Sergio García Prado

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

@@ -50,6 +50,16 @@ class SnapshotRepositoryTestCase(MinosTestCase, ABC):
 
     snapshot_repository: SnapshotRepository
 
+    class NumbersList(RootEntity):
+        """For testing purposes"""
+
+        numbers: list[int]
+
+    class Number(RootEntity):
+        """For testing purposes"""
+
+        value: int
+
     class Owner(RootEntity):
         """For testing purposes"""
 
@@ -386,6 +396,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.event_repository.create(
+            EventEntry(name=self.NumbersList.classname, data=a.avro_bytes, uuid=self.uuid_1)
+        )
+        await self.event_repository.create(
+            EventEntry(name=self.NumbersList.classname, data=b.avro_bytes, uuid=self.uuid_2)
+        )
+        await self.event_repository.create(
+            EventEntry(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.event_repository.create(EventEntry(name=self.Number.classname, data=a.avro_bytes, uuid=self.uuid_1))
+        await self.event_repository.create(EventEntry(name=self.Number.classname, data=b.avro_bytes, uuid=self.uuid_2))
+        await self.event_repository.create(EventEntry(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_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_root_entity(entity).as_raw().values()) for entity in entities]
+                    ),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_root_entity(entities[0]).as_raw().values())]),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_root_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_root_entity(entity).as_raw().values()) for entity in entities]
+                    ),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_root_entity(entities[0]).as_raw().values())]),
+                    FakeAsyncIterator([tuple(SnapshotEntry.from_root_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),

packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/aggregate/snapshots/queries.py

@@ -216,11 +216,11 @@ def _build_condition_contains(self, condition: _ContainsCondition) -> Composable
             raise ValueError(f"Cannot use 'contains' over non-list field '{field}'")
         else:
             name = self.generate_random_str()
-            self._parameters[name] = parameter
+            self._parameters[name] = Json(parameter)
 
             field = Literal("{{{}}}".format(field.replace(".", ",")))
             name = Placeholder(name)
-            return SQL("(data#>{name} IN {field}::jsonb)").format(field=field, name=name)
+            return SQL("(data#>{field} @> {name}::jsonb)").format(field=field, name=name)
 
     def _build_ordering(self, ordering: _Ordering) -> Composable:
         field = ordering.by

packages/plugins/minos-database-aiopg/tests/test_aiopg/test_factories/test_aggregate/test_snapshots/test_queries.py

@@ -283,7 +283,7 @@ async def test_build_contains(self):
         with patch.object(AiopgSnapshotQueryDatabaseOperationBuilder, "generate_random_str", side_effect=["hello"]):
             observed = AiopgSnapshotQueryDatabaseOperationBuilder(self.classname, condition).build()
 
-        expected_query = SQL(" WHERE ").join([self.base_select, SQL("(data#>%(hello)s IN '{numbers}'::jsonb)")])
+        expected_query = SQL(" WHERE ").join([self.base_select, SQL("(data#>'{numbers}' @> %(hello)s::jsonb)")])
         expected_parameters = {"hello": 1} | self.base_parameters
 
         self.assertEqual(await self._flatten_query(expected_query), await self._flatten_query(observed[0]))