Skip to content

LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows

16.7 KB
Raw Blame
import csv
import io
import uuid
from datetime import UTC, datetime, timedelta
from types import SimpleNamespace
from unittest.mock import patch

from configuration.enums import ConfigKey
from configuration.models import Configuration
from django.test import override_settings
from django.utils import timezone

from platform_audit.models import PlatformAuditEvent
from platform_audit.serializers import AuditEventQuerySerializer
from platform_audit.tests.base import AuditTestBase, make_user
from platform_audit.views import (
    CSV_COLUMNS,
    PlatformAuditActionListView,
    PlatformAuditActorListView,
    PlatformAuditEventExportView,
    PlatformAuditEventListView,
)

LIST = PlatformAuditEventListView.as_view()
EXPORT = PlatformAuditEventExportView.as_view()
ACTIONS = PlatformAuditActionListView.as_view()
ACTORS = PlatformAuditActorListView.as_view()


class AuditReadApiTests(AuditTestBase):
    def setUp(self) -> None:
        super().setUp()
        self.now = timezone.now()
        self.role = self._event(
            "member.role_changed",
            days_ago=1,
            target_name="[email protected]",
            summary="user → admin",
        )
        self.rotate = self._event(
            "key.rotated", days_ago=2, target_name="ci-key", actor_email="[email protected]"
        )
        self.group = self._event("group.created", days_ago=10, target_name="Finance")
        self.expired = self._event("group.deleted", days_ago=366, target_name="Old")
        # Its own identity, so a leak cannot hide behind a home-org row that
        # DISTINCT ON would merge it with.
        self.foreign = self._event(
            "group.created",
            days_ago=1,
            organization=self.other_org,
            actor=None,
            actor_email="[email protected]",
            actor_name="Them",
            target_id="foreign-target",
            target_name="Theirs",
        )

    def _event(self, action: str, days_ago: float, **kwargs) -> PlatformAuditEvent:
        fields = {
            "organization": self.org,
            "occurred_at": self.now - timedelta(days=days_ago),
            "actor": self.admin,
            "actor_type": "user",
            "actor_email": "[email protected]",
            "actor_name": "Ada Min",
            "action": action,
            "target_type": "x",
            "target_id": "1",
            **kwargs,
        }
        return PlatformAuditEvent.objects.create(**fields)

    def _get(self, view, params=None, user=None, **kwargs):
        response = self.call(view, "get", user=user, data=params or {}, **kwargs)
        return response

    def _ids(self, response) -> list[str]:
        return [row["id"] for row in response.data["results"]]

    # --- list ------------------------------------------------------------------

    def test_lists_this_org_inside_retention_newest_first(self) -> None:
        response = self._get(LIST)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            self._ids(response),
            [str(self.role.id), str(self.rotate.id), str(self.group.id)],
        )
        self.assertEqual(response.data["count"], 3)
        self.assertEqual(response.data["retention_days"], 365)

    def test_row_shape(self) -> None:
        row = self._get(LIST, {"action": "member.role_changed"}).data["results"][0]
        self.assertEqual(
            set(row),
            {
                "id",
                "occurred_at",
                "actor",
                "action",
                "action_label",
                "target",
                "summary",
                "changes",
                "request_id",
            },
        )
        self.assertEqual(
            row["actor"],
            {
                "id": self.admin.id,
                "email": "[email protected]",
                "name": "Ada Min",
                "type": "user",
                "key_id": "",
                "key_name": "",
            },
        )
        self.assertEqual(row["action_label"], "Role changed")
        self.assertEqual(
            row["target"], {"type": "x", "id": "1", "name": "[email protected]"}
        )

    def test_filters_combine(self) -> None:
        params = {
            "action": ["member.role_changed", "key.rotated"],
            "from": (self.now - timedelta(days=3)).date().isoformat(),
            "to": self.now.date().isoformat(),
        }
        self.assertEqual(
            self._ids(self._get(LIST, params)),
            [str(self.role.id), str(self.rotate.id)],
        )
        params["actor"] = "[email protected]"
        self.assertEqual(self._ids(self._get(LIST, params)), [str(self.rotate.id)])

    def test_search_matches_target_and_summary(self) -> None:
        self.assertEqual(
            self._ids(self._get(LIST, {"search": "FINANCE"})), [str(self.group.id)]
        )
        self.assertEqual(
            self._ids(self._get(LIST, {"search": "→ admin"})), [str(self.role.id)]
        )

    def test_date_to_covers_the_whole_day_and_datetime_to_is_inclusive(self) -> None:
        day = self.rotate.occurred_at.date()
        ids = self._ids(self._get(LIST, {"from": day.isoformat(), "to": day.isoformat()}))
        self.assertEqual(ids, [str(self.rotate.id)])
        exact = self.rotate.occurred_at.isoformat()
        self.assertEqual(
            self._ids(self._get(LIST, {"from": exact, "to": exact})),
            [str(self.rotate.id)],
        )

    def test_pagination(self) -> None:
        response = self._get(LIST, {"page_size": 2})
        self.assertEqual(len(response.data["results"]), 2)
        self.assertEqual(response.data["count"], 3)
        self.assertIsNotNone(response.data["next"])
        page2 = self._get(LIST, {"page_size": 2, "page": 2})
        self.assertEqual(self._ids(page2), [str(self.group.id)])

    def test_blank_filters_are_ignored(self) -> None:
        response = self._get(LIST, {"from": "", "to": " ", "action": ["", "key.rotated"]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(self._ids(response), [str(self.rotate.id)])

    def test_a_repeated_bound_uses_its_last_non_blank_value(self) -> None:
        group_day = self.group.occurred_at.date().isoformat()
        rotate_day = self.rotate.occurred_at.date().isoformat()
        response = self._get(
            LIST, {"from": [group_day, rotate_day, ""], "to": [rotate_day]}
        )
        self.assertEqual(self._ids(response), [str(self.rotate.id)])

    def test_a_trailing_blank_repeat_keeps_the_real_bound(self) -> None:
        day = self.rotate.occurred_at.date().isoformat()
        response = self._get(LIST, {"from": [day, ""], "to": [day, " "]})
        self.assertEqual(self._ids(response), [str(self.rotate.id)])

    def test_invalid_filters_are_400(self) -> None:
        for params in (
            {"action": "nope.unknown"},
            {"from": "yesterday"},
            {"from": "2026-10-10", "to": "2026-10-01"},
        ):
            with self.subTest(params=params):
                self.assertEqual(self._get(LIST, params).status_code, 400)

    def test_retention_override_per_org(self) -> None:
        Configuration.objects.create(
            organization=self.org,
            key=ConfigKey.PLATFORM_AUDIT_RETENTION_DAYS.name,
            value="5",
        )
        response = self._get(LIST)
        self.assertEqual(self._ids(response), [str(self.role.id), str(self.rotate.id)])
        self.assertEqual(response.data["retention_days"], 5)

    def test_from_before_retention_still_hides_expired(self) -> None:
        response = self._get(LIST, {"from": "2000-01-01"})
        self.assertNotIn(str(self.expired.id), self._ids(response))

    # --- permissions -----------------------------------------------------------

    def test_member_is_forbidden(self) -> None:
        views = {"list": LIST, "export": EXPORT, "actions": ACTIONS, "actors": ACTORS}
        for name, view in views.items():
            # A string, not the view: xdist cannot serialise a function.
            with self.subTest(view=name):
                self.assertEqual(self._get(view, user=self.member).status_code, 403)

    def test_platform_key_caller_is_forbidden(self) -> None:
        from tenant_account_v2.models import OrganizationMember

        service_account = make_user("[email protected]", is_service_account=True)
        # An admin membership, as the role endpoint can grant one, so the
        # refusal has to come from the service-account check.
        OrganizationMember.objects.create(
            organization=self.org, user=service_account, role=self.admin_role
        )
        key = SimpleNamespace(id=uuid.uuid4(), name="k", permission="full_access")
        views = {"list": LIST, "export": EXPORT, "actions": ACTIONS, "actors": ACTORS}
        for name, view in views.items():
            with self.subTest(view=name):
                response = self._get(view, user=service_account, platform_api_key=key)
                self.assertEqual(response.status_code, 403)

    def test_admin_of_another_org_sees_only_that_org(self) -> None:
        other_admin = make_user("[email protected]")
        from tenant_account_v2.models import OrganizationMember

        self.use_org(self.other_org)
        OrganizationMember.objects.create(
            organization=self.other_org, user=other_admin, role=self.admin_role
        )
        response = self._get(LIST, user=other_admin)
        self.assertEqual(self._ids(response), [str(self.foreign.id)])

    def test_no_read_shows_another_orgs_events(self) -> None:
        views = {"list": LIST, "export": EXPORT, "actors": ACTORS}
        for name, view in views.items():
            with self.subTest(view=name):
                response = self._get(view)
                self.assertEqual(response.status_code, 200)
                if name == "export":
                    body = response.content.decode()
                else:
                    body = str(response.data)
                for leaked in (
                    "[email protected]",
                    "Theirs",
                    "foreign-target",
                    str(self.foreign.id),
                ):
                    self.assertNotIn(leaked, body)

    # --- export ----------------------------------------------------------------

    def test_export_uses_the_same_filters(self) -> None:
        response = self._get(EXPORT, {"action": "key.rotated"})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response["Content-Type"], "text/csv; charset=utf-8")
        self.assertIn("attachment;", response["Content-Disposition"])
        rows = list(csv.reader(io.StringIO(response.content.decode())))
        self.assertEqual(rows[0], CSV_COLUMNS)
        self.assertEqual(len(rows), 2)
        record = dict(zip(CSV_COLUMNS, rows[1], strict=True))
        self.assertEqual(record["action"], "key.rotated")
        self.assertEqual(record["action_label"], "Key rotated")
        self.assertEqual(record["target_name"], "ci-key")

    def test_export_changes_cell(self) -> None:
        self._event(
            "group.changed",
            days_ago=0,
            target_name="With changes",
            # jsonb stores shorter keys first; sort_keys must reorder them.
            changes={"after": {"name": "B", "is_active": True}},
        )
        response = self._get(EXPORT, {"action": ["group.created", "group.changed"]})
        rows = list(csv.reader(io.StringIO(response.content.decode())))
        cells = {
            dict(zip(CSV_COLUMNS, row, strict=True))["target_name"]: dict(
                zip(CSV_COLUMNS, row, strict=True)
            )["changes"]
            for row in rows[1:]
        }
        self.assertEqual(cells["Finance"], "")
        self.assertEqual(
            cells["With changes"], '{"after": {"is_active": true, "name": "B"}}'
        )

    def test_export_neutralises_formulas(self) -> None:
        self._event(
            "group.created", days_ago=0, target_name="=HYPERLINK(1)", summary="-2+3"
        )
        response = self._get(EXPORT, {"action": "group.created"})
        rows = list(csv.reader(io.StringIO(response.content.decode())))
        record = dict(zip(CSV_COLUMNS, rows[1], strict=True))
        self.assertEqual(record["target_name"], "'=HYPERLINK(1)")
        self.assertEqual(record["summary"], "'-2+3")

    def test_export_over_the_cap_is_413(self) -> None:
        with patch("platform_audit.views.MAX_EXPORT_ROWS", 2):
            response = self._get(EXPORT)
        self.assertEqual(response.status_code, 413)
        # Exactly at the cap is allowed.
        with patch("platform_audit.views.MAX_EXPORT_ROWS", 3):
            self.assertEqual(self._get(EXPORT).status_code, 200)

    # --- actions & actors --------------------------------------------------------

    def test_actions_vocabulary(self) -> None:
        response = self._get(ACTIONS)
        self.assertEqual(response.status_code, 200)
        keys = {row["key"] for row in response.data}
        self.assertTrue(
            {
                "member.role_changed",
                "capability.changed",
                "key.expiry_set",
                "execution.aborted",
            }
            <= keys
        )
        self.assertEqual(set(response.data[0]), {"key", "label", "category"})

    def test_actors_are_one_per_identity_and_skip_the_system_actor(self) -> None:
        self._event("group.created", days_ago=0.5, actor_name="Ada Renamed")
        self._event(
            "group.created", days_ago=0.5, actor=None, actor_type="system", actor_email=""
        )
        response = self._get(ACTORS)
        admins = [row for row in response.data if row["email"] == "[email protected]"]
        self.assertEqual(len(admins), 1)
        self.assertEqual(admins[0]["name"], "Ada Renamed")
        self.assertNotIn("", [row["email"] for row in response.data])

    def test_actors_include_removed_members_and_skip_expired(self) -> None:
        gone = make_user("[email protected]")
        self._event(
            "member.removed", days_ago=3, actor=gone, actor_email="[email protected]"
        )
        self._event("member.removed", days_ago=370, actor_email="[email protected]")
        gone.delete()
        response = self._get(ACTORS)
        emails = [row["email"] for row in response.data]
        self.assertEqual(
            emails, ["[email protected]", "[email protected]", "[email protected]"]
        )
        self.assertIsNone(response.data[2]["id"])

    @override_settings(TIME_ZONE="Asia/Kolkata")
    def test_naive_datetime_is_read_in_server_time(self) -> None:
        query = AuditEventQuerySerializer(data={"from": "2026-01-01T09:00:00"})
        self.assertTrue(query.is_valid(), query.errors)
        self.assertEqual(
            query.validated_data["start"],
            datetime(2026, 1, 1, 3, 30, tzinfo=UTC),
        )

    def test_invalid_from_reports_the_parameter_name(self) -> None:
        for value in ("yesterday", "2999-01-01"):
            with self.subTest(value=value):
                query = AuditEventQuerySerializer(
                    data={"from": value, "to": "2026-01-01"}
                )
                self.assertFalse(query.is_valid())
                self.assertEqual(set(query.errors), {"from"})

    def test_to_at_the_end_of_the_calendar_is_not_a_500(self) -> None:
        for value in ("9999-12-31", "9999-12-31T23:59:59.999999+00:00"):
            with self.subTest(value=value):
                self.assertEqual(self._get(LIST, {"to": value}).status_code, 200)

    def test_ordering_parameter_is_ignored(self) -> None:
        response = self._get(LIST, {"ordering": "occurred_at"})
        self.assertEqual(
            self._ids(response),
            [str(self.role.id), str(self.rotate.id), str(self.group.id)],
        )

    def test_retention_default_out_of_range_fails_closed(self) -> None:
        for bad in (0, -5, 99999):
            with self.subTest(value=bad):
                with patch(
                    "platform_audit.retention.Configuration.get_value_by_organization",
                    return_value=bad,
                ):
                    with self.assertLogs("platform_audit.retention", "ERROR"):
                        response = self._get(LIST)
                self.assertEqual(response.data["retention_days"], 3650)
                self.assertIn(str(self.expired.id), self._ids(response))

    def test_page_out_of_range_is_404(self) -> None:
        self.assertEqual(self._get(LIST, {"page": 99}).status_code, 404)

    def test_actors_cap_keeps_the_first_by_email(self) -> None:
        # An api_key actor sorting last by e-mail: a type-first cap would keep it.
        self._event(
            "key.rotated", days_ago=1, actor_type="api_key", actor_email="[email protected]"
        )
        with patch("platform_audit.views.MAX_ACTORS", 2):
            emails = [row["email"] for row in self._get(ACTORS).data]
        self.assertEqual(emails, ["[email protected]", "[email protected]"])