The convert endpoint planned the whole selection inside the HTTP request, again for every mode, quality keystroke and confirmation, with no limit: behind a proxy an all-sequence conversion could never get past its dry run or its apply. - ReorganizePlanCache becomes PlanCache, shared by Reorganize and Convert: one plan per key made apart from the request, two at once across both kinds, eight kept, 15-minute timeout, 5-minute lifetime, 503 plan_dropped. Keys are typed records (ReorganizePlanKey, ConvertPlanKey) that also say which exceptions are refusals. - A conversion plan is keyed by archive, a convert stamp of the index (SequenceRepository.GetConvertStampAsync: the Reorganize stamp plus, per planned sequence, the photos' count, sizes, formats, pixel sizes and missing, corrupt, preview-only and undecodable flags), the sequences and the target with the quality that counts. Not the mode: the request's mode and options are set on the kept plan, and the free space is measured again at every request through the engine. A plan made while the volume was away is not kept (503 archive_offline). - New sequence holds the converted copies alone: the dry run says the skipped photos are not copied into it (Archive.Convert.NotCopied.*, Server.Convert.OnPcNew), the panel's totals, column and confirmation give the count, and so does the desktop's summary. - Panel: the preview is asked in Replace's neutral words; a dry run cut off by a proxy is asked again while the totals show how long it takes, plan_dropped is retried once; an apply the server let go plans again, a changed one shows Admin.Convert.PlanChanged, and one with no answer is not resent (its job may be queued). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit f0b1e379ce7c08b6d3459ab25ca6214c8f366f6c)
163 lines
10 KiB
C#
163 lines
10 KiB
C#
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Data.Tests.Infrastructure;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Repositories;
|
|
|
|
/// <summary>
|
|
/// The stamps of what a Reorganize and a conversion plan from in an archive's index (<see cref="SequenceRepository.GetStampAsync"/>,
|
|
/// <see cref="SequenceRepository.GetConvertStampAsync"/>) on both dialects: the server makes a kept plan again once its
|
|
/// stamp is another one, and only then (owner review 2, R7).
|
|
/// </summary>
|
|
public abstract class SequenceStampTests(TestContext context) : RepositoryTest(context)
|
|
{
|
|
[Test]
|
|
public async Task TheStampFollowsWhatAReorganizePlansFromAndNothingElse()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var archive = TestData.Archive();
|
|
var other = TestData.Archive("Other");
|
|
await db.Archives.UpsertAsync(archive, Ct);
|
|
await db.Archives.UpsertAsync(other, Ct);
|
|
var roof = TestData.Sequence(archive.Id, new DateTime(2026, 9, 28, 18, 0, 0), "Roof");
|
|
var inner = TestData.Sequence(archive.Id, null, "Inner") with { Folder = roof.Folder + "/inner" };
|
|
var ridge = TestData.Sequence(archive.Id, new DateTime(2026, 9, 29, 7, 0, 0), "Ridge");
|
|
IReadOnlyList<Guid> planned = [roof.Id];
|
|
var empty = await db.Sequences.GetStampAsync(archive.Id, planned, Ct);
|
|
foreach (var sequence in new[] { roof, inner, ridge }) await db.Sequences.UpsertAsync(sequence, Ct);
|
|
var stamp = await db.Sequences.GetStampAsync(archive.Id, planned, Ct);
|
|
Assert.NotEqual(empty, stamp);
|
|
Assert.Equal(stamp, await db.Sequences.GetStampAsync(archive.Id, planned, Ct));
|
|
Assert.NotEqual(stamp, await db.Sequences.GetStampAsync(archive.Id, null, Ct));
|
|
|
|
// What the plan does not read: another archive, and the writes of every upload, verify, tag or status change elsewhere.
|
|
await db.Sequences.UpsertAsync(TestData.Sequence(other.Id), Ct);
|
|
await VerifyAsync(db, await PhotoAsync(db, ridge, 0, hashed: false));
|
|
await VerifyAsync(db, await PhotoAsync(db, inner, 0, hashed: false));
|
|
Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(ridge.Id, new SequenceEdit { Title = "Ridge at dawn", Notes = "cold" }, null, Ct)).Outcome);
|
|
foreach (var id in new[] { roof.Id, ridge.Id })
|
|
{
|
|
Assert.True(await db.Sequences.SetTagsAsync(id, ["sky"], Ct));
|
|
Assert.True(await db.Sequences.UpdateStatusAsync(id, SequenceStatus.ProxiesBuilt, SequenceStatus.None, Ct));
|
|
Assert.True(await db.Sequences.RecordVerifiedAsync(id, SequenceStatus.None, SequenceStatus.None, TestData.Now, Ct));
|
|
}
|
|
Assert.Equal(stamp, await db.Sequences.GetStampAsync(archive.Id, planned, Ct));
|
|
|
|
// What it reads gives one never seen before: the sequences planned, the titles inside their folders, every folder.
|
|
var seen = new HashSet<string>(StringComparer.Ordinal) { empty, stamp };
|
|
async Task ChangedAsync(string what) => Assert.True(seen.Add(await db.Sequences.GetStampAsync(archive.Id, planned, Ct)), what);
|
|
Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(roof.Id, new SequenceEdit { Title = "Roof at noon" }, null, Ct)).Outcome);
|
|
await ChangedAsync("title");
|
|
var scanned = await PhotoAsync(db, roof, 0, hashed: false);
|
|
await ChangedAsync("photos");
|
|
await VerifyAsync(db, scanned);
|
|
await ChangedAsync("photos hashed by a verify, which a file template renames");
|
|
Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(inner.Id, new SequenceEdit { Title = "Inner court" }, null, Ct)).Outcome);
|
|
await ChangedAsync("title of a sequence a moving folder would carry");
|
|
Assert.True(await db.Sequences.RelocateAsync(ridge.Id, "2026/ridge", null, Ct));
|
|
await ChangedAsync("folder of a sequence not planned");
|
|
Assert.True(await db.Sequences.RelocateAsync(roof.Id, "2026/moved", null, Ct));
|
|
await ChangedAsync("folder");
|
|
var added = TestData.Sequence(archive.Id);
|
|
await db.Sequences.UpsertAsync(added, Ct);
|
|
await ChangedAsync("a sequence added");
|
|
Assert.True(await db.Sequences.DeleteAsync(added.Id, Ct));
|
|
Assert.Contains(await db.Sequences.GetStampAsync(archive.Id, planned, Ct), seen);
|
|
|
|
// With every sequence planned, a photo anywhere changes the plan read, and so does a verify that hashes one; a verify
|
|
// that hashes none still does not.
|
|
var all = await db.Sequences.GetStampAsync(archive.Id, null, Ct);
|
|
Assert.True(await db.Sequences.RecordVerifiedAsync(ridge.Id, SequenceStatus.None, SequenceStatus.None, TestData.Now.AddDays(1), Ct));
|
|
Assert.Equal(all, await db.Sequences.GetStampAsync(archive.Id, null, Ct));
|
|
var photo = await PhotoAsync(db, ridge, 1, hashed: false);
|
|
var uploaded = await db.Sequences.GetStampAsync(archive.Id, null, Ct);
|
|
Assert.NotEqual(all, uploaded);
|
|
await VerifyAsync(db, photo);
|
|
var verified = await db.Sequences.GetStampAsync(archive.Id, null, Ct);
|
|
Assert.False(verified == all || verified == uploaded, "a photo hashed");
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheConvertStampFollowsThePhotosAConversionPlansFrom()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var archive = TestData.Archive();
|
|
await db.Archives.UpsertAsync(archive, Ct);
|
|
var roof = TestData.Sequence(archive.Id, new DateTime(2026, 9, 28, 18, 0, 0), "Roof");
|
|
var ridge = TestData.Sequence(archive.Id, new DateTime(2026, 9, 29, 7, 0, 0), "Ridge");
|
|
foreach (var sequence in new[] { roof, ridge }) await db.Sequences.UpsertAsync(sequence, Ct);
|
|
var photo = await PhotoAsync(db, roof, 0);
|
|
var elsewhere = await PhotoAsync(db, ridge, 0);
|
|
IReadOnlyList<Guid> planned = [roof.Id];
|
|
var stamp = await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct);
|
|
Assert.Equal(stamp, await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct));
|
|
Assert.Equal(stamp, await db.Sequences.GetConvertStampAsync(archive.Id, [roof.Id, roof.Id], Ct));
|
|
Assert.NotEqual(stamp, await db.Sequences.GetConvertStampAsync(archive.Id, null, Ct));
|
|
|
|
// What a conversion does not read: the photos of a sequence not planned, light statistics, tags, a verify time.
|
|
Assert.Equal(1, await db.Frames.UpdateFlagsAsync([elsewhere.Id], FrameFlags.Missing, FrameFlags.None, Ct));
|
|
Assert.Equal(1, await db.Frames.UpdateLightStatsAsync([new FrameLightStats(photo.Id, -2.5, 0.01, 0.02)], Ct));
|
|
Assert.True(await db.Sequences.SetTagsAsync(roof.Id, ["sky"], Ct));
|
|
Assert.True(await db.Sequences.RecordVerifiedAsync(roof.Id, SequenceStatus.Verified, SequenceStatus.None, TestData.Now, Ct));
|
|
Assert.Equal(stamp, await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct));
|
|
|
|
// What it reads, without another frames version: each flag that keeps a photo as it is (a scan's, a verify's, a
|
|
// decode's), the format a decode records, the hash a verify records. Cleared again, the stamp is the one before.
|
|
var seen = new HashSet<string>(StringComparer.Ordinal) { stamp };
|
|
foreach (var flag in new[] { FrameFlags.Missing, FrameFlags.Corrupt, FrameFlags.PreviewOnly, FrameFlags.Undecodable })
|
|
{
|
|
Assert.Equal(1, await db.Frames.UpdateFlagsAsync([photo.Id], flag, FrameFlags.None, Ct));
|
|
Assert.True(seen.Add(await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct)), flag.ToString());
|
|
Assert.Equal(1, await db.Frames.UpdateFlagsAsync([photo.Id], FrameFlags.None, flag, Ct));
|
|
Assert.Equal(stamp, await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct));
|
|
}
|
|
Assert.Equal(1, await db.Frames.UpdateTiersAsync([new FrameTierFields(photo.Id, FrameFlags.None, 0, 0, ImageFileFormat.Dng)], Ct));
|
|
Assert.True(seen.Add(await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct)), "format");
|
|
var unhashed = await PhotoAsync(db, roof, 1, hashed: false);
|
|
Assert.True(seen.Add(await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct)), "a photo added");
|
|
await VerifyAsync(db, unhashed);
|
|
Assert.True(seen.Add(await db.Sequences.GetConvertStampAsync(archive.Id, planned, Ct)), "hashed by a verify");
|
|
|
|
// With every sequence planned, a flag on any photo changes it.
|
|
var all = await db.Sequences.GetConvertStampAsync(archive.Id, null, Ct);
|
|
Assert.Equal(1, await db.Frames.UpdateFlagsAsync([elsewhere.Id], FrameFlags.None, FrameFlags.Missing, Ct));
|
|
Assert.NotEqual(all, await db.Sequences.GetConvertStampAsync(archive.Id, null, Ct));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A photo indexed into a sequence, as an upload does, or without its hash, as a scan does: the frame, then the row's
|
|
/// counts and frames version.
|
|
/// </summary>
|
|
private async Task<Frame> PhotoAsync(ChronosDatabase db, Sequence sequence, int index, bool hashed = true)
|
|
{
|
|
var frame = TestData.Frame(sequence.Id, index);
|
|
frame = frame with { RelativePath = $"{sequence.Folder}/originals/{frame.FileName}", Sha256 = hashed ? frame.Sha256 : null };
|
|
await db.Frames.BulkInsertAsync([frame], Ct);
|
|
Assert.NotNull(await db.Sequences.RefreshStatsAsync(sequence.Id, Ct));
|
|
return frame;
|
|
}
|
|
|
|
/// <summary>What a verify writes once it hashed a photo never hashed: the hash, then the sequence's verify time, and not another frames version.</summary>
|
|
private async Task VerifyAsync(ChronosDatabase db, Frame frame)
|
|
{
|
|
var version = (await db.Sequences.GetAsync(frame.SequenceId, Ct))!.FramesVersion;
|
|
var sha256 = TestData.Frame(frame.SequenceId, frame.Index).Sha256;
|
|
Assert.Equal(1, await db.Frames.UpdateIntegrityAsync([new FrameIntegrity(frame.Id, FrameFlags.None, sha256)], Ct));
|
|
Assert.True(await db.Sequences.RecordVerifiedAsync(frame.SequenceId, SequenceStatus.Verified, SequenceStatus.None, TestData.Now, Ct));
|
|
Assert.Equal(version, (await db.Sequences.GetAsync(frame.SequenceId, Ct))!.FramesVersion);
|
|
}
|
|
}
|
|
|
|
public sealed class SqliteSequenceStampTests(TestContext context) : SequenceStampTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.SqliteMemory;
|
|
}
|
|
|
|
[RequiresEnvironment(PgTestServer.Variable)]
|
|
public sealed class PostgresSequenceStampTests(TestContext context) : SequenceStampTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.Postgres;
|
|
}
|