Phase 4b was built on phase 4a before its review fixes. Integrated on the reviewed 4a, the
conversion now follows the same rules as filing and the other writers.
- Names: a converted file is named as filing names a photo of its sequence (FrameNaming: the
archive's file template, the frame's context in the sequence with its camera, lens, number
and title, {name} the card's, {ext} the target's, a long name keeping its extension).
Replace through ConvertOptions.FileName; New sequence through the ingest itself
(StagedFrame.NamedAs), which numbers and names the copies in the new sequence. Names stay
unique against every file present, those leaving included, so a Replace never moves onto a
file; a test pins a stray file that keeps its bytes.
- Leases: stage A starts from the sidecar settled under the sequence's lease where the index
has it then (SequenceWriter.ReadLocked), and FrameTrash.ReplaceAsync reads the row again
under the lease, so a folder a Reorganize moved meanwhile is followed, never made again.
A Reorganize the archive waits for keeps the conversion off its sequences (pinned).
- Journals: the replace journal is settled with the others. MassRenamer steps, restores into
a sequence and sequence deletions wait for an unsettled replacement as they wait for a
restore, and so do photo deletions, whose frames version the recovery reads
(FrameTrash.EnsureReplaced); a scan settles it and reconciles nothing meanwhile; a restore
settles its sequence's replace journal first, at the folder the index has under the lease.
- The convert job tells each sequence converted or made as it completes, as a Reorganize
tells each step, so an editor open on it reads it again while the rest of the job runs.
- Desktop: JobKind.Convert gets its row in the settings' job priority list. A click on Apply
that commits the quality no longer starts the same dry run again under the click (as 4a
fixed for Reorganize).
- Panel: a dry run answered during the confirmation with the same plan no longer drops the
confirmed Apply; a different plan is shown with Admin.Convert.PlanChanged (en, it).
- Tests: TrashDialogTests.EmptyQueuesTheJobOfTheConfirmedPlanOnly waits for the command to
end before running it again (a running AsyncRelayCommand ignored the second Execute).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2e0d1d6dcc10575734970bb9c77749f00777c859)
392 lines
22 KiB
C#
392 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 TheUndoTakesTheNewestReplacedEntryOfEachSequenceTheJobConverted()
|
|
{
|
|
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, TrashKind kind = TrashKind.Replaced, Guid? owner = null) =>
|
|
new(owner ?? archive, name, sequence, name, "2026/" + name, 3, 3, 3_000, created.AddMinutes(minutes), null, kind);
|
|
TrashEntry[] trash =
|
|
[
|
|
Entry("before", harbour, -5),
|
|
Entry("first", harbour, 2),
|
|
Entry("second", harbour, 4),
|
|
Entry("comet", comet, 6),
|
|
Entry("deleted", comet, 7, TrashKind.Photos),
|
|
Entry("other", other, 5),
|
|
Entry("elsewhere", harbour, 5, owner: Guid.CreateVersion7()),
|
|
Entry("undo", comet, 12),
|
|
];
|
|
|
|
Assert.SequenceEqual(["second", "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);
|
|
}
|
|
}
|
|
}
|