test(gameplay): lock lobby host-transition delegation

lobby/tests.py

@@ -29,6 +29,27 @@ User = get_user_model()
 
 
 class LobbyGameplayExtractionTests(TestCase):
+    def setUp(self):
+        self.host = User.objects.create_user(username="extract_host", password="secret123")
+        self.client.login(username="extract_host", password="secret123")
+        self.session = GameSession.objects.create(
+            host=self.host,
+            code="EXTR42",
+            status=GameSession.Status.SCOREBOARD,
+        )
+        self.category = Category.objects.create(name="Historie", slug="historie-extract", is_active=True)
+        self.round_config = RoundConfig.objects.create(
+            session=self.session,
+            number=1,
+            category=self.category,
+        )
+        self.question = Question.objects.create(
+            category=self.category,
+            prompt="Hvornår faldt muren?",
+            correct_answer="1989",
+            is_active=True,
+        )
+
     def test_lobby_views_use_extracted_gameplay_helpers(self):
         self.assertIs(lobby_views._get_current_round_question, gameplay_services.get_current_round_question)
         self.assertIs(lobby_views._select_round_question, gameplay_services.select_round_question)
@@ -43,6 +64,87 @@ class LobbyGameplayExtractionTests(TestCase):
         self.assertIs(lobby_views._build_finish_game_phase_event, gameplay_payloads.build_finish_game_phase_event)
         self.assertIs(lobby_views._build_finish_game_response, gameplay_payloads.build_finish_game_response)
 
+    @patch("lobby.views.sync_broadcast_phase_event")
+    @patch("lobby.views._build_start_next_round_response", return_value={"ok": True})
+    @patch("lobby.views._build_start_next_round_phase_event")
+    @patch("lobby.views._start_next_round")
+    def test_start_next_round_view_delegates_transition_to_service(
+        self,
+        mock_start_next_round,
+        mock_build_phase_event,
+        mock_build_response,
+        mock_sync_broadcast_phase_event,
+    ):
+        next_round_config = RoundConfig.objects.create(
+            session=self.session,
+            number=2,
+            category=self.category,
+            started_from_scoreboard=True,
+        )
+        round_question = RoundQuestion.objects.create(
+            session=self.session,
+            round_number=2,
+            question=self.question,
+            correct_answer=self.question.correct_answer,
+        )
+        transition = gameplay_services.RoundTransitionResult(
+            session=self.session,
+            round_config=next_round_config,
+            round_question=round_question,
+            should_broadcast=True,
+        )
+        mock_start_next_round.return_value = transition
+        mock_build_phase_event.return_value = {
+            "name": "phase.lie_started",
+            "payload": {"round_question_id": round_question.id},
+        }
+
+        response = self.client.post(reverse("lobby:start_next_round", kwargs={"code": self.session.code}))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"ok": True})
+        mock_start_next_round.assert_called_once_with(self.session)
+        mock_build_phase_event.assert_called_once_with(self.session, next_round_config, round_question)
+        mock_build_response.assert_called_once_with(self.session, next_round_config, round_question)
+        mock_sync_broadcast_phase_event.assert_called_once_with(
+            self.session.code,
+            "phase.lie_started",
+            {"round_question_id": round_question.id},
+        )
+
+    @patch("lobby.views.sync_broadcast_phase_event")
+    @patch("lobby.views._build_finish_game_response", return_value={"ok": True})
+    @patch("lobby.views._build_finish_game_phase_event")
+    @patch("lobby.views._finish_game")
+    def test_finish_game_view_delegates_transition_to_service(
+        self,
+        mock_finish_game,
+        mock_build_phase_event,
+        mock_build_response,
+        mock_sync_broadcast_phase_event,
+    ):
+        finished_session = GameSession.objects.get(pk=self.session.pk)
+        finished_session.status = GameSession.Status.FINISHED
+        transition = gameplay_services.FinishGameResult(session=finished_session, should_broadcast=True)
+        mock_finish_game.return_value = transition
+        mock_build_phase_event.return_value = {
+            "name": "phase.game_over",
+            "payload": {"winner": None, "leaderboard": []},
+        }
+
+        response = self.client.post(reverse("lobby:finish_game", kwargs={"code": self.session.code}))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"ok": True})
+        mock_finish_game.assert_called_once_with(self.session)
+        mock_build_phase_event.assert_called_once_with(finished_session)
+        mock_build_response.assert_called_once_with(finished_session)
+        mock_sync_broadcast_phase_event.assert_called_once_with(
+            self.session.code,
+            "phase.game_over",
+            {"winner": None, "leaderboard": []},
+        )
+
 
 class LobbyFlowTests(TestCase):
     def setUp(self):