CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
194 lines
8.8 KiB
C#
194 lines
8.8 KiB
C#
using Chronos.App.Jobs;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.App.Tests.Jobs;
|
||
|
||
/// <summary>UI-08: which job endings raise the shell's toast, whichever screen started the job, and how a batch speaks once.</summary>
|
||
public sealed class JobNoticesTests
|
||
{
|
||
[Theory]
|
||
[Case(JobKind.Render)]
|
||
[Case(JobKind.DeepAnalyse)]
|
||
[Case(JobKind.Verify)]
|
||
[Case(JobKind.Rebuild)]
|
||
[Case(JobKind.Maintenance)]
|
||
[Case(JobKind.UploadCommit)]
|
||
[Case(JobKind.Move)]
|
||
[Case(JobKind.Adopt)]
|
||
[Case(JobKind.Convert)]
|
||
public void ALongOperationThatEndsSaysSo(JobKind kind)
|
||
{
|
||
Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(kind, JobState.Done)));
|
||
Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed)));
|
||
// Queued and finished between two flushes of the Jobs screen: still one notice.
|
||
Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Queued, Job(kind, JobState.Done)));
|
||
Assert.Equal(JobNotice.Done, JobNotices.For(null, Job(kind, JobState.Done)));
|
||
}
|
||
|
||
[Theory]
|
||
[Case(JobKind.Scan)]
|
||
[Case(JobKind.LightAnalyse)]
|
||
[Case(JobKind.Thumbs)]
|
||
[Case(JobKind.Proxies)]
|
||
[Case(JobKind.Cleanup)]
|
||
public void UpkeepAndScansEndSilently(JobKind kind)
|
||
{
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed)));
|
||
}
|
||
|
||
[Theory]
|
||
[Case(JobKind.Import)]
|
||
[Case(JobKind.Download)]
|
||
[Case(JobKind.Duplicates)]
|
||
[Case(JobKind.Orphans)]
|
||
[Case(JobKind.Backup)]
|
||
public void EveryOtherFailureIsSaid(JobKind kind)
|
||
{
|
||
// An import announces its result on the Import screen, a download on its Library card and Server row.
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done)));
|
||
Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed)));
|
||
}
|
||
|
||
[Test]
|
||
public void BackgroundPriorityCancelledAndRepeatedEndingsSayNothing()
|
||
{
|
||
// The deep analysis queued after an import, and the proxies sync fetches, run in the background.
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.DeepAnalyse, JobState.Done, JobPriority.Background)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Download, JobState.Failed, JobPriority.Background)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Cancelled)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Done, Job(JobKind.Render, JobState.Done)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Failed, Job(JobKind.Render, JobState.Failed)));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Queued, Job(JobKind.Render, JobState.Running)));
|
||
// "Add to queue" renders have Normal priority: they are announced too.
|
||
Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Done, JobPriority.Normal)));
|
||
}
|
||
|
||
[Test]
|
||
public void ABatchOfOneKindSpeaksOnceWhenItsLastJobEnds()
|
||
{
|
||
// Server › Upload all: 100 uploads queued; each one that ends waits for the rest.
|
||
var endings = new JobEndings();
|
||
var model = new JobListModel();
|
||
var uploads = Enumerable.Range(0, 100).Select(_ => Job(JobKind.UploadCommit, JobState.Queued)).ToList();
|
||
foreach (var upload in uploads) model.Apply(upload);
|
||
for (var i = 0; i < 99; i++)
|
||
{
|
||
var done = uploads[i] with { State = JobState.Done };
|
||
model.Apply(done);
|
||
endings.Add(JobNotices.For(JobState.Running, done), done);
|
||
Assert.Empty(endings.Take(model.IsBusy));
|
||
}
|
||
Assert.Equal(99, endings.Waiting);
|
||
|
||
// A render of the same flush is its own kind: it is said at once.
|
||
var render = Job(JobKind.Render, JobState.Done);
|
||
model.Apply(render);
|
||
endings.Add(JobNotice.Done, render);
|
||
var due = endings.Take(model.IsBusy);
|
||
Assert.Count(1, due);
|
||
Assert.Equal(JobNotice.Done, due[0].Notice);
|
||
Assert.SequenceEqual([render.Id], due[0].Jobs.Select(j => j.Id));
|
||
|
||
var last = uploads[99] with { State = JobState.Done };
|
||
model.Apply(last);
|
||
endings.Add(JobNotice.Done, last);
|
||
due = endings.Take(model.IsBusy);
|
||
Assert.Count(1, due);
|
||
Assert.SequenceEqual(uploads.Select(u => u.Id), due[0].Jobs.Select(j => j.Id));
|
||
Assert.Equal(0, endings.Waiting);
|
||
Assert.Empty(endings.Take(model.IsBusy));
|
||
}
|
||
|
||
[Test]
|
||
public void PausedAndBackgroundJobsDoNotHoldABatch()
|
||
{
|
||
var endings = new JobEndings();
|
||
var model = new JobListModel();
|
||
// An upload paused on a metered network, and the proxies sync fetches in the background, wait for something else.
|
||
model.Apply(Job(JobKind.UploadCommit, JobState.Paused));
|
||
model.Apply(Job(JobKind.Download, JobState.Running, JobPriority.Background));
|
||
var upload = Job(JobKind.UploadCommit, JobState.Done);
|
||
model.Apply(upload);
|
||
endings.Add(JobNotice.Done, upload);
|
||
Assert.Count(1, endings.Take(model.IsBusy));
|
||
Assert.False(model.IsBusy(JobKind.UploadCommit));
|
||
Assert.False(model.IsBusy(JobKind.Download));
|
||
}
|
||
|
||
[Test]
|
||
public void FailuresAreSaidAtTheEndOfTheirFlushTogether()
|
||
{
|
||
var endings = new JobEndings();
|
||
var model = new JobListModel();
|
||
// More uploads still run: failures do not wait for them.
|
||
model.Apply(Job(JobKind.UploadCommit, JobState.Running));
|
||
var first = Job(JobKind.UploadCommit, JobState.Failed);
|
||
var second = Job(JobKind.Verify, JobState.Failed);
|
||
endings.Add(JobNotice.Failed, first);
|
||
endings.Add(JobNotice.Failed, second);
|
||
endings.Add(JobNotice.None, Job(JobKind.Scan, JobState.Done));
|
||
var due = endings.Take(model.IsBusy);
|
||
Assert.Count(1, due);
|
||
Assert.Equal(JobNotice.Failed, due[0].Notice);
|
||
Assert.SequenceEqual([first.Id, second.Id], due[0].Jobs.Select(j => j.Id));
|
||
|
||
// The next flush starts again.
|
||
var third = Job(JobKind.UploadCommit, JobState.Failed);
|
||
endings.Add(JobNotice.Failed, third);
|
||
due = endings.Take(model.IsBusy);
|
||
Assert.Count(1, due);
|
||
Assert.SequenceEqual([third.Id], due[0].Jobs.Select(j => j.Id));
|
||
Assert.Empty(endings.Take(model.IsBusy));
|
||
}
|
||
|
||
/// <summary>Owner review 2, R10: a schedule's background run is said only when it fails, unless the next run repeats it anyway.</summary>
|
||
[Theory]
|
||
[Case(JobKind.Backup)]
|
||
[Case(JobKind.Verify)]
|
||
[Case(JobKind.Maintenance)]
|
||
[Case(JobKind.Duplicates)]
|
||
[Case(JobKind.DeepAnalyse)]
|
||
public void AScheduledBackgroundRunIsSaidOnlyWhenItFails(JobKind kind)
|
||
{
|
||
var schedule = Guid.CreateVersion7();
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done, JobPriority.Background) with { ScheduleId = schedule }));
|
||
Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule }));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Failed, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule }));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Cancelled, JobPriority.Background) with { ScheduleId = schedule }));
|
||
// The same work queued in the background by something else stays silent.
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background)));
|
||
}
|
||
|
||
[Theory]
|
||
[Case(JobKind.Scan)]
|
||
[Case(JobKind.Thumbs)]
|
||
[Case(JobKind.Proxies)]
|
||
[Case(JobKind.LightAnalyse)]
|
||
[Case(JobKind.Cleanup)]
|
||
public void AScheduledUpkeepRunEndsSilently(JobKind kind)
|
||
{
|
||
var schedule = Guid.CreateVersion7();
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done, JobPriority.Background) with { ScheduleId = schedule }));
|
||
Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule }));
|
||
}
|
||
|
||
[Test]
|
||
public void AScheduledRunAtAHigherPriorityIsSaidAsAnyOther()
|
||
{
|
||
var verify = Job(JobKind.Verify, JobState.Done, JobPriority.Normal) with { ScheduleId = Guid.CreateVersion7() };
|
||
Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, verify));
|
||
}
|
||
|
||
private static Job Job(JobKind kind, JobState state, JobPriority priority = JobPriority.User) => new()
|
||
{
|
||
Id = Guid.CreateVersion7(),
|
||
Kind = kind,
|
||
State = state,
|
||
Priority = priority,
|
||
TargetLabel = "Harbour sunset",
|
||
Created = DateTimeOffset.UtcNow,
|
||
};
|
||
}
|