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/StubWorkerClient.cs
+3
View File
@@ -98,6 +98,9 @@ public abstract class StubWorkerClient : IWorkerClient
public virtual Task UpdateSessionSkillAsync(string sourceUrl) => Task.CompletedTask;
public virtual Task RemoveSessionSkillAsync(string sourceUrl) => Task.CompletedTask;
public virtual Task<BaseDirtyWarningDto?> SetTaskStatusAsync(string taskId, TaskStatus status) => Task.FromResult<BaseDirtyWarningDto?>(null);
public virtual Task SetTaskDoneAsync(string taskId) => Task.CompletedTask;
public virtual Task UnsetTaskDoneAsync(string taskId) => Task.CompletedTask;
public virtual Task DequeueTaskAsync(string taskId) => Task.CompletedTask;
public virtual Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch) => Task.FromResult<MergeResultDto?>(null);
public virtual Task<MergePreviewDto?> PreviewMergeAsync(string taskId, string targetBranch) => Task.FromResult<MergePreviewDto?>(null);
public virtual Task<MergeResultDto> MergeTaskAsync(string taskId, string targetBranch, bool removeWorktree, string commitMessage) => Task.FromResult(new MergeResultDto("merged", System.Array.Empty<string>(), null));
tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandErrorFeedbackTests.cs
+70
View File
@@ -73,6 +73,8 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
public override bool IsConnected => Connected;
public Exception? ThrowOnCancelTask;
public Exception? ThrowOnSetTaskStatus;
public Exception? ThrowOnSetTaskDone;
public Exception? ThrowOnUnsetTaskDone;
public override Task CancelTaskAsync(string taskId)
{
@@ -85,6 +87,18 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
if (ThrowOnSetTaskStatus is not null) throw ThrowOnSetTaskStatus;
return Task.FromResult<BaseDirtyWarningDto?>(null);
}
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;
}
}
private DetailsIslandViewModel BuildVm(StubWorkerClient worker)
@@ -179,4 +193,60 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
Assert.NotNull(reportedError);
Assert.Contains("reset offline", reportedError);
}
[Fact]
public async Task ToggleDone_MarkDone_WhenWorkerThrows_ReportsError_AndRevertsTask()
{
var worker = new ThrowingWorkerClient { ThrowOnSetTaskDone = new Exception("mark done offline") };
var vm = BuildVm(worker);
vm.Bind(new TaskRowViewModel { Id = "task-toggle-done-throw", Status = TaskStatus.Idle, Done = false });
vm.Monitor.ApplyState(TaskStatus.Idle);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
await vm.ToggleDoneCommand.ExecuteAsync(null);
Assert.NotNull(reportedError);
Assert.Contains("mark done offline", reportedError);
Assert.False(vm.Task!.Done);
Assert.Equal(TaskStatus.Idle, vm.Task!.Status);
}
[Fact]
public async Task ToggleDone_Untoggle_WhenWorkerThrows_ReportsError_AndRevertsTask()
{
var worker = new ThrowingWorkerClient { ThrowOnUnsetTaskDone = new Exception("unmark done offline") };
var vm = BuildVm(worker);
vm.Bind(new TaskRowViewModel { Id = "task-untoggle-done-throw", Status = TaskStatus.Done, Done = true });
vm.Monitor.ApplyState(TaskStatus.Done);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
await vm.ToggleDoneCommand.ExecuteAsync(null);
Assert.NotNull(reportedError);
Assert.Contains("unmark done offline", reportedError);
Assert.True(vm.Task!.Done);
Assert.Equal(TaskStatus.Done, vm.Task!.Status);
}
[Fact]
public async Task ToggleDone_MarkDone_WhenWorkerSucceeds_UpdatesTask_NoError()
{
var worker = new ThrowingWorkerClient();
var vm = BuildVm(worker);
vm.Bind(new TaskRowViewModel { Id = "task-toggle-done-ok", Status = TaskStatus.Idle, Done = false });
vm.Monitor.ApplyState(TaskStatus.Idle);
string? reportedError = null;
vm.ErrorReported += msg => reportedError = msg;
await vm.ToggleDoneCommand.ExecuteAsync(null);
Assert.Null(reportedError);
Assert.True(vm.Task!.Done);
Assert.Equal(TaskStatus.Done, vm.Task!.Status);
}
}
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);
}
}
tests/ClaudeDo.Ui.Tests/ViewModels/TasksIslandRemoveFromQueueTests.cs
+26 -2
View File
@@ -1,5 +1,6 @@
using ClaudeDo.Data;
using ClaudeDo.Data.Models;
using ClaudeDo.Ui.Services;
using ClaudeDo.Ui.ViewModels.Islands;
using Microsoft.EntityFrameworkCore;
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
@@ -39,8 +40,31 @@ public class TasksIslandRemoveFromQueueTests : IDisposable
public ClaudeDoDbContext CreateDbContext() => _create();
}
private TasksIslandViewModel BuildViewModel() =>
new(new TestDbFactory(NewContext), worker: null);
// RemoveFromQueueAsync now routes the dequeue through IWorkerClient.DequeueTaskAsync (the
// guarded TaskStateService transition) instead of writing the DB directly. This fake performs
// the same write the real hub would, against the same DB, so these tests still exercise the
// ViewModel's cascade/read logic without needing a live worker.
private sealed class DequeuingWorkerClient : StubWorkerClient
{
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
public DequeuingWorkerClient(IDbContextFactory<ClaudeDoDbContext> dbFactory) => _dbFactory = dbFactory;
public override async Task DequeueTaskAsync(string taskId)
{
await using var db = await _dbFactory.CreateDbContextAsync();
var entity = await db.Tasks.FirstOrDefaultAsync(t => t.Id == taskId && t.Status == TaskStatus.Queued);
if (entity is null) return;
entity.Status = TaskStatus.Idle;
entity.BlockedByTaskId = null;
await db.SaveChangesAsync();
}
}
private TasksIslandViewModel BuildViewModel()
{
var factory = new TestDbFactory(NewContext);
return new(factory, worker: new DequeuingWorkerClient(factory));
}
private async Task SeedParentWithChainAsync(
string parentId,