Files
Chronos/tests/Chronos.Data.Tests/Repositories/CatalogRepositoryTests.cs
T
Alby96 eb2395d9b0 feat(archive): reorganize existing sequences with folder, file and title templates
Owner review 2, R7 asks for renaming and moving after import, on the web panel and the
desktop. This is the engine and the server API both UIs build on.

- FrameNaming (Core/Naming) is the one naming context and unique-name rule of a frame:
  imports, uploads and Reorganize now produce identical names (behaviour of the ingest and
  the import planner unchanged).
- RenamePlanner takes a file template: each step counts its renamed frames, shows the first
  three and the frames version they were planned at, and lists what keeps its name (photos
  in place outside originals/, never hashed, missing, unreadable sidecar). Names are given
  in index order with _2, _3 as filing does; XMP companions follow their photo.
- MassRenamer renames a step's files under the same leases after its folder moved, checks
  the frames version, journals .chronos/rename-files.json and moves files in two phases
  through temporary names so chains and swaps never meet; then sidecar, index
  (FrameRepository.RenameFilesAsync, both dialects) and journal. A failure puts every file
  back; a crash is completed by the next writer or the plan's resume, the index following.
  Plans a paused or cancelled job holds are left to that job.
- JobKind.Move gets MoveJobHandler: it plans again and applies only the confirmed plan
  (fingerprint and frames versions), with progress and checkpoints per sequence.
- POST /api/v1/archive/reorganize: dry run with the plan and its fingerprint, otherwise a
  202 move job; validated templates, audited, sequenceChanged reorganized events.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit aae1c3eb18ea932b4a6251c5e2a282b9295a5785)
2026-10-27 14:03:36 +01:00

523 lines
28 KiB
C#

