Files
Chronos/tests/Chronos.App.Tests/Jobs/JobNoticesTests.cs
T
Alby96 a1c1c21ebd feat(app): Convert sequences from the Archive manager and the Library, with Undo after a Replace
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)
2026-10-27 22:02:04 +01:00

194 lines
8.8 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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,
};
}