fix(kanban): address PR correctness and CI regressions (#1137)

app/src/test/java/com/m57/hermescontrol/ui/kanban/KanbanModelOverrideTest.kt

@@ -63,4 +63,20 @@ class KanbanModelOverrideTest {
         assertEquals("low", patch.reasoningEffort)
         assertFalse(patch.clearReasoningEffort)
     }
+
+    @Test
+    fun testFullReasoningScaleAndCapabilities() {
+        assertEquals(
+            listOf("none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"),
+            supportedKanbanReasoningEfforts(supportsReasoning = true, canDisableReasoning = true),
+        )
+        assertEquals(
+            listOf("minimal", "low", "medium", "high", "xhigh", "max", "ultra"),
+            supportedKanbanReasoningEfforts(supportsReasoning = true, canDisableReasoning = false),
+        )
+        assertEquals(
+            listOf(""),
+            supportedKanbanReasoningEfforts(supportsReasoning = false, canDisableReasoning = false),
+        )
+    }
 }

app/src/test/java/com/m57/hermescontrol/ui/kanban/KanbanMutationTest.kt

@@ -374,6 +374,40 @@ class KanbanMutationTest {
             assertEquals("Board created: Sprint 2", vm.uiState.value.toastMessage)
         }
 
+    @Test
+    fun testBulkAssignUsesReclaimAndRetainsOnlyFailures() =
+        runTest(testDispatcher) {
+            val board = KanbanBoard(id = "dev", name = "Dev")
+            coEvery { mockRepository.getBoard("dev") } returns
+                NetworkResult.Success(KanbanBoardResponse(columns = listOf(KanbanColumn("todo", emptyList()))))
+            coEvery { mockRepository.bulkTasks("dev", any()) } returns
+                NetworkResult.Success(
+                    BulkTasksResponse(
+                        results =
+                            listOf(
+                                BulkTaskResult("t_1", ok = true),
+                                BulkTaskResult("t_2", ok = false, error = "locked"),
+                            ),
+                    ),
+                )
+
+            val vm = createViewModel()
+            vm.selectBoard(board)
+            testDispatcher.scheduler.advanceUntilIdle()
+
+            var failedIds = emptySet<String>()
+            vm.bulkAssign(listOf("t_1", "t_2"), assignee = null) { failedIds = it }
+            testDispatcher.scheduler.advanceUntilIdle()
+
+            coVerify {
+                mockRepository.bulkTasks(
+                    "dev",
+                    match { it.ids == listOf("t_1", "t_2") && it.assignee == "" && it.reclaimFirst },
+                )
+            }
+            assertEquals(setOf("t_2"), failedIds)
+        }
+
     @Test
     fun testRenameBoardSuccess() =
         runTest(testDispatcher) {
@@ -408,11 +442,13 @@ class KanbanMutationTest {
                 )
 
             val vm = createViewModel()
+            preferences.setSelectedBoard("http://127.0.0.1:9119", "old-board")
             vm.deleteBoard("old-board")
             testDispatcher.scheduler.advanceUntilIdle()
 
             coVerify { mockRepository.deleteBoard("old-board", delete = false) }
             assertEquals("Board archived", vm.uiState.value.toastMessage)
+            assertEquals(null, preferences.getSelectedBoard("http://127.0.0.1:9119"))
         }
 
     @Test

app/src/test/java/com/m57/hermescontrol/ui/kanban/KanbanTaskViewModelTest.kt

@@ -15,6 +15,7 @@ import io.mockk.mockk
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
@@ -31,10 +32,11 @@ class KanbanTaskViewModelTest {
     private val mockRepository = mockk<KanbanRepository>(relaxed = true)
     private val mockEventsClient = mockk<KanbanEventsClient>(relaxed = true)
 
-    private fun createViewModel(): KanbanTaskViewModel =
+    private fun createViewModel(enableFallbackPolling: Boolean = false): KanbanTaskViewModel =
         KanbanTaskViewModel(
             repository = mockRepository,
             eventsClientProvider = { mockEventsClient },
+            enableFallbackPolling = enableFallbackPolling,
         )
 
     @Before
@@ -285,4 +287,38 @@ class KanbanTaskViewModelTest {
             assertTrue(deleted)
             assertEquals("Task deleted", vm.uiState.value.toastMessage)
         }
+
+    @Test
+    fun testFallbackPollingReloadsTaskWithoutEvents() =
+        runTest(testDispatcher) {
+            val first = KanbanTaskFull(id = "t_1", title = "Before", status = "todo")
+            val second = KanbanTaskFull(id = "t_1", title = "After", status = "todo")
+            coEvery { mockRepository.getTask("t_1", "dev") } returnsMany
+                listOf(
+                    NetworkResult.Success(KanbanTaskDetailResponse(task = first)),
+                    NetworkResult.Success(KanbanTaskDetailResponse(task = second)),
+                )
+
+            val vm = createViewModel(enableFallbackPolling = true)
+            vm.loadTask("dev", "t_1")
+            testDispatcher.scheduler.runCurrent()
+            assertEquals(
+                "Before",
+                vm.uiState.value.detail
+                    ?.task
+                    ?.title,
+            )
+
+            testDispatcher.scheduler.advanceTimeBy(30_000L)
+            testDispatcher.scheduler.runCurrent()
+
+            assertEquals(
+                "After",
+                vm.uiState.value.detail
+                    ?.task
+                    ?.title,
+            )
+            coVerify(exactly = 2) { mockRepository.getTask("t_1", "dev") }
+            vm.onCleared()
+        }
 }