BRIEF §8.2 tiers 2 and 3 had no writer: PreviewOnly and Undecodable were never set, so the advisor could not cap the output at the preview size and one unreadable frame failed a whole render. - ImageDecoder.Probe names a file's tier without decoding it (JPEG, PNG and TIFF without opening the file); the light analysis probes frames whose tier is unknown, and the deep analysis, renders from originals and thumbnail/proxy passes record what decoding actually found (FrameTiers). Sidecar frames gain "tier", "previewW" and "previewH"; the index gains frames.preview_width/height and sequences.preview_only_count (migration 0005, SQLite and PostgreSQL). - SequenceContext takes the preview size from preview-only frames, so the advisor's output cap applies; the light analysis reports format tiers (preview-only frames as information, undecodable ones as a warning under the deep analysis' key, listed once); a sequence that gains undecodable frames warns at once. - Only a file in a format the host decodes natively is flagged undecodable; files beyond the host's decoders keep their tier without the flag, so render nodes and proxies can still supply them. - A frame that stops decoding during a render is replaced by its nearest planned neighbour and logged instead of failing the job; the render fails only when no planned frame decodes. - The Library card shows a preview-only chip with the count (local and server sequences: SequenceDto.PreviewOnlyCount, FrameDto preview size). - GoPro GPR decodes through the JPEG the camera writes beside it when that is larger than the embedded preview (BRIEF §8.1). - Thumbnails use a stored embedded preview only when it reaches 320 px; a smaller one sends the frame through the host's decoders instead (BRIEF §8.5). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
456 lines
24 KiB
C#
456 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);
|
|
var frames = Enumerable.Range(0, 40).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(40, await db.Frames.UpdateTiersAsync(tiers, Ct));
|
|
var read = await db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: 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 db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: 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;
|
|
}
|