Files
Chronos/tests/Chronos.App.Tests/Archive/ConvertDialogTests.cs
T
Alby96 c669d0504d fix(convert): the job converts exactly the photos its preview listed, once
A conversion job could still do something its confirmed dry run did not show,
or refuse what it should have converted:

- An upload landing between the confirmation and the sequence's turn made the
  sequence Changed at every retry. Each ConvertSequence now names the photos
  the plan converts (Photos, their frame ids); the job takes those from its
  re-plan, checks their content against the confirmed digest and leaves photos
  that came in since as they are. A photo the plan did not list is never
  converted, whatever changed on disk or in the index since the dry run.
- A file another program held during the dry run was planned as Missing and
  then converted or not depending on the re-plan. It is now its own reason
  (inaccessible, "held open or cannot be opened"); a truncated file reads as
  undecodable. At job time a confirmed photo that cannot be opened leaves the
  sequence Blocked for the retry; a held photo the job does not convert does
  not hide a real change.
- The same sequences could be converted twice (two dialogs or tabs, a lost
  answer, no dry run at all). MassConverter.QueueAsync checks the queued,
  running and paused conversions and queues under one lock, in the caller's
  context (the desktop's enqueue shows a toast on the UI thread); a job's own
  re-plan treats sequences of conversions queued before it as busy.
- The per-photo space check reserved a full batch of photos even when fewer
  were left, so a job whose preview had the space could stop at every retry.
  It now reserves the photo and those after it that may convert at once.
- New sequence now says in the dry run, the panel's totals and confirmation,
  and a new desktop confirmation, how many photos each new sequence lacks;
  only sequences that are copied use those words.
- On the server, a confirmation takes only the plan kept for the index as it
  is now (503 plan_dropped otherwise, never a plan made inside the request),
  and busy sequences and free space are as they are at every request. The
  panel's Apply asks the dry run again first, with Close still available,
  and confirms only the same fingerprint.
- Maintenance keeps another host's conversion staging as long as its journal
  and purges both together; the unstaged-copy failure and blocked sequences
  are logged in catalog sentences.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit fefd9c34ebfeed1f9e84161610ef286026d38355)
2026-11-02 10:33:34 +01:00

