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; /// Archives, sequences, frames, renders and tags on both dialects. 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 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(); 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(() => db.Sequences.ListAsync(new SequenceQuery { Sort = SequenceSort.Size, Cursor = page.NextCursor }, Ct)); await Assert.ThrowsAsync(() => 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(); 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(() => 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(() => TagRepository.Normalize(" \t ")); Assert.Throws(() => 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", }; /// The order the database must produce: sort key with NULLS LAST, then id (as text) in the same direction. private static IEnumerable Expected(List all, SequenceSort sort) { int ById(Sequence a, Sequence b) => string.CompareOrdinal(a.Id.ToString("D"), b.Id.ToString("D")); int NullsLast(T? a, T? b, Comparison compare) where T : struct => a is null ? (b is null ? 0 : 1) : b is null ? -1 : compare(a.Value, b.Value); Comparison comparison = sort switch { SequenceSort.Newest => (a, b) => NullsLast(a.FirstCapture, b.FirstCapture, (x, y) => y.CompareTo(x)) is var c and not 0 ? c : -ById(a, b), SequenceSort.Oldest => (a, b) => NullsLast(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; }