fix(worker): route done-toggle and dequeue through guarded TaskStateService transitions

The task-list done toggle (both islands) and RemoveFromQueue wrote TaskEntity.Status directly via EF, bypassing TaskStateService: no TaskUpdated broadcast, no guard against a concurrent picker claim (lost update), and no status-based filter. Added guarded MarkDoneAsync/UnmarkDoneAsync/DequeueToIdleAsync transitions plus matching hub methods (SetTaskDone/UnsetTaskDone/DequeueTask) and IWorkerClient wrappers; the three UI call sites now route through the hub with optimistic-then-revert row updates and ErrorReported on failure. RemoveFromQueueAsync dequeues each queued child individually through the same guarded path instead of cascading via a raw EF update. Also closes two hub guard gaps: UpdateListConfig's delete branch now preserves a list's SerializeOnFileOverlap flag instead of dropping it, and SubmitTaskForReview's Idle/Failed status gate now runs before either mutation branch so a Done/Cancelled task can't get committed or stamped and then rejected.
2026-08-21 11:47:24 +02:00
parent ce98f65ca5
commit 7f337b36c7
20 changed files with 806 additions and 49 deletions
@@ -0,0 +1,160 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Microsoft.AspNetCore.SignalR;
+using Xunit;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Worker.Tests.Hub;
+
+/// Covers the guarded "manual done toggle" (SetTaskDone/UnsetTaskDone) and "remove from queue"
+/// (DequeueTask) hub methods added to replace the UI's raw EF writes -- each checks the expected
+/// starting status server-side so a concurrent picker claim can't be silently overwritten.
+public sealed class TaskDoneDequeueHubTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+    private readonly ClaudeDoDbContext _ctx;
+    private readonly TaskRepository _tasks;
+    private readonly ListRepository _lists;
+    private readonly RecordingClientProxy _proxy = new();
+
+    public TaskDoneDequeueHubTests()
+    {
+        _ctx = _db.CreateContext();
+        _tasks = new TaskRepository(_ctx);
+        _lists = new ListRepository(_ctx);
+    }
+
+    public void Dispose()
+    {
+        _ctx.Dispose();
+        _db.Dispose();
+    }
+
+    private WorkerHub CreateHub()
+    {
+        var factory = _db.CreateFactory();
+        var built = TaskStateServiceBuilder.Build(factory);
+        var hub = new WorkerHub(
+            null!, null!, null!, null!, null!, factory, null!, null!, null!,
+            null!, null!, null!, null!, null!, null!, null!, built.State, null!, null!,
+            null!, new ClaudeDo.Worker.Online.OnlineInboxConfig(), new ClaudeDo.Worker.Online.OnlineTokenStore(),
+            new ClaudeDo.Worker.Runner.PendingQuestionRegistry(), null!);
+        hub.Clients = new FakeHubCallerClients(_proxy);
+        hub.Context = new FakeHubCallerContext();
+        return hub;
+    }
+
+    private async Task<string> SeedListAsync()
+    {
+        var listId = Guid.NewGuid().ToString();
+        await _lists.AddAsync(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
+        return listId;
+    }
+
+    private async Task<TaskEntity> SeedTaskAsync(
+        string listId, TaskStatus status, string? blockedByTaskId = null, string title = "T")
+    {
+        var task = new TaskEntity
+        {
+            Id = Guid.NewGuid().ToString(),
+            ListId = listId,
+            Title = title,
+            Status = status,
+            BlockedByTaskId = blockedByTaskId,
+            CreatedAt = DateTime.UtcNow,
+        };
+        await _tasks.AddAsync(task);
+        return task;
+    }
+
+    // ── SetTaskDone ──
+
+    [Fact]
+    public async Task SetTaskDone_FromIdle_TransitionsToDone()
+    {
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, TaskStatus.Idle);
+
+        var hub = CreateHub();
+        await hub.SetTaskDone(task.Id);
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Done, reloaded!.Status);
+    }
+
+    [Fact]
+    public async Task SetTaskDone_FromRunning_Throws_AndLeavesStatusUnchanged()
+    {
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, TaskStatus.Running);
+
+        var hub = CreateHub();
+        await Assert.ThrowsAsync<HubException>(() => hub.SetTaskDone(task.Id));
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Running, reloaded!.Status);
+    }
+
+    // ── UnsetTaskDone ──
+
+    [Fact]
+    public async Task UnsetTaskDone_FromDone_TransitionsToIdle()
+    {
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, TaskStatus.Done);
+
+        var hub = CreateHub();
+        await hub.UnsetTaskDone(task.Id);
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Idle, reloaded!.Status);
+    }
+
+    [Fact]
+    public async Task UnsetTaskDone_FromRunning_Throws_AndLeavesStatusUnchanged()
+    {
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, TaskStatus.Running);
+
+        var hub = CreateHub();
+        await Assert.ThrowsAsync<HubException>(() => hub.UnsetTaskDone(task.Id));
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Running, reloaded!.Status);
+    }
+
+    // ── DequeueTask ──
+
+    [Fact]
+    public async Task DequeueTask_FromQueued_TransitionsToIdle_AndClearsBlockedByTaskId()
+    {
+        var listId = await SeedListAsync();
+        var pred = await SeedTaskAsync(listId, TaskStatus.Queued);
+        var task = await SeedTaskAsync(listId, TaskStatus.Queued, blockedByTaskId: pred.Id);
+
+        var hub = CreateHub();
+        await hub.DequeueTask(task.Id);
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Idle, reloaded!.Status);
+        Assert.Null(reloaded.BlockedByTaskId);
+    }
+
+    [Fact]
+    public async Task DequeueTask_FromRunning_Throws_AndLeavesStatusUnchanged()
+    {
+        // Simulates the picker having already claimed the task between the UI reading its
+        // row and the dequeue call landing -- the DB status must not be clobbered.
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, TaskStatus.Running);
+
+        var hub = CreateHub();
+        await Assert.ThrowsAsync<HubException>(() => hub.DequeueTask(task.Id));
+
+        var reloaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Running, reloaded!.Status);
+    }
+}