Fix aidbox_db fixture to work in tests

Author: ruscoder

aidbox_python_sdk/db.py

@@ -73,26 +73,34 @@ def create_table(table_name):
 
 
 class DBProxy:
-    _client = None
-    _settings = None
-    _table_cache = None
+    _client: ClientSession | None = None
+    _settings: Settings
+    _table_cache: dict
 
-    def __init__(self, settings: Settings):
+    def __init__(self, settings: Settings, _table_cache: dict | None = None):
         self._settings = settings
-        self._table_cache = {}
+        self._table_cache = _table_cache or {}
 
     async def initialize(self):
         basic_auth = BasicAuth(
             login=self._settings.APP_INIT_CLIENT_ID,
             password=self._settings.APP_INIT_CLIENT_SECRET,
         )
         self._client = ClientSession(auth=basic_auth)
-        # TODO: remove _init_table_cache
-        await self._init_table_cache()
+        if not self._table_cache:
+            await self._init_table_cache()
 
     async def deinitialize(self):
         await self._client.close()
 
+    def clone(self) -> "DBProxy":
+        """
+        Create a new DBProxy with the same settings and table cache
+        NOTE: it should be initialized after cloning
+        """
+
+        return DBProxy(self._settings, _table_cache=self._table_cache)
+
     async def raw_sql(self, sql_query, *, execute=False):
         """
         Executes SQL query and returns result. Specify `execute` to True
@@ -146,7 +154,9 @@ async def _get_all_entities_name(self):
 
         if not result:
             # Support legacy instalations with entity attribute data structure
-            query_url = f"{self._settings.APP_INIT_URL}/Entity?type=resource&_elements=id&_count=999"
+            query_url = (
+                f"{self._settings.APP_INIT_URL}/Entity?type=resource&_elements=id&_count=999"
+            )
             async with self._client.get(query_url) as resp:
                 json_resp = await resp.json()
                 result = [entry["resource"]["id"] for entry in json_resp.get("entry", [])]

aidbox_python_sdk/pytest_plugin.py

@@ -124,8 +124,13 @@ def aidbox_client(app):
 
 
 @pytest.fixture
-def aidbox_db(app):
-    return app[ak.db]
+async def aidbox_db(app):
+    # We clone it to init client session in the test thread
+    # because app is running in another thread with own loop
+    db = app[ak.db].clone()
+    await db.initialize()
+    yield db
+    await db.deinitialize()
 
 
 # Deprecated

envs/app

@@ -2,7 +2,7 @@ APP_INIT_CLIENT_ID=root
 APP_INIT_CLIENT_SECRET=secret
 APP_INIT_URL=http://aidbox:8080
 
-APP_ID=backend-test
+APP_ID=app-test
 APP_SECRET=secret
 APP_URL=http://app:8081
 APP_PORT=8081

main.py

@@ -1,13 +1,12 @@
 import asyncio
 import logging
-import time
 from datetime import datetime
 
 import coloredlogs
-import sqlalchemy as sa
 from aiohttp import web
-from sqlalchemy.sql.expression import insert, select
+from sqlalchemy.sql.expression import select
 
+from aidbox_python_sdk.db import DBProxy
 from aidbox_python_sdk.handlers import routes
 from aidbox_python_sdk.main import create_app as _create_app
 from aidbox_python_sdk.sdk import SDK
@@ -129,37 +128,16 @@ async def daily_patient_report(operation, request):
     return web.json_response({"type": "report", "success": "Ok", "msg": "Response from APP"})
 
 
+async def get_app_ids(db: DBProxy):
+    app = db.App
+    return await db.alchemy(select(app.c.id))
+
+
 @routes.get("/db_tests")
 async def db_tests(request):
     db = request.app["db"]
-    app = db.App.__table__
-    app_res = {
-        "type": "app",
-        "resources": {
-            "User": {},
-        },
-    }
-    unique_id = f"abc{time.time()}"
-    test_statements = [
-        insert(app)
-        .values(id=unique_id, txid=123, status="created", resource=app_res)
-        .returning(app.c.id),
-        app.update()
-        .where(app.c.id == unique_id)
-        .values(resource=app.c.resource.op("||")({"additional": "property"})),
-        app.select().where(app.c.id == unique_id),
-        app.select().where(app.c.status == "recreated"),
-        select([app.c.resource["type"].label("app_type")]),
-        app.select().where(app.c.resource["resources"].has_key("User")),
-        select([app.c.id]).where(app.c.resource["type"].astext == "app"),
-        select([sa.func.count(app.c.id)]).where(app.c.resource.contains({"type": "app"})),
-        # TODO: got an error for this query.
-        # select('*').where(app.c.resource['resources'].has_all(array(['User', 'Client']))),
-    ]
-    for statement in test_statements:
-        result = await db.alchemy(statement)
-        logging.debug("Result:\n%s", result)
-    return web.json_response({})
+
+    return web.json_response(await get_app_ids(db))
 
 
 @sdk.operation(
@@ -169,6 +147,7 @@ async def db_tests(request):
         "fhirCode": "observation-custom-op",
         "fhirUrl": "http://test.com",
         "fhirResource": ["Observation"],
-    })
+    },
+)
 async def observation_custom_op(operation, request):
     return {"message": "Observation custom operation response"}

tests/test_sdk.py

@@ -6,6 +6,7 @@
 from fhirpathpy import evaluate
 
 import main
+from aidbox_python_sdk.db import DBProxy
 
 
 @pytest.mark.skip("Skipped because of regression in Aidbox 2510")
@@ -175,3 +176,16 @@ async def test_database_isolation_with_history_in_name__2(aidbox_client, safe_db
 
     resources = await aidbox_client.resources("FamilyMemberHistory").fetch_all()
     assert len(resources) == 2
+
+
+async def test_aidbox_db_fixture(client, aidbox_db: DBProxy, safe_db):
+    """
+    Test that aidbox_db fixture works with isolated DB Proxy from app's instance
+    """
+    response = await client.get("/db_tests")
+    assert response.status == 200
+    json = await response.json()
+    assert json == [{"id": "app-test"}]
+
+    app_ids = await main.get_app_ids(aidbox_db)
+    assert app_ids == [{"id": "app-test"}]