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; /// /// 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. /// 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(TaskCreationOptions.RunContinuationsAsynchronously); List 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(); 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); } /// /// 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. /// [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(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(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? freeSpace = null) => new(db, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(TestTiming.Budget(20)), Decoder = DecoderFactory.CreateServer(), Parallelism = () => 2, FreeSpace = freeSpace, }); /// Uploads two photos ten seconds apart into a new sequence filed with the archive's templates; returns its id. private async Task 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 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 condition) { var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20)); while (!condition()) { Assert.True(DateTime.UtcNow < until, "timed out"); await Task.Delay(20); } } }