Files
Chronos/tests/Titano.Data.Tests/Repositories/JobRepositoryTests.cs
T
Claude 2fbb7bc179 test(data): cover migrations and every repository on both dialects
Shared abstract suites run against in-memory/temp-file SQLite and, with
TITANO_TEST_PG, a private PostgreSQL schema per test: migration
idempotency and version refusal, keyset paging with ties for every sort,
statistics, exclusive job claiming under 8 concurrent claimers, and the
100k-frame bulk insert under 15 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 10:05:43 +00:00

169 lines
8.2 KiB
C#

using System.Collections.Concurrent;
using Titano.Core.Model;
using Titano.Data.Tests.Infrastructure;
using Titano.Testing;
namespace Titano.Data.Tests.Repositories;
public abstract class JobRepositoryTests(TestContext context) : RepositoryTest(context)
{
[Test]
public async Task JobsRoundTripEveryField()
{
var db = await OpenTitanoAsync();
var job = TestData.Job(JobKind.Render, JobPriority.User) with
{
TargetIds = [Guid.CreateVersion7(), Guid.CreateVersion7()], TargetLabel = "Harbour sunset", ParametersJson = "{\"preset\": \"4K\"}",
ProgressDone = 5, ProgressTotal = 10, ItemsPerSecond = 2.5, Eta = TimeSpan.FromSeconds(2), Checkpoint = "frame:5",
LogTail = "line 1\nline 2", CreatedBy = Guid.CreateVersion7(), NodeId = "node-a", Attempts = 1, Error = "boom",
State = JobState.Failed, Started = TestData.Now.AddMinutes(1), Finished = TestData.Now.AddMinutes(2),
};
await db.Jobs.EnqueueAsync(job, Ct);
var read = Assert.NotNull(await db.Jobs.GetAsync(job.Id, Ct));
Assert.SequenceEqual(job.TargetIds, read.TargetIds);
Assert.Equal(job with { TargetIds = read.TargetIds }, read);
}
[Test]
public async Task ClaimsByPriorityThenAgeAndKind()
{
var db = await OpenTitanoAsync();
var oldBackground = TestData.Job(JobKind.Thumbs, JobPriority.Background, TestData.Now.AddMinutes(-10));
var newUser = TestData.Job(JobKind.Render, JobPriority.User, TestData.Now);
var oldUser = TestData.Job(JobKind.Import, JobPriority.User, TestData.Now.AddMinutes(-1));
var normal = TestData.Job(JobKind.Scan, JobPriority.Normal, TestData.Now.AddMinutes(-5));
foreach (var job in new[] { oldBackground, newUser, oldUser, normal }) await db.Jobs.EnqueueAsync(job, Ct);
var renderOnly = await db.Jobs.ClaimNextAsync("node-gpu", [JobKind.Render], Ct);
Assert.Equal(newUser.Id, renderOnly?.Id);
Assert.Equal(JobState.Running, renderOnly!.State);
Assert.Equal("node-gpu", renderOnly.NodeId);
Assert.Equal(1, renderOnly.Attempts);
Assert.NotNull(renderOnly.Started);
Assert.Null(await db.Jobs.ClaimNextAsync("node-gpu", [JobKind.Render], Ct));
var order = new List<Guid>();
while (await db.Jobs.ClaimNextAsync("server", cancellationToken: Ct) is { } claimed) order.Add(claimed.Id);
Assert.SequenceEqual([oldUser.Id, normal.Id, oldBackground.Id], order);
}
[Test]
public async Task ConcurrentClaimersNeverShareAJob()
{
var db = await OpenTitanoAsync(multiConnection: true);
var jobs = Enumerable.Range(0, 40).Select(i => TestData.Job(created: TestData.Now.AddSeconds(i))).ToList();
foreach (var job in jobs) await db.Jobs.EnqueueAsync(job, Ct);
var claims = new ConcurrentBag<(string Worker, Guid Job)>();
await Task.WhenAll(Enumerable.Range(0, 8).Select(w => Task.Run(async () =>
{
var worker = "worker-" + w;
while (await db.Jobs.ClaimNextAsync(worker, cancellationToken: Ct) is { } job) claims.Add((worker, job.Id));
})));
Assert.Equal(40, claims.Count);
Assert.Equal(40, claims.Select(c => c.Job).Distinct().Count());
foreach (var (worker, id) in claims)
{
var stored = await db.Jobs.GetAsync(id, Ct);
Assert.Equal(worker, stored!.NodeId);
Assert.Equal(1, stored.Attempts);
}
}
[Test]
public async Task ProgressIsRefusedOnceTheJobStopsRunning()
{
var db = await OpenTitanoAsync();
var job = TestData.Job();
await db.Jobs.EnqueueAsync(job, Ct);
Assert.False(await db.Jobs.UpdateProgressAsync(job.Id, 1, 10, null, null, null, null, Ct));
await db.Jobs.ClaimNextAsync("w", cancellationToken: Ct);
Assert.True(await db.Jobs.UpdateProgressAsync(job.Id, 4, 10, 2.0, TimeSpan.FromSeconds(3), "cursor:4", "tail", Ct));
var running = await db.Jobs.GetAsync(job.Id, Ct);
Assert.Equal((4L, 10L, "cursor:4", "tail"), (running!.ProgressDone, running.ProgressTotal, running.Checkpoint, running.LogTail));
Assert.Equal(TimeSpan.FromSeconds(3), running.Eta);
Assert.True(await db.Jobs.SetStateAsync(job.Id, JobState.Cancelled, cancellationToken: Ct));
Assert.False(await db.Jobs.UpdateProgressAsync(job.Id, 5, 10, null, null, "cursor:5", null, Ct));
var cancelled = await db.Jobs.GetAsync(job.Id, Ct);
Assert.Equal(JobState.Cancelled, cancelled!.State);
Assert.NotNull(cancelled.Finished);
Assert.True(await db.Jobs.SetStateAsync(job.Id, JobState.Queued, cancellationToken: Ct));
Assert.Null((await db.Jobs.GetAsync(job.Id, Ct))!.Finished);
Assert.Equal(2, (await db.Jobs.ClaimNextAsync("w", cancellationToken: Ct))!.Attempts);
Assert.False(await db.Jobs.SetStateAsync(Guid.CreateVersion7(), JobState.Done, cancellationToken: Ct));
}
[Test]
public async Task ListingPagesByStateNewestFirst()
{
var db = await OpenTitanoAsync();
var jobs = Enumerable.Range(0, 7).Select(i => TestData.Job(created: TestData.Now.AddMinutes(i % 3))).ToList();
foreach (var job in jobs) await db.Jobs.EnqueueAsync(job, Ct);
await db.Jobs.SetStateAsync(jobs[0].Id, JobState.Done, cancellationToken: Ct);
var seen = new List<Guid>();
string? cursor = null;
do
{
var page = await db.Jobs.ListAsync(JobState.Queued, limit: 2, cursor: cursor, cancellationToken: Ct);
seen.AddRange(page.Items.Select(j => j.Id));
cursor = page.NextCursor;
}
while (cursor is not null);
var expected = jobs.Skip(1)
.OrderByDescending(j => j.Created)
.ThenByDescending(j => j.Id.ToString("D"), StringComparer.Ordinal)
.Select(j => j.Id);
Assert.SequenceEqual(expected, seen);
Assert.SequenceEqual([jobs[0].Id], (await db.Jobs.ListAsync(JobState.Done, cancellationToken: Ct)).Items.Select(j => j.Id));
Assert.Equal(7, (await db.Jobs.ListAsync(cancellationToken: Ct)).Items.Count);
}
[Test]
public async Task HistoryPurgeKeepsRecentAndActiveJobs()
{
var db = await OpenTitanoAsync();
var old = TestData.Job() with { State = JobState.Done, Finished = TestData.Now.AddDays(-100) };
var oldFailed = TestData.Job() with { State = JobState.Failed, Finished = TestData.Now.AddDays(-91) };
var recent = TestData.Job() with { State = JobState.Done, Finished = TestData.Now.AddDays(-10) };
var queued = TestData.Job(created: TestData.Now.AddDays(-200));
foreach (var job in new[] { old, oldFailed, recent, queued }) await db.Jobs.EnqueueAsync(job, Ct);
Assert.Equal(2, await db.Jobs.PurgeHistoryAsync(TestData.Now.AddDays(-90), Ct));
Assert.Equal(2, (await db.Jobs.ListAsync(cancellationToken: Ct)).Items.Count);
}
[Test]
public async Task RunningJobsAreRequeuedAfterACrash()
{
var db = await OpenTitanoAsync();
for (var i = 0; i < 3; i++) await db.Jobs.EnqueueAsync(TestData.Job(created: TestData.Now.AddSeconds(i)), Ct);
var a = await db.Jobs.ClaimNextAsync("node-a", cancellationToken: Ct);
var b = await db.Jobs.ClaimNextAsync("node-b", cancellationToken: Ct);
await db.Jobs.UpdateProgressAsync(a!.Id, 3, 9, null, null, "resume-here", null, Ct);
Assert.Equal(1, await db.Jobs.RequeueRunningAsync("node-a", Ct));
var requeued = await db.Jobs.GetAsync(a.Id, Ct);
Assert.Equal(JobState.Queued, requeued!.State);
Assert.Equal("resume-here", requeued.Checkpoint);
Assert.Null(requeued.NodeId);
Assert.Equal(JobState.Running, (await db.Jobs.GetAsync(b!.Id, Ct))!.State);
Assert.Equal(1, await db.Jobs.RequeueRunningAsync(cancellationToken: Ct));
Assert.Equal(0, await db.Jobs.RequeueRunningAsync(cancellationToken: Ct));
}
}
public sealed class SqliteJobRepositoryTests(TestContext context) : JobRepositoryTests(context)
{
protected override Backend Backend => Backend.SqliteMemory;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresJobRepositoryTests(TestContext context) : JobRepositoryTests(context)
{
protected override Backend Backend => Backend.Postgres;
}