Add governed Dataflow audience outputs

2026-07-31 21:00:02 +02:00
parent 8724591bf9
commit cef2ba9482
12 changed files with 1226 additions and 6 deletions
@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import unittest
+
+from govoplan_core.auth import ApiPrincipal
+from govoplan_core.core.access import PrincipalRef
+from govoplan_core.core.dataflows import DataflowDatasetRequest, DataflowRunConflictError
+from govoplan_core.db.base import Base
+from govoplan_core.db.session import configure_database, reset_database
+from govoplan_dataflow.backend.dataset_output import SqlDataflowDatasetOutputProvider
+from govoplan_dataflow.backend.db.models import DataflowPipeline, DataflowPipelineRevision
+from govoplan_dataflow.backend.schemas import PipelineGraph
+from govoplan_dataflow.backend.service import definition_hash
+
+
+def principal(tenant_id: str = "tenant-1") -> ApiPrincipal:
+    return ApiPrincipal(
+        principal=PrincipalRef(
+            account_id="account-1",
+            membership_id="membership-1",
+            tenant_id=tenant_id,
+            scopes=frozenset({"dataflow:pipeline:read", "dataflow:pipeline:run"}),
+        ),
+        account=object(),
+        user=object(),
+    )
+
+
+class DataflowDatasetOutputTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.database = configure_database("sqlite:///:memory:")
+        Base.metadata.create_all(
+            self.database.engine,
+            tables=[DataflowPipeline.__table__, DataflowPipelineRevision.__table__],
+        )
+
+    def tearDown(self) -> None:
+        reset_database(dispose=True)
+
+    def test_pinned_revision_executes_through_typed_registry(self) -> None:
+        graph = PipelineGraph.model_validate(
+            {
+                "nodes": [
+                    {
+                        "id": "source",
+                        "type": "source.inline",
+                        "label": "Source",
+                        "position": {"x": 0, "y": 0},
+                        "config": {
+                            "source_name": "audience",
+                            "rows": [
+                                {"recipient_key": "one", "email": "one@example.test"},
+                                {"recipient_key": "two", "email": "two@example.test"},
+                            ]
+                        },
+                    },
+                    {
+                        "id": "output",
+                        "type": "output",
+                        "label": "Output",
+                        "position": {"x": 200, "y": 0},
+                        "config": {},
+                    },
+                ],
+                "edges": [{"id": "edge-1", "source": "source", "target": "output"}],
+            }
+        )
+        content_hash = definition_hash(graph, None)
+        with self.database.session() as session:
+            pipeline = DataflowPipeline(
+                id="pipeline-1",
+                tenant_id="tenant-1",
+                scope_type="tenant",
+                scope_id="tenant-1",
+                definition_kind="flow",
+                name="Audience",
+                status="active",
+                current_revision=1,
+                allow_run=True,
+                metadata_={},
+            )
+            revision = DataflowPipelineRevision(
+                id="revision-1",
+                tenant_id="tenant-1",
+                pipeline_id=pipeline.id,
+                revision=1,
+                graph=graph.model_dump(mode="json"),
+                sql_text=None,
+                editor_mode="graph",
+                content_hash=content_hash,
+            )
+            session.add_all((pipeline, revision))
+            session.flush()
+
+            provider = SqlDataflowDatasetOutputProvider()
+            descriptors = provider.list_outputs(session, principal())
+            result = provider.read_output(
+                session,
+                principal(),
+                request=DataflowDatasetRequest(
+                    pipeline_ref=pipeline.id,
+                    revision=1,
+                    expected_definition_hash=content_hash,
+                ),
+            )
+
+            self.assertEqual(1, len(descriptors))
+            self.assertEqual(2, result.total_rows)
+            self.assertEqual("one", result.rows[0]["recipient_key"])
+            self.assertEqual(64, len(result.output_hash))
+
+            replay = provider.read_output(
+                session,
+                principal(),
+                request=DataflowDatasetRequest(
+                    pipeline_ref=pipeline.id,
+                    revision=1,
+                    expected_definition_hash=content_hash,
+                    expected_source_fingerprints=result.source_fingerprints,
+                ),
+            )
+            self.assertEqual(result.output_hash, replay.output_hash)
+
+            with self.assertRaises(DataflowRunConflictError):
+                provider.read_output(
+                    session,
+                    principal(),
+                    request=DataflowDatasetRequest(
+                        pipeline_ref=pipeline.id,
+                        revision=1,
+                        expected_definition_hash="wrong",
+                    ),
+                )
+            with self.assertRaises(DataflowRunConflictError):
+                provider.read_output(
+                    session,
+                    principal(),
+                    request=DataflowDatasetRequest(
+                        pipeline_ref=pipeline.id,
+                        revision=1,
+                        expected_definition_hash=content_hash,
+                        expected_source_fingerprints=(
+                            {"node_id": "source", "fingerprint": "changed"},
+                        ),
+                    ),
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()