509 lines
30 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 System.Globalization;
using System.IO;
using System.Security.Cryptography;
using System.Text.Json;
using Chronos.App.Archiving;
using Chronos.App.Infrastructure;
using Chronos.App.Tests.Import;
using Chronos.App.Tests.Uploader;
using Chronos.Core.Archiving;
using Chronos.Core.Conversion;
using Chronos.Core.Imaging;
using Chronos.Core.Imaging.Decoders;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Data.Archiving.Jobs;
using Chronos.Data.Jobs;
using Chronos.Testing;
namespace Chronos.App.Tests.Archiving;
/// <summary>
/// Convert… (owner review 2, R7): the format, the JPEG quality and the mode chosen at every run, the dry run listed sequence
/// by sequence with the space line, the typed confirmation of a Replace, Apply queuing the job of exactly the plan on
/// screen, and the Undo a finished Replace offers.
/// </summary>
public sealed class ConvertDialogTests(TestContext context)
{
private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0);
private static ConvertFramePlan Frame(int index, long size = 1_000_000, long estimated = 2_000_000) =>
new(Guid.CreateVersion7(), index, $"originals/IMG_{index + 1:0000}.JPG", ImageFileFormat.Jpeg, size, estimated);
[Test]
public void TheDryRunIsListedSequenceBySequence()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var harbour = new ConvertSequencePlan(Guid.CreateVersion7(), "Harbour sunset", "2026/2026-09-28 Canon EOS R5", 4, [Frame(0), Frame(1), Frame(2)],
[new ConvertSkipped(ConvertSkip.SameFormat, 2), new ConvertSkipped(ConvertSkip.Unhashed, 1)], []);
var comet = new ConvertSequencePlan(Guid.CreateVersion7(), "Comet", "2025/Comet", 2, [], [], [ConvertBlock.Busy, ConvertBlock.Offline]);
var empty = new ConvertSequencePlan(Guid.CreateVersion7(), "Empty", "2025/Empty", 1, [], [], []);
var untitled = new ConvertSequencePlan(Guid.CreateVersion7(), string.Empty, "2026/2026-09-29", 1, [Frame(0, 500_000, 700_000)], [], []);
var plan = new ConvertPlan(Guid.CreateVersion7(), new ConvertOptions(ConvertTarget.LinearDng), ConvertMode.Replace, [harbour, comet, empty, untitled],
new ConvertSpace(ConvertPlanner.Required(6_700_000), 40_000_000_000));
var rows = ConvertPlans.Rows(plan);
Assert.SequenceEqual([harbour.SequenceId, comet.SequenceId, untitled.SequenceId], rows.Select(r => r.SequenceId), "a sequence with nothing to say is left out");
var first = rows[0];
Assert.Equal(("Harbour sunset", false, false), (first.Name, first.IsNamePath, first.IsBlocked));
Assert.Equal(Loc.Plural("Shell.Status.Photos", 3) + Loc.Separator + ConvertPlans.Sizes(3_000_000, 6_000_000), first.Note);
Assert.SequenceEqual(
[
Loc.L("Archive.Convert.Skipped.SameFormat") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 2),
Loc.L("Archive.Convert.Skipped.Unhashed") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 1),
],
first.Kept);
Assert.Contains(first.Note, first.Description);
Assert.Contains(first.Kept[1], first.Description);
var busy = rows[1];
Assert.True(busy.IsBlocked);
Assert.False(busy.HasNote, "nothing of it converts");
Assert.SequenceEqual([Loc.L("Archive.Convert.Blocked.Busy"), Loc.L("Archive.Convert.Blocked.Offline")], busy.Kept);
var folder = rows[2];
Assert.Equal(("2026/2026-09-29", true), (folder.Name, folder.IsNamePath), "without a title, the row is named by its folder, left to right");
Assert.Equal(string.Join(Loc.Separator, Loc.Plural("Archive.Rename.Summary", 2, 4), Loc.Plural("Shell.Status.Photos", 4), ConvertPlans.Sizes(3_500_000, 6_700_000),
Loc.Plural("Archive.Convert.SkippedPhotos", 3)), ConvertPlans.Summary(plan));
Assert.Equal(Loc.Plural("Archive.Rename.Summary", 0, 1), ConvertPlans.Summary(plan with { Sequences = [comet] }), "nothing converts, nothing more is said");
// Into a new sequence, which holds the converted copies alone: the photos skipped are not copied into it. Of a
// sequence that converts nothing no copy is made, and its photos stay as they are.
var same = new ConvertSequencePlan(Guid.CreateVersion7(), "Lake", "2025/Lake", 1, [], [new ConvertSkipped(ConvertSkip.SameFormat, 2)], []);
var copies = plan with { Mode = ConvertMode.NewSequence, Sequences = [harbour, comet, empty, untitled, same] };
var copied = ConvertPlans.Rows(copies);
Assert.SequenceEqual(
[
Loc.L("Archive.Convert.NotCopied.SameFormat") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 2),
Loc.L("Archive.Convert.NotCopied.Unhashed") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 1),
],
copied[0].Kept);
Assert.SequenceEqual(busy.Kept, copied[1].Kept, "what blocks a sequence reads the same");
Assert.SequenceEqual([Loc.L("Archive.Convert.Skipped.SameFormat") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 2)], copied[3].Kept);
Assert.Equal(3, ConvertPlans.LeftOut(copies));
Assert.Equal(string.Join(Loc.Separator, Loc.Plural("Archive.Rename.Summary", 2, 5), Loc.Plural("Shell.Status.Photos", 4), ConvertPlans.Sizes(3_500_000, 6_700_000),
Loc.Plural("Archive.Convert.NotCopiedPhotos", 3), Loc.Plural("Archive.Convert.SkippedPhotos", 2)), ConvertPlans.Summary(copies));
// New sequence is confirmed too, before anything is queued: what is copied, nothing to type, and which photos the
// new sequences lack, with their count, sequence by sequence.
var copy = Assert.NotNull(ConvertPlans.NewRequest(copies));
Assert.False(copy.IsDestructive);
Assert.Null(copy.TypedConfirmation);
Assert.Equal(Loc.Plural("Archive.Convert.NewHeading", 2), copy.Heading);
Assert.Equal(Loc.L("Archive.Convert.NewMessage", Loc.Plural("Shell.Status.Photos", 4), Formatting.Bytes(3_500_000), Loc.L("Archive.Convert.Target.LinearDng"))
+ " " + Loc.Plural("Archive.Convert.NewLeftOut", 3), copy.Message);
Assert.SequenceEqual(
[
Loc.L("Archive.Delete.Line", "Harbour sunset", Loc.Plural("Shell.Status.Photos", 3), ConvertPlans.Sizes(3_000_000, 6_000_000))
+ Loc.Separator + Loc.Plural("Archive.Convert.NotCopiedPhotos", 3),
Loc.L("Archive.Delete.Line", "2026/2026-09-29", Loc.Plural("Shell.Status.Photos", 1), ConvertPlans.Sizes(500_000, 700_000)),
],
copy.Detail!.Split(Environment.NewLine));
Assert.Equal((Loc.L("Archive.Convert.Confirm"), Loc.L("Archive.Dialog.Cancel")), (copy.ActionText, copy.SafeText));
Assert.Equal(Loc.L("Archive.Convert.NewMessage", Loc.Plural("Shell.Status.Photos", 1), Formatting.Bytes(500_000), Loc.L("Archive.Convert.Target.LinearDng")),
ConvertPlans.NewRequest(copies with { Sequences = [untitled, same] })!.Message, "nothing left out, nothing said of it");
Assert.Null(ConvertPlans.NewRequest(copies with { Sequences = [comet, empty, same] }), "nothing to copy, nothing to confirm");
// The space line: enough, short, or not measurable.
var required = Formatting.Bytes(plan.Space.Required);
Assert.Equal(new ConvertSpaceLine(Loc.L("Archive.Convert.Space", required, Formatting.Bytes(40_000_000_000)), false), ConvertPlans.Space(plan.Space));
Assert.Equal(new ConvertSpaceLine(Loc.L("Archive.Convert.SpaceShort", required, Formatting.Bytes(1_000)), true),
ConvertPlans.Space(plan.Space with { Free = 1_000 }));
Assert.Equal(new ConvertSpaceLine(Loc.L("Archive.Convert.SpaceUnknown", required), false), ConvertPlans.Space(plan.Space with { Free = null }));
// A Replace is confirmed by typing the number of photos it replaces.
var request = Assert.NotNull(ConvertPlans.ReplaceRequest(plan));
Assert.True(request.IsDestructive);
Assert.Equal("4", request.TypedConfirmation);
Assert.Equal(Loc.L("Archive.Delete.Type", "4"), request.TypedPrompt);
Assert.Equal(Loc.Plural("Archive.Convert.ReplaceHeading", 2), request.Heading);
Assert.Contains(Loc.L("Archive.Convert.Target.LinearDng"), request.Message);
Assert.Contains("Harbour sunset", request.Detail!);
Assert.False(request.Detail!.Contains("Comet", StringComparison.Ordinal), "a blocked sequence keeps its photos");
Assert.Null(ConvertPlans.ReplaceRequest(plan with { Sequences = [comet, empty] }), "nothing to replace, nothing to confirm");
Assert.Null(ConvertPlans.ValidateQuality("95"));
Assert.Null(ConvertPlans.ValidateQuality(" 1 "));
Assert.NotNull(ConvertPlans.ValidateQuality("0"));
Assert.NotNull(ConvertPlans.ValidateQuality("101"));
Assert.NotNull(ConvertPlans.ValidateQuality("high"));
}
[Test]
public async Task TheModeIsChosenAtEveryRunAndApplyQueuesExactlyThatPlan()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var directory = context.CreateTempDirectory("convert-dialog");
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation);
var archives = Service(db);
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation);
var harbour = await UploadAsync(archives, archive, "harbour", Start, 1);
var comet = await UploadAsync(archives, archive, "comet", Start.AddDays(1), 11);
var queued = new TaskCompletionSource<ArchiveJobRequest>(TaskCreationOptions.RunContinuationsAsynchronously);
List<ConfirmRequest> asked = [];
var closed = false;
using var dialog = new ConvertDialogViewModel(archives, archive, [harbour, comet], request =>
{
queued.TrySetResult(request);
return Task.CompletedTask;
}, request =>
{
asked.Add(request);
return true;
}, _ => closed = true);
// The archival format, the default quality, and no mode: every run chooses it.
Assert.Equal(ConvertTarget.LinearDng, dialog.Target);
Assert.True(dialog.IsLinearDng);
Assert.False(dialog.IsQualityEnabled, "only a JPEG has a quality");
Assert.Equal(ConvertOptions.DefaultQuality.ToString(CultureInfo.InvariantCulture), dialog.Quality.Text);
Assert.Null(dialog.Mode);
Assert.False(dialog.IsReplace || dialog.IsNewSequence);
Assert.Equal(Loc.Plural("Archive.Convert.Heading", 2), dialog.Heading);
await dialog.PlanAsync();
var plan = Assert.NotNull(dialog.Plan);
Assert.Equal(4, plan.Frames);
Assert.Count(2, dialog.Rows);
Assert.True(dialog.Rows.All(r => r.HasNote && !r.HasKept));
Assert.Equal(Loc.Plural("Archive.Rename.Summary", 2, 2), dialog.SummaryText.Split(Loc.Separator)[0]);
Assert.True(dialog.IsSpaceFine);
Assert.NotNull(dialog.SpaceText);
Assert.Equal(Loc.L("Archive.Blocked.NoMode"), dialog.ApplyToolTip, "the mode is never assumed");
Assert.False(dialog.ApplyCommand.CanExecute(null));
dialog.IsNewSequence = true;
Assert.Equal(ConvertMode.NewSequence, dialog.Mode);
Assert.Equal(ConvertMode.NewSequence, dialog.Plan!.Mode, "the plan on screen is the mode chosen");
Assert.Equal(Loc.L("Tooltips.Archive.ConvertApplyNew"), dialog.ApplyToolTip);
Assert.True(dialog.ApplyCommand.CanExecute(null));
// JPEG to JPEG converts nothing: no new sequence is made of them, so in either mode the rows and the summary say the
// photos stay as they are. A quality outside 1-100 blocks a JPEG only.
dialog.IsJpeg = true;
Assert.Equal(Loc.L("Archive.Blocked.Planning"), dialog.ApplyToolTip, "the dry run on screen is not the one of the format chosen");
await dialog.PlanAsync();
Assert.SequenceEqual([Loc.L("Archive.Convert.Skipped.SameFormat") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 2)], dialog.Rows[0].Kept);
Assert.Equal(Loc.Plural("Archive.Convert.SkippedPhotos", 4), dialog.SummaryText.Split(Loc.Separator)[^1]);
dialog.IsReplace = true;
Assert.SequenceEqual([Loc.L("Archive.Convert.Skipped.SameFormat") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 2)], dialog.Rows[0].Kept);
Assert.Equal(Loc.Plural("Archive.Convert.SkippedPhotos", 4), dialog.SummaryText.Split(Loc.Separator)[^1]);
dialog.IsNewSequence = true;
Assert.Equal(Loc.L("Archive.Blocked.NothingToConvert"), dialog.ApplyToolTip);
// A click on Apply takes the focus from the quality first, which commits it: the dry run on screen is of that
// quality already, so no other one starts under the click.
dialog.Quality.Text = "90";
await dialog.PlanAsync();
Assert.True(dialog.Quality.IsDirty, "typed, not committed");
Assert.True(dialog.Quality.Commit());
Assert.Null(dialog.BusyText);
Assert.Equal(new ConvertOptions(ConvertTarget.Jpeg, 90), dialog.Plan!.Options);
dialog.Quality.Text = "0";
Assert.Null(dialog.Current());
Assert.Equal(dialog.Quality.Error, dialog.ApplyToolTip);
dialog.IsTiff16 = true;
Assert.Null(dialog.Quality.Error, "a TIFF has no quality");
Assert.Equal(new ConvertOptions(ConvertTarget.Tiff16), dialog.Current());
await dialog.PlanAsync();
plan = Assert.NotNull(dialog.Plan);
Assert.Equal(4, plan.Frames);
dialog.ApplyCommand.Execute(null);
var request = await queued.Task.WaitAsync(TimeSpan.FromSeconds(TestTiming.Budget(20)));
await UntilAsync(() => closed);
// Confirmed first, with what the new sequences hold: the originals stay as they are, so nothing to type.
var confirmed = asked.Single();
Assert.Equal(ConvertPlans.NewRequest(plan with { Mode = ConvertMode.NewSequence }), confirmed);
Assert.Null(confirmed.TypedConfirmation);
Assert.Equal(JobKind.Convert, request.Kind);
Assert.SequenceEqual(new[] { harbour, comet }.Order(), request.Targets.Order());
Assert.Equal(archive.Name, request.Label);
Assert.Equal(JobPriority.User, request.Priority);
using (var parameters = JsonDocument.Parse(request.ParametersJson!))
{
var json = parameters.RootElement;
Assert.Equal("Tiff16", json.GetProperty("target").GetString());
Assert.Equal("NewSequence", json.GetProperty("mode").GetString());
var fingerprint = (await archives.PlanConvertAsync(archive.Id, [harbour, comet], new ConvertOptions(ConvertTarget.Tiff16), ConvertMode.NewSequence,
context.Cancellation)).Fingerprint();
Assert.Equal(fingerprint, json.GetProperty("fingerprint").GetString(), "the job is the plan of the mode chosen");
}
Assert.Equal(2, (await db.Frames.ListBySequenceAsync(harbour)).Count(f => f.Format == ImageFileFormat.Jpeg), "the job converts, not the dialog");
}
[Test]
public async Task ASecondDialogOnTheSameSequencesIsRefusedAndShowsThemBusy()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var directory = context.CreateTempDirectory("convert-twice");
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation);
var archives = Service(db);
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation);
var harbour = await UploadAsync(archives, archive, "harbour", Start, 1);
// Queued as the engine does: the job waits in the index.
async Task Enqueue(ArchiveJobRequest request) => await db.Jobs.EnqueueAsync(new Job
{
Id = Guid.CreateVersion7(),
Kind = request.Kind,
TargetIds = request.Targets,
ParametersJson = request.ParametersJson,
State = JobState.Queued,
Created = DateTimeOffset.UtcNow,
}, context.Cancellation);
var closed = new List<ArchiveDialogViewModel>();
ConvertDialogViewModel Open() => new(archives, archive, [harbour], Enqueue, _ => true, closed.Add) { IsNewSequence = true };
// The Library's dialog and the Archive manager's, both planned before either applies.
using var library = Open();
using var manager = Open();
await library.PlanAsync();
await manager.PlanAsync();
library.ApplyCommand.Execute(null);
await UntilAsync(() => closed.Contains(library));
// The second is refused: it says why, plans again with the sequence busy, and stays open.
manager.ApplyCommand.Execute(null);
await UntilAsync(() => manager.ErrorText is not null && !manager.IsBusy && manager.Plan is not null);
Assert.Equal(Loc.L("Archive.Convert.AlreadyQueued"), manager.ErrorText);
Assert.SequenceEqual([Loc.L("Archive.Convert.Blocked.Busy")], manager.Rows.Single().Kept);
Assert.Equal(Loc.L("Archive.Blocked.NothingToConvert"), manager.ApplyToolTip);
Assert.DoesNotContain(manager, closed);
Assert.Count(1, (await db.Jobs.ListAsync(JobState.Queued, JobKind.Convert)).Items);
}
/// <summary>
/// Apply queues the job on the dialog's own thread, the check against the conversions queued already included: the
/// desktop's enqueue tells the user with a toast, which only the UI thread may show.
/// </summary>
[Test]
public void TheJobIsQueuedOnTheDialogsThread() => SingleThreadedContext.Run(async () =>
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var directory = context.CreateTempDirectory("convert-thread");
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation);
var archives = Service(db);
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation);
var harbour = await UploadAsync(archives, archive, "harbour", Start, 1);
var ui = Environment.CurrentManagedThreadId;
int? queuedOn = null;
var closed = false;
using var dialog = new ConvertDialogViewModel(archives, archive, [harbour], _ =>
{
queuedOn = Environment.CurrentManagedThreadId;
return Task.CompletedTask;
}, _ => true, _ => closed = true);
dialog.IsNewSequence = true;
await dialog.PlanAsync();
dialog.ApplyCommand.Execute(null);
await UntilAsync(() => closed);
Assert.Equal<int?>(ui, queuedOn);
});
[Test]
public async Task AVolumeWithoutTheSpaceBlocksApply()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var directory = context.CreateTempDirectory("convert-space");
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation);
var archives = Service(db, freeSpace: _ => 1_000);
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation);
var harbour = await UploadAsync(archives, archive, "harbour", Start, 1);
using var dialog = new ConvertDialogViewModel(archives, archive, null, _ => Task.CompletedTask, _ => true, _ => { });
Assert.Equal(Loc.L("Archive.Convert.HeadingAll", "Main"), dialog.Heading, "every sequence of the archive");
dialog.Mode = ConvertMode.Replace;
await dialog.PlanAsync();
var plan = Assert.NotNull(dialog.Plan);
Assert.SequenceEqual([harbour], plan.Sequences.Select(s => s.SequenceId));
Assert.True(dialog.IsSpaceShort);
Assert.False(dialog.IsSpaceFine);
Assert.Equal(ConvertPlans.Space(plan.Space).Text, dialog.SpaceText);
Assert.Equal(dialog.SpaceText, dialog.ApplyToolTip);
Assert.False(dialog.ApplyCommand.CanExecute(null));
}
[Test]
public async Task AReplaceIsTypedFirstAndItsUndoBringsTheOriginalsBack()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var directory = context.CreateTempDirectory("convert-replace");
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation);
var archives = Service(db);
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation);
var harbour = await UploadAsync(archives, archive, "harbour", Start, 1);
var comet = await UploadAsync(archives, archive, "comet", Start.AddDays(1), 11);
var originals = (await db.Frames.ListBySequenceAsync(harbour)).Select(f => (f.Id, f.Sha256, f.Format)).ToList();
var queued = new TaskCompletionSource<ArchiveJobRequest>(TaskCreationOptions.RunContinuationsAsynchronously);
var answer = false;
ConfirmRequest? asked = null;
var closed = false;
using var dialog = new ConvertDialogViewModel(archives, archive, [harbour, comet], request =>
{
queued.TrySetResult(request);
return Task.CompletedTask;
}, request =>
{
asked = request;
return answer;
}, _ => closed = true);
dialog.IsReplace = true;
await dialog.PlanAsync();
Assert.Equal(Loc.L("Tooltips.Archive.ConvertApplyReplace"), dialog.ApplyToolTip);
// Not typed: nothing is queued and the dialog stays.
dialog.ApplyCommand.Execute(null);
var confirm = Assert.NotNull(asked);
Assert.Equal("4", confirm.TypedConfirmation);
Assert.True(confirm.IsDestructive);
Assert.False(queued.Task.IsCompleted);
Assert.False(closed);
answer = true;
dialog.ApplyCommand.Execute(null);
var request = await queued.Task.WaitAsync(TimeSpan.FromSeconds(TestTiming.Budget(20)));
await UntilAsync(() => closed);
using (var parameters = JsonDocument.Parse(request.ParametersJson!))
Assert.Equal("Replace", parameters.RootElement.GetProperty("mode").GetString());
// The job replaces the photos; its end offers Undo, which takes back exactly its originals.
Job job;
await using (var engine = new JobEngine(db, archives.CreateJobHandlers(),
new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }))
{
await engine.StartAsync(context.Cancellation);
job = await WaitForAsync(db, (await engine.EnqueueAsync(request, cancellationToken: context.Cancellation)).Id);
}
Assert.True((await db.Frames.ListBySequenceAsync(harbour)).All(f => f.Format == ImageFileFormat.Dng));
Assert.True(ConvertUndo.Replaces(job));
var parametersOf = Assert.NotNull(ConvertUndo.Parameters(job));
Assert.Equal((archive.Id, ConvertMode.Replace, ConvertTarget.LinearDng), (parametersOf.ArchiveId, parametersOf.Mode, parametersOf.Target));
var trash = await archives.ListTrashAsync(archive.Id, context.Cancellation);
Assert.SequenceEqual(new[] { harbour, comet }.Order(), ConvertUndo.Entries(job, parametersOf, trash).Select(e => e.SequenceId).Order());
var undone = await ConvertUndo.UndoAsync(archives, [job], null, context.Cancellation);
Assert.Equal((2, 0, 2), (undone.Restored, undone.AsNew, undone.Entries));
Assert.Null(undone.Failure);
Assert.Empty(undone.Kept);
Assert.SequenceEqual(originals, (await db.Frames.ListBySequenceAsync(harbour)).Select(f => (f.Id, f.Sha256, f.Format)));
Assert.Equal((Loc.Plural("Archive.Convert.Undone", 2), (string?)null, false), ConvertUndo.Words(undone));
// The converted files are in the trash now: a second undo finds no originals of this job to bring back.
Assert.Count(2, (await archives.ListTrashAsync(archive.Id, context.Cancellation)).Where(e => e.Kind == TrashKind.Replaced));
var again = await ConvertUndo.UndoAsync(archives, [job], null, context.Cancellation);
Assert.Equal(0, again.Entries);
Assert.Equal((Loc.L("Archive.Convert.UndoNothing"), (string?)null, true), ConvertUndo.Words(again));
Assert.SequenceEqual(originals, (await db.Frames.ListBySequenceAsync(harbour)).Select(f => (f.Id, f.Sha256, f.Format)));
}
[Test]
public void TheUndoTakesTheReplacedEntriesTheJobMade()
{
var archive = Guid.CreateVersion7();
var (harbour, comet, other) = (Guid.CreateVersion7(), Guid.CreateVersion7(), Guid.CreateVersion7());
var created = new DateTimeOffset(2026, 10, 27, 9, 0, 0, TimeSpan.Zero);
var parameters = new ConvertJobParameters(archive, ConvertTarget.Jpeg, 90, ConvertMode.Replace, [new ConvertSequence(harbour, 3), new ConvertSequence(comet, 1)], "fp");
var job = new Job
{
Id = Guid.CreateVersion7(),
Kind = JobKind.Convert,
TargetIds = [harbour, comet],
State = JobState.Done,
ParametersJson = $$"""{"archiveId":"{{archive}}","target":"Jpeg","quality":90,"mode":"Replace","sequences":[{"id":"{{harbour}}","framesVersion":3},{"id":"{{comet}}","framesVersion":1}],"fingerprint":"fp"}""",
Created = created,
Finished = created.AddMinutes(10),
};
TrashEntry Entry(string name, Guid sequence, int minutes, Guid? madeBy, TrashKind kind = TrashKind.Replaced, Guid? owner = null) =>
new(owner ?? archive, name, sequence, name, "2026/" + name, 3, 3, 3_000, created.AddMinutes(minutes), null, kind) { JobId = madeBy };
TrashEntry[] trash =
[
Entry("before", harbour, -5, Guid.CreateVersion7()),
Entry("harbour", harbour, 2, job.Id),
// A restore from Maintenance › Trash while the job ran: the converted files of its swap-back, made by no job.
Entry("restored", harbour, 4, null),
Entry("comet", comet, 6, job.Id),
Entry("deleted", comet, 7, job.Id, TrashKind.Photos),
Entry("other", other, 5, job.Id),
Entry("elsewhere", harbour, 5, job.Id, owner: Guid.CreateVersion7()),
Entry("undo", comet, 12, null),
];
Assert.SequenceEqual(["harbour", "comet"], ConvertUndo.Entries(job, parameters, trash).Select(e => e.Name));
Assert.True(ConvertUndo.Replaces(job));
Assert.False(ConvertUndo.Replaces(job with { ParametersJson = job.ParametersJson!.Replace("\"Replace\"", "\"NewSequence\"", StringComparison.Ordinal) }));
Assert.False(ConvertUndo.Replaces(job with { Kind = JobKind.Move }), "only a conversion");
Assert.Null(ConvertUndo.Parameters(job with { ParametersJson = "{ torn" }));
}
[Test]
public void AnUndoSaysWhatCameBackAndHow()
{
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
var asNew = ConvertUndo.Words(new ConvertUndoResult(2, 1, [], 3, null));
Assert.Equal((Loc.Plural("Archive.Convert.Undone", 3), Loc.Plural("Archive.Convert.UndoneNew", 1), false), asNew);
var kept = ConvertUndo.Words(new ConvertUndoResult(1, 0, [new KeptPhoto("IMG_0002.JPG", KeptReason.Mismatch)], 1, null));
Assert.Equal(TrashDialogViewModel.KeptText([new KeptPhoto("IMG_0002.JPG", KeptReason.Mismatch)]).Text, kept.Message);
var failed = ConvertUndo.Words(new ConvertUndoResult(0, 0, [], 1, new UnauthorizedAccessException("denied")));
Assert.Equal((Loc.L("Archive.Convert.UndoFailed"), Loc.L("Archive.Failed.Access"), true), failed);
}
private static ArchiveService Service(ChronosDatabase db, Func<string, long?>? freeSpace = null) =>
new(db, new ArchiveServiceOptions
{
Owner = "test",
LeaseWait = TimeSpan.FromSeconds(TestTiming.Budget(20)),
Decoder = DecoderFactory.CreateServer(),
Parallelism = () => 2,
FreeSpace = freeSpace,
});
/// <summary>Uploads two photos ten seconds apart into a new sequence filed with the archive's templates; returns its id.</summary>
private async Task<Guid> UploadAsync(ArchiveService archives, Core.Model.Archive archive, string key, DateTime start, int seed)
{
Guid id = default;
var staging = Path.Combine(new ArchivePaths(archive.RootPath).StagingDirectory, "uploads");
Directory.CreateDirectory(staging);
for (var i = 0; i < 2; i++)
{
var bytes = ImportTestData.Jpeg(start.AddSeconds(10 * i), seed + i);
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part");
await File.WriteAllBytesAsync(path, bytes, context.Cancellation);
var request = new IngestRequest(archive.Id, null, null, key, path, $"IMG_{seed + i:0000}.JPG", bytes.Length, Convert.ToHexStringLower(SHA256.HashData(bytes)),
null, null);
id = (await archives.Ingest.CommitAsync(request, context.Cancellation)).SequenceId;
}
return id;
}
private async Task<Job> WaitForAsync(ChronosDatabase db, Guid jobId)
{
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(60));
Job? job = null;
while (DateTime.UtcNow < until)
{
job = await db.Jobs.GetAsync(jobId, context.Cancellation);
if (job?.State == JobState.Done) return job;
if (job?.State is JobState.Failed or JobState.Cancelled) Assert.Fail($"The conversion job ended {job.State}: {job.Error}\n{job.LogTail}");
await Task.Delay(20, context.Cancellation);
}
Assert.Fail($"The conversion job did not finish (now {job?.State}).");
return job!;
}
private static async Task UntilAsync(Func<bool> condition)
{
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20));
while (!condition())
{
Assert.True(DateTime.UtcNow < until, "timed out");
await Task.Delay(20);
}
}
}