Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Daylily-Informatics_bloom /tests /test_beta_lab.py
| """Focused tests for beta lab route guards and resolver contract.""" | |
| from __future__ import annotations | |
| import asyncio | |
| import os | |
| import secrets | |
| import sys | |
| import pytest | |
| from fastapi import HTTPException | |
| from fastapi.testclient import TestClient | |
| from bloom_lims.api.v1.beta_lab import require_external_ursa_read | |
| from bloom_lims.api.v1.dependencies import ( | |
| APIUser, | |
| require_external_token_auth, | |
| require_external_ursa_api_enabled, | |
| ) | |
| from bloom_lims.auth.rbac import ENABLE_ATLAS_API_GROUP, ENABLE_URSA_API_GROUP | |
| from bloom_lims.domain import BloomObj | |
| from bloom_lims.tapdb_adapter import get_parent_lineages | |
| os.environ["BLOOM_DEV_AUTH_BYPASS"] = "true" | |
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) | |
| from main import app # noqa: E402 | |
| def _token_user(groups: list[str]) -> APIUser: | |
| return APIUser( | |
| email="token-user@example.com", | |
| user_id="token-user", | |
| roles=["READ_ONLY"], | |
| groups=groups, | |
| auth_source="token", | |
| ) | |
| def test_require_external_ursa_api_enabled_rejects_missing_group(): | |
| with pytest.raises(HTTPException) as exc: | |
| asyncio.run(require_external_ursa_api_enabled(_token_user(groups=[]))) | |
| assert exc.value.status_code == 403 | |
| assert "ENABLE_URSA_API" in str(exc.value.detail) | |
| def test_require_external_ursa_api_enabled_allows_group_member(): | |
| user = _token_user(groups=[ENABLE_URSA_API_GROUP]) | |
| resolved = asyncio.run(require_external_ursa_api_enabled(user)) | |
| assert resolved.user_id == "token-user" | |
| def test_run_resolver_requires_full_key_query_params(): | |
| client = TestClient(app) | |
| app.dependency_overrides[require_external_ursa_read] = lambda: APIUser( | |
| email="resolver-user@example.com", | |
| user_id="resolver-user", | |
| roles=["READ_ONLY"], | |
| groups=[ENABLE_URSA_API_GROUP], | |
| auth_source="token", | |
| ) | |
| try: | |
| response = client.get("/api/v1/external/atlas/beta/runs/RUN-1/resolve") | |
| assert response.status_code == 422 | |
| finally: | |
| app.dependency_overrides.pop(require_external_ursa_read, None) | |
| def test_material_registration_links_fulfillment_items_on_container_and_specimen( | |
| bdb, | |
| ): | |
| def _atlas_rw_user() -> APIUser: | |
| token = secrets.token_hex(8) | |
| return APIUser( | |
| email="atlas-beta@example.com", | |
| user_id=f"atlas-user-{token}", | |
| roles=["READ_WRITE"], | |
| groups=[ENABLE_ATLAS_API_GROUP], | |
| auth_source="token", | |
| is_service_account=True, | |
| token_scope="internal_rw", | |
| token_id=f"token-{token}", | |
| ) | |
| def _atlas_refs(instance): | |
| refs: list[dict] = [] | |
| for lineage in get_parent_lineages(instance): | |
| if ( | |
| lineage.is_deleted | |
| or lineage.relationship_type != "has_external_reference" | |
| ): | |
| continue | |
| child = lineage.child_instance | |
| if child is None or child.is_deleted: | |
| continue | |
| payload = child.json_addl or {} | |
| props = payload.get("properties") if isinstance(payload, dict) else {} | |
| if not isinstance(props, dict): | |
| continue | |
| if str(props.get("provider") or "").strip() != "atlas": | |
| continue | |
| refs.append(props) | |
| return refs | |
| app.dependency_overrides[require_external_token_auth] = _atlas_rw_user | |
| client = TestClient(app) | |
| try: | |
| atlas_context = { | |
| "atlas_tenant_id": f"tenant-{secrets.token_hex(8)}", | |
| "atlas_trf_euid": f"trf-{secrets.token_hex(8)}", | |
| "atlas_patient_euid": f"patient-{secrets.token_hex(8)}", | |
| "atlas_testkit_euid": f"kit-{secrets.token_hex(8)}", | |
| "atlas_shipment_euid": f"shipment-{secrets.token_hex(8)}", | |
| "atlas_organization_site_euid": f"site-{secrets.token_hex(8)}", | |
| "fulfillment_items": [ | |
| { | |
| "atlas_test_euid": f"test-{secrets.token_hex(8)}", | |
| "atlas_test_fulfillment_item_euid": f"proc-{secrets.token_hex(8)}", | |
| } | |
| ], | |
| } | |
| material = client.post( | |
| "/api/v1/external/atlas/beta/materials", | |
| headers={"Idempotency-Key": f"idem-material-{secrets.token_hex(8)}"}, | |
| json={ | |
| "specimen_name": "container-first-link-check", | |
| "atlas_context": atlas_context, | |
| }, | |
| ) | |
| assert material.status_code == 200, material.text | |
| material_body = material.json() | |
| specimen_euid = material_body["specimen_euid"] | |
| container_euid = material_body["container_euid"] | |
| assert ( | |
| material_body["atlas_context"]["atlas_testkit_euid"] | |
| == atlas_context["atlas_testkit_euid"] | |
| ) | |
| assert ( | |
| material_body["atlas_context"]["atlas_shipment_euid"] | |
| == atlas_context["atlas_shipment_euid"] | |
| ) | |
| assert ( | |
| material_body["atlas_context"]["atlas_organization_site_euid"] | |
| == atlas_context["atlas_organization_site_euid"] | |
| ) | |
| bobj = BloomObj(bdb) | |
| specimen = bobj.get_by_euid(specimen_euid) | |
| container = bobj.get_by_euid(container_euid) | |
| assert container.created_dt <= specimen.created_dt | |
| specimen_refs = _atlas_refs(specimen) | |
| container_refs = _atlas_refs(container) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_patient" | |
| and str(ref.get("atlas_patient_euid")) | |
| == atlas_context["atlas_patient_euid"] | |
| for ref in specimen_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_test_fulfillment_item" | |
| and str(ref.get("atlas_test_fulfillment_item_euid")) | |
| == atlas_context["fulfillment_items"][0]["atlas_test_fulfillment_item_euid"] | |
| for ref in specimen_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_test_fulfillment_item" | |
| and str(ref.get("atlas_test_fulfillment_item_euid")) | |
| == atlas_context["fulfillment_items"][0]["atlas_test_fulfillment_item_euid"] | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_trf" | |
| and str(ref.get("atlas_trf_euid")) == atlas_context["atlas_trf_euid"] | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_testkit" | |
| and str(ref.get("atlas_testkit_euid")) | |
| == atlas_context["atlas_testkit_euid"] | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_shipment" | |
| and str(ref.get("atlas_shipment_euid")) | |
| == atlas_context["atlas_shipment_euid"] | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_organization_site" | |
| and str(ref.get("atlas_organization_site_euid")) | |
| == atlas_context["atlas_organization_site_euid"] | |
| for ref in container_refs | |
| ) | |
| queued = client.post( | |
| f"/api/v1/external/atlas/beta/queues/extraction_prod/items/{container_euid}", | |
| headers={"Idempotency-Key": f"idem-queue-{secrets.token_hex(8)}"}, | |
| json={"metadata": {"source": "test_beta_lab"}}, | |
| ) | |
| assert queued.status_code == 200, queued.text | |
| extraction = client.post( | |
| "/api/v1/external/atlas/beta/extractions", | |
| headers={"Idempotency-Key": f"idem-extract-{secrets.token_hex(8)}"}, | |
| json={ | |
| "source_specimen_euid": specimen_euid, | |
| "well_name": "A1", | |
| "extraction_type": "gdna", | |
| "atlas_test_fulfillment_item_euid": atlas_context["fulfillment_items"][ | |
| 0 | |
| ]["atlas_test_fulfillment_item_euid"], | |
| }, | |
| ) | |
| assert extraction.status_code == 200, extraction.text | |
| finally: | |
| client.close() | |
| app.dependency_overrides.pop(require_external_token_auth, None) | |
| def test_empty_tube_create_and_specimen_update_use_collection_event_reference(bdb): | |
| def _atlas_rw_user() -> APIUser: | |
| token = secrets.token_hex(8) | |
| return APIUser( | |
| email="atlas-beta@example.com", | |
| user_id=f"atlas-user-{token}", | |
| roles=["READ_WRITE"], | |
| groups=[ENABLE_ATLAS_API_GROUP], | |
| auth_source="token", | |
| is_service_account=True, | |
| token_scope="internal_rw", | |
| token_id=f"token-{token}", | |
| ) | |
| def _atlas_refs(instance): | |
| refs: list[dict] = [] | |
| for lineage in get_parent_lineages(instance): | |
| if ( | |
| lineage.is_deleted | |
| or lineage.relationship_type != "has_external_reference" | |
| ): | |
| continue | |
| child = lineage.child_instance | |
| if child is None or child.is_deleted: | |
| continue | |
| payload = child.json_addl or {} | |
| props = payload.get("properties") if isinstance(payload, dict) else {} | |
| if not isinstance(props, dict): | |
| continue | |
| if str(props.get("provider") or "").strip() != "atlas": | |
| continue | |
| refs.append(props) | |
| return refs | |
| app.dependency_overrides[require_external_token_auth] = _atlas_rw_user | |
| client = TestClient(app) | |
| try: | |
| tenant_id = f"tenant-{secrets.token_hex(8)}" | |
| shipment_euid = f"shipment-{secrets.token_hex(8)}" | |
| testkit_euid = f"kit-{secrets.token_hex(8)}" | |
| site_euid = f"site-{secrets.token_hex(8)}" | |
| create_tube = client.post( | |
| "/api/v1/external/atlas/beta/tubes", | |
| headers={"Idempotency-Key": f"idem-tube-{secrets.token_hex(8)}"}, | |
| json={ | |
| "atlas_context": { | |
| "atlas_tenant_id": tenant_id, | |
| "atlas_shipment_euid": shipment_euid, | |
| "atlas_testkit_euid": testkit_euid, | |
| "atlas_organization_site_euid": site_euid, | |
| } | |
| }, | |
| ) | |
| assert create_tube.status_code == 200, create_tube.text | |
| tube_body = create_tube.json() | |
| container_euid = tube_body["container_euid"] | |
| collection_event_euid = f"cev-{secrets.token_hex(8)}" | |
| specimen_resp = client.post( | |
| "/api/v1/external/atlas/beta/materials", | |
| headers={"Idempotency-Key": f"idem-specimen-{secrets.token_hex(8)}"}, | |
| json={ | |
| "container_euid": container_euid, | |
| "atlas_context": { | |
| "atlas_tenant_id": tenant_id, | |
| "atlas_shipment_euid": shipment_euid, | |
| "atlas_testkit_euid": testkit_euid, | |
| "atlas_organization_site_euid": site_euid, | |
| "atlas_collection_event_euid": collection_event_euid, | |
| "collection_event_snapshot": { | |
| "collection_event_euid": collection_event_euid, | |
| "collection_type": "venipuncture", | |
| }, | |
| }, | |
| }, | |
| ) | |
| assert specimen_resp.status_code == 200, specimen_resp.text | |
| specimen_body = specimen_resp.json() | |
| bobj = BloomObj(bdb) | |
| container = bobj.get_by_euid(container_euid) | |
| specimen = bobj.get_by_euid(specimen_body["specimen_euid"]) | |
| container_refs = _atlas_refs(container) | |
| specimen_refs = _atlas_refs(specimen) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_shipment" | |
| and str(ref.get("atlas_shipment_euid")) == shipment_euid | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_testkit" | |
| and str(ref.get("atlas_testkit_euid")) == testkit_euid | |
| for ref in container_refs | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_collection_event" | |
| and str(ref.get("atlas_collection_event_euid")) == collection_event_euid | |
| and str(ref.get("collection_event_snapshot", {}).get("collection_type")) | |
| == "venipuncture" | |
| for ref in specimen_refs | |
| ) | |
| assert not any( | |
| str(ref.get("reference_type")) == "atlas_patient" for ref in specimen_refs | |
| ) | |
| patched = client.patch( | |
| f"/api/v1/external/atlas/beta/specimens/{specimen_body['specimen_euid']}", | |
| json={ | |
| "atlas_context": { | |
| "atlas_tenant_id": tenant_id, | |
| "atlas_collection_event_euid": collection_event_euid, | |
| "collection_event_snapshot": { | |
| "collection_event_euid": collection_event_euid, | |
| "collection_type": "fingerstick", | |
| "expected_name": "Pat Ient", | |
| }, | |
| } | |
| }, | |
| ) | |
| assert patched.status_code == 200, patched.text | |
| updated_specimen_refs = _atlas_refs( | |
| bobj.get_by_euid(specimen_body["specimen_euid"]) | |
| ) | |
| assert any( | |
| str(ref.get("reference_type")) == "atlas_collection_event" | |
| and str(ref.get("collection_event_snapshot", {}).get("collection_type")) | |
| == "fingerstick" | |
| and str(ref.get("collection_event_snapshot", {}).get("expected_name")) | |
| == "Pat Ient" | |
| for ref in updated_specimen_refs | |
| ) | |
| assert not any( | |
| str(ref.get("reference_type")) == "atlas_patient" | |
| for ref in updated_specimen_refs | |
| ) | |
| finally: | |
| client.close() | |
| app.dependency_overrides.pop(require_external_token_auth, None) | |
Xet Storage Details
- Size:
- 13.9 kB
- Xet hash:
- 5c26949fa674ee329adb6ccb89d5a4558bf150e800cf427714b0c3097c353e63
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.