Shared abstract suites run against in-memory/temp-file SQLite and, with TITANO_TEST_PG, a private PostgreSQL schema per test: migration idempotency and version refusal, keyset paging with ties for every sort, statistics, exclusive job claiming under 8 concurrent claimers, and the 100k-frame bulk insert under 15 s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
388 lines
21 KiB
C#
388 lines
21 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"] };
|
|
var stars = TestData.Sequence(main.Id, new DateTime(2025, 1, 2), "Milky way", "Z8") with { CameraMake = "Nikon", Tags = ["Night Sky"], OwnerUserId = owner };
|
|
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() { 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);
|
|
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;
|
|
}
|