using System.Text.Json; using System.Text.Json.Serialization; using Chronos.Core.Model; using Chronos.Data.Repositories; using Chronos.Data.Tests.Infrastructure; using Chronos.Testing; namespace Chronos.Data.Tests.Repositories; /// Users, tokens, render nodes, settings, audit log and uploads on both dialects. public abstract class ServerRepositoryTests(TestContext context) : RepositoryTest(context) { [Test] public async Task UsersAreUniqueIgnoringCase() { var db = await OpenChronosAsync(); var alice = TestData.User("Alice") with { DisplayName = "Alice A.", QuotaBytes = 1L << 40, MustChangePassword = true, Role = UserRole.Admin, Permissions = Permissions.All }; await db.Users.CreateAsync(alice, Ct); var duplicate = await Assert.ThrowsAsync(() => db.Users.CreateAsync(TestData.User("ALICE"), Ct)); Assert.True(duplicate.IsUniqueViolation); Assert.Equal(alice, await db.Users.GetByUsernameAsync(" alice ", Ct)); Assert.True(await db.Users.UpdateAsync(alice with { Username = "alice2", Disabled = true, MustChangePassword = false }, Ct)); Assert.True(await db.Users.RecordLoginAsync(alice.Id, TestData.Now, Ct)); Assert.True(await db.Users.AddUsedBytesAsync(alice.Id, 5000, Ct)); Assert.True(await db.Users.AddUsedBytesAsync(alice.Id, -1000, Ct)); var read = Assert.NotNull(await db.Users.GetAsync(alice.Id, Ct)); Assert.Equal(alice with { Username = "alice2", Disabled = true, MustChangePassword = false, LastLogin = TestData.Now, UsedBytes = 4000 }, read); Assert.Null(await db.Users.GetByUsernameAsync("alice", Ct)); Assert.Equal(1, await db.Users.CountAsync(Ct)); Assert.Count(1, await db.Users.ListAsync(Ct)); } [Test] public async Task DeletingAUserRemovesTheirTokensNodesAndUploads() { var db = await OpenChronosAsync(); var user = TestData.User(); await db.Users.CreateAsync(user, Ct); await db.Tokens.InsertAsync(Token(user.Id, "h1"), Ct); await db.RenderNodes.RegisterAsync(Node(user.Id), Ct); await db.Uploads.CreateAsync(Upload(user.Id, 10), Ct); Assert.True(await db.Users.DeleteAsync(user.Id, Ct)); Assert.Null(await db.Tokens.GetAsync("h1", Ct)); Assert.Empty(await db.RenderNodes.ListAsync(Ct)); Assert.Empty(await db.Uploads.ListByUserAsync(user.Id, Ct)); } [Test] public async Task TokensSlideRevokeAndPurge() { var db = await OpenChronosAsync(); var user = TestData.User(); await db.Users.CreateAsync(user, Ct); var token = Token(user.Id, "hash-1"); await db.Tokens.InsertAsync(token, Ct); await db.Tokens.InsertAsync(Token(user.Id, "hash-2"), Ct); await db.Tokens.InsertAsync(Token(user.Id, "expired") with { Expires = TestData.Now.AddDays(-1) }, Ct); Assert.Equal(token, await db.Tokens.GetAsync("hash-1", Ct)); var later = TestData.Now.AddDays(3); Assert.True(await db.Tokens.TouchAsync("hash-1", later, later.AddDays(30), Ct)); var touched = await db.Tokens.GetAsync("hash-1", Ct); Assert.Equal((later, later.AddDays(30)), (touched!.LastUsed, touched.Expires)); Assert.False(await db.Tokens.TouchAsync("expired", TestData.Now, later, Ct)); Assert.False(await db.Tokens.TouchAsync("missing", TestData.Now, later, Ct)); Assert.True(await db.Tokens.RevokeAsync("hash-1", Ct)); Assert.False(await db.Tokens.RevokeAsync("hash-1", Ct)); Assert.False(await db.Tokens.TouchAsync("hash-1", later, later.AddDays(30), Ct)); Assert.True((await db.Tokens.GetAsync("hash-1", Ct))!.Revoked); Assert.Equal(2, await db.Tokens.RevokeAllAsync(user.Id, Ct)); Assert.Count(3, await db.Tokens.ListByUserAsync(user.Id, Ct)); Assert.Equal(3, await db.Tokens.PurgeAsync(TestData.Now, Ct)); } [Test] public async Task RenderNodesReportHeartbeats() { var db = await OpenChronosAsync(); var user = TestData.User(); await db.Users.CreateAsync(user, Ct); var node = Node(user.Id); await db.RenderNodes.RegisterAsync(node, Ct); var stale = Node(user.Id) with { ClientName = "old-pc", LastHeartbeat = TestData.Now.AddHours(-1) }; await db.RenderNodes.RegisterAsync(stale, Ct); await db.RenderNodes.RegisterAsync(node with { CapabilitiesJson = "{\"encoders\": [\"nvenc\"]}" }, Ct); Assert.Equal("{\"encoders\": [\"nvenc\"]}", (await db.RenderNodes.GetAsync(node.Id, Ct))!.CapabilitiesJson); Assert.SequenceEqual([node.Id], (await db.RenderNodes.ListOnlineAsync(TestData.Now.AddMinutes(-2), Ct)).Select(n => n.Id)); Assert.True(await db.RenderNodes.HeartbeatAsync(stale.Id, "rendering", TestData.Now.AddMinutes(1), Ct)); var online = await db.RenderNodes.ListOnlineAsync(TestData.Now.AddMinutes(-2), Ct); Assert.SequenceEqual([stale.Id, node.Id], online.Select(n => n.Id)); Assert.Equal("rendering", online[0].State); Assert.True(await db.RenderNodes.DeleteAsync(stale.Id, Ct)); Assert.False(await db.RenderNodes.HeartbeatAsync(stale.Id, "idle", TestData.Now, Ct)); } [Test] public async Task SettingsAreTypedAndScoped() { var db = await OpenChronosAsync(); var archive = Guid.CreateVersion7(); var user = Guid.CreateVersion7(); var preferences = new Preferences("it", 4, [1.5, 2]); await db.Settings.SetAsync(SettingScope.App, null, "ui", preferences, TestJson.Default.Preferences, Ct); await db.Settings.SetAsync(SettingScope.User, user, "ui", preferences with { Language = "en" }, TestJson.Default.Preferences, Ct); await db.Settings.SetJsonAsync(SettingScope.Archive, archive, "proxy", "{\"longEdge\": 1920}", Ct); Assert.Equal(preferences, await db.Settings.GetAsync(SettingScope.App, null, "ui", TestJson.Default.Preferences, Ct), "app scope"); Assert.Equal("en", (await db.Settings.GetAsync(SettingScope.User, user, "ui", TestJson.Default.Preferences, Ct))!.Language); Assert.Null(await db.Settings.GetAsync(SettingScope.User, Guid.CreateVersion7(), "ui", TestJson.Default.Preferences, Ct)); Assert.Equal(1920, JsonDocument.Parse((await db.Settings.GetJsonAsync(SettingScope.Archive, archive, "proxy", Ct))!).RootElement.GetProperty("longEdge").GetInt32()); await db.Settings.SetAsync(SettingScope.App, null, "ui", preferences with { Columns = 6 }, TestJson.Default.Preferences, Ct); Assert.Equal(6, (await db.Settings.GetAsync(SettingScope.App, null, "ui", TestJson.Default.Preferences, Ct))!.Columns); await db.Settings.SetAsync(SettingScope.App, null, "count", 42, TestJson.Default.Int32, Ct); Assert.SequenceEqual(["count", "ui"], (await db.Settings.ListAsync(SettingScope.App, null, Ct)).Keys.Order(StringComparer.Ordinal)); Assert.True(await db.Settings.DeleteAsync(SettingScope.App, null, "count", Ct)); Assert.False(await db.Settings.DeleteAsync(SettingScope.App, null, "count", Ct)); await Assert.ThrowsAsync(() => db.Settings.GetJsonAsync(SettingScope.User, null, "ui", Ct)); await Assert.ThrowsAsync(() => db.Settings.GetJsonAsync(SettingScope.App, user, "ui", Ct)); await Assert.ThrowsAsync(() => db.Settings.SetJsonAsync(SettingScope.App, null, "bad", "{not json", Ct)); } [Test] public async Task AuditLogPagesNewestFirst() { var db = await OpenChronosAsync(); var user = Guid.CreateVersion7(); var entries = Enumerable.Range(0, 9).Select(i => new AuditEntry { Id = Guid.CreateVersion7(), At = TestData.Now.AddSeconds(i / 2), Action = "sequence.delete", UserId = i % 3 == 0 ? user : null, Username = "alice", TargetKind = "sequence", TargetId = Guid.CreateVersion7().ToString(), Details = "{\"frames\": 10}", RemoteAddress = "10.0.0.1", }).ToList(); foreach (var e in entries) await db.Audit.AppendAsync(e, Ct); var seen = new List(); string? cursor = null; do { var page = await db.Audit.ListAsync(limit: 4, cursor: cursor, cancellationToken: Ct); seen.AddRange(page.Items); cursor = page.NextCursor; } while (cursor is not null); Assert.SequenceEqual( entries.OrderByDescending(e => e.At).ThenByDescending(e => e.Id.ToString("D"), StringComparer.Ordinal), seen); Assert.Equal(3, (await db.Audit.ListAsync(user, cancellationToken: Ct)).Items.Count); } [Test] public async Task TheAuditRetentionRemovesOnlyOlderEntries() { var db = await OpenChronosAsync(); foreach (var days in new[] { 400, 366, 10 }) await db.Audit.AppendAsync(new AuditEntry { Id = Guid.CreateVersion7(), At = TestData.Now.AddDays(-days), Action = "user.login" }, Ct); Assert.Equal(2, await db.Audit.PurgeAsync(TestData.Now.AddDays(-365), Ct)); Assert.Equal(TestData.Now.AddDays(-10), Assert.NotNull((await db.Audit.ListAsync(cancellationToken: Ct)).Items.SingleOrDefault()).At); Assert.Equal(0, await db.Audit.PurgeAsync(TestData.Now.AddDays(-365), Ct)); } [Test] public async Task UploadsTrackChunksAndStates() { var db = await OpenChronosAsync(); var user = TestData.User(); await db.Users.CreateAsync(user, Ct); var created = await db.Uploads.CreateAsync(Upload(user.Id, 8 * 1024 * 1024 * 9 + 1), Ct); Assert.Equal(10, created.ChunkCount); Assert.Equal(2, created.Received.Length); Assert.Equal(created.Id, (await db.Uploads.FindReceivingAsync(user.Id, created.Sha256.ToUpperInvariant(), Ct))!.Id); foreach (var chunk in new[] { 0, 9, 3, 9 }) { var updated = await db.Uploads.MarkChunkReceivedAsync(created.Id, chunk, Ct); Assert.True(updated!.HasChunk(chunk)); } await Assert.ThrowsAsync(() => db.Uploads.MarkChunkReceivedAsync(created.Id, 10, Ct)); Assert.Null(await db.Uploads.MarkChunkReceivedAsync(Guid.CreateVersion7(), 0, Ct)); var stored = Assert.NotNull(await db.Uploads.GetAsync(created.Id, Ct)); Assert.Equal(3, stored.ReceivedCount); Assert.SequenceEqual([0, 3, 9], Enumerable.Range(0, 10).Where(stored.HasChunk)); Assert.False(stored.IsComplete); await Task.WhenAll(Enumerable.Range(0, 10).Select(i => db.Uploads.MarkChunkReceivedAsync(created.Id, i, Ct))); Assert.True((await db.Uploads.GetAsync(created.Id, Ct))!.IsComplete); Assert.Count(1, await db.Uploads.ListStaleAsync(TestData.Now.AddYears(10), Ct)); var frameId = Guid.CreateVersion7(); Assert.True(await db.Uploads.SetStateAsync(created.Id, UploadState.Committed, frameId, Ct)); Assert.True(await db.Uploads.SetStateAsync(created.Id, UploadState.Committed, cancellationToken: Ct)); var committed = await db.Uploads.GetAsync(created.Id, Ct); Assert.Equal((UploadState.Committed, (Guid?)frameId), (committed!.State, committed.FrameId)); Assert.Empty(await db.Uploads.ListStaleAsync(TestData.Now.AddYears(10), Ct)); Assert.Null(await db.Uploads.FindReceivingAsync(user.Id, created.Sha256, Ct)); Assert.True(await db.Uploads.DeleteAsync(created.Id, Ct)); } private static SessionToken Token(Guid userId, string hash) => new() { TokenHash = hash, UserId = userId, ClientName = "Chronos desktop", Created = TestData.Now, Expires = TestData.Now.AddDays(30), LastUsed = TestData.Now, }; private static RenderNode Node(Guid userId) => new() { Id = Guid.CreateVersion7(), UserId = userId, ClientName = "studio-pc", CapabilitiesJson = "{\"encoders\": []}", LastHeartbeat = TestData.Now, }; private static Upload Upload(Guid userId, long size) => new() { Id = Guid.CreateVersion7(), UserId = userId, FileName = "IMG_0001.CR3", Size = size, Sha256 = new string('A', 64), CapturedAt = new DateTime(2026, 9, 28, 18, 0, 0), ChunkSize = 8 * 1024 * 1024, Created = TestData.Now, UpdatedAt = TestData.Now, }; } public sealed record Preferences(string Language, int Columns, double[] Zoom) { public bool Equals(Preferences? other) => other is not null && Language == other.Language && Columns == other.Columns && Zoom.SequenceEqual(other.Zoom); public override int GetHashCode() => HashCode.Combine(Language, Columns); } [JsonSerializable(typeof(Preferences))] [JsonSerializable(typeof(int))] internal sealed partial class TestJson : JsonSerializerContext; public sealed class SqliteServerRepositoryTests(TestContext context) : ServerRepositoryTests(context) { protected override Backend Backend => Backend.SqliteMemory; } [RequiresEnvironment(PgTestServer.Variable)] public sealed class PostgresServerRepositoryTests(TestContext context) : ServerRepositoryTests(context) { protected override Backend Backend => Backend.Postgres; }