Add poll-backed scheduling backend

tests/test_manifest.py

@@ -18,6 +18,8 @@ class SchedulingManifestTests(unittest.TestCase):
         self.assertFalse(manifest.required_capabilities)
         self.assertIn("auth.principalResolver", manifest.optional_capabilities)
         self.assertIn("evaluation", manifest.optional_dependencies)
+        self.assertIsNotNone(manifest.route_factory)
+        self.assertIsNotNone(manifest.migration_spec)
         self.assertIn("poll.availability_matrix", {interface.name for interface in manifest.requires_interfaces})
         self.assertIn("poll.workflow_context", {interface.name for interface in manifest.requires_interfaces})
         self.assertIn("poll.signed_participation", {interface.name for interface in manifest.requires_interfaces})

tests/test_service.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import unittest
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from govoplan_core.db.base import Base
+from govoplan_poll.backend.db.models import Poll, PollInvitation, PollOption, PollResponse
+from govoplan_poll.backend.schemas import PollAnswerInput, PollSubmitResponseRequest
+from govoplan_poll.backend.service import get_poll, submit_poll_response_with_token
+from govoplan_scheduling.backend.db.models import SchedulingCandidateSlot, SchedulingParticipant, SchedulingRequest
+from govoplan_scheduling.backend.schemas import (
+    SchedulingCalendarPreferences,
+    SchedulingCandidateSlotInput,
+    SchedulingDecisionRequest,
+    SchedulingParticipantInput,
+    SchedulingRequestCreateRequest,
+)
+from govoplan_scheduling.backend.service import (
+    SchedulingError,
+    close_scheduling_request,
+    create_scheduling_request,
+    decide_scheduling_request,
+    scheduling_request_summary,
+)
+
+
+class SchedulingServiceTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.engine = create_engine("sqlite:///:memory:")
+        Base.metadata.create_all(
+            self.engine,
+            tables=[
+                Poll.__table__,
+                PollOption.__table__,
+                PollResponse.__table__,
+                PollInvitation.__table__,
+                SchedulingRequest.__table__,
+                SchedulingCandidateSlot.__table__,
+                SchedulingParticipant.__table__,
+            ],
+        )
+        self.Session = sessionmaker(bind=self.engine)
+        self.session: Session = self.Session()
+
+    def tearDown(self) -> None:
+        self.session.close()
+        Base.metadata.drop_all(
+            self.engine,
+            tables=[
+                SchedulingParticipant.__table__,
+                SchedulingCandidateSlot.__table__,
+                SchedulingRequest.__table__,
+                PollInvitation.__table__,
+                PollResponse.__table__,
+                PollOption.__table__,
+                Poll.__table__,
+            ],
+        )
+        self.engine.dispose()
+
+    def _payload(self) -> SchedulingRequestCreateRequest:
+        start = datetime(2026, 7, 20, 9, tzinfo=timezone.utc)
+        return SchedulingRequestCreateRequest(
+            title="Steering group",
+            description="Find a slot",
+            location="Room 1",
+            timezone="Europe/Berlin",
+            status="collecting",
+            deadline_at=start + timedelta(days=3),
+            calendar=SchedulingCalendarPreferences(
+                enabled=True,
+                calendar_id="calendar-1",
+                freebusy_enabled=True,
+                create_event_on_decision=True,
+            ),
+            slots=[
+                SchedulingCandidateSlotInput(start_at=start, end_at=start + timedelta(hours=1), label="Monday 09:00"),
+                SchedulingCandidateSlotInput(start_at=start + timedelta(days=1), end_at=start + timedelta(days=1, hours=1), label="Tuesday 09:00"),
+            ],
+            participants=[
+                SchedulingParticipantInput(display_name="Alice", email="alice@example.test"),
+                SchedulingParticipantInput(display_name="Bob", email="bob@example.test", required=False),
+            ],
+        )
+
+    def test_create_request_creates_poll_slots_and_signed_invitations(self) -> None:
+        request, tokens = create_scheduling_request(
+            self.session,
+            tenant_id="tenant-1",
+            user_id="user-1",
+            payload=self._payload(),
+        )
+        poll = get_poll(self.session, tenant_id="tenant-1", poll_id=request.poll_id)
+
+        self.assertEqual(request.status, "collecting")
+        self.assertEqual(request.calendar_id, "calendar-1")
+        self.assertEqual(poll.kind, "availability")
+        self.assertEqual(poll.status, "open")
+        self.assertEqual(poll.context_module, "scheduling")
+        self.assertEqual(poll.context_resource_id, request.id)
+        self.assertEqual(len(request.slots), 2)
+        self.assertTrue(all(slot.poll_option_id for slot in request.slots))
+        self.assertEqual(len(tokens), 2)
+        self.assertTrue(all(participant.poll_invitation_id for participant in request.participants))
+
+    def test_signed_response_summary_and_decision_handoff(self) -> None:
+        request, tokens = create_scheduling_request(
+            self.session,
+            tenant_id="tenant-1",
+            user_id="user-1",
+            payload=self._payload(),
+        )
+        first_participant = request.participants[0]
+        first_slot = request.slots[0]
+        second_slot = request.slots[1]
+
+        submit_poll_response_with_token(
+            self.session,
+            token=tokens[first_participant.id],
+            payload=PollSubmitResponseRequest(
+                answers=[
+                    PollAnswerInput(option_id=first_slot.poll_option_id, value="available"),
+                    PollAnswerInput(option_id=second_slot.poll_option_id, value="maybe"),
+                ]
+            ),
+        )
+        summary = scheduling_request_summary(self.session, tenant_id="tenant-1", request_id=request.id)
+
+        self.assertEqual(summary["response_count"], 1)
+        self.assertEqual(first_participant.status, "responded")
+        self.assertIsNotNone(first_participant.responded_at)
+        values = {result["option_id"]: result["values"] for result in summary["option_results"]}
+        self.assertEqual(values[first_slot.poll_option_id]["available"], 1)
+        self.assertEqual(values[second_slot.poll_option_id]["maybe"], 1)
+
+        close_scheduling_request(self.session, tenant_id="tenant-1", request_id=request.id)
+        decided = decide_scheduling_request(
+            self.session,
+            tenant_id="tenant-1",
+            request_id=request.id,
+            payload=SchedulingDecisionRequest(slot_id=first_slot.id, handoff_to_calendar=True),
+        )
+        poll = get_poll(self.session, tenant_id="tenant-1", poll_id=request.poll_id)
+
+        self.assertEqual(decided.status, "handed_off")
+        self.assertEqual(decided.selected_slot_id, first_slot.id)
+        self.assertEqual(decided.metadata_["calendar_handoff"]["status"], "pending")
+        self.assertEqual(poll.status, "decided")
+        self.assertEqual(poll.workflow_state, "handed_off")
+
+    def test_external_participants_can_be_rejected(self) -> None:
+        payload = self._payload().model_copy(update={"allow_external_participants": False})
+
+        with self.assertRaisesRegex(SchedulingError, "External participants are not allowed"):
+            create_scheduling_request(
+                self.session,
+                tenant_id="tenant-1",
+                user_id="user-1",
+                payload=payload,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()