Files
Chronos/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs
T
Claude dcc9dcd213 feat(data): filter sequences by renders and sync state; read a remote sequence's first frame alone
SequenceQuery.Rendered and SyncStates back the Library's Rendered, Not
rendered and Synced status choices. ISyncRemote.FirstFrameAsync reads one row
of the frames page (default: the whole list), so a remote card without a hero
frame no longer downloads the server's manifest for its thumbnail.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-05 22:13:55 +00:00

426 lines
22 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,
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,
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 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;
}