Files
Chronos/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs
T
Alby96andClaude Opus 5.5 34d03051f5 fix: stalled jobs, editor cancellation stops and GoPro DNG decoding
Owner review 1, phase 1 (docs/requests/2026-10-15-owner-review-1.md).

Thumbnail and proxy jobs over several sequences counted sequences while
they checkpointed inside one: the rate decayed until the time left
overflowed TimeSpan, the job failed while publishing progress and again
while saving it, and stayed Running. The throughput is now seeded by the
first window with progress, the time left is bounded (JobEta), saving
progress never throws, image passes count frames, and job speeds use the
right unit (bytes for verify and import).

The debugger stops in WicDecoderProvider.cs when presets changed were
cancelled preview decodes leaving synchronous thread-pool delegates; the
editor's sources, LatestRunner and the render node's proxy task now keep
them in their own tasks, and a cancellation is never an unreadable frame.

GoPro DNGs converted by Adobe software were classified GPR and read only
through their 8-bit preview, and Windows' preview-only DNG decoder was
reported as a native decode. A DNG is GPR only when its raw image is
VC-5, WIC decodes RAW only through the Raw Image Extension and never DNG,
analyses and previews take an adequate embedded preview by choice while
renders develop natively, and frames already indexed as GPR are
reclassified by the next light analysis.

Also records the owner's request (docs/requests), the BRIEF amendments
(§8.1, §8.2, new §24), DECISIONS, CHANGELOG, STATUS and ARCHITECTURE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:20:26 +02: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, f.Format)).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;
}