Feature/sqlite repo

xcov19/tests/start_server.py

@@ -1,10 +1,27 @@
 from collections.abc import AsyncGenerator
 from blacksheep import Application
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 from rodi import Container, ContainerProtocol
-from xcov19.app.database import configure_database_session, setup_database
+from xcov19.app.database import (
+    configure_database_session,
+    setup_database,
+    start_db_session,
+)
 from xcov19.app.settings import load_settings
-from sqlalchemy.ext.asyncio import AsyncEngine
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+from sqlmodel.ext.asyncio.session import AsyncSession as AsyncSessionWrapper
+
+
+class InvalidSessionTypeError(RuntimeError):
+    """Exception raised when the session is not of the expected type."""
+
+    pass
+
+
+class InvalidDIContainerTypeError(RuntimeError):
+    """Exception raised when valid DI container not found."""
+
+    pass
 
 
 @asynccontextmanager
@@ -18,10 +35,40 @@ async def start_server(app: Application) -> AsyncGenerator[Application, None]:
             await app.stop()
 
 
-async def start_test_database(container: ContainerProtocol) -> None:
-    """Database setup for integration tests."""
-    if not isinstance(container, Container):
-        raise RuntimeError("container not of type Container.")
-    configure_database_session(container, load_settings())
-    engine = container.resolve(AsyncEngine)
-    await setup_database(engine)
+class setUpTestDatabase:
+    """Manages the lifecycle of the test database."""
+
+    def __init__(self) -> None:
+        self._stack = AsyncExitStack()
+        self._session: AsyncSession | AsyncSessionWrapper | None = None
+        self._container: ContainerProtocol = Container()
+
+    async def setup_test_database(self) -> None:
+        """Database setup for integration tests."""
+        if not isinstance(self._container, Container):
+            raise InvalidDIContainerTypeError("Container not of valid type.")
+        configure_database_session(self._container, load_settings())
+        engine = self._container.resolve(AsyncEngine)
+        await setup_database(engine)
+
+    async def start_async_session(self) -> AsyncSession | AsyncSessionWrapper:
+        if not isinstance(self._container, Container):
+            raise InvalidDIContainerTypeError("Container not of valid type.")
+        self._session = await self._stack.enter_async_context(
+            start_db_session(self._container)
+        )
+        if not isinstance(self._session, AsyncSessionWrapper):
+            raise InvalidSessionTypeError(
+                f"{self._session} is not a AsyncSessionWrapper value."
+            )
+        return self._session
+
+    async def aclose(self) -> None:
+        print("async closing test server db session closing.")
+        if not isinstance(self._session, AsyncSessionWrapper):
+            raise InvalidSessionTypeError(
+                f"{self._session} is not a AsyncSessionWrapper value."
+            )
+        await self._session.commit()
+        await self._stack.aclose()
+        print("async test server closing.")

xcov19/tests/test_geolocation_api.py

@@ -4,7 +4,7 @@
 from blacksheep import Content, Response
 
 
-@pytest.mark.integration
+@pytest.mark.api
 @pytest.mark.usefixtures("client")
 class TestGeolocationAPI:
     async def test_location_query_endpoint(self, client):

xcov19/tests/test_services.py

@@ -1,13 +1,12 @@
 from collections.abc import Callable
-from contextlib import AsyncExitStack
 from typing import List
 import pytest
 import unittest
+import random
+
 
-from rodi import Container, ContainerProtocol
-from xcov19.app.database import start_db_session
 from xcov19.tests.data.seed_db import seed_data
-from xcov19.tests.start_server import start_test_database
+from xcov19.tests.start_server import setUpTestDatabase
 from xcov19.domain.models.provider import (
     Contact,
     FacilityEstablishment,
@@ -24,9 +23,6 @@
 
 
 from xcov19.utils.mixins import InterfaceProtocolCheckMixin
-
-import random
-
 from sqlmodel.ext.asyncio.session import AsyncSession as AsyncSessionWrapper
 
 
@@ -201,37 +197,44 @@ class GeoLocationServiceSqlRepoDBTest(unittest.IsolatedAsyncioTestCase):
     3. patient_query_lookup_svc is configured to call sqlite repository.
     """
 
+    @pytest.fixture(autouse=True)
+    def autouse(
+        self,
+        dummy_geolocation_query_json: LocationQueryJSON,
+        dummy_reverse_geo_lookup_svc: Callable[[LocationQueryJSON], dict],
+    ):
+        self.dummy_geolocation_query_json = dummy_geolocation_query_json
+        self.dummy_reverse_geo_lookup_svc = dummy_reverse_geo_lookup_svc
+
     async def asyncSetUp(self) -> None:
-        self._stack = AsyncExitStack()
-        container: ContainerProtocol = Container()
-        await start_test_database(container)
-        self._session = await self._stack.enter_async_context(
-            start_db_session(container)
-        )
-        if not isinstance(self._session, AsyncSessionWrapper):
-            raise RuntimeError(f"{self._session} is not a AsyncSessionWrapper value.")
+        self._test_db = setUpTestDatabase()
+        await self._test_db.setup_test_database()
+        self._session = await self._test_db.start_async_session()
+        assert isinstance(self._session, AsyncSessionWrapper)
         await seed_data(self._session)
         await super().asyncSetUp()
 
     async def asyncTearDown(self) -> None:
-        print("async closing test server db session closing.")
-        await self._session.commit()
-        await self._stack.aclose()
-        print("async test server closing.")
+        await self._test_db.aclose()
         await super().asyncTearDown()
 
     def _patient_query_lookup_svc_using_repo(
         self, address: Address, query: LocationQueryJSON
-    ) -> Callable[[Address, LocationQueryJSON], List[FacilitiesResult]]: ...
+    ) -> List[FacilitiesResult]:
+        # TODO: Implement a patient query lookup service
+        # that returns type List[FacilitiesResult]
+        ...
 
     async def test_fetch_facilities(self):
         # TODO Implement test_fetch_facilities like this:
-        # providers = await GeolocationQueryService.fetch_facilities(
-        #     dummy_reverse_geo_lookup_svc,
-        #     dummy_geolocation_query_json,
-        #     self._patient_query_lookup_svc_using_repo
-        # )
-        ...
+        providers = await GeolocationQueryService.fetch_facilities(
+            self.dummy_reverse_geo_lookup_svc,
+            self.dummy_geolocation_query_json,
+            self._patient_query_lookup_svc_using_repo,
+        )
+        assert providers
+        self.assertIsInstance(providers, list)
+        self.assertIs(len(providers), 1)
 
 
 @pytest.mark.usefixtures("dummy_geolocation_query_json", "dummy_reverse_geo_lookup_svc")