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.
This commit is contained in:
mika kuns
@@ -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));
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
using ClaudeDo.Data;
|
||||
using ClaudeDo.Data.Models;
|
||||
using ClaudeDo.Data.Repositories;
|
||||
using ClaudeDo.Worker.Hub;
|
||||
using ClaudeDo.Worker.Tests.Infrastructure;
|
||||
using Xunit;
|
||||
|
||||
namespace ClaudeDo.Worker.Tests.Hub;
|
||||
|
||||
/// UpdateListConfig's "all fields blank -> delete the row" branch used to delete unconditionally,
|
||||
/// silently dropping SerializeOnFileOverlap -- a flag with no UI/hub affordance of its own (set
|
||||
/// only via set_list_config or directly against ListConfigEntity).
|
||||
public sealed class ListConfigHubTests : IDisposable
|
||||
{
|
||||
private readonly DbFixture _db = new();
|
||||
|
||||
public void Dispose() => _db.Dispose();
|
||||
|
||||
private WorkerHub CreateHub()
|
||||
{
|
||||
var factory = _db.CreateFactory();
|
||||
var broadcaster = new HubBroadcaster(new CapturingHubContext());
|
||||
var hub = new WorkerHub(
|
||||
null!, null!, null!, null!, broadcaster, factory,
|
||||
null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!, null!,
|
||||
null!, new ClaudeDo.Worker.Online.OnlineInboxConfig(), new ClaudeDo.Worker.Online.OnlineTokenStore(),
|
||||
new ClaudeDo.Worker.Runner.PendingQuestionRegistry(), null!);
|
||||
hub.Clients = new FakeHubCallerClients(new RecordingClientProxy());
|
||||
hub.Context = new FakeHubCallerContext();
|
||||
return hub;
|
||||
}
|
||||
|
||||
// Each helper opens (and disposes) its own short-lived context/repository -- ListRepository's
|
||||
// GetConfigAsync doesn't AsNoTracking(), so reusing one long-lived instance across a hub call
|
||||
// that writes via a *different* context would return a stale, identity-mapped entity.
|
||||
|
||||
private async Task<string> SeedListAsync()
|
||||
{
|
||||
var listId = Guid.NewGuid().ToString();
|
||||
await using var ctx = _db.CreateContext();
|
||||
await new ListRepository(ctx).AddAsync(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
|
||||
return listId;
|
||||
}
|
||||
|
||||
private async Task SeedConfigAsync(string listId, string? model = null, bool serializeOnFileOverlap = false)
|
||||
{
|
||||
await using var ctx = _db.CreateContext();
|
||||
await new ListRepository(ctx).SetConfigAsync(new ListConfigEntity
|
||||
{
|
||||
ListId = listId, Model = model, SerializeOnFileOverlap = serializeOnFileOverlap,
|
||||
});
|
||||
}
|
||||
|
||||
private async Task<ListConfigEntity?> GetConfigAsync(string listId)
|
||||
{
|
||||
await using var ctx = _db.CreateContext();
|
||||
return await new ListRepository(ctx).GetConfigAsync(listId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateListConfig_AllBlank_NoUnrelatedSettings_DeletesRow()
|
||||
{
|
||||
var hub = CreateHub();
|
||||
var listId = await SeedListAsync();
|
||||
await SeedConfigAsync(listId, model: "opus");
|
||||
|
||||
await hub.UpdateListConfig(new UpdateListConfigDto(listId, null, null, null));
|
||||
|
||||
Assert.Null(await GetConfigAsync(listId));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateListConfig_AllBlank_WithSerializeOnFileOverlap_KeepsFlag_RowSurvives()
|
||||
{
|
||||
var hub = CreateHub();
|
||||
var listId = await SeedListAsync();
|
||||
await SeedConfigAsync(listId, model: "opus", serializeOnFileOverlap: true);
|
||||
|
||||
await hub.UpdateListConfig(new UpdateListConfigDto(listId, null, null, null));
|
||||
|
||||
var config = await GetConfigAsync(listId);
|
||||
Assert.NotNull(config);
|
||||
Assert.True(config!.SerializeOnFileOverlap);
|
||||
Assert.Null(config.Model);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateListConfig_WithModel_UpsertsNormally_PreservesSerializeOnFileOverlap()
|
||||
{
|
||||
var hub = CreateHub();
|
||||
var listId = await SeedListAsync();
|
||||
await SeedConfigAsync(listId, serializeOnFileOverlap: true);
|
||||
|
||||
await hub.UpdateListConfig(new UpdateListConfigDto(listId, "opus", null, null));
|
||||
|
||||
var config = await GetConfigAsync(listId);
|
||||
Assert.NotNull(config);
|
||||
Assert.Equal("opus", config!.Model);
|
||||
Assert.True(config.SerializeOnFileOverlap);
|
||||
}
|
||||
}
|
||||
@@ -214,6 +214,51 @@ public sealed class MergeHelperTaskHubTests : IDisposable
|
||||
var hub = CreateHub();
|
||||
await Assert.ThrowsAsync<HubException>(() => hub.SubmitTaskForReview(task.Id));
|
||||
}
|
||||
|
||||
// The status gate (Idle or Failed) must run before either mutation branch below, so a
|
||||
// Done/Cancelled task can never get its worktree committed or its HandlerHeadCommit stamped
|
||||
// and then rejected by SubmitInteractiveForReviewAsync, stranding the work.
|
||||
|
||||
[Fact]
|
||||
public async Task SubmitTaskForReview_DoneTask_WorktreePath_ThrowsBeforeCommit_WorktreeUntouched()
|
||||
{
|
||||
var listId = await SeedListAsync(Path.GetTempPath());
|
||||
var task = await SeedTaskAsync(listId, TaskStatus.Done);
|
||||
var worktree = new WorktreeEntity
|
||||
{
|
||||
TaskId = task.Id,
|
||||
Path = Path.Combine(Path.GetTempPath(), $"cd_no_such_worktree_{Guid.NewGuid():N}"),
|
||||
BranchName = "claudedo/does-not-matter",
|
||||
BaseCommit = "abc123",
|
||||
State = WorktreeState.Active,
|
||||
CreatedAt = DateTime.UtcNow,
|
||||
};
|
||||
await new WorktreeRepository(_ctx).AddAsync(worktree);
|
||||
|
||||
var hub = CreateHub();
|
||||
var ex = await Assert.ThrowsAsync<HubException>(() => hub.SubmitTaskForReview(task.Id));
|
||||
Assert.Contains("Idle or Failed", ex.Message);
|
||||
|
||||
var reloadedWorktree = await new WorktreeRepository(_ctx).GetByTaskIdAsync(task.Id);
|
||||
Assert.Null(reloadedWorktree!.HeadCommit);
|
||||
var reloadedTask = await _tasks.GetByIdAsync(task.Id);
|
||||
Assert.Equal(TaskStatus.Done, reloadedTask!.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SubmitTaskForReview_CancelledTask_HandlerPath_ThrowsBeforeStamp_HandlerHeadCommitUntouched()
|
||||
{
|
||||
var listId = await SeedListAsync(Path.GetTempPath());
|
||||
var task = await SeedTaskAsync(listId, TaskStatus.Cancelled, handlerBaseCommit: "abc123");
|
||||
|
||||
var hub = CreateHub();
|
||||
var ex = await Assert.ThrowsAsync<HubException>(() => hub.SubmitTaskForReview(task.Id));
|
||||
Assert.Contains("Idle or Failed", ex.Message);
|
||||
|
||||
var reloaded = await _tasks.GetByIdAsync(task.Id);
|
||||
Assert.Null(reloaded!.HandlerHeadCommit);
|
||||
Assert.Equal(TaskStatus.Cancelled, reloaded.Status);
|
||||
}
|
||||
}
|
||||
|
||||
// RecordingClientProxy / FakeHubCallerClients / FakeHubCallerContext are defined once for the
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -871,6 +871,9 @@ file sealed class ApproveObservingTaskStateService : ITaskStateService
|
||||
public Task<TransitionResult> RejectToIdleAsync(string taskId, CancellationToken ct) => _inner.RejectToIdleAsync(taskId, ct);
|
||||
public Task<TransitionResult> ClearReviewFeedbackAsync(string taskId, CancellationToken ct) => _inner.ClearReviewFeedbackAsync(taskId, ct);
|
||||
public Task<TransitionResult> ForceSetStatusAsync(string taskId, TaskStatus status, CancellationToken ct) => _inner.ForceSetStatusAsync(taskId, status, ct);
|
||||
public Task<TransitionResult> MarkDoneAsync(string taskId, DateTime finishedAt, CancellationToken ct) => _inner.MarkDoneAsync(taskId, finishedAt, ct);
|
||||
public Task<TransitionResult> UnmarkDoneAsync(string taskId, CancellationToken ct) => _inner.UnmarkDoneAsync(taskId, ct);
|
||||
public Task<TransitionResult> DequeueToIdleAsync(string taskId, CancellationToken ct) => _inner.DequeueToIdleAsync(taskId, ct);
|
||||
public Task<TransitionResult> StartPlanningAsync(string parentId, CancellationToken ct) => _inner.StartPlanningAsync(parentId, ct);
|
||||
public Task<TransitionResult> FinalizePlanningAsync(string parentId, CancellationToken ct) => _inner.FinalizePlanningAsync(parentId, ct);
|
||||
public Task<TransitionResult> BlockOnAsync(string taskId, string predecessorTaskId, CancellationToken ct) => _inner.BlockOnAsync(taskId, predecessorTaskId, ct);
|
||||
|
||||
@@ -477,6 +477,84 @@ public sealed class TaskStateServiceTests : IDisposable
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── MarkDoneAsync / UnmarkDoneAsync ─────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task MarkDoneAsync_FromIdle_TransitionsToDone_AndStampsFinishedAt()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Idle);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
var result = await _sut.MarkDoneAsync(id, now, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Done, t.Status);
|
||||
Assert.Equal(now, t.FinishedAt);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MarkDoneAsync_FromRunning_Rejects_AndLeavesStatusUnchanged()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.MarkDoneAsync(id, DateTime.UtcNow, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UnmarkDoneAsync_FromDone_TransitionsToIdle()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Done);
|
||||
|
||||
var result = await _sut.UnmarkDoneAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
Assert.Equal(TaskStatus.Idle, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UnmarkDoneAsync_FromRunning_Rejects_AndLeavesStatusUnchanged()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.UnmarkDoneAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── DequeueToIdleAsync ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task DequeueToIdleAsync_FromQueued_TransitionsToIdle_AndClearsBlockedByTaskId()
|
||||
{
|
||||
var pred = await SeedTaskAsync(TaskStatus.Queued);
|
||||
var id = await SeedTaskAsync(TaskStatus.Queued, blockedBy: pred);
|
||||
|
||||
var result = await _sut.DequeueToIdleAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Idle, t.Status);
|
||||
Assert.Null(t.BlockedByTaskId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DequeueToIdleAsync_FromRunning_Rejects_AndLeavesStatusUnchanged()
|
||||
{
|
||||
// Simulates the picker having already claimed the task between the UI reading
|
||||
// its row and the dequeue call landing.
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.DequeueToIdleAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── StartPlanningAsync ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -65,6 +65,9 @@ sealed class FakeWorkerClient : IWorkerClient
|
||||
SetTaskStatusCalls.Add((taskId, status));
|
||||
return Task.FromResult<BaseDirtyWarningDto?>(null);
|
||||
}
|
||||
public Task SetTaskDoneAsync(string taskId) => Task.CompletedTask;
|
||||
public Task UnsetTaskDoneAsync(string taskId) => Task.CompletedTask;
|
||||
public Task DequeueTaskAsync(string taskId) => Task.CompletedTask;
|
||||
public Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch) => Task.FromResult<MergeResultDto?>(null);
|
||||
public Task<MergePreviewDto?> PreviewMergeAsync(string taskId, string targetBranch) => Task.FromResult<MergePreviewDto?>(null);
|
||||
public Task<MergeResultDto> MergeTaskAsync(string taskId, string targetBranch, bool removeWorktree, string commitMessage) => Task.FromResult(new MergeResultDto("merged", System.Array.Empty<string>(), null));
|
||||
|
||||
Reference in New Issue
Block a user