Owner review 2, phase 4b, fix round 1 (trash, undo, recovery, sync and ingest). - Replace journal: records a phase (moving, written, undoing) and the name each swapped frame is filed under. Recovery decides "sidecar written" by what the sidecar lists, not by the frames version any writer moves; a failed rollback stays undoing and its failure now stops the writer (as a photo deletion's recovery does). The ingest settles restores and replacements first, so an upload can no longer complete a swap that never happened. - Emptying a Replaced entry re-verifies each replacement where it is now: in the sequence through later conversions (a second conversion no longer strands the first originals), or, when the conversion was deleted, its copy in the trash. The dry run marks such entries "conversion deleted" (fingerprinted, shown on the desktop and the panel), and the confirmed emptying may then erase them instead of keeping them forever. - Undo of a conversion takes exactly the entries its job made (the job id is recorded on the entry), never entries found by time window. - Project positions translated by photo use the sidecar's photo of every frame still there, so positions on a converted frame stay put when another frame went meanwhile. - Sync aliases are equivalence classes: an original converted on both sides is one photo; link-by-content, proxy counting and proxy upload follow aliases; a download into a frame missing here swaps the other encoding into that frame instead of adding a frame. - The ingest answers a converted photo's original (a card or folder imported again, a download) as a duplicate of its conversion and keeps the alias tombstone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 3341a2f845753fc4c5bcba51a3b645f126c95eaf)
393 lines
22 KiB
C#
393 lines
22 KiB
C#
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.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");
|
||
|
||
// 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);
|
||
var asked = 0;
|
||
var closed = false;
|
||
using var dialog = new ConvertDialogViewModel(archives, archive, [harbour, comet], request =>
|
||
{
|
||
queued.TrySetResult(request);
|
||
return Task.CompletedTask;
|
||
}, _ =>
|
||
{
|
||
asked++;
|
||
return false;
|
||
}, _ => 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; 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.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);
|
||
Assert.Equal(0, asked, "a new sequence leaves the originals as they are: nothing to type");
|
||
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 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);
|
||
}
|
||
}
|
||
}
|