using System.Text.Json.Nodes;
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>Archives, sequences, frames, renders and tags on both dialects.</summary>
public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTest(context)
{
[Test]
public async Task ArchivesRoundTripAndDelete()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive() with { ProxyLongEdge = -1, FolderTemplate = "{year}/{title}" };
await db.Archives.UpsertAsync(archive, Ct);
await db.Archives.UpsertAsync(archive with { Name = "Renamed" }, Ct);
Assert.Equal(archive with { Name = "Renamed" }, await db.Archives.GetAsync(archive.Id, Ct));
Assert.Count(1, await db.Archives.ListAsync(Ct));
Assert.True(await db.Archives.DeleteAsync(archive.Id, Ct));
Assert.Null(await db.Archives.GetAsync(archive.Id, Ct));
Assert.False(await db.Archives.DeleteAsync(archive.Id, Ct));
}
[Test]
public async Task SequencesRoundTripEveryField()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id, new DateTime(2026, 9, 28, 18, 30, 15, 250), "Harbour sunset") with
{
CameraSerial = "0123",
Lens = "RF 24-70",
FrameCount = 1200,
MedianInterval = 5.0,
TotalBytes = 30_000_000_000,
Status = SequenceStatus.AnalyzedLight | SequenceStatus.ThumbsBuilt,
RenderedCount = 0,
VerifiedAt = TestData.Now,
HeroFrameId = Guid.CreateVersion7(),
Rating = 4,
Notes = "windy",
SettingsJson = "{\"fps\": 25, \"deflicker\": true}",
AnalysisJson = "{\"ev\": [12.5, 13]}",
Origin = SequenceOrigin.Server,
SyncState = SyncState.LocalAhead,
SettingsVersion = 3,
FramesVersion = 7,
OwnerUserId = Guid.CreateVersion7(),
WarningCount = 2,
PreviewOnlyCount = 1150,
Tags = ["Sunset", "harbour", "SUNSET"],
};
await db.Sequences.UpsertAsync(sequence, Ct);
var read = Assert.NotNull(await db.Sequences.GetAsync(sequence.Id, Ct));
Assert.True(JsonNode.DeepEquals(JsonNode.Parse(sequence.SettingsJson!), JsonNode.Parse(read.SettingsJson!)));
Assert.True(JsonNode.DeepEquals(JsonNode.Parse(sequence.AnalysisJson!), JsonNode.Parse(read.AnalysisJson!)));
Assert.SequenceEqual(["harbour", "Sunset"], read.Tags);
Assert.Equal(sequence with { Tags = read.Tags, SettingsJson = read.SettingsJson, AnalysisJson = read.AnalysisJson }, read);
await db.Sequences.UpsertAsync(sequence with { Title = null, Tags = ["night"], Rating = 1 }, Ct);
read = Assert.NotNull(await db.Sequences.GetAsync(sequence.Id, Ct));
Assert.Null(read.Title);
Assert.Equal("2026-09-28 EOS R5", read.DisplayTitle);
Assert.SequenceEqual(["night"], read.Tags);
Assert.Equal(1, read.Rating);
}
[Test]
public async Task DeletingASequenceRemovesItsFramesRendersAndTagLinks()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id) with { Tags = ["a"] };
await db.Sequences.UpsertAsync(sequence, Ct);
await db.Frames.BulkInsertAsync(Enumerable.Range(0, 10).Select(i => TestData.Frame(sequence.Id, i)), Ct);
await db.Renders.InsertAsync(Render(sequence.Id), Ct);
Assert.True(await db.Sequences.DeleteAsync(sequence.Id, Ct));
Assert.Empty(await db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: Ct));
Assert.Empty(await db.Renders.ListBySequenceAsync(sequence.Id, Ct));
Assert.Equal(0, (await db.Tags.ListAsync(Ct)).Single().SequenceCount);
Assert.Equal(1, await db.Tags.DeleteUnusedAsync(Ct));
}
[Test]
public async Task ListingFiltersCombine()
{
var db = await OpenChronosAsync();
var main = TestData.Archive();
var other = TestData.Archive("Other");
await db.Archives.UpsertAsync(main, Ct);
await db.Archives.UpsertAsync(other, Ct);
var owner = Guid.CreateVersion7();
var harbour = TestData.Sequence(main.Id, new DateTime(2024, 6, 1), "Porto di CITTÀ vecchia") with
{
Status = SequenceStatus.AnalyzedLight,
Tags = ["sea"],
RenderedCount = 2,
};
var stars = TestData.Sequence(main.Id, new DateTime(2025, 1, 2), "Milky way", "Z8") with
{
CameraMake = "Nikon",
Tags = ["Night Sky"],
OwnerUserId = owner,
Origin = SequenceOrigin.Server,
SyncState = SyncState.LocalAhead,
};
var clouds = TestData.Sequence(main.Id, new DateTime(2024, 12, 31, 23, 59, 59), "50%_clouds") with { Status = SequenceStatus.AnalyzedLight | SequenceStatus.Verified };
var elsewhere = TestData.Sequence(other.Id, new DateTime(2024, 3, 3), "Elsewhere");
var undated = TestData.Sequence(main.Id, null, "Undated");
foreach (var s in new[] { harbour, stars, clouds, elsewhere, undated }) await db.Sequences.UpsertAsync(s, Ct);
async Task<string[]> Titles(SequenceQuery q) =>
[.. (await db.Sequences.ListAsync(q with { Sort = SequenceSort.Title }, Ct)).Items.Select(s => s.Title!)];
Assert.SequenceEqual(["50%_clouds", "Porto di CITTÀ vecchia"], await Titles(new() { ArchiveId = main.Id, Year = 2024 }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { Camera = "Z8" }));
Assert.SequenceEqual(["50%_clouds", "Porto di CITTÀ vecchia"], await Titles(new() { WithStatus = SequenceStatus.AnalyzedLight }));
Assert.SequenceEqual(["Porto di CITTÀ vecchia"], await Titles(new() { WithStatus = SequenceStatus.AnalyzedLight, WithoutStatus = SequenceStatus.Verified }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { Tag = " night SKY " }));
Assert.SequenceEqual(["Porto di CITTÀ vecchia"], await Titles(new() { Rendered = true }));
Assert.SequenceEqual(["50%_clouds", "Elsewhere", "Milky way", "Undated"], await Titles(new() { Rendered = false }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { SyncStates = [SyncState.InSync, SyncState.LocalAhead] }));
Assert.Equal(5, (await Titles(new() { SyncStates = [] })).Length);
Assert.SequenceEqual(["Porto di CITTÀ vecchia"], await Titles(new() { Text = "città" }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { Text = "NIKON" }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { Text = "ght sk" }));
Assert.SequenceEqual(["50%_clouds"], await Titles(new() { Text = "50%_" }));
Assert.Empty(await Titles(new() { Text = "5_%" }));
Assert.SequenceEqual(["Milky way"], await Titles(new() { OwnerUserId = owner }));
Assert.Equal(4, await db.Sequences.CountAsync(new() { ArchiveId = main.Id }, Ct));
Assert.Equal(2, await db.Sequences.CountAsync(new() { ArchiveId = main.Id, Year = 2024 }, Ct));
Assert.Equal(5, await db.Sequences.CountAsync(new(), Ct));
}
[Theory]
[Case(SequenceSort.Newest)]
[Case(SequenceSort.Oldest)]
[Case(SequenceSort.Title)]
[Case(SequenceSort.FrameCount)]
[Case(SequenceSort.Size)]
public async Task KeysetPagesVisitEveryRowOnceInOrderDespiteTies(SequenceSort sort)
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var all = Enumerable.Range(0, 23).Select(i => TestData.Sequence(archive.Id,
i % 5 == 4 ? null : new DateTime(2024 + i % 3, 1, 1, 12, 0, 0),
i % 4 == 0 ? null : "T" + (i % 6)) with
{ FrameCount = i % 3, TotalBytes = i % 4 * 1000L })
.ToList();
foreach (var s in all) await db.Sequences.UpsertAsync(s, Ct);
var expected = Expected(all, sort).Select(s => s.Id).ToList();
var seen = new List<Guid>();
string? cursor = null;
var pages = 0;
do
{
var page = await db.Sequences.ListAsync(new SequenceQuery { ArchiveId = archive.Id, Sort = sort, Limit = 4, Cursor = cursor }, Ct);
Assert.True(page.Items.Count is > 0 and <= 4);
seen.AddRange(page.Items.Select(s => s.Id));
cursor = page.NextCursor;
pages++;
}
while (cursor is not null);
Assert.Equal(6, pages);
Assert.SequenceEqual(expected, seen);
}
[Test]
public async Task CursorsOnlyWorkForTheirOwnSort()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
for (var i = 0; i < 3; i++) await db.Sequences.UpsertAsync(TestData.Sequence(archive.Id, new DateTime(2024, 1, 1 + i)), Ct);
var page = await db.Sequences.ListAsync(new SequenceQuery { Limit = 1 }, Ct);
Assert.NotNull(page.NextCursor);
await Assert.ThrowsAsync<FormatException>(() => db.Sequences.ListAsync(new SequenceQuery { Sort = SequenceSort.Size, Cursor = page.NextCursor }, Ct));
await Assert.ThrowsAsync<FormatException>(() => db.Sequences.ListAsync(new SequenceQuery { Cursor = "not-a-cursor" }, Ct));
}
[Test]
public async Task StatisticsAggregateTheArchive()
{
var db = await OpenChronosAsync();
var main = TestData.Archive();
var other = TestData.Archive("Other");
await db.Archives.UpsertAsync(main, Ct);
await db.Archives.UpsertAsync(other, Ct);
Sequence Seq(Guid archive, DateTime? first, string model, int frames, long bytes, SequenceStatus status) =>
TestData.Sequence(archive, first, camera: model) with { FrameCount = frames, TotalBytes = bytes, Status = status };
var a = Seq(main.Id, new DateTime(2024, 3, 10), "EOS R5", 10, 1000, SequenceStatus.AnalyzedLight) with { VerifiedAt = TestData.Now };
var b = Seq(main.Id, new DateTime(2024, 3, 20), "Z8", 20, 2000, SequenceStatus.HasWarnings) with { CameraMake = "Nikon" };
var c = Seq(main.Id, new DateTime(2025, 7, 1), "EOS R5", 30, 3000, SequenceStatus.HasErrors | SequenceStatus.AnalyzedLight);
var d = Seq(main.Id, null, "EOS R5", 0, 0, SequenceStatus.None) with { WarningCount = 1 };
var e = Seq(other.Id, new DateTime(2023, 1, 1), "X-T5", 5, 500, SequenceStatus.None);
foreach (var s in new[] { a, b, c, d, e }) await db.Sequences.UpsertAsync(s, Ct);
await db.Frames.BulkInsertAsync(
[
TestData.Frame(a.Id, 0) with { Flags = FrameFlags.Missing, Size = 100 },
TestData.Frame(a.Id, 1) with { Format = ImageFileFormat.Jpeg, Size = 10, Flags = FrameFlags.Duplicate | FrameFlags.Corrupt },
TestData.Frame(b.Id, 0) with { Size = 200 },
TestData.Frame(e.Id, 0) with { Format = ImageFileFormat.Raf, Flags = FrameFlags.Missing },
], Ct);
var stats = await db.Sequences.GetStatsAsync(main.Id, Ct);
Assert.Equal(4, stats.Sequences);
Assert.Equal(60L, stats.Photos);
Assert.Equal(6000L, stats.Bytes);
Assert.SequenceEqual([new YearBucket(2024, 2, 30, 3000), new YearBucket(2025, 1, 30, 3000)], stats.ByYear);
Assert.SequenceEqual([new MonthBucket(2024, 3, 2, 30), new MonthBucket(2025, 7, 1, 30)], stats.ByMonth);
Assert.SequenceEqual(
[new CameraBucket("Canon", "EOS R5", 3, 40, 4000), new CameraBucket("Nikon", "Z8", 1, 20, 2000)],
stats.ByCamera);
Assert.SequenceEqual([new FormatBucket(ImageFileFormat.Cr3, 2, 300), new FormatBucket(ImageFileFormat.Jpeg, 1, 10)], stats.ByFormat);
Assert.Equal(new ArchiveHealth(Unverified: 3, WithWarnings: 2, WithErrors: 1, NotAnalyzed: 2, MissingFrames: 1, CorruptFrames: 1, DuplicateFrames: 1), stats.Health);
var everything = await db.Sequences.GetStatsAsync(cancellationToken: Ct);
Assert.Equal(5, everything.Sequences);
Assert.Equal(2L, everything.Health.MissingFrames);
Assert.Equal(2023, everything.ByYear[0].Year);
}
[Test]
public async Task FacetsListTheYearsCamerasAndTagsOfOneArchive()
{
// The admin panel's Library filters (owner review 2, R6): what one archive has, with counts, as the listing filters take it.
var db = await OpenChronosAsync();
var main = TestData.Archive();
var other = TestData.Archive("Other");
await db.Archives.UpsertAsync(main, Ct);
await db.Archives.UpsertAsync(other, Ct);
var seqs = new[]
{
TestData.Sequence(main.Id, new DateTime(2024, 3, 10), camera: "EOS R5") with { Tags = ["Night", "roof"] },
TestData.Sequence(main.Id, new DateTime(2025, 7, 1), camera: "EOS R5") with { Tags = ["night"] },
TestData.Sequence(main.Id, new DateTime(2025, 1, 2), camera: "Z 8") with { CameraMake = "NIKON CORPORATION" },
TestData.Sequence(main.Id, null, camera: "") with { CameraMake = null },
TestData.Sequence(other.Id, new DateTime(2023, 1, 1), camera: "X-T5") with { Tags = ["elsewhere"] },
};
foreach (var s in seqs) await db.Sequences.UpsertAsync(s, Ct);
var facets = await db.Sequences.GetFacetsAsync(main.Id, Ct);
Assert.SequenceEqual([new ArchiveFacet("2025", 2), new ArchiveFacet("2024", 1)], facets.Years);
Assert.SequenceEqual([new ArchiveFacet("EOS R5", 2, "Canon"), new ArchiveFacet("Z 8", 1, "NIKON CORPORATION")], facets.Cameras);
Assert.SequenceEqual([new ArchiveFacet("Night", 2), new ArchiveFacet("roof", 1)], facets.Tags);
foreach (var facet in facets.Cameras)
Assert.Equal(facet.Sequences, await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = main.Id, Camera = facet.Value }, Ct));
Assert.Equal(2, await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = main.Id, Tag = facets.Tags[0].Value }, Ct));
}
[Test]
public async Task FramesBulkInsertPageAndFindDuplicates()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
var frames = Enumerable.Range(0, 250).Select(i => TestData.Frame(sequence.Id, i)).ToList();
frames[7] = frames[7] with
{
OriginalFileName = "DSC_7.NEF",
CapturedAt = new DateTime(2026, 9, 28, 18, 0, 35, 123),
UtcOffsetMinutes = 120,
ExposureBias = -0.3,
WhiteBalance = 5600,
Orientation = 6,
PreviewOffset = 1024,
PreviewLength = 65536,
PreviewWidth = 1620,
PreviewHeight = 1080,
MeanLogLuminance = -2.5,
ClipLow = 0.01,
ClipHigh = 0.02,
Flags = FrameFlags.Excluded,
Sha256 = "AB" + new string('c', 62),
};
Assert.Equal(250L, await db.Frames.BulkInsertAsync(frames, Ct));
var copy = TestData.Frame(sequence.Id, 1000) with { Sha256 = frames[7].Sha256 };
await db.Frames.InsertAsync(copy, Ct);
Assert.Equal(frames[7] with { Sha256 = frames[7].Sha256!.ToLowerInvariant() }, await db.Frames.GetAsync(frames[7].Id, Ct));
var pageOne = await db.Frames.ListBySequenceAsync(sequence.Id, limit: 100, cancellationToken: Ct);
var pageThree = await db.Frames.ListBySequenceAsync(sequence.Id, afterIndex: 199, limit: 100, cancellationToken: Ct);
Assert.SequenceEqual(Enumerable.Range(0, 100), pageOne.Select(f => f.Index));
Assert.SequenceEqual(Enumerable.Range(200, 50).Append(1000), pageThree.Select(f => f.Index));
var duplicates = await db.Frames.FindBySha256Async(frames[7].Sha256!.ToUpperInvariant(), Ct);
Assert.SequenceEqual([7, 1000], duplicates.Select(f => f.Index));
var stats = Assert.NotNull(await db.Sequences.RefreshStatsAsync(sequence.Id, Ct));
Assert.Equal(251, stats.FrameCount);
Assert.Equal(frames.Sum(f => f.Size) + copy.Size, stats.TotalBytes);
Assert.Equal(frames[0].CapturedAt, stats.FirstCapture);
Assert.Equal(copy.CapturedAt, stats.LastCapture);
Assert.Equal(1, stats.FramesVersion);
}
[Test]
public async Task FrameAnalysisAndFlagsUpdateInBulk()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
var frames = Enumerable.Range(0, 1200).Select(i => TestData.Frame(sequence.Id, i) with { Flags = FrameFlags.Missing }).ToList();
await db.Frames.BulkInsertAsync(frames, Ct);
var stats = frames.Select((f, i) => new FrameLightStats(f.Id, -i / 100.0, i % 2 == 0 ? null : 0.5, 0.001 * i)).ToList();
Assert.Equal(1200, await db.Frames.UpdateLightStatsAsync(stats, Ct));
var ids = frames.Where(f => f.Index % 3 == 0).Select(f => f.Id).ToList();
Assert.Equal(400, await db.Frames.UpdateFlagsAsync(ids, FrameFlags.Duplicate | FrameFlags.Excluded, FrameFlags.Missing, Ct));
var read = new List<Frame>();
for (var after = -1; ; after = read[^1].Index)
{
var page = await db.Frames.ListBySequenceAsync(sequence.Id, after, 500, Ct);
if (page.Count == 0) break;
read.AddRange(page);
}
Assert.Equal(1200, read.Count);
foreach (var f in read)
{
Assert.Equal(-f.Index / 100.0, f.MeanLogLuminance);
Assert.Equal(f.Index % 2 == 0 ? null : 0.5, f.ClipLow);
Assert.Equal(f.Index % 3 == 0 ? FrameFlags.Duplicate | FrameFlags.Excluded : FrameFlags.Missing, f.Flags);
}
Assert.Equal(1200, await db.Frames.DeleteBySequenceAsync(sequence.Id, Ct));
}
[Test]
public async Task FrameTiersUpdateInBulkAndSurviveASyncFromTheSidecar()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
// More frames than one batched PostgreSQL statement holds.
const int count = 1205;
var frames = Enumerable.Range(0, count).Select(i => TestData.Frame(sequence.Id, i) with { Flags = FrameFlags.Duplicate }).ToList();
await db.Frames.BulkInsertAsync(frames, Ct);
var tiers = frames.Select(f => new FrameTierFields(f.Id, f.Index % 2 == 0 ? FrameFlags.PreviewOnly : FrameFlags.Undecodable, 1620 + f.Index, 1080, f.Format)).ToList();
Assert.Equal(count, await db.Frames.UpdateTiersAsync(tiers, Ct));
var read = await Chronos.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct);
Assert.SequenceEqual(tiers.Select(t => (t.Flags, t.PreviewWidth, t.PreviewHeight)), read.Select(f => (f.Flags, f.PreviewWidth, f.PreviewHeight)));
// A sync from the sidecar writes the tier fields like every other one.
await db.Frames.SyncSequenceAsync(sequence.Id, [.. read.Select(f => f with { PreviewWidth = 4, PreviewHeight = 3, Flags = FrameFlags.None })], Ct);
Assert.True((await Chronos.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct)).All(f => (f.Flags, f.PreviewWidth, f.PreviewHeight) == (FrameFlags.None, 4, 3)));
}
[Test]
public async Task FramesTakeTheNamesAReorganizeGaveTheirFiles()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id) with { FramesVersion = 3 };
var other = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
await db.Sequences.UpsertAsync(other, Ct);
// More frames than one batched PostgreSQL statement holds, and a frame of another sequence named in the same call.
const int count = 1203;
var frames = Enumerable.Range(0, count).Select(i => TestData.Frame(sequence.Id, i)).ToList();
var foreign = TestData.Frame(other.Id, 0);
await db.Frames.BulkInsertAsync([.. frames, foreign], Ct);
var renamed = frames.Take(count - 1).Select(f => new FrameFileName(f.Id, $"s/originals/{count - f.Index:00000}.cr3", $"{count - f.Index:00000}.cr3")).ToList();
Assert.Equal(count - 1, await db.Frames.RenameFilesAsync(sequence.Id, [.. renamed, new FrameFileName(foreign.Id, "x/y.cr3", "y.cr3")], 3, 4, Ct));
var read = new List<Frame>();
for (var last = -1; ;)
{
var page = await db.Frames.ListBySequenceAsync(sequence.Id, last, 1000, Ct);
read.AddRange(page);
if (page.Count < 1000) break;
last = page[^1].Index;
}
Assert.SequenceEqual(frames.Select(f => f.Id), read.Select(f => f.Id));
Assert.SequenceEqual([.. renamed.Select(r => (r.RelativePath, r.FileName)), (frames[^1].RelativePath, frames[^1].FileName)],
read.Select(f => (f.RelativePath, f.FileName)));
Assert.Equal((foreign.RelativePath, foreign.FileName), (await db.Frames.GetAsync(foreign.Id, Ct)) is { } f2 ? (f2.RelativePath, f2.FileName) : default);
Assert.Equal(4, (await db.Sequences.GetAsync(sequence.Id, Ct))!.FramesVersion);
// A row another writer moved past the version the renames started from keeps its own.
await db.Frames.RenameFilesAsync(sequence.Id, [], 3, 9, Ct);
Assert.Equal(4, (await db.Sequences.GetAsync(sequence.Id, Ct))!.FramesVersion);
}
[Test]
public async Task RendersKeepTheSequenceCountInStep()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
var first = Render(sequence.Id) with { Created = TestData.Now };
var second = Render(sequence.Id) with { Created = TestData.Now.AddMinutes(5), SettingsJson = null, Codec = null };
await db.Renders.InsertAsync(first, Ct);
await db.Renders.InsertAsync(second, Ct);
Assert.Equal(2, (await db.Sequences.GetAsync(sequence.Id, Ct))!.RenderedCount);
await db.Sequences.UpsertAsync(sequence with { Title = "Renamed from a stale copy" }, Ct);
Assert.Equal(2, (await db.Sequences.GetAsync(sequence.Id, Ct))!.RenderedCount);
var list = await db.Renders.ListBySequenceAsync(sequence.Id, Ct);
Assert.SequenceEqual([second.Id, first.Id], list.Select(r => r.Id));
Assert.Equal(second, list[0]);
Assert.True(await db.Renders.DeleteAsync(second.Id, Ct));
Assert.False(await db.Renders.DeleteAsync(second.Id, Ct));
Assert.Equal(1, (await db.Sequences.GetAsync(sequence.Id, Ct))!.RenderedCount);
}
[Test]
public async Task TagsCanBeListedRenamedAndDeleted()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var one = TestData.Sequence(archive.Id) with { Tags = ["Alps", "snow"] };
var two = TestData.Sequence(archive.Id) with { Tags = ["alps"] };
await db.Sequences.UpsertAsync(one, Ct);
await db.Sequences.UpsertAsync(two, Ct);
Assert.False(await db.Sequences.SetTagsAsync(Guid.CreateVersion7(), ["x"], Ct));
var tags = await db.Tags.ListAsync(Ct);
Assert.SequenceEqual([("Alps", 2), ("snow", 1)], tags.Select(t => (t.Name, t.SequenceCount)));
var snow = tags.Single(t => t.Name == "snow");
await Assert.ThrowsAsync<DatabaseException>(() => db.Tags.RenameAsync(snow.Id, "ALPS", Ct));
Assert.True(await db.Tags.RenameAsync(snow.Id, "Snow fields", Ct));
Assert.SequenceEqual(["Alps", "Snow fields"], (await db.Sequences.GetAsync(one.Id, Ct))!.Tags);
Assert.True(await db.Tags.DeleteAsync(snow.Id, Ct));
Assert.SequenceEqual(["Alps"], (await db.Sequences.GetAsync(one.Id, Ct))!.Tags);
Assert.True(await db.Sequences.SetTagsAsync(two.Id, [], Ct));
Assert.Equal(1, (await db.Tags.ListAsync(Ct)).Single().SequenceCount);
Assert.Throws<ArgumentException>(() => TagRepository.Normalize(" \t "));
Assert.Throws<ArgumentException>(() => TagRepository.Normalize("bad\u0001tag"));
}
[Test]
public async Task TransactionsGroupRepositoryCalls()
{
var db = await OpenChronosAsync();
var archive = TestData.Archive();
await db.Archives.UpsertAsync(archive, Ct);
var sequence = TestData.Sequence(archive.Id);
await using (var tx = await db.BeginAsync(Ct))
{
await tx.Sequences.UpsertAsync(sequence, Ct);
await tx.Frames.InsertAsync(TestData.Frame(sequence.Id, 0), Ct);
Assert.NotNull(await tx.Sequences.GetAsync(sequence.Id, Ct));
}
Assert.Null(await db.Sequences.GetAsync(sequence.Id, Ct));
await using (var tx = await db.BeginAsync(Ct))
{
await tx.Sequences.UpsertAsync(sequence, Ct);
await tx.Frames.InsertAsync(TestData.Frame(sequence.Id, 0), Ct);
await tx.Sequences.RefreshStatsAsync(sequence.Id, Ct);
await tx.CommitAsync(Ct);
}
Assert.Equal(1, (await db.Sequences.GetAsync(sequence.Id, Ct))!.FrameCount);
}
private static Render Render(Guid sequenceId) => new()
{
Id = Guid.CreateVersion7(),
SequenceId = sequenceId,
PresetName = "4K HEVC",
SettingsJson = "{\"crf\": 18}",
OutputPath = "exports/out.mp4",
Codec = "hevc",
Width = 3840,
Height = 2160,
Fps = 29.97,
DurationSeconds = 41.5,
Bytes = 123_456_789,
Created = TestData.Now,
ProducedBy = "node-1",
};
/// <summary>The order the database must produce: sort key with NULLS LAST, then id (as text) in the same direction.</summary>
private static IEnumerable<Sequence> Expected(List<Sequence> all, SequenceSort sort)
{
int ById(Sequence a, Sequence b) => string.CompareOrdinal(a.Id.ToString("D"), b.Id.ToString("D"));
int NullsLast<T>(T? a, T? b, Comparison<T> compare) where T : struct =>
a is null ? (b is null ? 0 : 1) : b is null ? -1 : compare(a.Value, b.Value);
Comparison<Sequence> comparison = sort switch
{
SequenceSort.Newest => (a, b) => NullsLast<DateTime>(a.FirstCapture, b.FirstCapture, (x, y) => y.CompareTo(x)) is var c and not 0 ? c : -ById(a, b),
SequenceSort.Oldest => (a, b) => NullsLast<DateTime>(a.FirstCapture, b.FirstCapture, (x, y) => x.CompareTo(y)) is var c and not 0 ? c : ById(a, b),
SequenceSort.Title => (a, b) => string.CompareOrdinal(a.DisplayTitle.ToLowerInvariant(), b.DisplayTitle.ToLowerInvariant()) is var c and not 0 ? c : ById(a, b),
SequenceSort.FrameCount => (a, b) => b.FrameCount.CompareTo(a.FrameCount) is var c and not 0 ? c : -ById(a, b),
_ => (a, b) => b.TotalBytes.CompareTo(a.TotalBytes) is var c and not 0 ? c : -ById(a, b),
};
var sorted = all.ToList();
sorted.Sort(comparison);
return sorted;
}
}
public sealed class SqliteCatalogRepositoryTests(TestContext context) : CatalogRepositoryTests(context)
{
protected override Backend Backend => Backend.SqliteMemory;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresCatalogRepositoryTests(TestContext context) : CatalogRepositoryTests(context)
{
protected override Backend Backend => Backend.Postgres;
}