The web panel now manages the library without editing it: the owner can browse and view sequences and photos, delete sequences and photos into the archive's trash, restore or empty the trash and run mass operations, as R6 asks, on top of the engine endpoints of the previous commit. - Library page right after the Dashboard: search, Year/Camera/Status/Tag filters fed by a new GET /api/v1/sequences/facets, sort, cards or list (remembered per browser), lazy cover thumbnails, Load more by cursor, multi-select with Shift ranges and "Select all N" of the filter, and a sticky bar for the selection: Analyse, Proxies, Thumbnails, Verify, Tags (add/remove), Export CSV (client-side) and Delete (dry run, list of what moves to the trash, then the move). Filters live in the address, so Back from a sequence finds them again. - Sequence view (#/library?id=): inline title, tags, rating and notes, facts, photos in pages of 500 with content-visibility, a photo viewer (proxy, arrows, Esc, Exif facts), Set cover, Download original, Delete photos (typing the count above 20 photos), Delete sequence, renders to download. No video editing controls. - Trash view (#/library?view=trash, also linked from Archive): entries, Restore, and Empty (dry run, list, the localised word typed, the plan's fingerprint sent back, the job followed to its end). - Live updates from sequenceChanged and jobState; keyboard grid (one tab stop, arrows, Space, Shift+Space, Enter, Ctrl+A, Esc); RTL, dark theme. - GET /sequences takes rendered=true|false for the Status filter. - ui.js: confirmDialog's typed confirmation by name, word or count, with a list of what the action concerns; formDialog. api.js: putBytes for the web upload, which the Library imports on demand (upload.js, optional). - New web icons from icons.py (Image for the Library, trash, grid/list, arrows, stars, cover); directional glyphs mirror in right-to-left pages. - Strings in en and it; tests for the facets (both dialects), the rendered filter, the menu, the modules and the on-demand upload import. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 029cf334f66cb6fa1265b96a6f8faff2964c11ea)
486 lines
25 KiB
C#
486 lines
25 KiB
C#
using System.Text.Json.Nodes;
|
|
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Data.Tests.Infrastructure;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 FacetsListTheYearsCamerasAndTagsOfOneArchive()
|
|
{
|
|
// The admin panel's Library filters (owner review 2, R6): what one archive has, with counts, as the listing filters take it.
|
|
var db = await OpenChronosAsync();
|
|
var main = TestData.Archive();
|
|
var other = TestData.Archive("Other");
|
|
await db.Archives.UpsertAsync(main, Ct);
|
|
await db.Archives.UpsertAsync(other, Ct);
|
|
var seqs = new[]
|
|
{
|
|
TestData.Sequence(main.Id, new DateTime(2024, 3, 10), camera: "EOS R5") with { Tags = ["Night", "roof"] },
|
|
TestData.Sequence(main.Id, new DateTime(2025, 7, 1), camera: "EOS R5") with { Tags = ["night"] },
|
|
TestData.Sequence(main.Id, new DateTime(2025, 1, 2), camera: "Z 8") with { CameraMake = "NIKON CORPORATION" },
|
|
TestData.Sequence(main.Id, null, camera: "") with { CameraMake = null },
|
|
TestData.Sequence(other.Id, new DateTime(2023, 1, 1), camera: "X-T5") with { Tags = ["elsewhere"] },
|
|
};
|
|
foreach (var s in seqs) await db.Sequences.UpsertAsync(s, Ct);
|
|
|
|
var facets = await db.Sequences.GetFacetsAsync(main.Id, Ct);
|
|
Assert.SequenceEqual([new ArchiveFacet("2025", 2), new ArchiveFacet("2024", 1)], facets.Years);
|
|
Assert.SequenceEqual([new ArchiveFacet("EOS R5", 2, "Canon"), new ArchiveFacet("Z 8", 1, "NIKON CORPORATION")], facets.Cameras);
|
|
Assert.SequenceEqual([new ArchiveFacet("Night", 2), new ArchiveFacet("roof", 1)], facets.Tags);
|
|
foreach (var facet in facets.Cameras)
|
|
Assert.Equal(facet.Sequences, await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = main.Id, Camera = facet.Value }, Ct));
|
|
Assert.Equal(2, await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = main.Id, Tag = facets.Tags[0].Value }, Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task FramesBulkInsertPageAndFindDuplicates()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 Chronos.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 Chronos.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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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 OpenChronosAsync();
|
|
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;
|
|
}
|