Merge pull request #454 from minos-framework/issue-453-add-snapshot-find-one

#453 - Add `find_one` method to `SnapshotRepository`

Author: Sergio García Prado

packages/core/minos-microservice-aggregate/minos/aggregate/entities/repositories.py

@@ -97,6 +97,16 @@ def get_all(
         # noinspection PyTypeChecker
         return self._snapshot_repository.get_all(type_, ordering, limit, **kwargs)
 
+    async def find_one(self, type_: type[T], condition: _Condition, **kwargs) -> T:
+        """Find a ``Entity`` instance based on a ``Condition``.
+
+        :param type_: The type of the entity to be looked for.
+        :param condition: The condition that must be satisfied by the ``Entity`` instances.
+        :param kwargs: Additional named arguments.
+        :return: An asynchronous iterator that containing the ``Entity`` instances.
+        """
+        return await self._snapshot_repository.find_one(type_, condition, **kwargs)
+
     def find(
         self,
         type_: type[T],
@@ -107,15 +117,14 @@ def find(
     ) -> AsyncIterator[T]:
         """Find a collection of instances based on a given ``Condition``.
 
-        :param type_: The of the entity to be looked for.
+        :param type_: The type of the entity to be looked for.
         :param condition: The ``Condition`` that must be satisfied by all the instances.
         :param ordering: Optional argument to return the instance with specific ordering strategy. The default behaviour
             is to retrieve them without any order pattern.
         :param limit: Optional argument to return only a subset of instances. The default behaviour is to return all the
             instances that meet the given condition.
         :return: An asynchronous iterator of ``Entity`` instances.
         """
-        # noinspection PyTypeChecker
         return self._snapshot_repository.find(type_, condition, ordering, limit, **kwargs)
 
     async def create(self, type_or_instance: Union[T, type[T]], *args, **kwargs) -> tuple[T, Delta]:

packages/core/minos-microservice-aggregate/minos/aggregate/snapshots/repositories/abc.py

@@ -126,6 +126,28 @@ def get_all(
             **kwargs,
         )
 
+    async def find_one(
+        self,
+        name: Union[str, type[Entity]],
+        condition: _Condition,
+        transaction: Optional[TransactionEntry] = None,
+        **kwargs,
+    ) -> Entity:
+        """Find a ``Entity`` instance based on a ``Condition``.
+
+        :param name: Class name of the ``Entity``.
+        :param condition: The condition that must be satisfied by the ``Entity`` instances.
+        :param transaction: The transaction within the operation is performed. If not any value is provided, then the
+            transaction is extracted from the context var. If not any transaction is being scoped then the query is
+            performed to the global snapshot.
+        :param kwargs: Additional named arguments.
+        :return: An asynchronous iterator that containing the ``Entity`` instances.
+        """
+        try:
+            return await self.find(name, condition=condition, limit=1, transaction=transaction, **kwargs).__anext__()
+        except StopAsyncIteration:
+            raise NotFoundException(f"There are not any instance matching the given condition: {condition}")
+
     async def find(
         self,
         name: Union[str, type[Entity], ModelType],

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

@@ -532,6 +532,39 @@ async def test_find_empty(self):
         expected = set()
         self.assertEqual(expected, observed)
 
+    async def test_find_one(self):
+        await self.populate_and_synchronize()
+        condition = Condition.IN("uuid", {self.uuid_2})
+
+        observed = await self.snapshot_repository.find_one(self.Car, condition)
+
+        expected = self.Car(
+            3,
+            "blue",
+            uuid=self.uuid_2,
+            version=2,
+            created_at=observed.created_at,
+            updated_at=observed.updated_at,
+        )
+        self.assertEqual(expected, observed)
+
+    async def test_find_one_raises(self):
+        await self.populate_and_synchronize()
+        condition = Condition.FALSE
+
+        with self.assertRaises(NotFoundException):
+            await self.snapshot_repository.find_one(self.Car, condition)
+
+    async def test_get_all(self):
+        await self.populate_and_synchronize()
+        iterable = self.snapshot_repository.find(self.Car, Condition.TRUE, ordering=Ordering.ASC("updated_at"))
+        expected = [v async for v in iterable]
+
+        iterable = self.snapshot_repository.get_all(self.Car, ordering=Ordering.ASC("updated_at"))
+        observed = [v async for v in iterable]
+
+        self.assertEqual(expected, observed)
+
     async def test_get(self):
         await self.populate_and_synchronize()
         observed = await self.snapshot_repository.get(self.Car, self.uuid_2)

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_entities/test_repositories/test_base.py

@@ -110,6 +110,23 @@ async def test_find(self):
 
         self.assertEqual(originals, recovered)
 
+    async def test_find_one(self):
+        originals = list(
+            map(
+                itemgetter(0),
+                await gather(
+                    self.repository.create(Car, doors=3, color="blue"),
+                    self.repository.create(Car, doors=3, color="red"),
+                    self.repository.create(Car, doors=5, color="blue"),
+                ),
+            )
+        )
+        condition = Condition.IN("uuid", {originals[0].uuid})
+        observed = await self.repository.find_one(Car, condition)
+        expected = originals[0]
+
+        self.assertEqual(expected, observed)
+
     async def test_get(self):
         original, _ = await self.repository.create(Car, doors=3, color="blue")
         recovered = await self.repository.get(Car, original.uuid)

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

@@ -414,6 +414,45 @@ async def test_find_empty(self):
             ):
                 await super().test_find_empty()
 
+    async def test_find_one(self):
+        entities = [
+            SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_2, version=2),
+        ]
+        with patch.object(DatabaseClient, "fetch_one", return_value=(9999,)):
+            with patch.object(
+                DatabaseClient,
+                "fetch_all",
+                return_value=FakeAsyncIterator(
+                    [tuple(SnapshotEntry.from_entity(entity).as_raw().values()) for entity in entities]
+                ),
+            ):
+                await super().test_find_one()
+
+    async def test_find_one_raises(self):
+        with patch.object(DatabaseClient, "fetch_one", return_value=(9999,)):
+            with patch.object(
+                DatabaseClient,
+                "fetch_all",
+                return_value=FakeAsyncIterator([]),
+            ):
+                await super().test_find_one_raises()
+
+    async def test_get_all(self):
+        entities = [
+            SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_1, version=1),
+            SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_2, version=2),
+            SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_3, version=1),
+        ]
+        with patch.object(DatabaseClient, "fetch_one", return_value=(9999,)):
+            with patch.object(
+                DatabaseClient,
+                "fetch_all",
+                side_effect=lambda: FakeAsyncIterator(
+                    [tuple(SnapshotEntry.from_entity(entity).as_raw().values()) for entity in entities]
+                ),
+            ):
+                await super().test_get_all()
+
     async def test_get(self):
         entities = [
             SnapshotRepositoryTestCase.Car(3, "blue", uuid=self.uuid_2, version=2),