Files
Chronos/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs
T
Claude 5599e4de89 fix(imaging): record only what decoding proves and find GPR JPEGs across sequences
- Preview sizes come from probes and unscaled decodes: a size-limited decode
  picks the smallest preview that reaches its edge (CR3 PRVW 1620x1080), so
  renders and deep passes record its tier without a size and the output cap
  keeps the largest preview's.
- A read error is not an undecodable file: ImageDecoder.Decode throws the
  IOException when a provider could not read the file and none produced
  pixels. Deep passes never flag frames they could not read or that
  vanished, and frames only an interrupted earlier run found undecodable
  are decoded again before they are flagged.
- Renders resolve stand-ins only for frames the pipeline asks for; frames
  the read-ahead meets on the way (skipped by speed-ups) are left alone.
- A GoPro GPR finds its JPEG in the index when an import or upload kept it
  in a sequence of its own (same original stem and capture time), for
  probes, deep analysis, renders, thumbnails, proxies and the editor;
  GPRs whose JPEG is indexed later are probed again.
- Thumbnails judge an embedded preview by its own JPEG header.
- PostgreSQL writes tier fields 1000 frames per statement.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 11:17:49 +00:00

458 lines
24 KiB
C#

using System.Text.Json.Nodes;
using Titano.Core.Imaging;
using Titano.Core.Model;
using Titano.Data.Repositories;
using Titano.Data.Tests.Infrastructure;
using Titano.Testing;
namespace Titano.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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 FramesBulkInsertPageAndFindDuplicates()
{
var db = await OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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)).ToList();
Assert.Equal(count, await db.Frames.UpdateTiersAsync(tiers, Ct));
var read = await Titano.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 Titano.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct)).All(f => (f.Flags, f.PreviewWidth, f.PreviewHeight) == (FrameFlags.None, 4, 3)));
}
[Test]
public async Task RendersKeepTheSequenceCountInStep()
{
var db = await OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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;
}