Owner review 2, R7 asks for mass conversion after import on the desktop too, with a choice at every run between Replace and New sequence. The desktop now uses the engine's conversion, the same plan and job as the web panel. - Convert... in the Archive manager's mass operations (the set) and the Library's mass bar (the selection of one archive; server cards are left out, two archives are refused with their own reason). The dialog has the format (JPEG, TIFF 16-bit, Linear DNG, the archival default), a JPEG's quality (1-100, 95) and the mode, which starts unchosen at every open: Apply waits for it. Each choice has a tooltip that says what becomes of the originals. - The dry run stays in the dialog and follows the choices: each sequence with its photos and sizes before and after, the photos that stay as they are with why, the sequences left as they are (busy, offline, unreadable), a summary and the free space line; a volume without the space blocks Apply. The mode does not change what converts, so choosing it plans nothing again. - Apply asks to type the number of photos a Replace replaces, then queues the convert job of exactly the plan shown; New sequence leaves the originals as they are and asks nothing. - When a Replace job ends, its toast offers Undo: for each sequence it converted, the newest Replaced trash entry made while it ran goes back (a sequence changed since gets its originals as a new sequence). Undo runs once and never from the Windows notification. - The Library and the Archive screen read the sequences again after a conversion; --capture renders archive-convert from a sample plan. - Strings in en and it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 275469284f895fc92e2569339809e18bf59d1d6a) (cherry picked from commit 76ba41f58983275ae4b1478edd403efb11da7c79)
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,
|
||
};
|
||
}
|