Files
Alby96andClaude Opus 5.5 efa87f68ce
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
feat: owner review 2 phase 4b: mass conversion after import (#13)
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>
2026-11-03 10:41:50 +01:00

509 lines
30 KiB
C#
Raw Permalink 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);
}
}
}