Files
Chronos/tests/Chronos.App.Tests/Archive/ConvertDialogTests.cs
T
Alby96 341fb77507 fix: conversions name, lock and settle as phase 4a's writers do
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)
2026-10-27 22:03:07 +01:00

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);
}
}
}