refactor(worker/state): introduce TaskStateService and route mutations through it
Slice 2 of the worker state consolidation refactor (spec sections 2 and 8). Adds Worker/State/ITaskStateService + TaskStateService as the single component that mutates Status, PlanningPhase, and BlockedByTaskId. Each transition is one atomic ExecuteUpdate with a WHERE filter on the expected source status, so parallel claims are TOCTOU-free. Side effects (queue wake on -> Queued, hub TaskUpdated broadcast, chain advance + parent completion on terminal child) are owned by the service so callers no longer need to remember them. Migrated callers (mechanical, behavior preserved): - TaskRunner: HandleSuccess/HandleFailure/MarkFailed/RunAsync/ContinueAsync - StaleTaskRecovery: bulk recover stale Running tasks - TaskResetService: status flip (worktree cleanup stays in service) - PlanningSessionManager.StartAsync: status flip via state, token write via repo - PlanningChainCoordinator.OnChildFinishedAsync: routes the next-sibling write through state.UnblockAsync (Slice 4 finishes the rewrite) - ExternalMcpService.UpdateTaskStatus: Queued case via state.EnqueueAsync Repo Mark*Async helpers (MarkRunning/MarkDone/MarkFailed/FlipAllRunningToFailed) are now internal; ClaudeDo.Data grants InternalsVisibleTo to ClaudeDo.Worker and ClaudeDo.Worker.Tests for the existing repo-level tests. DI: TaskStateService is registered as Singleton in both the main app and the external-MCP app; the queue-wake delegate captures sp -> QueueService.WakeQueue to break the TaskStateService -> QueueService -> TaskRunner -> TaskStateService construction cycle. PlanningChainCoordinator takes Func<ITaskStateService> for the same reason; Slice 3 will replace both with IQueueWaker. Tests: TaskStateServiceTests covers happy + reject for every transition, the parallel StartRunningAsync claim race, child-terminal chain advancement, and stale recovery. Existing service/repo tests are updated to construct the new state-service via a TaskStateServiceBuilder helper. Pre-existing constructor drift in QueueService/ExternalMcp/PlanningHub tests is patched to keep the test project building (the surrounding test logic is otherwise untouched). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Mika Kuns
383
tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs
Normal file
383
tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs
Normal file
@@ -0,0 +1,383 @@
|
||||
using ClaudeDo.Data;
|
||||
using ClaudeDo.Data.Models;
|
||||
using ClaudeDo.Data.Repositories;
|
||||
using ClaudeDo.Worker.State;
|
||||
using ClaudeDo.Worker.Tests.Infrastructure;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
|
||||
|
||||
namespace ClaudeDo.Worker.Tests.State;
|
||||
|
||||
public sealed class TaskStateServiceTests : IDisposable
|
||||
{
|
||||
private readonly DbFixture _db = new();
|
||||
private readonly TestDbContextFactory _factory;
|
||||
private readonly TaskStateServiceBuilder.Built _built;
|
||||
private readonly ITaskStateService _sut;
|
||||
private readonly string _listId;
|
||||
|
||||
public TaskStateServiceTests()
|
||||
{
|
||||
_factory = _db.CreateFactory();
|
||||
_built = TaskStateServiceBuilder.Build(_factory);
|
||||
_sut = _built.State;
|
||||
|
||||
_listId = Guid.NewGuid().ToString();
|
||||
using var ctx = _factory.CreateDbContext();
|
||||
ctx.Lists.Add(new ListEntity
|
||||
{
|
||||
Id = _listId,
|
||||
Name = "Test",
|
||||
CreatedAt = DateTime.UtcNow,
|
||||
DefaultCommitType = "chore",
|
||||
});
|
||||
ctx.SaveChanges();
|
||||
}
|
||||
|
||||
public void Dispose() => _db.Dispose();
|
||||
|
||||
private async Task<string> SeedTaskAsync(TaskStatus status, string? parentId = null, int sortOrder = 0)
|
||||
{
|
||||
var id = Guid.NewGuid().ToString();
|
||||
await using var ctx = _factory.CreateDbContext();
|
||||
ctx.Tasks.Add(new TaskEntity
|
||||
{
|
||||
Id = id,
|
||||
ListId = _listId,
|
||||
Title = "task",
|
||||
Status = status,
|
||||
CreatedAt = DateTime.UtcNow,
|
||||
ParentTaskId = parentId,
|
||||
SortOrder = sortOrder,
|
||||
});
|
||||
await ctx.SaveChangesAsync();
|
||||
return id;
|
||||
}
|
||||
|
||||
private async Task<TaskStatus> GetStatusAsync(string id)
|
||||
{
|
||||
await using var ctx = _factory.CreateDbContext();
|
||||
return await ctx.Tasks.Where(t => t.Id == id).Select(t => t.Status).FirstAsync();
|
||||
}
|
||||
|
||||
private async Task<TaskEntity> GetTaskAsync(string id)
|
||||
{
|
||||
await using var ctx = _factory.CreateDbContext();
|
||||
return await new TaskRepository(ctx).GetByIdAsync(id) ?? throw new InvalidOperationException($"task {id} not found");
|
||||
}
|
||||
|
||||
// ─── EnqueueAsync ─────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task EnqueueAsync_FromIdle_TransitionsToQueued_AndWakesQueue()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Idle);
|
||||
var wakesBefore = _built.WakeCount();
|
||||
|
||||
var result = await _sut.EnqueueAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
Assert.Equal(TaskStatus.Queued, await GetStatusAsync(id));
|
||||
Assert.True(_built.WakeCount() > wakesBefore);
|
||||
Assert.Contains(_built.Hub.Proxy.Calls, c => c.Method == "TaskUpdated");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task EnqueueAsync_FromRunning_Rejects_AndDoesNotMutate()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.EnqueueAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── StartRunningAsync ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task StartRunningAsync_FromQueued_TransitionsToRunning_AndStampsStartedAt()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Queued);
|
||||
var startedAt = new DateTime(2026, 4, 27, 10, 0, 0, DateTimeKind.Utc);
|
||||
|
||||
var result = await _sut.StartRunningAsync(id, startedAt, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Running, t.Status);
|
||||
Assert.Equal(startedAt, t.StartedAt);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task StartRunningAsync_FromRunning_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.StartRunningAsync(id, DateTime.UtcNow, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task StartRunningAsync_TwoParallelClaims_ExactlyOneWins()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Queued);
|
||||
var startedAt = DateTime.UtcNow;
|
||||
|
||||
// Two concurrent calls: only one ExecuteUpdate should affect a row.
|
||||
var t1 = Task.Run(() => _sut.StartRunningAsync(id, startedAt, default));
|
||||
var t2 = Task.Run(() => _sut.StartRunningAsync(id, startedAt, default));
|
||||
var results = await Task.WhenAll(t1, t2);
|
||||
|
||||
var winners = results.Count(r => r.Ok);
|
||||
Assert.Equal(1, winners);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── CompleteAsync ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task CompleteAsync_FromRunning_TransitionsToDone()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.CompleteAsync(id, DateTime.UtcNow, "ok", default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Done, t.Status);
|
||||
Assert.Equal("ok", t.Result);
|
||||
Assert.NotNull(t.FinishedAt);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CompleteAsync_FromQueued_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Queued);
|
||||
|
||||
var result = await _sut.CompleteAsync(id, DateTime.UtcNow, "ok", default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Queued, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── FailAsync ────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task FailAsync_FromRunning_TransitionsToFailed()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.FailAsync(id, DateTime.UtcNow, "boom", default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Failed, t.Status);
|
||||
Assert.Equal("boom", t.Result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task FailAsync_FromDone_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Done);
|
||||
|
||||
var result = await _sut.FailAsync(id, DateTime.UtcNow, "boom", default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Done, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── CancelAsync ──────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task CancelAsync_FromRunning_TransitionsToCancelled()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.CancelAsync(id, DateTime.UtcNow, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
Assert.Equal(TaskStatus.Cancelled, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CancelAsync_FromDone_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Done);
|
||||
|
||||
var result = await _sut.CancelAsync(id, DateTime.UtcNow, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Done, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── ResetToIdleAsync ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task ResetToIdleAsync_FromFailed_ClearsTimestamps()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Failed);
|
||||
await using (var ctx = _factory.CreateDbContext())
|
||||
{
|
||||
await ctx.Tasks.Where(t => t.Id == id)
|
||||
.ExecuteUpdateAsync(s => s
|
||||
.SetProperty(t => t.StartedAt, DateTime.UtcNow.AddMinutes(-5))
|
||||
.SetProperty(t => t.FinishedAt, DateTime.UtcNow.AddMinutes(-1))
|
||||
.SetProperty(t => t.Result, "old"));
|
||||
}
|
||||
|
||||
var result = await _sut.ResetToIdleAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Idle, t.Status);
|
||||
Assert.Null(t.StartedAt);
|
||||
Assert.Null(t.FinishedAt);
|
||||
Assert.Null(t.Result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ResetToIdleAsync_FromRunning_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.ResetToIdleAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
|
||||
}
|
||||
|
||||
// ─── StartPlanningAsync ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task StartPlanningAsync_FromManual_FlipsStatus_AndPlanningPhase()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Manual);
|
||||
|
||||
var result = await _sut.StartPlanningAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(TaskStatus.Planning, t.Status);
|
||||
Assert.Equal(PlanningPhase.Active, t.PlanningPhase);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task StartPlanningAsync_FromRunning_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Running);
|
||||
|
||||
var result = await _sut.StartPlanningAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
}
|
||||
|
||||
// ─── FinalizePlanningAsync ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task FinalizePlanningAsync_OnActivePhase_TransitionsToFinalized()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Manual);
|
||||
await _sut.StartPlanningAsync(id, default);
|
||||
|
||||
var result = await _sut.FinalizePlanningAsync(id, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(id);
|
||||
Assert.Equal(PlanningPhase.Finalized, t.PlanningPhase);
|
||||
Assert.NotNull(t.PlanningFinalizedAt);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task FinalizePlanningAsync_OnNonePhase_Rejects()
|
||||
{
|
||||
var id = await SeedTaskAsync(TaskStatus.Manual);
|
||||
|
||||
var result = await _sut.FinalizePlanningAsync(id, default);
|
||||
|
||||
Assert.False(result.Ok);
|
||||
}
|
||||
|
||||
// ─── BlockOnAsync / UnblockAsync ─────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task BlockOnAsync_SetsBlockedByTaskId()
|
||||
{
|
||||
var pred = await SeedTaskAsync(TaskStatus.Queued);
|
||||
var task = await SeedTaskAsync(TaskStatus.Queued);
|
||||
|
||||
var result = await _sut.BlockOnAsync(task, pred, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(task);
|
||||
Assert.Equal(pred, t.BlockedByTaskId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UnblockAsync_ClearsBlockedByTaskId_AndWakesQueue()
|
||||
{
|
||||
var pred = await SeedTaskAsync(TaskStatus.Queued);
|
||||
var task = await SeedTaskAsync(TaskStatus.Queued);
|
||||
await _sut.BlockOnAsync(task, pred, default);
|
||||
var wakesBefore = _built.WakeCount();
|
||||
|
||||
var result = await _sut.UnblockAsync(task, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
var t = await GetTaskAsync(task);
|
||||
Assert.Null(t.BlockedByTaskId);
|
||||
Assert.True(_built.WakeCount() > wakesBefore);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UnblockAsync_OnWaitingTask_FlipsToQueued()
|
||||
{
|
||||
// Bridge to legacy chain layout: a Status=Waiting sibling becomes Queued on unblock.
|
||||
var task = await SeedTaskAsync(TaskStatus.Waiting);
|
||||
|
||||
var result = await _sut.UnblockAsync(task, default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
Assert.Equal(TaskStatus.Queued, await GetStatusAsync(task));
|
||||
}
|
||||
|
||||
// ─── RecoverStaleRunningAsync ─────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task RecoverStaleRunningAsync_FlipsAllRunningToFailed_ReturnsCount()
|
||||
{
|
||||
var r1 = await SeedTaskAsync(TaskStatus.Running);
|
||||
var r2 = await SeedTaskAsync(TaskStatus.Running);
|
||||
var q = await SeedTaskAsync(TaskStatus.Queued);
|
||||
|
||||
var count = await _sut.RecoverStaleRunningAsync("worker restart", default);
|
||||
|
||||
Assert.Equal(2, count);
|
||||
Assert.Equal(TaskStatus.Failed, await GetStatusAsync(r1));
|
||||
Assert.Equal(TaskStatus.Failed, await GetStatusAsync(r2));
|
||||
Assert.Equal(TaskStatus.Queued, await GetStatusAsync(q));
|
||||
var t = await GetTaskAsync(r1);
|
||||
Assert.StartsWith("[stale] ", t.Result);
|
||||
}
|
||||
|
||||
// ─── Child terminal → chain advance ───────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task CompleteAsync_OnChild_AdvancesNextWaitingSibling()
|
||||
{
|
||||
var parent = await SeedTaskAsync(TaskStatus.Planned);
|
||||
var c0 = await SeedTaskAsync(TaskStatus.Running, parentId: parent, sortOrder: 0);
|
||||
var c1 = await SeedTaskAsync(TaskStatus.Waiting, parentId: parent, sortOrder: 1);
|
||||
var c2 = await SeedTaskAsync(TaskStatus.Waiting, parentId: parent, sortOrder: 2);
|
||||
|
||||
var result = await _sut.CompleteAsync(c0, DateTime.UtcNow, "ok", default);
|
||||
|
||||
Assert.True(result.Ok);
|
||||
Assert.Equal(TaskStatus.Done, await GetStatusAsync(c0));
|
||||
// Next sibling was Waiting → chain coordinator unblocks → Queued.
|
||||
Assert.Equal(TaskStatus.Queued, await GetStatusAsync(c1));
|
||||
// Subsequent sibling untouched.
|
||||
Assert.Equal(TaskStatus.Waiting, await GetStatusAsync(c2));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user