Owner review 2, R7 asks for mass conversion after import on the desktop too, with a choice at every run between Replace and New sequence. The desktop now uses the engine's conversion, the same plan and job as the web panel. - Convert... in the Archive manager's mass operations (the set) and the Library's mass bar (the selection of one archive; server cards are left out, two archives are refused with their own reason). The dialog has the format (JPEG, TIFF 16-bit, Linear DNG, the archival default), a JPEG's quality (1-100, 95) and the mode, which starts unchosen at every open: Apply waits for it. Each choice has a tooltip that says what becomes of the originals. - The dry run stays in the dialog and follows the choices: each sequence with its photos and sizes before and after, the photos that stay as they are with why, the sequences left as they are (busy, offline, unreadable), a summary and the free space line; a volume without the space blocks Apply. The mode does not change what converts, so choosing it plans nothing again. - Apply asks to type the number of photos a Replace replaces, then queues the convert job of exactly the plan shown; New sequence leaves the originals as they are and asks nothing. - When a Replace job ends, its toast offers Undo: for each sequence it converted, the newest Replaced trash entry made while it ran goes back (a sequence changed since gets its originals as a new sequence). Undo runs once and never from the Windows notification. - The Library and the Archive screen read the sequences again after a conversion; --capture renders archive-convert from a sample plan. - Strings in en and it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 275469284f895fc92e2569339809e18bf59d1d6a) (cherry picked from commit 76ba41f58983275ae4b1478edd403efb11da7c79)
384 lines
22 KiB
C#
384 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);
|
|
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);
|
|
}
|
|
}
|
|
}
|