aidbox-python-sdk 0.1.25__tar.gz → 0.2.1__tar.gz

{aidbox_python_sdk-0.1.25/aidbox_python_sdk.egg-info → aidbox_python_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aidbox-python-sdk
-Version: 0.1.25
+Version: 0.2.1
 Summary: Aidbox SDK for python
 Author-email: "beda.software" <aidbox-python-sdk@beda.software>
 License: MIT License
@@ -41,7 +41,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: aiohttp>=3.11.0
@@ -239,4 +239,80 @@ organizationType: non-profit
 employeesCount: 10
 ```
 
+## Testing with the pytest plugin
+
+The SDK provides a pytest plugin that starts your app, exposes fixtures for the SDK and Aidbox client, and helps isolate tests that create resources.
+
+### Activating the plugin
+
+In your project’s **`conftest.py`** (e.g. `tests/conftest.py`), register the plugin:
+
+```python
+pytest_plugins = ["aidbox_python_sdk.pytest_plugin"]
+```
+
+### Configuring the app factory
+
+The plugin needs your app factory (the callable that returns the `web.Application`). You can set it in pytest ini:
+
+**`pyproject.toml`**
+```toml
+[tool.pytest.ini_options]
+aidbox_create_app = "main:create_app"
+```
+
+Use the dotted path to your callable: either `module:name` (e.g. `main:create_app`) or `module.submodule.name` (e.g. `mypackage.main.create_app`). The default is `main:create_app`.
+
+To use a different factory without changing ini, override the fixture in your `conftest.py`:
+
+```python
+@pytest.fixture(scope="session")
+def create_app():
+    from myapp.entry import create_app
+    return create_app
+```
+
+### Fixtures provided
+
+| Fixture          | Description |
+|------------------|-------------|
+| `app`            | The running `web.Application` (server in a background thread on port 8081). |
+| `client`         | HTTP client for the app + `client.server.app` for the application instance. |
+| `sdk`            | The SDK instance: `app[ak.sdk]`. |
+| `aidbox_client`  | `AsyncAidboxClient` for calling Aidbox (operations, `/$psql`, etc.). |
+| `aidbox_db`      | DB proxy: `app[ak.db]`. |
+| `safe_db`        | Isolated DB for the test; see below. |
+
+### Using `safe_db` for tests that create resources
+
+Use the **`safe_db`** fixture in tests that create or change data. It records the current transaction id, runs your test, then rolls back everything created in that test so the DB stays clean.
+
+**NOTE:** Without `safe_db`, all subscriptions are implicitly ignored for that test.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_create_patient(aidbox_client, safe_db):
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    patients = await aidbox_client.resources("Patient").fetch_all()
+    assert len(patients) >= 1
+    # after the test, safe_db rolls back and the patient is not persisted
+```
+
+### Subscription trigger helper (`was_subscription_triggered`)
+
+Use **`sdk.was_subscription_triggered(entity)`** (or `was_subscription_triggered_n_times(entity, n)`) only together with the **`safe_db`** fixture. Without `safe_db`, subscription handling is skipped for the test and the returned future is never completed, so the test will hang until the timeout.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_patient_subscription(aidbox_client, safe_db, sdk):
+    was_patient_sub_triggered = sdk.was_subscription_triggered("Patient")
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    await was_patient_sub_triggered
+    # assertions...
+```
+
 

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/README.md

@@ -177,4 +177,80 @@ organizationType: non-profit
 employeesCount: 10
 ```
 
+## Testing with the pytest plugin
+
+The SDK provides a pytest plugin that starts your app, exposes fixtures for the SDK and Aidbox client, and helps isolate tests that create resources.
+
+### Activating the plugin
+
+In your project’s **`conftest.py`** (e.g. `tests/conftest.py`), register the plugin:
+
+```python
+pytest_plugins = ["aidbox_python_sdk.pytest_plugin"]
+```
+
+### Configuring the app factory
+
+The plugin needs your app factory (the callable that returns the `web.Application`). You can set it in pytest ini:
+
+**`pyproject.toml`**
+```toml
+[tool.pytest.ini_options]
+aidbox_create_app = "main:create_app"
+```
+
+Use the dotted path to your callable: either `module:name` (e.g. `main:create_app`) or `module.submodule.name` (e.g. `mypackage.main.create_app`). The default is `main:create_app`.
+
+To use a different factory without changing ini, override the fixture in your `conftest.py`:
+
+```python
+@pytest.fixture(scope="session")
+def create_app():
+    from myapp.entry import create_app
+    return create_app
+```
+
+### Fixtures provided
+
+| Fixture          | Description |
+|------------------|-------------|
+| `app`            | The running `web.Application` (server in a background thread on port 8081). |
+| `client`         | HTTP client for the app + `client.server.app` for the application instance. |
+| `sdk`            | The SDK instance: `app[ak.sdk]`. |
+| `aidbox_client`  | `AsyncAidboxClient` for calling Aidbox (operations, `/$psql`, etc.). |
+| `aidbox_db`      | DB proxy: `app[ak.db]`. |
+| `safe_db`        | Isolated DB for the test; see below. |
+
+### Using `safe_db` for tests that create resources
+
+Use the **`safe_db`** fixture in tests that create or change data. It records the current transaction id, runs your test, then rolls back everything created in that test so the DB stays clean.
+
+**NOTE:** Without `safe_db`, all subscriptions are implicitly ignored for that test.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_create_patient(aidbox_client, safe_db):
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    patients = await aidbox_client.resources("Patient").fetch_all()
+    assert len(patients) >= 1
+    # after the test, safe_db rolls back and the patient is not persisted
+```
+
+### Subscription trigger helper (`was_subscription_triggered`)
+
+Use **`sdk.was_subscription_triggered(entity)`** (or `was_subscription_triggered_n_times(entity, n)`) only together with the **`safe_db`** fixture. Without `safe_db`, subscription handling is skipped for the test and the returned future is never completed, so the test will hang until the timeout.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_patient_subscription(aidbox_client, safe_db, sdk):
+    was_patient_sub_triggered = sdk.was_subscription_triggered("Patient")
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    await was_patient_sub_triggered
+    # assertions...
+```
+
 

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/aidbox_python_sdk/__init__.py

@@ -1,5 +1,5 @@
 __title__ = "aidbox-python-sdk"
-__version__ = "0.1.25"
+__version__ = "0.2.1"
 __author__ = "beda.software"
 __license__ = "None"
 __copyright__ = "Copyright 2024 beda.software"

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/aidbox_python_sdk/db.py

@@ -1,5 +1,6 @@
 import json
 import logging
+from typing import Optional
 
 from aiohttp import BasicAuth, ClientSession
 from sqlalchemy import (
@@ -73,13 +74,13 @@ def create_table(table_name):
 
 
 class DBProxy:
-    _client = None
-    _settings = None
-    _table_cache = None
+    _client: Optional[ClientSession] = None
+    _settings: Settings
+    _table_cache: dict
 
-    def __init__(self, settings: Settings):
+    def __init__(self, settings: Settings, _table_cache: Optional[dict] = None):
         self._settings = settings
-        self._table_cache = {}
+        self._table_cache = _table_cache or {}
 
     async def initialize(self):
         basic_auth = BasicAuth(
@@ -87,12 +88,20 @@ class DBProxy:
             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 +155,9 @@ class DBProxy:
 
         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-0.1.25 → aidbox_python_sdk-0.2.1}/aidbox_python_sdk/handlers.py

@@ -1,9 +1,10 @@
 import asyncio
+import json
 import logging
 from typing import Any
 
 from aiohttp import web
-from fhirpy.base.exceptions import OperationOutcome
+from fhirpy.base.exceptions import BaseFHIRError, OperationOutcome
 
 from . import app_keys as ak
 
@@ -48,6 +49,12 @@ async def operation(request: web.Request, data: dict[str, Any]):
         return result
     except OperationOutcome as exc:
         return web.json_response(exc.resource, status=422)
+    except BaseFHIRError as exc:
+        try:
+            payload = json.loads(str(exc))
+            return web.json_response(payload, status=422)
+        except (json.JSONDecodeError, TypeError):
+            return web.Response(text=str(exc), status=422, content_type="text/plain")
 
 
 TYPES = {
@@ -59,10 +66,10 @@ TYPES = {
 @routes.post("/aidbox")
 async def dispatch(request):
     logger.debug("Dispatch new request %s %s", request.method, request.url)
-    json = await request.json()
-    if "type" in json and json["type"] in TYPES:
-        logger.debug("Dispatch to `%s` handler", json["type"])
-        return await TYPES[json["type"]](request, json)
+    data = await request.json()
+    if "type" in data and data["type"] in TYPES:
+        logger.debug("Dispatch to `%s` handler", data["type"])
+        return await TYPES[data["type"]](request, data)
     req = {
         "method": request.method,
         "url": str(request.url),

aidbox_python_sdk-0.2.1/aidbox_python_sdk/pytest_plugin.py

@@ -0,0 +1,165 @@
+import asyncio
+import importlib
+import os
+import threading
+import warnings
+from collections.abc import Generator
+from types import SimpleNamespace
+
+import pytest
+from aiohttp import BasicAuth, ClientSession, web
+from yarl import URL
+
+from aidbox_python_sdk.aidboxpy import AsyncAidboxClient
+
+from . import app_keys as ak
+
+_TEST_SERVER_URL = "http://127.0.0.1:8081"
+
+
+def pytest_addoption(parser):
+    parser.addini(
+        "aidbox_create_app",
+        "Dotted path to the create_app callable (module:name or module.name), e.g. main:create_app",
+        default="main:create_app",
+    )
+
+
+def _load_create_app(path: str):
+    """Import and return the create_app callable from the given dotted path."""
+    if ":" in path:
+        module_path, attr = path.split(":", 1)
+    else:
+        module_path, attr = path.rsplit(".", 1)
+    mod = importlib.import_module(module_path)
+    return getattr(mod, attr)
+
+
+@pytest.fixture(scope="session")
+def create_app(request):
+    """App factory; override in conftest or set pytest ini option aidbox_create_app."""
+    path = request.config.getini("aidbox_create_app")
+    return _load_create_app(path)
+
+
+@pytest.fixture(scope="session", autouse=True)
+def app(create_app) -> Generator[web.Application, None, None]:
+    """Start the aiohttp application server in a background thread.
+
+    Uses a dedicated event loop running continuously via loop.run_forever()
+    in a daemon thread. This is necessary (rather than an async fixture) because
+    the app needs the loop running at all times to handle external callbacks
+    from Aidbox (subscriptions, SDK heartbeats, etc.), not just during await
+    points in test code.
+
+    The server is guaranteed to be listening before any test runs (no sleep-based
+    waiting) since site.start() completes synchronously before yielding.
+    """
+
+    app = create_app()
+    app[ak.sdk]._test_start_txid = -1
+    loop = asyncio.new_event_loop()
+
+    runner = web.AppRunner(app)
+    loop.run_until_complete(runner.setup())
+    site = web.TCPSite(runner, host="0.0.0.0", port=8081)
+    loop.run_until_complete(site.start())
+
+    thread = threading.Thread(target=loop.run_forever, daemon=True)
+    thread.start()
+
+    yield app
+
+    loop.call_soon_threadsafe(loop.stop)
+    thread.join(timeout=5)
+    loop.run_until_complete(runner.cleanup())
+    loop.close()
+
+
+@pytest.fixture
+async def client(app):
+    server = SimpleNamespace(app=app)
+    session = ClientSession(base_url=URL(_TEST_SERVER_URL))
+    wrapper = SimpleNamespace(server=server)
+    wrapper.get = session.get
+    wrapper.post = session.post
+    wrapper.put = session.put
+    wrapper.patch = session.patch
+    wrapper.delete = session.delete
+    wrapper.request = session.request
+    wrapper._session = session
+    try:
+        yield wrapper
+    finally:
+        await session.close()
+
+
+@pytest.fixture
+async def safe_db(aidbox_client: AsyncAidboxClient, sdk):
+    results = await aidbox_client.execute(
+        "/$psql",
+        data={"query": "SELECT last_value from transaction_id_seq;"},
+    )
+    txid = results[0]["result"][0]["last_value"]
+    sdk._test_start_txid = int(txid)
+
+    yield txid
+
+    sdk._test_start_txid = -1
+    await aidbox_client.execute(
+        "/$psql",
+        data={"query": f"select drop_before_all({txid});"},
+        params={"execute": "true"},
+    )
+
+
+@pytest.fixture
+def sdk(app):
+    return app[ak.sdk]
+
+
+@pytest.fixture
+def aidbox_client(app):
+    return app[ak.client]
+
+
+@pytest.fixture
+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
+class AidboxSession(ClientSession):
+    def __init__(self, *args, base_url=None, **kwargs):
+        base_url_resolved = base_url or os.environ.get("AIDBOX_BASE_URL")
+        assert base_url_resolved, "Either base_url arg or AIDBOX_BASE_URL env var must be set"
+        self.base_url = URL(base_url_resolved)
+        super().__init__(*args, **kwargs)
+
+    def make_url(self, path):
+        return self.base_url.with_path(path)
+
+    async def _request(self, method, path, *args, **kwargs):
+        url = self.make_url(path)
+        return await super()._request(method, url, *args, **kwargs)
+
+
+@pytest.fixture
+async def aidbox(sdk, app):
+    warnings.warn(
+        "The 'aidbox' fixture is deprecated; use 'aidbox_client' for the Aidbox client instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    basic_auth = BasicAuth(
+        login=app[ak.settings].APP_INIT_CLIENT_ID,
+        password=app[ak.settings].APP_INIT_CLIENT_SECRET,
+    )
+    session = AidboxSession(auth=basic_auth, base_url=app[ak.settings].APP_INIT_URL)
+    yield session
+    await session.close()

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/aidbox_python_sdk/sdk.py

@@ -11,9 +11,12 @@ from .types import Compliance
 
 logger = logging.getLogger("aidbox_sdk")
 
+# (target_loop, future, counter) per entity for was_subscription_triggered_*
+_SubTriggered = dict[str, tuple[asyncio.AbstractEventLoop, asyncio.Future[bool], int]]
+
 
 class SDK:
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
         settings,
         *,
@@ -42,7 +45,7 @@ class SDK:
         self._seeds = seeds or {}
         self._migrations = migrations or []
         self._app_endpoint_name = f"{settings.APP_ID}-endpoint"
-        self._sub_triggered = {}
+        self._sub_triggered: _SubTriggered = {}
         self._test_start_txid = None
 
     async def apply_migrations(self, client: AsyncAidboxClient):
@@ -112,14 +115,14 @@ class SDK:
                     result = coro_or_result
 
                 if entity in self._sub_triggered:
-                    future, counter = self._sub_triggered[entity]
+                    target_loop, future, counter = self._sub_triggered[entity]
                     if counter > 1:
-                        self._sub_triggered[entity] = (future, counter - 1)
+                        self._sub_triggered[entity] = (target_loop, future, counter - 1)
                     elif future.done():
                         pass
                         # logger.warning('Uncaught subscription for %s', entity)
                     else:
-                        future.set_result(True)
+                        target_loop.call_soon_threadsafe(future.set_result, True)
 
                 return result
 
@@ -133,14 +136,13 @@ class SDK:
 
     def was_subscription_triggered_n_times(self, entity, counter):
         timeout = 10
-
-        future = asyncio.Future()
-        self._sub_triggered[entity] = (future, counter)
-        asyncio.get_event_loop().call_later(
+        target_loop = asyncio.get_running_loop()
+        future = target_loop.create_future()
+        self._sub_triggered[entity] = (target_loop, future, counter)
+        target_loop.call_later(
             timeout,
             lambda: None if future.done() else future.set_exception(Exception()),
         )
-
         return future
 
     def was_subscription_triggered(self, entity):

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/aidbox_python_sdk/types.py

@@ -1,16 +1,25 @@
-from typing import Any, List
+from typing import Any
 
 from aiohttp import web
 from typing_extensions import TypedDict
 
+
 class Compliance(TypedDict, total=True):
     fhirUrl: str
     fhirCode: str
-    fhirResource: List[str]
+    fhirResource: list[str]
+
 
 SDKOperationRequest = TypedDict(
     "SDKOperationRequest",
-    {"app": web.Application, "params": dict, "route-params": dict, "headers": dict, "resource": Any},
+    {
+        "app": web.Application,
+        "params": dict,
+        "route-params": dict,
+        "form-params": dict,
+        "headers": dict,
+        "resource": Any,
+    },
 )
 
 

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1/aidbox_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aidbox-python-sdk
-Version: 0.1.25
+Version: 0.2.1
 Summary: Aidbox SDK for python
 Author-email: "beda.software" <aidbox-python-sdk@beda.software>
 License: MIT License
@@ -41,7 +41,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: aiohttp>=3.11.0
@@ -239,4 +239,80 @@ organizationType: non-profit
 employeesCount: 10
 ```
 
+## Testing with the pytest plugin
+
+The SDK provides a pytest plugin that starts your app, exposes fixtures for the SDK and Aidbox client, and helps isolate tests that create resources.
+
+### Activating the plugin
+
+In your project’s **`conftest.py`** (e.g. `tests/conftest.py`), register the plugin:
+
+```python
+pytest_plugins = ["aidbox_python_sdk.pytest_plugin"]
+```
+
+### Configuring the app factory
+
+The plugin needs your app factory (the callable that returns the `web.Application`). You can set it in pytest ini:
+
+**`pyproject.toml`**
+```toml
+[tool.pytest.ini_options]
+aidbox_create_app = "main:create_app"
+```
+
+Use the dotted path to your callable: either `module:name` (e.g. `main:create_app`) or `module.submodule.name` (e.g. `mypackage.main.create_app`). The default is `main:create_app`.
+
+To use a different factory without changing ini, override the fixture in your `conftest.py`:
+
+```python
+@pytest.fixture(scope="session")
+def create_app():
+    from myapp.entry import create_app
+    return create_app
+```
+
+### Fixtures provided
+
+| Fixture          | Description |
+|------------------|-------------|
+| `app`            | The running `web.Application` (server in a background thread on port 8081). |
+| `client`         | HTTP client for the app + `client.server.app` for the application instance. |
+| `sdk`            | The SDK instance: `app[ak.sdk]`. |
+| `aidbox_client`  | `AsyncAidboxClient` for calling Aidbox (operations, `/$psql`, etc.). |
+| `aidbox_db`      | DB proxy: `app[ak.db]`. |
+| `safe_db`        | Isolated DB for the test; see below. |
+
+### Using `safe_db` for tests that create resources
+
+Use the **`safe_db`** fixture in tests that create or change data. It records the current transaction id, runs your test, then rolls back everything created in that test so the DB stays clean.
+
+**NOTE:** Without `safe_db`, all subscriptions are implicitly ignored for that test.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_create_patient(aidbox_client, safe_db):
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    patients = await aidbox_client.resources("Patient").fetch_all()
+    assert len(patients) >= 1
+    # after the test, safe_db rolls back and the patient is not persisted
+```
+
+### Subscription trigger helper (`was_subscription_triggered`)
+
+Use **`sdk.was_subscription_triggered(entity)`** (or `was_subscription_triggered_n_times(entity, n)`) only together with the **`safe_db`** fixture. Without `safe_db`, subscription handling is skipped for the test and the returned future is never completed, so the test will hang until the timeout.
+
+Example:
+
+```python
+@pytest.mark.asyncio
+async def test_patient_subscription(aidbox_client, safe_db, sdk):
+    was_patient_sub_triggered = sdk.was_subscription_triggered("Patient")
+    patient = await aidbox_client.resource("Patient", name=[{"family": "Test"}]).save()
+    await was_patient_sub_triggered
+    # assertions...
+```
+
 

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/pyproject.toml

@@ -12,7 +12,7 @@ pre-commit = ["autohooks.plugins.black", "autohooks.plugins.ruff"]
 
 [tool.black]
 line-length = 100
-target-version = ['py311']
+target-version = ['py39']
 exclude = '''
 (
   /(
@@ -25,7 +25,7 @@ exclude = '''
 '''
 
 [tool.ruff]
-target-version = "py311"
+target-version = "py39"
 line-length = 100
 extend-exclude = ["example"]
 
@@ -83,7 +83,7 @@ classifiers = [
   "Topic :: Internet :: WWW/HTTP",
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 
 [project.optional-dependencies]
 test = [

{aidbox_python_sdk-0.1.25 → aidbox_python_sdk-0.2.1}/tests/test_sdk.py

@@ -4,12 +4,14 @@ from unittest import mock
 
 import pytest
 from fhirpathpy import evaluate
+from fhirpy.base.exceptions import OperationOutcome
 
 import main
+from aidbox_python_sdk.db import DBProxy
 
 
 @pytest.mark.skip("Skipped because of regression in Aidbox 2510")
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("expression", "expected"),
     [
@@ -36,7 +38,7 @@ async def test_operation_with_compliance_params(aidbox_client, expression, expec
     assert evaluate(response, expression, {})[0] == expected
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_health_check(client):
     resp = await client.get("/health")
     assert resp.status == 200
@@ -44,7 +46,7 @@ async def test_health_check(client):
     assert json == {"status": "OK"}
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_live_health_check(client):
     resp = await client.get("/live")
     assert resp.status == 200
@@ -52,34 +54,30 @@ async def test_live_health_check(client):
     assert json == {"status": "OK"}
 
 
-@pytest.mark.skip()
-async def test_signup_reg_op(client, aidbox):
-    resp = await aidbox.post("signup/register/21.02.19/testvalue")
-    assert resp.status == 200
-    json = await resp.json()
+@pytest.mark.asyncio
+async def test_signup_reg_op(aidbox_client):
+    json = await aidbox_client.execute("signup/register/21.02.19/testvalue")
     assert json == {
         "success": "Ok",
         "request": {"date": "21.02.19", "test": "testvalue"},
     }
 
 
-@pytest.mark.skip()
-async def test_appointment_sub(client, aidbox):
+@pytest.mark.asyncio
+async def test_appointment_sub(sdk, aidbox_client, safe_db):
     with mock.patch.object(main, "_appointment_sub") as appointment_sub:
         f = asyncio.Future()
         f.set_result("")
         appointment_sub.return_value = f
-        sdk = client.server.app["sdk"]
         was_appointment_sub_triggered = sdk.was_subscription_triggered("Appointment")
-        resp = await aidbox.post(
+        resource = aidbox_client.resource(
             "Appointment",
-            json={
+            **{
                 "status": "proposed",
                 "participant": [{"status": "accepted"}],
-                "resourceType": "Appointment",
             },
         )
-        assert resp.status == 201
+        await resource.save()
         await was_appointment_sub_triggered
         event = appointment_sub.call_args_list[0][0][0]
         logging.debug("event: %s", event)
@@ -94,7 +92,7 @@ async def test_appointment_sub(client, aidbox):
         assert expected["resource"].items() <= event["resource"].items()
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_database_isolation__1(aidbox_client, safe_db):
     patients = await aidbox_client.resources("Patient").fetch_all()
     assert len(patients) == 2
@@ -106,7 +104,7 @@ async def test_database_isolation__1(aidbox_client, safe_db):
     assert len(patients) == 3
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_database_isolation__2(aidbox_client, safe_db):
     patients = await aidbox_client.resources("Patient").fetch_all()
     assert len(patients) == 2
@@ -121,7 +119,7 @@ async def test_database_isolation__2(aidbox_client, safe_db):
     assert len(patients) == 4
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_database_isolation_with_history_in_name__1(aidbox_client, safe_db):
     resources = await aidbox_client.resources("FamilyMemberHistory").fetch_all()
     assert len(resources) == 0
@@ -144,7 +142,7 @@ async def test_database_isolation_with_history_in_name__1(aidbox_client, safe_db
     assert len(resources) == 1
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 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) == 0
@@ -179,3 +177,34 @@ 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"}]
+
+
+async def test_operation_base_fhir_error_json_test_op(aidbox_client):
+    with pytest.raises(OperationOutcome) as exc:
+        await aidbox_client.execute("/$base-fhir-error-json-test")
+    assert exc.value.resource.get("issue")[0].get("diagnostics") == "Resource Patient/id not found"
+
+
+async def test_operation_base_fhir_error_text_test_op(aidbox_client):
+    with pytest.raises(OperationOutcome) as exc:
+        await aidbox_client.execute("/$base-fhir-error-text-test")
+    assert exc.value.resource.get("issue")[0].get("diagnostics") == "plain"
+
+
+async def test_operation_outcome_test_op(aidbox_client):
+    with pytest.raises(OperationOutcome) as exc:
+        await aidbox_client.execute("/$operation-outcome-test")
+    assert exc.value.resource.get("issue")[0].get("diagnostics") == "test reason"

aidbox_python_sdk-0.1.25/aidbox_python_sdk/pytest_plugin.py

@@ -1,89 +0,0 @@
-import os
-from typing import cast
-
-import pytest
-from aiohttp import BasicAuth, ClientSession, web
-from yarl import URL
-
-from main import create_app as _create_app
-
-from . import app_keys as ak
-
-
-async def start_app(aiohttp_client):
-    app = await aiohttp_client(_create_app(), server_kwargs={"host": "0.0.0.0", "port": 8081})
-    sdk = cast(web.Application, app.server.app)[ak.sdk]
-    sdk._test_start_txid = -1
-
-    return app
-
-
-@pytest.fixture
-async def client(aiohttp_client):
-    """Instance of app's server and client"""
-    return await start_app(aiohttp_client)
-
-
-class AidboxSession(ClientSession):
-    def __init__(self, *args, base_url=None, **kwargs):
-        base_url_resolved = base_url or os.environ.get("AIDBOX_BASE_URL")
-        assert base_url_resolved, "Either base_url arg or AIDBOX_BASE_URL env var must be set"
-        self.base_url = URL(base_url_resolved)
-        super().__init__(*args, **kwargs)
-
-    def make_url(self, path):
-        return self.base_url.with_path(path)
-
-    async def _request(self, method, path, *args, **kwargs):
-        url = self.make_url(path)
-        return await super()._request(method, url, *args, **kwargs)
-
-
-@pytest.fixture
-async def aidbox(client):
-    """HTTP client for making requests to Aidbox"""
-    app = cast(web.Application, client.server.app)
-    basic_auth = BasicAuth(
-        login=app[ak.settings].APP_INIT_CLIENT_ID,
-        password=app[ak.settings].APP_INIT_CLIENT_SECRET,
-    )
-    session = AidboxSession(auth=basic_auth, base_url=app[ak.settings].APP_INIT_URL)
-    yield session
-    await session.close()
-
-
-@pytest.fixture
-async def safe_db(aidbox, client, sdk):
-    resp = await aidbox.post(
-        "/$psql",
-        json={"query": "SELECT last_value from transaction_id_seq;"},
-        raise_for_status=True,
-    )
-    results = await resp.json()
-    txid = results[0]["result"][0]["last_value"]
-    sdk._test_start_txid = int(txid)
-
-    yield txid
-
-    sdk._test_start_txid = -1
-    await aidbox.post(
-        "/$psql",
-        json={"query": f"select drop_before_all({txid});"},
-        params={"execute": "true"},
-        raise_for_status=True,
-    )
-
-
-@pytest.fixture
-def sdk(client):
-    return cast(web.Application, client.server.app)[ak.sdk]
-
-
-@pytest.fixture
-def aidbox_client(client):
-    return cast(web.Application, client.server.app)[ak.client]
-
-
-@pytest.fixture
-def aidbox_db(client):
-    return cast(web.Application, client.server.app)[ak.db]