using System.Text.Json;
using System.Text.Json.Serialization;
using Titano.Core.Model;
using Titano.Data.Repositories;
using Titano.Data.Tests.Infrastructure;
using Titano.Testing;
namespace Titano.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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 OpenTitanoAsync();
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 UploadsTrackChunksAndStates()
{
var db = await OpenTitanoAsync();
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 = "Titano 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;
}