346 lines
13 KiB
C#
346 lines
13 KiB
C#
using ClaudeDo.Data;
|
|
using ClaudeDo.Data.Models;
|
|
using ClaudeDo.Data.Repositories;
|
|
using ClaudeDo.Worker.Queue;
|
|
using ClaudeDo.Worker.Tests.Infrastructure;
|
|
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
|
|
|
|
namespace ClaudeDo.Worker.Tests.Queue;
|
|
|
|
public sealed class QueuePickerTests : IDisposable
|
|
{
|
|
private readonly DbFixture _db = new();
|
|
private readonly ClaudeDoDbContext _ctx;
|
|
private readonly TaskRepository _tasks;
|
|
private readonly ListRepository _lists;
|
|
private readonly QueuePicker _picker;
|
|
|
|
public QueuePickerTests()
|
|
{
|
|
_ctx = _db.CreateContext();
|
|
_tasks = new TaskRepository(_ctx);
|
|
_lists = new ListRepository(_ctx);
|
|
_picker = new QueuePicker(_db.CreateFactory());
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_ctx.Dispose();
|
|
_db.Dispose();
|
|
}
|
|
|
|
private async Task<string> CreateListAsync(bool listAgentTag = false)
|
|
{
|
|
var listId = Guid.NewGuid().ToString();
|
|
await _lists.AddAsync(new ListEntity
|
|
{
|
|
Id = listId,
|
|
Name = "Test",
|
|
CreatedAt = DateTime.UtcNow,
|
|
});
|
|
return listId;
|
|
}
|
|
|
|
private async Task<TaskEntity> SeedAsync(
|
|
string listId,
|
|
TaskStatus status = TaskStatus.Queued,
|
|
DateTime? createdAt = null,
|
|
DateTime? scheduledFor = null,
|
|
string? blockedBy = null,
|
|
bool taskAgentTag = false,
|
|
int? sortOrder = null,
|
|
bool isManual = false,
|
|
string? scopeGlobs = null,
|
|
string? dependsOn = null)
|
|
{
|
|
var task = new TaskEntity
|
|
{
|
|
Id = Guid.NewGuid().ToString(),
|
|
ListId = listId,
|
|
Title = "T",
|
|
Status = status,
|
|
CreatedAt = createdAt ?? DateTime.UtcNow,
|
|
ScheduledFor = scheduledFor,
|
|
BlockedByTaskId = blockedBy,
|
|
DependsOnTaskId = dependsOn,
|
|
CommitType = "feat",
|
|
IsManual = isManual,
|
|
ScopeGlobs = scopeGlobs,
|
|
};
|
|
await _tasks.AddAsync(task);
|
|
if (sortOrder is not null)
|
|
{
|
|
task.SortOrder = sortOrder.Value;
|
|
await _tasks.UpdateAsync(task);
|
|
}
|
|
return task;
|
|
}
|
|
|
|
private async Task SetSerializeOnFileOverlapAsync(string listId, bool value)
|
|
=> await _lists.SetConfigAsync(new ListConfigEntity { ListId = listId, SerializeOnFileOverlap = value });
|
|
|
|
private async Task SeedWorktreeAsync(string taskId, WorktreeState state, string? diffStat)
|
|
{
|
|
_ctx.Worktrees.Add(new WorktreeEntity
|
|
{
|
|
TaskId = taskId,
|
|
Path = $"C:\\fake\\{taskId}",
|
|
BranchName = $"claudedo/{taskId[..8]}",
|
|
BaseCommit = "base",
|
|
HeadCommit = "head",
|
|
DiffStat = diffStat,
|
|
State = state,
|
|
CreatedAt = DateTime.UtcNow,
|
|
});
|
|
await _ctx.SaveChangesAsync();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_ManualTasks()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
await SeedAsync(listId, isManual: true);
|
|
|
|
Assert.Null(await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_ManualTask_ButClaimsTheNextOne()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(-5), isManual: true);
|
|
var claudeTask = await SeedAsync(listId, createdAt: DateTime.UtcNow);
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(claudeTask.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_TasksWithBlockedByTaskId()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
var blocker = await SeedAsync(listId);
|
|
await SeedAsync(listId, blockedBy: blocker.Id);
|
|
|
|
// Only `blocker` is unblocked → it should be claimed; the second pick is null.
|
|
var first = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.NotNull(first);
|
|
Assert.Equal(blocker.Id, first!.Id);
|
|
|
|
var second = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.Null(second);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_TasksWithUnmetDependsOn()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
var dependency = await SeedAsync(listId, status: TaskStatus.Idle);
|
|
await SeedAsync(listId, dependsOn: dependency.Id);
|
|
|
|
// The dependency is only Idle (not Done), so both stay unclaimed: the dependent is
|
|
// gated on depends_on_task_id, and the dependency itself was never queued.
|
|
Assert.Null(await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Claims_TaskWhoseDependsOnIsDone()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
var dependency = await SeedAsync(listId, status: TaskStatus.Done);
|
|
var dependent = await SeedAsync(listId, dependsOn: dependency.Id);
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(dependent.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_TaskWhoseDependsOnFailed_ButKeepsClaimingOthers()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
var dependency = await SeedAsync(listId, status: TaskStatus.Failed);
|
|
await SeedAsync(listId, dependsOn: dependency.Id);
|
|
var independent = await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(1));
|
|
|
|
// A Failed dependency does not cascade-cancel or auto-unblock the dependent (unlike the
|
|
// planning chain's BlockedByTaskId) -- it just stays Queued and skipped forever.
|
|
var first = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.NotNull(first);
|
|
Assert.Equal(independent.Id, first!.Id);
|
|
|
|
var second = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.Null(second);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Picks_TasksWithoutAgentTag()
|
|
{
|
|
// Queueing a task is itself the explicit "run me" signal — no tag gate.
|
|
var listId = await CreateListAsync(listAgentTag: false);
|
|
var task = await SeedAsync(listId);
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(task.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_FutureScheduledFor()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
await SeedAsync(listId, scheduledFor: DateTime.UtcNow.AddHours(1));
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.Null(picked);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Skips_NonQueuedStatuses()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
await SeedAsync(listId, status: TaskStatus.Idle);
|
|
await SeedAsync(listId, status: TaskStatus.Running);
|
|
await SeedAsync(listId, status: TaskStatus.Done);
|
|
await SeedAsync(listId, status: TaskStatus.Failed);
|
|
await SeedAsync(listId, status: TaskStatus.Cancelled);
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.Null(picked);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_Picks_ByUserSortOrder_ThenCreatedAt()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
|
|
// Created in order first, second; reorder so second is sort-order 0.
|
|
var first = await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(-10));
|
|
var second = await SeedAsync(listId, createdAt: DateTime.UtcNow);
|
|
await _tasks.ReorderAsync(listId, new[] { second.Id, first.Id });
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(second.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_FlipsToRunning_WithStartedAt()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
var task = await SeedAsync(listId);
|
|
|
|
var before = DateTime.UtcNow;
|
|
var picked = await _picker.ClaimNextAsync(before, CancellationToken.None);
|
|
Assert.NotNull(picked);
|
|
|
|
var loaded = await _tasks.GetByIdAsync(task.Id);
|
|
Assert.Equal(TaskStatus.Running, loaded!.Status);
|
|
Assert.NotNull(loaded.StartedAt);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_TwoParallelPickers_OnlyOneClaimsRow()
|
|
{
|
|
var listId = await CreateListAsync(listAgentTag: true);
|
|
await SeedAsync(listId);
|
|
|
|
// Two pickers, same DB factory, racing each other.
|
|
var picker1 = new QueuePicker(_db.CreateFactory());
|
|
var picker2 = new QueuePicker(_db.CreateFactory());
|
|
|
|
var t1 = Task.Run(() => picker1.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
|
|
var t2 = Task.Run(() => picker2.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
|
|
|
|
var results = await Task.WhenAll(t1, t2);
|
|
|
|
var nonNull = results.Where(r => r is not null).ToList();
|
|
Assert.Single(nonNull);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_SerializeOff_ClaimsOverlappingQueuedTask_EvenWithRunningOverlap()
|
|
{
|
|
// Default (option off): behavior is unaffected by ScopeGlobs, even when it overlaps a
|
|
// running sibling's declared scope.
|
|
var listId = await CreateListAsync();
|
|
await SeedAsync(listId, status: TaskStatus.Running, scopeGlobs: "src/Foo.cs");
|
|
var queued = await SeedAsync(listId, scopeGlobs: "src/Foo.cs");
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(queued.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_SerializeOn_SkipsQueuedTask_OverlappingRunningSibling()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
await SetSerializeOnFileOverlapAsync(listId, true);
|
|
|
|
await SeedAsync(listId, status: TaskStatus.Running, scopeGlobs: "src/Foo.cs");
|
|
var overlapping = await SeedAsync(listId, scopeGlobs: "src/Foo.cs", sortOrder: 0, createdAt: DateTime.UtcNow.AddMinutes(-5));
|
|
var clear = await SeedAsync(listId, scopeGlobs: "src/Bar.cs", sortOrder: 1, createdAt: DateTime.UtcNow);
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(clear.Id, picked!.Id);
|
|
|
|
var stillQueued = await _tasks.GetByIdAsync(overlapping.Id);
|
|
Assert.Equal(TaskStatus.Queued, stillQueued!.Status);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_SerializeOn_NoDeclaredScope_StillClaimed()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
await SetSerializeOnFileOverlapAsync(listId, true);
|
|
|
|
await SeedAsync(listId, status: TaskStatus.Running, scopeGlobs: "src/Foo.cs");
|
|
var queued = await SeedAsync(listId); // no ScopeGlobs declared -- no basis to hold it back
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(queued.Id, picked!.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_SerializeOn_SkipsQueuedTask_OverlappingUnmergedFinishedSiblingDiff()
|
|
{
|
|
var listId = await CreateListAsync();
|
|
await SetSerializeOnFileOverlapAsync(listId, true);
|
|
|
|
var finished = await SeedAsync(listId, status: TaskStatus.WaitingForReview);
|
|
await SeedWorktreeAsync(finished.Id, WorktreeState.Active, "src/Foo.cs | 3 ++-");
|
|
await SeedAsync(listId, scopeGlobs: "src/Foo.cs");
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.Null(picked);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClaimNextAsync_SerializeOn_IgnoresMergedSiblingDiff()
|
|
{
|
|
// A merged sibling's changes are already on the base branch -- not a live conflict risk,
|
|
// so it must not hold back an overlapping queued task.
|
|
var listId = await CreateListAsync();
|
|
await SetSerializeOnFileOverlapAsync(listId, true);
|
|
|
|
var merged = await SeedAsync(listId, status: TaskStatus.Done);
|
|
await SeedWorktreeAsync(merged.Id, WorktreeState.Merged, "src/Foo.cs | 3 ++-");
|
|
var queued = await SeedAsync(listId, scopeGlobs: "src/Foo.cs");
|
|
|
|
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
|
|
|
|
Assert.NotNull(picked);
|
|
Assert.Equal(queued.Id, picked!.Id);
|
|
}
|
|
}
|