Files
Chronos/tests/Chronos.Data.Tests/Jobs/JobPriorityQueueTests.cs
T
Alby96andClaude Opus 5.5 2e1c67f531 feat(workspace): lay the phase 5c foundation
Phase 5c (owner review 2, R8) is built by six packages in parallel. This
commit settles everything they share, so each one touches its own files:

- job kinds WorkspaceRender (21), WorkspaceSend (22) and WorkspaceMove (23)
  with their wire names, default priorities, notices and parameter records;
  their handlers are registered as skeletons that throw until their
  package lands
- WorkspaceJobOptions and a new CreateHandlers overload; the earlier ones
  stay and default the options
- originals in the media index (an index of phase 5b reads as proxies
  only), their file names, and the exports/renders.json ledger of local
  renders, written atomically
- the optional project and version of an uploaded render
- the workspace settings (size limit, default media, version on render,
  clean-up age, project to open) and when each project was opened, which
  Reset and Import keep and Export leaves out
- WorkspaceHost split into partial files, with stubs for usage, trash and
  the folder move, removal hooks for unsent renders and last originals,
  and a guard that holds work while the workspace moves
- every new string of the phase in English and Italian, with tooltips

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:05:09 +01:00

136 lines
6.8 KiB
C#

using Chronos.Core.Model;
using Chronos.Data.Jobs;
using Chronos.Testing;
namespace Chronos.Data.Tests.Jobs;
/// <summary>The priority queue of the settings (owner review 1, R2): levels per kind of job, the claim order and what interrupts.</summary>
[Category("jobs")]
public sealed class JobPriorityQueueTests
{
private static readonly DateTimeOffset T0 = new(2026, 10, 16, 9, 0, 0, TimeSpan.Zero);
[Test]
public void RendersImportsAndDownloadsComeFirstAndTheLongResumablePassesLast()
{
var queue = new JobPriorityQueue();
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Render));
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Import));
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Download));
// Edit waits for the copy of a project's media into the workspace: it goes before scans and analyses.
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceCopy));
var on = queue with { Enabled = true };
Assert.True(on.Interrupts(JobKind.WorkspaceCopy, JobKind.Scan));
Assert.False(on.Interrupts(JobKind.WorkspaceCopy, JobKind.Render));
Assert.Equal(JobKindPriority.Low, queue.LevelOf(JobKind.Verify));
Assert.Equal(JobKindPriority.Low, queue.LevelOf(JobKind.Proxies));
foreach (var kind in new[] { JobKind.Scan, JobKind.Thumbs, JobKind.LightAnalyse, JobKind.DeepAnalyse, JobKind.Maintenance })
Assert.Equal(JobKindPriority.Normal, queue.LevelOf(kind));
// A level the user set wins over the default.
Assert.Equal(JobKindPriority.Low, (queue with { Levels = new Dictionary<JobKind, JobKindPriority> { [JobKind.Render] = JobKindPriority.Low } }).LevelOf(JobKind.Render));
}
[Test]
public void ALocalRenderAndAWorkspaceMoveGoFirstAndSendingARenderHomeWaitsItsTurn()
{
var queue = new JobPriorityQueue();
// The user waits on a local render as on a render, and Edit is held while the workspace moves.
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceRender));
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceMove));
Assert.Equal(JobKindPriority.Normal, queue.LevelOf(JobKind.WorkspaceSend));
var on = queue with { Enabled = true };
Assert.True(on.Interrupts(JobKind.WorkspaceRender, JobKind.WorkspaceSend));
Assert.False(on.Interrupts(JobKind.WorkspaceSend, JobKind.Scan));
// The defaults are no change: settings store none of them, and read back as they are.
var defaults = new Dictionary<JobKind, JobKindPriority>
{
[JobKind.WorkspaceRender] = JobKindPriority.High,
[JobKind.WorkspaceSend] = JobKindPriority.Normal,
[JobKind.WorkspaceMove] = JobKindPriority.High,
};
Assert.Empty(JobPriorityQueue.Changed(defaults));
var changed = JobPriorityQueue.Changed(new Dictionary<JobKind, JobKindPriority> { [JobKind.WorkspaceSend] = JobKindPriority.Low });
Assert.Equal("low", changed["workspace-send"]);
Assert.Equal(JobKindPriority.Low, JobPriorityQueue.From(true, changed).LevelOf(JobKind.WorkspaceSend));
}
[Test]
public void OnlyAHigherLevelInterruptsAndOnlyWhileTheQueueIsOn()
{
var on = new JobPriorityQueue { Enabled = true };
Assert.True(on.Interrupts(JobKind.Render, JobKind.Scan));
Assert.True(on.Interrupts(JobKind.Scan, JobKind.Verify));
Assert.False(on.Interrupts(JobKind.Scan, JobKind.Render));
Assert.False(on.Interrupts(JobKind.Thumbs, JobKind.Scan));
Assert.False(on.Interrupts(JobKind.Import, JobKind.Render));
Assert.False(JobPriorityQueue.Off.Interrupts(JobKind.Render, JobKind.Verify));
}
[Test]
public void TheQueueOrdersByLevelThenPriorityThenAge()
{
var on = new JobPriorityQueue { Enabled = true };
var oldVerify = Job(JobKind.Verify, JobPriority.User, -30);
var backgroundScan = Job(JobKind.Scan, JobPriority.Background, -20);
var userThumbs = Job(JobKind.Thumbs, JobPriority.User, -10);
var render = Job(JobKind.Render, JobPriority.Normal, 0);
Job[] jobs = [oldVerify, backgroundScan, userThumbs, render];
Assert.SequenceEqual([render, userThumbs, backgroundScan, oldVerify], Sorted(jobs, on));
// Off, the strict queue of before: priority, then age.
Assert.SequenceEqual([oldVerify, userThumbs, render, backgroundScan], Sorted(jobs, JobPriorityQueue.Off));
// Two jobs alike fall back to the id.
var twin = render with { Id = Guid.CreateVersion7() };
Assert.True(on.ClaimsBefore(render, twin) != on.ClaimsBefore(twin, render));
}
[Test]
public void SettingsKeepOnlyTheLevelsThatDifferAndSkipWhatTheyCannotRead()
{
var queue = JobPriorityQueue.From(true, new Dictionary<string, string>
{
["deep-analyse"] = "high",
["Scan"] = "LOW",
["render"] = "high",
["teleport"] = "high",
["verify"] = "urgent",
["99"] = "low",
});
Assert.True(queue.Enabled);
Assert.Equal((JobKindPriority.High, JobKindPriority.Low, JobKindPriority.Low), (queue.LevelOf(JobKind.DeepAnalyse), queue.LevelOf(JobKind.Scan), queue.LevelOf(JobKind.Verify)));
var stored = JobPriorityQueue.Changed(Enum.GetValues<JobKind>().ToDictionary(k => k, queue.LevelOf));
Assert.SequenceEqual(["deep-analyse", "scan"], stored.Keys.Order(StringComparer.Ordinal));
Assert.Equal(("high", "low"), (stored["deep-analyse"], stored["scan"]));
var reread = JobPriorityQueue.From(true, stored);
foreach (var kind in Enum.GetValues<JobKind>()) Assert.Equal(queue.LevelOf(kind), reread.LevelOf(kind));
Assert.Equal(JobKindPriority.High, JobPriorityQueue.From(false, stored).LevelOf(JobKind.DeepAnalyse));
Assert.False(JobPriorityQueue.From(false, null).Enabled);
}
[Test]
public void TheClaimOrderOfTheDatabaseListsOnlyTheLevelsOtherThanNormal()
{
var on = new JobPriorityQueue { Enabled = true };
Assert.Equal(string.Empty, JobPriorityQueue.Off.OrderSql([JobKind.Render, JobKind.Verify]));
Assert.Equal(string.Empty, on.OrderSql([JobKind.Scan, JobKind.Thumbs]));
Assert.Equal("CASE WHEN kind IN (7) THEN 2 WHEN kind IN (2) THEN 0 ELSE 1 END DESC, ", on.OrderSql([JobKind.Render, JobKind.Verify, JobKind.Scan, JobKind.Render]));
}
private static Job[] Sorted(Job[] jobs, JobPriorityQueue queue)
{
var list = jobs.ToList();
list.Sort((a, b) => a.Id == b.Id ? 0 : queue.ClaimsBefore(a, b) ? -1 : 1);
return [.. list];
}
private static Job Job(JobKind kind, JobPriority priority, int minutes) => new()
{
Id = Guid.CreateVersion7(),
Kind = kind,
Priority = priority,
State = JobState.Queued,
Created = T0.AddMinutes(minutes),
};
}