GovOPlaN/govoplan-decisions
2
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Expose decision filing and search sources

Browse Source
This commit is contained in:
zemion
2026-08-06 12:42:20 +02:00
parent 8719fd7258
commit 3845e068de
7 changed files with 857 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_decisions.py
+124 -19
View File
@@ -22,7 +22,9 @@ from govoplan_core.core.temporal import (
bind_temporal_data_context,
reset_temporal_data_context,
)
from govoplan_core.core.records import RecordContractError, RecordSourceLocator
from govoplan_decisions.backend.db.models import FormalDecisionRevision
from govoplan_decisions.backend.record_source import DecisionsRecordSource
from govoplan_decisions.backend.service import (
DecisionStoreError,
SqlDecisionRegistry,
@@ -37,22 +39,57 @@ NOW = datetime(2026, 8, 1, 12, 0, tzinfo=UTC)
class Principal:
tenant_id: str = "tenant-1"
account_id: str = "account-1"
scopes: tuple[str, ...] = (
"decisions:decision:read",
"decisions:decision:read_sensitive",
)
def has(self, scope: str) -> bool:
return scope in self.scopes
def reference(kind: str, object_id: str, owner: str, version: str | None = "1") -> InstitutionalReference:
return InstitutionalReference(kind=kind, owner_module=owner, object_id=object_id, tenant_id="tenant-1", version=version, valid_at=NOW) # type: ignore[arg-type]
def reference(
kind: str, object_id: str, owner: str, version: str | None = "1"
) -> InstitutionalReference:
return InstitutionalReference(
kind=kind,
owner_module=owner,
object_id=object_id,
tenant_id="tenant-1",
version=version,
valid_at=NOW,
) # type: ignore[arg-type]
def decision() -> FormalDecision:
temporal = TemporalRevision(revision="1", valid_from=NOW, recorded_at=NOW, change_reason="Decision accepted.")
temporal = TemporalRevision(
revision="1",
valid_from=NOW,
recorded_at=NOW,
change_reason="Decision accepted.",
)
decision_ref = reference("decision", "decision-1", "decisions")
mandate_ref = reference("mandate", "mandate-1", "mandates", "7")
evidence = EvidenceReference(kind="record", owner_module="committee", evidence_id="minutes-1", tenant_id="tenant-1", version="1", captured_at=NOW)
basis = LegalBasisReference(kind="statute", authority="Council", reference="rules:12", version="2026")
evidence = EvidenceReference(
kind="record",
owner_module="committee",
evidence_id="minutes-1",
tenant_id="tenant-1",
version="1",
captured_at=NOW,
)
basis = LegalBasisReference(
kind="statute", authority="Council", reference="rules:12", version="2026"
)
context = GovernedContextEnvelope(
tenant_id="tenant-1",
temporal=temporal,
actor=ActorRepresentationReference(tenant_id="tenant-1", account_id="account-1", identity_id="identity-1", mandate_ref=mandate_ref),
actor=ActorRepresentationReference(
tenant_id="tenant-1",
account_id="account-1",
identity_id="identity-1",
mandate_ref=mandate_ref,
),
mandate_ref=mandate_ref,
decision_ref=decision_ref,
legal_bases=(basis,),
@@ -85,29 +122,64 @@ class DecisionTests(unittest.TestCase):
def test_record_replay_revise_and_exact_history(self) -> None:
registry = SqlDecisionRegistry()
first = registry.record_decision(self.session, self.principal, decision=decision())
self.assertEqual(first, registry.record_decision(self.session, self.principal, decision=decision()))
temporal = TemporalRevision(revision="2", valid_from=NOW, recorded_at=NOW + timedelta(minutes=1), change_reason="Effect confirmed.")
revised = revise_formal_decision(first, expected_revision="1", temporal=temporal, state="effective")
registry.record_decision(self.session, self.principal, decision=revised, expected_revision="1")
current = registry.get_decision(self.session, self.principal, reference=reference("decision", "decision-1", "decisions", None))
historical = registry.get_decision(self.session, self.principal, reference=first.reference)
first = registry.record_decision(
self.session, self.principal, decision=decision()
)
self.assertEqual(
first,
registry.record_decision(self.session, self.principal, decision=decision()),
)
temporal = TemporalRevision(
revision="2",
valid_from=NOW,
recorded_at=NOW + timedelta(minutes=1),
change_reason="Effect confirmed.",
)
revised = revise_formal_decision(
first, expected_revision="1", temporal=temporal, state="effective"
)
registry.record_decision(
self.session, self.principal, decision=revised, expected_revision="1"
)
current = registry.get_decision(
self.session,
self.principal,
reference=reference("decision", "decision-1", "decisions", None),
)
historical = registry.get_decision(
self.session, self.principal, reference=first.reference
)
self.assertEqual("2", current.temporal.revision if current else None)
self.assertEqual("1", historical.temporal.revision if historical else None)
def test_occ_and_tenant_isolation(self) -> None:
registry = SqlDecisionRegistry()
first = registry.record_decision(self.session, self.principal, decision=decision())
temporal = TemporalRevision(revision="2", valid_from=NOW, recorded_at=NOW + timedelta(minutes=1), change_reason="Effect confirmed.")
revised = revise_formal_decision(first, expected_revision="1", temporal=temporal, state="effective")
first = registry.record_decision(
self.session, self.principal, decision=decision()
)
temporal = TemporalRevision(
revision="2",
valid_from=NOW,
recorded_at=NOW + timedelta(minutes=1),
change_reason="Effect confirmed.",
)
revised = revise_formal_decision(
first, expected_revision="1", temporal=temporal, state="effective"
)
with self.assertRaisesRegex(DecisionStoreError, "stale"):
registry.record_decision(self.session, self.principal, decision=revised, expected_revision="0")
registry.record_decision(
self.session, self.principal, decision=revised, expected_revision="0"
)
with self.assertRaisesRegex(Exception, "same-tenant"):
registry.get_decision(self.session, Principal("tenant-2"), reference=first.reference)
registry.get_decision(
self.session, Principal("tenant-2"), reference=first.reference
)
def test_temporal_context_selects_valid_and_recorded_state(self) -> None:
registry = SqlDecisionRegistry()
first = registry.record_decision(self.session, self.principal, decision=decision())
first = registry.record_decision(
self.session, self.principal, decision=decision()
)
temporal = TemporalRevision(
revision="2",
valid_from=NOW,
@@ -161,6 +233,39 @@ class DecisionTests(unittest.TestCase):
finally:
reset_temporal_data_context(token)
def test_record_source_requires_protected_read_and_hashes_exact_revision(
self,
) -> None:
SqlDecisionRegistry().record_decision(
self.session,
self.principal,
decision=decision(),
)
locator = RecordSourceLocator(
tenant_id="tenant-1",
source_module="decisions",
resource_type="decision_revision",
resource_id="decision-1",
source_revision="1",
)
result = DecisionsRecordSource().resolve(
self.session,
self.principal,
locator=locator,
purpose="file formal outcome",
)
self.assertEqual(64, len(result.content_sha256 or ""))
self.assertEqual("decided", result.metadata["state"])
self.assertTrue(result.metadata["protected_snapshot"])
with self.assertRaisesRegex(RecordContractError, "Protected Decision"):
DecisionsRecordSource().resolve(
self.session,
Principal(scopes=("decisions:decision:read",)),
locator=locator,
purpose="file formal outcome",
)
if __name__ == "__main__":
unittest.main()
tests/test_search_source.py
+133
View File
@@ -0,0 +1,133 @@
from __future__ import annotations
from datetime import UTC, datetime
from types import SimpleNamespace
import unittest
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
from govoplan_core.auth import ApiPrincipal
from govoplan_core.core.access import PrincipalRef
from govoplan_core.core.events import EventObjectRef, EventTenantRef, PlatformEvent
from govoplan_core.core.search import (
SearchAuthorizationRequest,
SearchBackfillRequest,
SearchResourceReference,
)
from govoplan_decisions.backend.db.models import FormalDecisionRevision
from govoplan_decisions.backend.search_source import DecisionsSearchSource, PROVIDER_ID
NOW = datetime(2026, 8, 6, 11, 0, tzinfo=UTC)
class DecisionsSearchSourceTests(unittest.TestCase):
def setUp(self) -> None:
self.engine = create_engine("sqlite+pysqlite:///:memory:")
FormalDecisionRevision.__table__.create(self.engine)
self.session = Session(self.engine)
self.session.add(
FormalDecisionRevision(
tenant_id="tenant-1",
decision_id="decision-1",
revision="1",
decision_type="permit",
state="decided",
valid_from=NOW,
recorded_at=NOW,
payload={
"operative_result": "PROTECTED-RESULT",
"reasoning": "PROTECTED-REASONING",
"conditions": ["PROTECTED-CONDITION"],
"subject_refs": [
{"kind": "party", "owner_module": "parties", "object_id": "applicant-1"}
],
"legal_bases": [
{"authority": "Example", "reference": "law:3", "version": "2026"}
],
"authority_context": {
"case_ref": {"object_id": "case-1"}
},
"delivery_refs": ["postbox:delivery-1"],
"remedy_refs": ["remedy:appeal"],
"review_refs": [],
},
created_by="account-1",
)
)
self.session.commit()
self.source = DecisionsSearchSource()
def tearDown(self) -> None:
self.session.close()
self.engine.dispose()
def test_search_projection_excludes_protected_decision_content(self) -> None:
page = self.source.backfill(
self.session,
request=SearchBackfillRequest(
tenant_id="tenant-1",
provider_id=PROVIDER_ID,
resource_type="formal_decision",
rebuild_id="rebuild-1",
),
)
document = page.documents[0]
serialized = repr(
(document.title, document.summary, document.body, document.keywords, document.metadata)
)
self.assertNotIn("PROTECTED-", serialized)
self.assertEqual("/cases/case-1", document.url)
self.assertFalse(document.metadata["protected_content_indexed"])
reference = SearchResourceReference(
tenant_id="tenant-1",
module_id="decisions",
resource_type="formal_decision",
resource_id="decision-1",
)
request = SearchAuthorizationRequest(reference=reference, source_revision="1")
self.assertTrue(
self.source.authorize(
self.session,
_principal({"decisions:decision:read"}),
requests=(request,),
)[reference.key]
)
self.assertFalse(
self.source.authorize(
self.session,
_principal(set()),
requests=(request,),
)[reference.key]
)
changes = self.source.index_changes_for_event(
self.session,
event=PlatformEvent(
type="decisions.decision.recorded",
module_id="decisions",
tenant=EventTenantRef(id="tenant-1"),
resource=EventObjectRef(type="formal_decision", id="decision-1"),
),
delivery_key="delivery-1",
)
self.assertEqual("upsert", changes[0].kind)
def _principal(scopes: set[str]) -> ApiPrincipal:
return ApiPrincipal(
principal=PrincipalRef(
account_id="account-1",
membership_id="membership-1",
tenant_id="tenant-1",
scopes=frozenset(scopes),
),
account=SimpleNamespace(id="account-1"),
user=SimpleNamespace(id="membership-1"),
)
if __name__ == "__main__":
unittest.main()