Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Daylily-Informatics_bloom /tests /test_anomalies.py
| from __future__ import annotations | |
| import os | |
| import sys | |
| from datetime import UTC, datetime | |
| from types import SimpleNamespace | |
| from fastapi.testclient import TestClient | |
| os.environ["BLOOM_OAUTH"] = "no" | |
| os.environ["BLOOM_DEV_AUTH_BYPASS"] = "true" | |
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) | |
| from bloom_lims import observability_routes | |
| from bloom_lims.anomalies import AnomalyRecord, TapdbAnomalyRepository | |
| from bloom_lims.gui.routes import operations | |
| from main import app | |
| class _FakeSession: | |
| def add(self, _obj) -> None: | |
| return None | |
| def flush(self) -> None: | |
| return None | |
| def commit(self) -> None: | |
| return None | |
| def _build_fake_repository() -> TapdbAnomalyRepository: | |
| repository = TapdbAnomalyRepository(_FakeSession()) | |
| instances: list[SimpleNamespace] = [] | |
| counter = {"value": 0} | |
| def create_instance( | |
| *, template_code: str, name: str, properties: dict, session | |
| ) -> SimpleNamespace: | |
| counter["value"] += 1 | |
| category, type_name, subtype, version = template_code.strip("/").split("/") | |
| instance = SimpleNamespace( | |
| euid=f"BAN-{counter['value']:04d}", | |
| name=name, | |
| json_addl={"properties": properties}, | |
| created_dt=datetime.now(UTC), | |
| category=category, | |
| type=type_name, | |
| subtype=subtype, | |
| version=version, | |
| is_deleted=False, | |
| ) | |
| instances.append(instance) | |
| return instance | |
| repository._ensure_templates = lambda: None # type: ignore[method-assign] | |
| repository._instances = lambda: list(instances) # type: ignore[method-assign] | |
| repository.factory = SimpleNamespace(create_instance=create_instance) | |
| repository._test_instances = instances # type: ignore[attr-defined] | |
| return repository | |
| def _sample_record() -> AnomalyRecord: | |
| now = datetime.now(UTC).isoformat() | |
| return AnomalyRecord( | |
| id="BAN-0001", | |
| service="bloom", | |
| environment="dev", | |
| category="database", | |
| severity="error", | |
| fingerprint="db-fingerprint", | |
| summary="Bloom database probe failed", | |
| first_seen_at=now, | |
| last_seen_at=now, | |
| occurrence_count=2, | |
| redacted_context={"token": "[redacted]", "sql": "[redacted-sql]"}, | |
| source_view_url="/admin/anomalies/BAN-0001", | |
| ) | |
| class _StubRepository: | |
| def __init__(self): | |
| self._record = _sample_record() | |
| def list(self, *, skip: int = 0, limit: int = 100): | |
| return [self._record][skip : skip + limit] | |
| def get(self, anomaly_id: str): | |
| if anomaly_id == self._record.id: | |
| return self._record | |
| return None | |
| def projection(self): | |
| return SimpleNamespace( | |
| observed_at=self._record.last_seen_at, | |
| model_dump=lambda: { | |
| "state": "ready", | |
| "stale": False, | |
| "observed_at": self._record.last_seen_at, | |
| "last_synced_at": self._record.last_seen_at, | |
| "detail": None, | |
| }, | |
| ) | |
| class _StubBloomDB: | |
| def __init__(self, app_username: str = ""): | |
| self.app_username = app_username | |
| self.session = None | |
| def close(self) -> None: | |
| return None | |
| def test_anomaly_repository_upserts_and_redacts_context() -> None: | |
| repository = _build_fake_repository() | |
| context = { | |
| "authorization": "Bearer super-secret-token", | |
| "nested": { | |
| "cookie": "session=abc123", | |
| "path": "/documents/123456/details", | |
| "sql": "SELECT * FROM users WHERE id = 123456", | |
| }, | |
| "items": [{"password": "open-sesame"}, "/patients/987654321"], | |
| } | |
| first = repository.record( | |
| category="database", | |
| severity="error", | |
| fingerprint="db-fingerprint", | |
| summary="Bloom database probe failed", | |
| redacted_context=context, | |
| ) | |
| second = repository.record( | |
| category="database", | |
| severity="error", | |
| fingerprint="db-fingerprint", | |
| summary="Bloom database probe failed", | |
| redacted_context=context, | |
| ) | |
| assert first.id == second.id | |
| assert len(repository.list()) == 1 | |
| assert second.occurrence_count == 2 | |
| assert second.redacted_context["authorization"] == "[redacted]" | |
| assert second.redacted_context["nested"]["cookie"] == "[redacted]" | |
| assert second.redacted_context["nested"]["path"] == "/documents/{id}/details" | |
| assert second.redacted_context["nested"]["sql"] == "[redacted-sql]" | |
| assert second.redacted_context["items"][0]["password"] == "[redacted]" | |
| assert second.redacted_context["items"][1] == "/patients/{id}" | |
| def test_anomaly_api_lists_and_reads_records(monkeypatch) -> None: | |
| monkeypatch.setattr( | |
| observability_routes, | |
| "_anomaly_repository", | |
| lambda _app_username: (_StubBloomDB(), _StubRepository()), | |
| ) | |
| with TestClient(app, raise_server_exceptions=False) as client: | |
| listing = client.get("/api/anomalies") | |
| detail = client.get("/api/anomalies/BAN-0001") | |
| missing = client.get("/api/anomalies/BAN-DOES-NOT-EXIST") | |
| assert listing.status_code == 200 | |
| payload = listing.json() | |
| assert payload["service"] == "bloom" | |
| assert payload["projection"]["state"] == "ready" | |
| assert payload["count"] == 1 | |
| assert payload["items"][0]["redacted_context"]["token"] == "[redacted]" | |
| assert detail.status_code == 200 | |
| assert detail.json()["item"]["id"] == "BAN-0001" | |
| assert missing.status_code == 404 | |
| def test_admin_anomalies_views_render(monkeypatch) -> None: | |
| monkeypatch.setattr(operations, "BLOOMdb3", _StubBloomDB) | |
| monkeypatch.setattr( | |
| operations, "TapdbAnomalyRepository", lambda _session: _StubRepository() | |
| ) | |
| with TestClient(app, raise_server_exceptions=False) as client: | |
| listing = client.get("/admin/anomalies") | |
| detail = client.get("/admin/anomalies/BAN-0001") | |
| missing = client.get("/admin/anomalies/BAN-DOES-NOT-EXIST") | |
| assert listing.status_code == 200 | |
| assert "Operational Anomalies" in listing.text | |
| assert "Bloom database probe failed" in listing.text | |
| assert detail.status_code == 200 | |
| assert "BAN-0001" in detail.text | |
| assert "[redacted]" in detail.text | |
| assert missing.status_code == 404 | |
| def test_anomaly_api_tolerates_malformed_stored_properties(monkeypatch) -> None: | |
| repository = _build_fake_repository() | |
| repository._test_instances.append( # type: ignore[attr-defined] | |
| SimpleNamespace( | |
| euid="BAN-0099", | |
| name="malformed", | |
| json_addl={ | |
| "properties": { | |
| "service": "bloom", | |
| "environment": "dev", | |
| "category": "database", | |
| "severity": "error", | |
| "fingerprint": "db-malformed", | |
| "summary": "Malformed stored anomaly payload", | |
| "first_seen_at": "2026-03-29T22:00:00+00:00", | |
| "last_seen_at": "2026-03-29T22:01:00+00:00", | |
| "occurrence_count": "not-an-int", | |
| "redacted_context": ["opaque", "payload"], | |
| } | |
| }, | |
| created_dt=datetime.now(UTC), | |
| category="BAN", | |
| type="ops", | |
| subtype="anomaly-record", | |
| version="1.0", | |
| is_deleted=False, | |
| ) | |
| ) | |
| monkeypatch.setattr( | |
| observability_routes, | |
| "_anomaly_repository", | |
| lambda _app_username: (_StubBloomDB(), repository), | |
| ) | |
| with TestClient(app, raise_server_exceptions=False) as client: | |
| response = client.get("/api/anomalies") | |
| assert response.status_code == 200 | |
| payload = response.json() | |
| item = next(record for record in payload["items"] if record["id"] == "BAN-0099") | |
| assert item["occurrence_count"] == 0 | |
| assert item["redacted_context"] == {"value": ["opaque", "payload"]} | |
Xet Storage Details
- Size:
- 7.98 kB
- Xet hash:
- 86a3eaa5e93fa2ac77beae1471997cf1ae2790e2f8eb7458ec802aa89d8371d3
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.