releases/ClaudeDo
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 25 Wiki Activity

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

Browse Source 
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.
This commit is contained in:
mika kuns
2026-08-21 11:47:24 +02:00
parent ce98f65ca5
commit 7f337b36c7
20 changed files with 806 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ClaudeDo.Ui.Tests/ViewModels/TasksIslandErrorFeedbackTests.cs
+132
View File
@@ -57,6 +57,10 @@ public class TasksIslandErrorFeedbackTests : IDisposable
public Exception? ThrowOnCancelTask;
public Exception? ThrowOnRejectToQueue;
public Exception? ThrowOnRejectToIdle;
public Exception? ThrowOnSetTaskDone;
public Exception? ThrowOnUnsetTaskDone;
public Exception? ThrowOnDequeueTask;
public readonly List<string> DequeuedTaskIds = new();
public override Task<BaseDirtyWarningDto?> SetTaskStatusAsync(string taskId, TaskStatus status)
{
@@ -81,6 +85,25 @@ public class TasksIslandErrorFeedbackTests : IDisposable
if (ThrowOnRejectToIdle is not null) throw ThrowOnRejectToIdle;
return Task.CompletedTask;
}
public override Task SetTaskDoneAsync(string taskId)
{
if (ThrowOnSetTaskDone is not null) throw ThrowOnSetTaskDone;
return Task.CompletedTask;
}
public override Task UnsetTaskDoneAsync(string taskId)
{
if (ThrowOnUnsetTaskDone is not null) throw ThrowOnUnsetTaskDone;
return Task.CompletedTask;
}
public override Task DequeueTaskAsync(string taskId)
{
DequeuedTaskIds.Add(taskId);
if (ThrowOnDequeueTask is not null) throw ThrowOnDequeueTask;
return Task.CompletedTask;
}
}
[Fact]
@@ -146,4 +169,113 @@ public class TasksIslandErrorFeedbackTests : IDisposable
Assert.NotNull(reportedError);
Assert.Contains("reject-to-idle offline", reportedError);
}
[Fact]
public async Task ToggleDone_MarkDone_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
{
var worker = new ThrowingWorkerClient { ThrowOnSetTaskDone = new Exception("mark done offline") };
var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
var row = new TaskRowViewModel { Id = "task-toggle-done-1", Status = TaskStatus.Idle, Done = false };
await vm.ToggleDoneCommand.ExecuteAsync(row);
Assert.NotNull(reportedError);
Assert.Contains("mark done offline", reportedError);
Assert.False(row.Done);
Assert.Equal(TaskStatus.Idle, row.Status);
}
[Fact]
public async Task ToggleDone_Untoggle_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
{
var worker = new ThrowingWorkerClient { ThrowOnUnsetTaskDone = new Exception("unmark done offline") };
var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
var row = new TaskRowViewModel { Id = "task-toggle-done-2", Status = TaskStatus.Done, Done = true };
await vm.ToggleDoneCommand.ExecuteAsync(row);
Assert.NotNull(reportedError);
Assert.Contains("unmark done offline", reportedError);
Assert.True(row.Done);
Assert.Equal(TaskStatus.Done, row.Status);
}
[Fact]
public async Task ToggleDone_MarkDone_WhenWorkerSucceeds_UpdatesRow_NoError()
{
var worker = new ThrowingWorkerClient();
var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
var row = new TaskRowViewModel { Id = "task-toggle-done-3", Status = TaskStatus.Idle, Done = false };
await vm.ToggleDoneCommand.ExecuteAsync(row);
Assert.Null(reportedError);
Assert.True(row.Done);
Assert.Equal(TaskStatus.Done, row.Status);
}
[Fact]
public async Task RemoveFromQueue_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
{
var worker = new ThrowingWorkerClient { ThrowOnDequeueTask = new Exception("dequeue offline") };
var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
var row = new TaskRowViewModel { Id = "task-dequeue-1", Status = TaskStatus.Queued };
await vm.RemoveFromQueueCommand.ExecuteAsync(row);
Assert.NotNull(reportedError);
Assert.Contains("dequeue offline", reportedError);
Assert.Equal(TaskStatus.Queued, row.Status);
}
[Fact]
public async Task RemoveFromQueue_CascadesToQueuedChildren_ViaGuardedHubCall()
{
var listId = Guid.NewGuid().ToString();
var parentId = Guid.NewGuid().ToString();
var childId = Guid.NewGuid().ToString();
await using (var db = NewContext())
{
db.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
db.Tasks.Add(new TaskEntity
{
Id = parentId, ListId = listId, Title = "parent", Status = TaskStatus.Queued,
Number = 1, CreatedAt = DateTime.UtcNow,
});
db.Tasks.Add(new TaskEntity
{
Id = childId, ListId = listId, Title = "child", Status = TaskStatus.Queued,
Number = 2, ParentTaskId = parentId, BlockedByTaskId = parentId, CreatedAt = DateTime.UtcNow,
});
await db.SaveChangesAsync();
}
var worker = new ThrowingWorkerClient();
var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
var parentRow = new TaskRowViewModel { Id = parentId, Status = TaskStatus.Queued, HasQueuedSubtasks = true };
var childRow = new TaskRowViewModel { Id = childId, ParentTaskId = parentId, Status = TaskStatus.Queued, BlockedByTaskId = parentId };
vm.Items.Add(parentRow);
vm.Items.Add(childRow);
await vm.RemoveFromQueueCommand.ExecuteAsync(parentRow);
Assert.Contains(childId, worker.DequeuedTaskIds);
Assert.Contains(parentId, worker.DequeuedTaskIds);
Assert.Equal(TaskStatus.Idle, childRow.Status);
Assert.Null(childRow.BlockedByTaskId);
Assert.Equal(TaskStatus.Idle, parentRow.Status);
Assert.False(parentRow.HasQueuedSubtasks);
}
}