LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
import json
import uuid
from types import SimpleNamespace
from unittest.mock import patch
from django.db import connection, transaction
from django.utils import timezone
from platform_audit.actions import Action, TargetType
from platform_audit.models import PlatformAuditEvent
from platform_audit.recorder import _write, best_effort, record_platform_event
from platform_audit.tests.base import AuditTestBase, make_user
class RecorderTests(AuditTestBase):
def _record(self, **kwargs):
defaults = {
"action": Action.GROUP_CREATED,
"target_type": TargetType.GROUP,
"target_id": 7,
"target_name": "Team",
"actor": self.admin,
}
with self.captureOnCommitCallbacks(execute=True):
record_platform_event(**{**defaults, **kwargs})
def test_stores_every_field(self) -> None:
request = SimpleNamespace(user=self.admin, id="req-123")
self._record(
actor=None,
request=request,
changes={"before": {"name": "A"}, "after": {"name": "B"}},
summary="renamed",
metadata={"x": uuid.UUID(int=1)},
)
event = self.only_event()
self.assert_admin_actor(event)
self.assertEqual(event.action, "group.created")
self.assertEqual(
(event.target_type, event.target_id, event.target_name),
("group", "7", "Team"),
)
self.assertEqual(event.changes, {"before": {"name": "A"}, "after": {"name": "B"}})
self.assertEqual(event.summary, "renamed")
self.assertEqual(event.metadata, {"x": str(uuid.UUID(int=1))})
def test_platform_key_caller_is_recorded_as_the_key(self) -> None:
service_account = make_user("[email protected]", is_service_account=True)
key = SimpleNamespace(id=uuid.UUID(int=5), name="ci-bot")
request = SimpleNamespace(user=service_account, platform_api_key=key)
self._record(actor=None, request=request)
event = self.only_event()
self.assertEqual(event.actor, service_account)
self.assertEqual(event.actor_type, "api_key")
self.assertEqual(event.actor_email, "[email protected]")
self.assertEqual(event.actor_key_id, str(key.id))
self.assertEqual(event.actor_key_name, "ci-bot")
def test_no_actor_is_system(self) -> None:
self._record(actor=None)
event = self.only_event()
self.assertEqual(event.actor_type, "system")
self.assertIsNone(event.actor)
self.assertEqual(event.actor_email, "")
def test_explicit_organization_wins_over_context(self) -> None:
self._record(organization=self.other_org)
self.assertEqual(self.only_event().organization, self.other_org)
def test_unregistered_action_is_logged_not_stored(self) -> None:
with self.assertLogs("platform_audit.recorder", "ERROR"):
self._record(action="nope.unknown")
self.assertEqual(self.events(), [])
def test_missing_organization_is_logged_not_stored(self) -> None:
with patch(
"platform_audit.recorder.UserContext.get_organization", return_value=None
):
with self.assertLogs("platform_audit.recorder", "WARNING"):
self._record()
self.assertEqual(self.events(), [])
def test_failing_write_is_logged_and_swallowed(self) -> None:
with patch.object(
PlatformAuditEvent.objects, "create", side_effect=RuntimeError("db down")
):
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
self._record() # must not raise
self.assertIn("failed to write", logs.output[0])
self.assertEqual(self.events(), [])
def test_failure_while_resolving_is_logged_and_swallowed(self) -> None:
with patch(
"platform_audit.recorder._resolve_actor", side_effect=RuntimeError("boom")
):
with self.assertLogs("platform_audit.recorder", "ERROR"):
self._record()
self.assertEqual(self.events(), [])
def test_nothing_is_recorded_when_the_change_rolls_back(self) -> None:
with self.captureOnCommitCallbacks(execute=True):
try:
with transaction.atomic():
record_platform_event(
action=Action.GROUP_DELETED,
target_type=TargetType.GROUP,
target_id=1,
actor=self.admin,
)
raise RuntimeError("change failed")
except RuntimeError:
pass
self.assertEqual(self.events(), [])
def test_changes_keep_only_before_and_after_and_drop_unknown_sides(self) -> None:
with self.assertLogs("platform_audit.recorder", "WARNING"):
self._record(changes={"before": None, "after": {"a": 1}, "old": 2})
self.assertEqual(self.only_event().changes, {"after": {"a": 1}})
def test_write_failure_log_names_the_change(self) -> None:
with patch.object(
PlatformAuditEvent.objects, "create", side_effect=RuntimeError("db down")
):
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
self._record()
self.assertIn("org=org-a target=group:7", logs.output[0])
def test_write_failure_log_redacts_an_email_target(self) -> None:
with patch.object(
PlatformAuditEvent.objects, "create", side_effect=RuntimeError("db down")
):
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
self._record(
action=Action.MEMBER_INVITED,
target_type=TargetType.INVITATION,
target_id="[email protected]",
)
self.assertNotIn("[email protected]", logs.output[0])
self.assertIn("target=invitation:<redacted>", logs.output[0])
self.assertIn(f"actor=user:{self.admin.pk}", logs.output[0])
self.assertNotIn("[email protected]", logs.output[0])
def test_a_real_database_error_logs_sqlstate_not_the_row(self) -> None:
"""Postgres echoes a rejected row ("Failing row contains ...")."""
fields = {
"organization": None, # NOT NULL: 23502
"occurred_at": timezone.now(),
"action": Action.MEMBER_INVITED,
"target_type": TargetType.INVITATION,
"target_id": "[email protected]",
"actor_type": "system",
"summary": "as [email protected]",
}
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
_write(fields)
output = "\n".join(logs.output)
self.assertIn("IntegrityError, sqlstate=23502", output)
self.assertNotIn("[email protected]", output)
self.assertNotIn("Failing row", output)
def test_a_non_database_error_logs_where_it_was_raised(self) -> None:
with patch.object(
PlatformAuditEvent.objects,
"create",
side_effect=TypeError("Object of type set is not JSON serializable"),
):
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
self._record()
output = "\n".join(logs.output)
self.assertIn("TypeError, sqlstate=None, at ", output)
self.assertIn("recorder.py:", output)
self.assertNotIn("JSON serializable", output)
def test_a_recording_failure_logs_no_message(self) -> None:
with patch(
"platform_audit.recorder._resolve_actor",
side_effect=RuntimeError("no user [email protected]"),
):
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
self._record()
self.assertIn("failed to record", logs.output[0])
self.assertIn("RuntimeError", logs.output[0])
self.assertNotIn("[email protected]", logs.output[0])
def test_the_log_names_the_app_frame_that_raised_not_library_frames(self) -> None:
@best_effort
def snapshot() -> None:
json.dumps({1, 2}) # raises inside the stdlib encoder
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
snapshot()
self.assertIn("test_recorder.py:", logs.output[0])
self.assertIn(" snapshot", logs.output[0])
self.assertNotIn("encoder.py", logs.output[0])
def test_helper_failures_leave_out_the_message_too(self) -> None:
@best_effort
def lookup() -> None:
raise RuntimeError("no member [email protected]")
with self.assertLogs("platform_audit.recorder", "ERROR") as logs:
lookup()
self.assertIn("RuntimeError", logs.output[0])
self.assertNotIn("[email protected]", logs.output[0])
def test_long_values_are_clipped_to_the_column(self) -> None:
self._record(target_name="x" * 400)
self.assertEqual(len(self.only_event().target_name), 255)
class ImmutabilityTests(AuditTestBase):
def setUp(self) -> None:
super().setUp()
self.event = PlatformAuditEvent.objects.create(
organization=self.org,
actor_type="system",
action=Action.GROUP_CREATED,
target_type=TargetType.GROUP,
)
def test_saving_an_existing_event_is_refused(self) -> None:
self.event.summary = "edited"
with self.assertRaises(PermissionError):
self.event.save()
def test_deleting_an_event_is_refused(self) -> None:
with self.assertRaises(PermissionError):
self.event.delete()
def test_queryset_update_and_delete_are_refused(self) -> None:
with self.assertRaises(PermissionError):
PlatformAuditEvent.objects.filter(pk=self.event.pk).update(summary="x")
with self.assertRaises(PermissionError):
PlatformAuditEvent.objects.filter(pk=self.event.pk).delete()
def test_purge_deletes(self) -> None:
deleted = PlatformAuditEvent.objects.purge(
PlatformAuditEvent.objects.filter(pk=self.event.pk)
)
self.assertEqual(deleted, 1)
self.assertFalse(PlatformAuditEvent.objects.exists())
class BestEffortTests(AuditTestBase):
def test_returns_none_and_logs_on_error(self) -> None:
@best_effort
def broken() -> int:
raise ValueError("nope")
with self.assertLogs("platform_audit.recorder", "ERROR"):
self.assertIsNone(broken())
def test_passes_the_result_through(self) -> None:
self.assertEqual(best_effort(lambda: 3)(), 3)
class BestEffortSavepointTests(AuditTestBase):
"""TestCase runs inside a transaction, like a request under ATOMIC_REQUESTS."""
def test_a_failed_query_does_not_abort_the_outer_transaction(self) -> None:
@best_effort
def broken_lookup() -> None:
with connection.cursor() as cursor:
cursor.execute("SELECT 1 / 0")
with self.assertLogs("platform_audit.recorder", "ERROR"):
self.assertIsNone(broken_lookup())
# Without a savepoint Postgres refuses every further statement here.
self.assertFalse(PlatformAuditEvent.objects.exists())
def test_a_failed_read_in_the_recorder_does_not_abort_it_either(self) -> None:
def broken_organisation_lookup():
with connection.cursor() as cursor:
cursor.execute("SELECT 1 / 0")
with patch(
"platform_audit.recorder.UserContext.get_organization",
side_effect=broken_organisation_lookup,
):
with self.assertLogs("platform_audit.recorder", "ERROR"):
record_platform_event(
action=Action.GROUP_CREATED, target_type=TargetType.GROUP
)
self.assertFalse(PlatformAuditEvent.objects.exists())
def test_outside_a_transaction_no_transaction_is_opened(self) -> None:
"""Outside ATOMIC_REQUESTS a helper must not defer its on_commit writes."""
@best_effort
def helper() -> int:
return 5
not_atomic = type("Conn", (), {"in_atomic_block": False})()
with (
patch(
"platform_audit.recorder.transaction.get_connection",
return_value=not_atomic,
),
patch(
"platform_audit.recorder.transaction.atomic",
side_effect=AssertionError("opened a transaction"),
),
):
self.assertEqual(helper(), 5)