Merge claudedo/c4930a56575e45b2ae9be47b1c49eb39

tests/ClaudeDo.Worker.Tests/Hub/DeleteTaskHubTests.cs

@@ -0,0 +1,107 @@
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.EntityFrameworkCore;
+using Xunit;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Worker.Tests.Hub;
+
+public sealed class DeleteTaskHubTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+
+    public void Dispose() => _db.Dispose();
+
+    private WorkerHub CreateHub()
+    {
+        var factory = _db.CreateFactory();
+        var built = TaskStateServiceBuilder.Build(factory);
+        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!,
+            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(new RecordingClientProxy());
+        hub.Context = new FakeHubCallerContext();
+        return hub;
+    }
+
+    private async Task<(string ParentId, string ChildId)> SeedParentWithChildAsync(TaskStatus childStatus)
+    {
+        using var ctx = _db.CreateContext();
+        var listId = Guid.NewGuid().ToString();
+        await new ListRepository(ctx).AddAsync(new ListEntity
+        {
+            Id = listId, Name = "L", CreatedAt = DateTime.UtcNow,
+        });
+
+        var repo = new TaskRepository(ctx);
+        var parentId = Guid.NewGuid().ToString();
+        await repo.AddAsync(new TaskEntity
+        {
+            Id = parentId, ListId = listId, Title = "Parent",
+            Status = TaskStatus.WaitingForChildren, PlanningPhase = PlanningPhase.Finalized,
+            CreatedAt = DateTime.UtcNow, CommitType = "feat",
+        });
+
+        var childId = Guid.NewGuid().ToString();
+        await repo.AddAsync(new TaskEntity
+        {
+            Id = childId, ListId = listId, Title = "Child", ParentTaskId = parentId,
+            Status = childStatus, CreatedAt = DateTime.UtcNow, CommitType = "feat",
+        });
+
+        return (parentId, childId);
+    }
+
+    [Fact]
+    public async Task DeleteTask_LastChildOfWaitingForChildrenParent_AdvancesParentToWaitingForReview()
+    {
+        var (parentId, childId) = await SeedParentWithChildAsync(TaskStatus.Idle);
+        var hub = CreateHub();
+
+        await hub.DeleteTask(childId, default);
+
+        await using var ctx = _db.CreateContext();
+        Assert.Null(await ctx.Tasks.FindAsync(childId));
+        var parent = await ctx.Tasks.FindAsync(parentId);
+        Assert.Equal(TaskStatus.WaitingForReview, parent!.Status);
+    }
+
+    [Fact]
+    public async Task DeleteTask_RunningTask_Throws_AndDoesNotDelete()
+    {
+        var (_, childId) = await SeedParentWithChildAsync(TaskStatus.Running);
+        var hub = CreateHub();
+
+        await Assert.ThrowsAsync<HubException>(() => hub.DeleteTask(childId, default));
+
+        await using var ctx = _db.CreateContext();
+        Assert.NotNull(await ctx.Tasks.FindAsync(childId));
+    }
+
+    [Fact]
+    public async Task DeleteTask_TaskWithChildren_ThrowsFriendlyForeignKeyMessage()
+    {
+        var (parentId, _) = await SeedParentWithChildAsync(TaskStatus.Idle);
+        var hub = CreateHub();
+
+        var ex = await Assert.ThrowsAsync<HubException>(() => hub.DeleteTask(parentId, default));
+
+        Assert.Contains("child tasks", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task DeleteTask_Missing_Throws()
+    {
+        var hub = CreateHub();
+
+        await Assert.ThrowsAsync<HubException>(() => hub.DeleteTask("does-not-exist", default));
+    }
+}

tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs

@@ -498,4 +498,42 @@ public sealed class TaskStateServiceTests : IDisposable
         Assert.Equal(TaskStatus.Queued, t2.Status);
         Assert.Equal(c1, t2.BlockedByTaskId);
     }
+
+    // ─── TryAdvanceParentAsync ────────────────────────────────────────────
+
+    [Fact]
+    public async Task TryAdvanceParentAsync_ZeroChildren_AdvancesToWaitingForReview()
+    {
+        // Mirrors deleting the last remaining child: no terminal transition fires for it,
+        // so the caller invokes TryAdvanceParentAsync directly with zero children left.
+        var parent = await SeedTaskAsync(TaskStatus.WaitingForChildren, phase: PlanningPhase.Finalized);
+
+        await _sut.TryAdvanceParentAsync(parent);
+
+        Assert.Equal(TaskStatus.WaitingForReview, await GetStatusAsync(parent));
+    }
+
+    [Fact]
+    public async Task TryAdvanceParentAsync_AllChildrenTerminal_AdvancesToWaitingForReview()
+    {
+        var parent = await SeedTaskAsync(TaskStatus.WaitingForChildren, phase: PlanningPhase.Finalized);
+        await SeedTaskAsync(TaskStatus.Done, parentId: parent);
+        await SeedTaskAsync(TaskStatus.Done, parentId: parent);
+
+        await _sut.TryAdvanceParentAsync(parent);
+
+        Assert.Equal(TaskStatus.WaitingForReview, await GetStatusAsync(parent));
+    }
+
+    [Fact]
+    public async Task TryAdvanceParentAsync_SomeChildrenStillRunning_DoesNotAdvance()
+    {
+        var parent = await SeedTaskAsync(TaskStatus.WaitingForChildren, phase: PlanningPhase.Finalized);
+        await SeedTaskAsync(TaskStatus.Done, parentId: parent);
+        await SeedTaskAsync(TaskStatus.Running, parentId: parent);
+
+        await _sut.TryAdvanceParentAsync(parent);
+
+        Assert.Equal(TaskStatus.WaitingForChildren, await GetStatusAsync(parent));
+    }
 }

tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs

@@ -47,6 +47,7 @@ sealed class FakeWorkerClient : IWorkerClient
     public Task<PendingQuestionDto?> GetPendingQuestionAsync(string taskId) => Task.FromResult<PendingQuestionDto?>(null);
     public Task ResetTaskAsync(string taskId) => Task.CompletedTask;
     public Task CancelTaskAsync(string taskId) => Task.CompletedTask;
+    public Task<(bool Ok, string? Error)> DeleteTaskAsync(string taskId) => Task.FromResult<(bool, string?)>((true, null));
     public Task<List<AgentInfo>> GetAgentsAsync() => Task.FromResult(new List<AgentInfo>());
     public Task RefreshAgentsAsync() => Task.CompletedTask;
     public Task<SeedResultDto?> RestoreDefaultAgentsAsync() => Task.FromResult<SeedResultDto?>(null);