diff --git a/tests/Titano.Server.Tests/Api/AdminTests.cs b/tests/Titano.Server.Tests/Api/AdminTests.cs new file mode 100644 index 00000000..bdae948e --- /dev/null +++ b/tests/Titano.Server.Tests/Api/AdminTests.cs @@ -0,0 +1,90 @@ +using System.Net; +using System.Net.Http.Json; +using System.Text.Json.Nodes; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests.Api; + +[Category("server")] +public sealed class AdminTests(TestContext context) +{ + [Test] + public async Task TheDashboardSummarisesTheServer() + { + await using var server = await TestServer.StartAsync(context, o => o.ServerName = "Studio NAS"); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + await Uploads.UploadAsync(editor, Uploads.Photo(4000, 61)); + var admin = await server.AdminAsync(); + using var response = await admin.GetAsync("/api/v1/server/dashboard"); + await response.ExpectAsync(HttpStatusCode.OK); + var dashboard = await response.ReadAsync(ProtocolJson.Default.DashboardDto); + Assert.Equal(("Studio NAS", 2, 1L, 1L), (dashboard.ServerName, dashboard.Users, dashboard.Archive.Sequences, dashboard.Archive.Photos)); + Assert.True(dashboard.Database.StartsWith("SQLite ", StringComparison.Ordinal), dashboard.Database); + Assert.Equal(1L, dashboard.Uploads.Single().Frames); + Assert.Contains(dashboard.Activity, a => a.Action == "user_created"); + Assert.True(dashboard.Archive.CapacityBytes > 0); + } + + [Test] + public async Task SettingsAreSavedAndRestartOnlyValuesFlagged() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using var read = await admin.GetAsync("/api/v1/server/settings"); + var settings = await read.ReadAsync(ProtocolJson.Default.ServerSettingsDto); + Assert.False(settings.RestartRequired); + + var edited = settings with { ServerName = "Rooftop", Discovery = true, HttpPort = 18080, HttpsPort = 18443 }; + using (var saved = await admin.PutAsJsonAsync("/api/v1/server/settings", edited, ProtocolJson.Default.ServerSettingsDto)) + Assert.True((await saved.ReadAsync(ProtocolJson.Default.ServerSettingsDto)).RestartRequired); + // Name and discovery apply at once; ports wait for the restart. + Assert.Equal(("Rooftop", true, 0), (server.Options.ServerName, server.Options.Discovery, server.Options.HttpPort)); + using (var again = await admin.GetAsync("/api/v1/server/settings")) + Assert.Equal(18080, (await again.ReadAsync(ProtocolJson.Default.ServerSettingsDto)).HttpPort); + var file = JsonNode.Parse(await File.ReadAllTextAsync(server.Options.SettingsFile))!.AsObject(); + Assert.Equal(("Rooftop", 18080), (file["ServerName"]!.GetValue(), file["HttpPort"]!.GetValue())); + Assert.False(file.ContainsKey("AdminPassword")); + + using var invalid = await admin.PutAsJsonAsync("/api/v1/server/settings", edited with { Language = "tlh" }, ProtocolJson.Default.ServerSettingsDto); + Assert.Equal("Language", (await invalid.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_setting")).Details); + } + + [Test] + public async Task LogsAreReadableButOnlyByName() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using var tail = await admin.GetAsync("/api/v1/logs?lines=20"); + var lines = await tail.ReadAsync(ProtocolJson.Default.LogTailDto); + Assert.NotEmpty(lines.Lines); + Assert.True(lines.Lines.Count <= 20); + using var files = await admin.GetAsync("/api/v1/logs/files"); + var name = (await files.ReadAsync(ProtocolJson.Default.ListLogFileDto)).First().Name; + using (var download = await admin.GetAsync($"/api/v1/logs/files/{name}")) await download.ExpectAsync(HttpStatusCode.OK); + using var traversal = await admin.GetAsync("/api/v1/logs/files/..%2Fserver.json"); + await traversal.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + } + + [Test] + public async Task ArchiveSettingsValidateTemplatesAndJobsNeedHandlers() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using var read = await admin.GetAsync("/api/v1/archive/settings"); + var archive = await read.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(Path.GetFullPath(server.Options.ArchivePath), archive.RootPath); + + using (var bad = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { FolderTemplate = "{year/{date" }, ProtocolJson.Default.ArchiveSettingsDto)) + Assert.Equal("folderTemplate", (await bad.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details); + using (var good = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { Name = "Studio", ProxyLongEdge = 2560 }, ProtocolJson.Default.ArchiveSettingsDto)) + { + var saved = await good.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(("Studio", 2560), (saved.Name, saved.ProxyLongEdge)); + } + using var scan = await admin.PostAsync("/api/v1/archive/scan", null); + await scan.ExpectErrorAsync(HttpStatusCode.Conflict, "job_unavailable"); + using var stats = await admin.GetAsync("/api/v1/archive/stats"); + await stats.ExpectAsync(HttpStatusCode.OK); + } +} diff --git a/tests/Titano.Server.Tests/Api/SequenceTests.cs b/tests/Titano.Server.Tests/Api/SequenceTests.cs new file mode 100644 index 00000000..abcddbac --- /dev/null +++ b/tests/Titano.Server.Tests/Api/SequenceTests.cs @@ -0,0 +1,173 @@ +using System.Net; +using System.Net.Http.Headers; +using System.Net.Http.Json; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests.Api; + +[Category("server")] +public sealed class SequenceTests(TestContext context) +{ + [Test] + public async Task ConcurrentSettingsEditsConflict() + { + await using var server = await TestServer.StartAsync(context); + var (alberto, _, _) = await server.UserAsync("alberto", "editor"); + var (giulia, _, _) = await server.UserAsync("giulia", "editor"); + using var created = await alberto.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Harbour sunset", null), ProtocolJson.Default.CreateSequenceRequest); + await created.ExpectAsync(HttpStatusCode.Created); + var sequence = await created.ReadAsync(ProtocolJson.Default.SequenceDto); + Assert.Equal(0, sequence.SettingsVersion); + + using (var first = await alberto.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}", + new UpdateSequenceRequest(null, ["sunset", "harbour"], 4, null, """{"deflicker":{"strength":0.8}}""", 0), ProtocolJson.Default.UpdateSequenceRequest)) + { + await first.ExpectAsync(HttpStatusCode.OK); + var updated = await first.ReadAsync(ProtocolJson.Default.SequenceDto); + Assert.Equal(1, updated.SettingsVersion); + Assert.SequenceEqual(["harbour", "sunset"], updated.Tags); + Assert.Equal(4, updated.Rating); + } + + using (var stale = await giulia.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}", + new UpdateSequenceRequest(null, null, null, null, """{"deflicker":{"strength":0.2}}""", 0), ProtocolJson.Default.UpdateSequenceRequest)) + { + var error = await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "settings_conflict"); + Assert.Equal("1", error.Details); + } + + // The ETag of a fresh read works as If-Match. + using var read = await giulia.GetAsync($"/api/v1/sequences/{sequence.Id}"); + var etag = Assert.NotNull(read.Headers.ETag); + using var request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/sequences/{sequence.Id}") + { + Content = JsonContent.Create(new UpdateSequenceRequest(null, null, null, null, """{"deflicker":{"strength":0.2}}""", null), ProtocolJson.Default.UpdateSequenceRequest), + }; + request.Headers.IfMatch.Add(etag); + using (var retried = await giulia.SendAsync(request)) + { + await retried.ExpectAsync(HttpStatusCode.OK); + Assert.Equal(2, (await retried.ReadAsync(ProtocolJson.Default.SequenceDto)).SettingsVersion); + } + + using var notModified = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{sequence.Id}"); + notModified.Headers.IfNoneMatch.Add(etag); + using (var changed = await giulia.SendAsync(notModified)) await changed.ExpectAsync(HttpStatusCode.OK); + + using var invalid = await giulia.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}", + new UpdateSequenceRequest(null, null, null, null, "{ broken", null), ProtocolJson.Default.UpdateSequenceRequest); + await invalid.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_settings"); + } + + [Test] + public async Task TheManifestCarriesHashesAndAnEtag() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var a = Uploads.Photo(2000, 31); + var b = Uploads.Photo(2000, 32); + var first = await Uploads.UploadAsync(editor, a, "a.CR3", sessionKey: "k"); + await Uploads.UploadAsync(editor, b, "b.CR3", sessionKey: "k"); + + using var response = await editor.GetAsync($"/api/v1/sequences/{first.SequenceId}/manifest"); + await response.ExpectAsync(HttpStatusCode.OK); + var manifest = await response.ReadAsync(ProtocolJson.Default.SequenceManifest); + Assert.SequenceEqual([Uploads.Sha(a), Uploads.Sha(b)], manifest.Frames.Select(f => f.Sha256)); + Assert.Equal(2, manifest.FramesVersion); + + using var cached = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{first.SequenceId}/manifest"); + cached.Headers.IfNoneMatch.Add(response.Headers.ETag!); + using (var unchanged = await editor.SendAsync(cached)) await unchanged.ExpectAsync(HttpStatusCode.NotModified); + + await Uploads.UploadAsync(editor, Uploads.Photo(2000, 33), "c.CR3", sessionKey: "k"); + using var again = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{first.SequenceId}/manifest"); + again.Headers.IfNoneMatch.Add(response.Headers.ETag!); + using var changed = await editor.SendAsync(again); + await changed.ExpectAsync(HttpStatusCode.OK); + Assert.Count(3, (await changed.ReadAsync(ProtocolJson.Default.SequenceManifest)).Frames); + } + + [Test] + public async Task ListingFiltersAndPagesWithACursor() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + for (var i = 0; i < 5; i++) + { + using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest($"Shoot {i}", null), ProtocolJson.Default.CreateSequenceRequest); + await created.ExpectAsync(HttpStatusCode.Created); + } + var seen = new List(); + string? cursor = null; + long? total = null; + do + { + using var page = await editor.GetAsync($"/api/v1/sequences?sort=title&limit=2{(cursor is null ? string.Empty : "&cursor=" + Uri.EscapeDataString(cursor))}"); + await page.ExpectAsync(HttpStatusCode.OK); + var items = await page.ReadAsync(ProtocolJson.Default.PageSequenceDto); + total ??= items.Total; + seen.AddRange(items.Items.Select(s => s.DisplayTitle)); + cursor = items.NextCursor; + } + while (cursor is not null); + Assert.Equal(5L, total); + Assert.SequenceEqual(["Shoot 0", "Shoot 1", "Shoot 2", "Shoot 3", "Shoot 4"], seen); + + using (var search = await editor.GetAsync("/api/v1/sequences?q=shoot%203")) Assert.Count(1, (await search.ReadAsync(ProtocolJson.Default.PageSequenceDto)).Items); + using (var badCursor = await editor.GetAsync("/api/v1/sequences?cursor=bm9wZQ")) await badCursor.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_cursor"); + using var badStatus = await editor.GetAsync("/api/v1/sequences?status=shiny"); + await badStatus.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_filter"); + } + + [Test] + public async Task DeletingPlansFirstAndMovesTheFolderToTrash() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var (other, _, _) = await server.UserAsync("giulia", "editor"); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(3000, 34)); + var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; + var folder = Path.Combine(server.Options.ArchivePath, sequence.Folder); + + using (var notOwner = await other.DeleteAsync($"/api/v1/sequences/{sequence.Id}")) await notOwner.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using (var plan = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}?dryRun=true")) + { + var dryRun = await plan.ReadAsync(ProtocolJson.Default.SequenceDeletePlan); + Assert.True(dryRun.DryRun); + Assert.Equal(1, dryRun.FrameCount); + Assert.Equal($".titano/trash/{sequence.Id:N}", dryRun.TrashFolder); + } + Assert.True(Directory.Exists(folder), "a dry run changes nothing"); + Assert.NotNull(await server.Database.Sequences.GetAsync(sequence.Id)); + + using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}")) await deleted.ExpectAsync(HttpStatusCode.OK); + Assert.False(Directory.Exists(folder)); + Assert.True(Directory.Exists(Path.Combine(server.Options.TrashPath, sequence.Id.ToString("N"))), "the files are kept in the trash"); + Assert.Null(await server.Database.Sequences.GetAsync(sequence.Id)); + using var gone = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}"); + await gone.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + } + + [Test] + public async Task FramesAndStatsArePaged() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var first = await Uploads.UploadAsync(editor, Uploads.Photo(1000, 40), "f0.jpg", sessionKey: "p"); + for (var i = 1; i < 4; i++) await Uploads.UploadAsync(editor, Uploads.Photo(1000 + i, 40 + i), $"f{i}.jpg", sessionKey: "p"); + var id = first.SequenceId; + using var page1 = await editor.GetAsync($"/api/v1/sequences/{id}/frames?limit=2"); + var frames = await page1.ReadAsync(ProtocolJson.Default.PageFrameDto); + Assert.SequenceEqual([0, 1], frames.Items.Select(f => f.Index)); + using var page2 = await editor.GetAsync($"/api/v1/sequences/{id}/frames?limit=2&cursor={Uri.EscapeDataString(frames.NextCursor!)}"); + Assert.SequenceEqual([2, 3], (await page2.ReadAsync(ProtocolJson.Default.PageFrameDto)).Items.Select(f => f.Index)); + + using var stats = await editor.GetAsync($"/api/v1/sequences/{id}/stats"); + var dto = await stats.ReadAsync(ProtocolJson.Default.SequenceStatsDto); + Assert.Equal(4, dto.FrameCount); + Assert.Equal(4L, dto.ByFormat.Sum(f => f.Count)); + using var analysis = await editor.GetAsync($"/api/v1/sequences/{id}/analysis"); + Assert.Equal("analysis", (await analysis.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details); + } +} diff --git a/tests/Titano.Server.Tests/Api/UserTests.cs b/tests/Titano.Server.Tests/Api/UserTests.cs new file mode 100644 index 00000000..d64d7d2f --- /dev/null +++ b/tests/Titano.Server.Tests/Api/UserTests.cs @@ -0,0 +1,78 @@ +using System.Net; +using System.Net.Http.Json; +using Titano.Core.Model; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests.Api; + +[Category("server")] +public sealed class UserTests(TestContext context) +{ + [Test] + public async Task AdminsManageAccountsAndTemporaryPasswords() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using var created = await admin.PostAsJsonAsync("/api/v1/users", new CreateUserRequest("lucia", "Lucia", "editor", 2_000_000_000_000, null, AllowRenderNode: false), + ProtocolJson.Default.CreateUserRequest); + await created.ExpectAsync(HttpStatusCode.Created); + var account = await created.ReadAsync(ProtocolJson.Default.TemporaryPasswordResponse); + Assert.True(account.User.MustChangePassword); + Assert.Equal(14, account.TemporaryPassword.Length); + Assert.Equal(0L, account.User.Permissions & (long)Permissions.RenderNode); + + using (var taken = await admin.PostAsJsonAsync("/api/v1/users", new CreateUserRequest("LUCIA", null, "viewer", 0, null, false), ProtocolJson.Default.CreateUserRequest)) + await taken.ExpectErrorAsync(HttpStatusCode.Conflict, "username_taken"); + using (var badName = await admin.PostAsJsonAsync("/api/v1/users", new CreateUserRequest("lu cia", null, "viewer", 0, null, false), ProtocolJson.Default.CreateUserRequest)) + await badName.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_username"); + using (var badRole = await admin.PostAsJsonAsync("/api/v1/users", new CreateUserRequest("lucio", null, "owner", 0, null, false), ProtocolJson.Default.CreateUserRequest)) + await badRole.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_role"); + + using (var promoted = await admin.PatchAsJsonAsync($"/api/v1/users/{account.User.Id}", new UpdateUserRequest(null, "uploader", 5, null, true), ProtocolJson.Default.UpdateUserRequest)) + { + var user = await promoted.ReadAsync(ProtocolJson.Default.UserDto); + Assert.Equal(("uploader", 5L), (user.Role, user.QuotaBytes)); + Assert.Equal((long)(RolePermissions.Default(UserRole.Uploader) | Permissions.RenderNode), user.Permissions); + } + + using var reset = await admin.PostAsJsonAsync($"/api/v1/users/{account.User.Id}/reset-password", new ResetPasswordRequest(null), ProtocolJson.Default.ResetPasswordRequest); + var temporary = await reset.ReadAsync(ProtocolJson.Default.TemporaryPasswordResponse); + var login = await server.LoginAsync("lucia", temporary.TemporaryPassword); + Assert.True(login.MustChangePassword); + + using var list = await admin.GetAsync("/api/v1/users"); + var rows = await list.ReadAsync(ProtocolJson.Default.ListUserSummaryDto); + var lucia = rows.Single(r => r.User.Username == "lucia"); + Assert.Equal("tests", lucia.LastClient); + Assert.NotNull(lucia.LastSeen); + } + + [Test] + public async Task TheLastAdministratorStays() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using var me = await admin.GetAsync("/api/v1/auth/me"); + var self = await me.ReadAsync(ProtocolJson.Default.UserDto); + using (var demote = await admin.PatchAsJsonAsync($"/api/v1/users/{self.Id}", new UpdateUserRequest(null, "editor", null, null, null), ProtocolJson.Default.UpdateUserRequest)) + await demote.ExpectErrorAsync(HttpStatusCode.Conflict, "self"); + using (var delete = await admin.DeleteAsync($"/api/v1/users/{self.Id}")) await delete.ExpectErrorAsync(HttpStatusCode.Conflict, "self"); + } + + [Test] + public async Task DeletingAUserHandsTheirSequencesToTheAdmin() + { + await using var server = await TestServer.StartAsync(context); + var (editor, user, _) = await server.UserAsync("simone", "editor"); + using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Comet", null), ProtocolJson.Default.CreateSequenceRequest); + var sequence = await created.ReadAsync(ProtocolJson.Default.SequenceDto); + var admin = await server.AdminAsync(); + using (var deleted = await admin.DeleteAsync($"/api/v1/users/{user.Id}")) await deleted.ExpectAsync(HttpStatusCode.NoContent); + using var me = await admin.GetAsync("/api/v1/auth/me"); + var adminId = (await me.ReadAsync(ProtocolJson.Default.UserDto)).Id; + Assert.Equal(adminId, (await server.Database.Sequences.GetAsync(sequence.Id))!.OwnerUserId); + using var audit = await admin.GetAsync("/api/v1/audit?action=user_deleted"); + Assert.Count(1, (await audit.ReadAsync(ProtocolJson.Default.PageAuditEntryDto)).Items); + } +} diff --git a/tests/Titano.Server.Tests/Events/EventTests.cs b/tests/Titano.Server.Tests/Events/EventTests.cs new file mode 100644 index 00000000..820c0678 --- /dev/null +++ b/tests/Titano.Server.Tests/Events/EventTests.cs @@ -0,0 +1,83 @@ +using System.Net; +using System.Net.WebSockets; +using Microsoft.Extensions.DependencyInjection; +using Titano.Core.Model; +using Titano.Data.Jobs; +using Titano.Protocol; +using Titano.Protocol.Client; +using Titano.Server.Tests.Jobs; +using Titano.Testing; + +namespace Titano.Server.Tests.Events; + +[Category("server")] +public sealed class EventTests(TestContext context) +{ + [Test] + public async Task AWebSocketClientReceivesJobProgressAndStates() + { + var handler = new BlockingJobHandler(JobKind.DeepAnalyse); + await using var server = await TestServer.StartAsync(context, services: s => s.AddSingleton(handler)); + var (editor, _, token) = await server.UserAsync("alberto", "editor"); + var sequence = await JobApiTests.CreateSequenceAsync(editor); + + using var client = new TitanoClient(server.HttpBase, new CertificatePinning([]), "tests") { Token = token }; + using var listening = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation); + listening.CancelAfter(TimeSpan.FromSeconds(20)); + var received = new List(); + var connected = new TaskCompletionSource(); + var reader = Task.Run(async () => + { + var events = client.EventsAsync(listening.Token).GetAsyncEnumerator(listening.Token); + var first = events.MoveNextAsync(); + connected.TrySetResult(); + try + { + if (!await first) return; + do + { + received.Add(events.Current); + if (events.Current is JobStateEvent { State: "done" }) return; + } + while (await events.MoveNextAsync()); + } + finally + { + await events.DisposeAsync(); + } + }); + await connected.Task; + await WaitForSubscriberAsync(server); + + var job = await JobApiTests.CreateAsync(editor, "deep-analyse", sequence); + await handler.Started.Task.WaitAsync(TimeSpan.FromSeconds(10)); + handler.Release(); + await reader.WaitAsync(TimeSpan.FromSeconds(20)); + + Assert.Contains(received, e => e is JobProgressEvent p && p.JobId == job.Id && p.Total == 4); + Assert.Contains(received, e => e is JobStateEvent { State: "running" } s && s.JobId == job.Id); + Assert.Contains(received, e => e is JobStateEvent { State: "done" } s && s.JobId == job.Id); + } + + [Test] + public async Task TheEventSocketNeedsAValidToken() + { + await using var server = await TestServer.StartAsync(context); + var ws = new UriBuilder(new Uri(server.HttpBase, "/api/v1/events")) { Scheme = "ws" }.Uri; + using (var anonymous = new ClientWebSocket()) + { + var error = await Assert.ThrowsAsync(() => anonymous.ConnectAsync(ws, context.Cancellation)); + Assert.Contains("401", error.Message); + } + var admin = await server.AdminAsync(); + using var plain = await admin.GetAsync("/api/v1/events"); + await plain.ExpectErrorAsync(HttpStatusCode.BadRequest, "websocket_required"); + } + + private static async Task WaitForSubscriberAsync(TestServer server) + { + var hub = server.Services.GetRequiredService(); + for (var i = 0; i < 200 && hub.SubscriberCount == 0; i++) await Task.Delay(25); + Assert.Equal(1, hub.SubscriberCount); + } +} diff --git a/tests/Titano.Server.Tests/Hosting/DiscoveryTests.cs b/tests/Titano.Server.Tests/Hosting/DiscoveryTests.cs new file mode 100644 index 00000000..f2e5dc3a --- /dev/null +++ b/tests/Titano.Server.Tests/Hosting/DiscoveryTests.cs @@ -0,0 +1,41 @@ +using System.Net; +using System.Net.Sockets; +using System.Text; +using Microsoft.Extensions.DependencyInjection; +using Titano.Protocol; +using Titano.Server.Api; +using Titano.Server.Hosting; +using Titano.Testing; + +namespace Titano.Server.Tests.Hosting; + +[Category("server")] +public sealed class DiscoveryTests(TestContext context) +{ + [Test] + public async Task TheBeaconTravelsOverUdpAndParses() + { + await using var server = await TestServer.StartAsync(context, o => o.ServerName = "Studio NAS"); + var service = server.Services.GetRequiredService(); + using var listener = new UdpClient(new IPEndPoint(IPAddress.Loopback, 0)); + using var sender = new UdpClient(AddressFamily.InterNetwork); + await service.SendOnceAsync(sender, [(IPEndPoint)listener.Client.LocalEndPoint!], context.Cancellation); + + var datagram = await listener.ReceiveAsync(context.Cancellation).AsTask().WaitAsync(TimeSpan.FromSeconds(5)); + var beacon = Assert.NotNull(DiscoveryBeacon.TryParse(datagram.Buffer)); + Assert.Equal("Studio NAS", beacon.Name); + Assert.Equal(SystemEndpoints.Version, beacon.Version); + Assert.Equal(server.HttpBase.Port, beacon.HttpPort); + Assert.Equal(server.HttpsBase!.Port, beacon.HttpsPort); + using var info = await server.Client.GetAsync("/api/v1/server/info"); + Assert.Equal((await info.ReadAsync(ProtocolJson.Default.ServerInfo)).TlsFingerprint, beacon.TlsFingerprint); + } + + [Test] + public void ForeignDatagramsAreIgnored() + { + Assert.Null(DiscoveryBeacon.TryParse(Encoding.UTF8.GetBytes("HELLO {}"))); + Assert.Null(DiscoveryBeacon.TryParse(Encoding.UTF8.GetBytes("TITANO1 {not json"))); + Assert.Null(DiscoveryBeacon.TryParse(new byte[4096])); + } +} diff --git a/tests/Titano.Server.Tests/Hosting/StartupTests.cs b/tests/Titano.Server.Tests/Hosting/StartupTests.cs new file mode 100644 index 00000000..c375aaef --- /dev/null +++ b/tests/Titano.Server.Tests/Hosting/StartupTests.cs @@ -0,0 +1,67 @@ +using Titano.Data; +using Titano.Server.Configuration; +using Titano.Server.Hosting; +using Titano.Testing; + +namespace Titano.Server.Tests.Hosting; + +[Category("server")] +public sealed class StartupTests(TestContext context) +{ + [Test] + public void TheServerRefusesToStartWithoutTheArchiveModule() + { + var root = context.CreateTempDirectory("bare"); + var options = new ServerOptions + { + DataPath = Path.Combine(root, "data"), + ArchivePath = Path.Combine(root, "archive"), + HttpPort = 0, + HttpsPort = 0, + Database = DatabaseKind.Sqlite, + Discovery = false, + }; + var error = Assert.Throws(() => ServerHost.Build(options, [])); + Assert.Contains("IArchiveIngest", error.Message); + Assert.Contains("IFrameAssetLocator", error.Message); + } + + [Test] + public void TitanoDbAcceptsAConnectionString() + { + var root = context.CreateTempDirectory("env"); + var options = ServerOptions.Load(new Dictionary + { + ["TITANO_DATA_PATH"] = root, + ["TITANO_DB"] = "Host=db.lan;Port=6543;Database=archive;Username=titano;Password=secret", + }); + Assert.Equal(DatabaseKind.Postgres, options.Database); + var database = options.ToDatabaseOptions(); + Assert.Equal(Dialect.Postgres, database.Dialect); + Assert.Equal(6543, Titano.Data.Postgres.PostgresSettings.Parse(database.ConnectionString).Port); + } + + [Test] + public void PartsBuildAQuotedPostgresConnectionString() + { + var options = new ServerOptions { DbHost = "postgres", DbName = "titano", DbUser = "titano", DbPassword = "it's;secret", DbSslMode = "disable" }; + var settings = Titano.Data.Postgres.PostgresSettings.Parse(options.ToDatabaseOptions().ConnectionString); + Assert.Equal(("postgres", "titano", "it's;secret"), (settings.Host, settings.Database, settings.Password)); + Assert.Equal(Titano.Data.Postgres.SslMode.Disable, settings.SslMode); + } + + [Test] + public void EnvironmentVariablesLockTheirSettings() + { + var root = context.CreateTempDirectory("locked"); + var options = ServerOptions.Load(new Dictionary + { + ["TITANO_DATA_PATH"] = root, + ["TITANO_DB"] = "postgres", + ["TITANO_HTTP_PORT"] = "9090", + ["TITANO_DISCOVERY"] = "false", + }); + Assert.SequenceEqual(["Database", "HttpPort", "Discovery"], options.Locked); + Assert.Throws(() => ServerOptions.Load(new Dictionary { ["TITANO_DATA_PATH"] = root, ["TITANO_DB"] = "postgres", ["TITANO_WORKERS"] = "many" })); + } +} diff --git a/tests/Titano.Server.Tests/Hosting/WindowsServiceTests.cs b/tests/Titano.Server.Tests/Hosting/WindowsServiceTests.cs new file mode 100644 index 00000000..d09c7c7e --- /dev/null +++ b/tests/Titano.Server.Tests/Hosting/WindowsServiceTests.cs @@ -0,0 +1,55 @@ +using Titano.Server.Hosting; +using Titano.Server.Hosting.Windows; +using Titano.Testing; + +namespace Titano.Server.Tests.Hosting; + +public sealed class WindowsServiceTests +{ + [Test] + public void CommandSwitchesAreParsedAndTheRestPassedOn() + { + Assert.Equal(ServerCommand.Run, ServerCommandLine.Parse([]).Command); + var service = ServerCommandLine.Parse(["--service", "--urls", "x"]); + Assert.Equal(ServerCommand.Service, service.Command); + Assert.SequenceEqual(["--urls", "x"], service.HostArguments); + Assert.Equal(ServerCommand.InstallService, ServerCommandLine.Parse(["--install-service"]).Command); + Assert.Equal(ServerCommand.UninstallService, ServerCommandLine.Parse(["--uninstall-service"]).Command); + Assert.Equal(ServerCommand.HealthCheck, ServerCommandLine.Parse(["--healthcheck"]).Command); + Assert.Equal(ServerCommand.Help, ServerCommandLine.Parse(["/?"]).Command); + Assert.NotNull(ServerCommandLine.Parse(["--install-service", "--uninstall-service"]).Error); + Assert.Null(ServerCommandLine.Parse(["--service", "--service"]).Error); + } + + [Test] + public void StatusReportsFollowTheServiceControlManagerRules() + { + var tracker = new ServiceStatusTracker(); + var start = tracker.StartPending(60_000); + Assert.Equal((ServiceState.StartPending, 0u, 1u, 60_000u), (start.State, start.ControlsAccepted, start.CheckPoint, start.WaitHintMilliseconds)); + Assert.Equal(2u, tracker.StartPending(60_000).CheckPoint); + var running = tracker.Running(); + Assert.Equal((ServiceState.Running, ServiceStatusTracker.AcceptStop | ServiceStatusTracker.AcceptShutdown, 0u), (running.State, running.ControlsAccepted, running.CheckPoint)); + Assert.Throws(() => tracker.Running()); + Assert.Equal(1u, tracker.StopPending(35_000).CheckPoint); + Assert.Equal(2u, tracker.StopPending(35_000).CheckPoint); + var stopped = tracker.Stopped(0); + Assert.Equal((ServiceState.Stopped, 0u, 0u), (stopped.State, stopped.ControlsAccepted, stopped.CheckPoint)); + Assert.Throws(() => tracker.StopPending(1)); + Assert.Equal(1064u, new ServiceStatusTracker().Stopped(1064).ExitCode); + } + + [Test] + [WindowsOnly] + public void TheDispatcherDeclinesAConsoleProcess() + { + if (!OperatingSystem.IsWindows()) return; + var built = false; + Assert.False(WindowsServiceHost.Run(() => + { + built = true; + throw new InvalidOperationException("never built outside the SCM"); + })); + Assert.False(built); + } +} diff --git a/tests/Titano.Server.Tests/Http.cs b/tests/Titano.Server.Tests/Http.cs new file mode 100644 index 00000000..6f5b38f1 --- /dev/null +++ b/tests/Titano.Server.Tests/Http.cs @@ -0,0 +1,41 @@ +using System.Net; +using System.Net.Http.Json; +using System.Text.Json.Serialization.Metadata; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests; + +/// Assertions and JSON helpers for API calls. +internal static class Http +{ + /// The body of a successful response (an error response fails the test with its body). + public static async Task ReadAsync(this HttpResponseMessage response, JsonTypeInfo type) where T : class + { + if (!response.IsSuccessStatusCode) Assert.Fail($"Expected success, got {(int)response.StatusCode}: {await response.Content.ReadAsStringAsync()}"); + return Assert.NotNull(await response.Content.ReadFromJsonAsync(type)); + } + + /// Asserts the status, the { code, message, details } body with , and the API header. + public static async Task ExpectErrorAsync(this HttpResponseMessage response, HttpStatusCode status, string code) + { + var body = await response.Content.ReadAsStringAsync(); + Assert.Equal(status, response.StatusCode, body); + Assert.Equal("1", response.Headers.GetValues(ApiVersion.Header).Single()); + var error = Assert.NotNull(System.Text.Json.JsonSerializer.Deserialize(body, ProtocolJson.Default.ApiError)); + Assert.Equal(code, error.Code, body); + Assert.False(string.IsNullOrWhiteSpace(error.Message), "message is empty"); + return error; + } + + public static async Task BytesEqualAsync(byte[] expected, Task actual) + { + var bytes = await actual; + Assert.BytesEqual(expected, bytes); + } + + public static async Task ExpectAsync(this HttpResponseMessage response, HttpStatusCode status) + { + if (response.StatusCode != status) Assert.Fail($"Expected {(int)status}, got {(int)response.StatusCode}: {await response.Content.ReadAsStringAsync()}"); + } +} diff --git a/tests/Titano.Server.Tests/Jobs/JobApiTests.cs b/tests/Titano.Server.Tests/Jobs/JobApiTests.cs new file mode 100644 index 00000000..2957d42c --- /dev/null +++ b/tests/Titano.Server.Tests/Jobs/JobApiTests.cs @@ -0,0 +1,139 @@ +using System.Net; +using System.Net.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using Titano.Core.Model; +using Titano.Data.Jobs; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests.Jobs; + +[Category("server")] +public sealed class JobApiTests(TestContext context) +{ + [Test] + public async Task JobsMoveThroughPauseResumeAndDone() + { + var handler = new BlockingJobHandler(JobKind.DeepAnalyse); + await using var server = await TestServer.StartAsync(context, services: s => s.AddSingleton(handler)); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var sequence = await CreateSequenceAsync(editor); + + var job = await CreateAsync(editor, "deep-analyse", sequence); + Assert.Equal(("queued", "user", "Harbour sunset"), (job.State, job.Priority, job.TargetLabel)); + await handler.Started.Task.WaitAsync(TimeSpan.FromSeconds(10)); + await WaitForAsync(editor, job.Id, "running"); + + Assert.Equal("paused", (await ActAsync(editor, job.Id, "pause", HttpStatusCode.OK)).State); + await WaitForAsync(editor, job.Id, "paused"); + await ActAsync(editor, job.Id, "pause", HttpStatusCode.Conflict); + await ActAsync(editor, job.Id, "retry", HttpStatusCode.Conflict); + + await ActAsync(editor, job.Id, "resume", HttpStatusCode.OK); + await WaitForAsync(editor, job.Id, "running"); + handler.Release(); + var done = await WaitForAsync(editor, job.Id, "done"); + Assert.Equal((4L, 4L), (done.ProgressDone, done.ProgressTotal)); + await ActAsync(editor, job.Id, "cancel", HttpStatusCode.Conflict); + + using var list = await editor.GetAsync("/api/v1/jobs?state=done&kind=deep-analyse"); + Assert.Equal(job.Id, (await list.ReadAsync(ProtocolJson.Default.PageJobDto)).Items.Single().Id); + } + + [Test] + public async Task FailedJobsRetryAndRunningJobsCancel() + { + var handler = new BlockingJobHandler(JobKind.Proxies) { FailWith = "decoder exploded" }; + await using var server = await TestServer.StartAsync(context, services: s => s.AddSingleton(handler)); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var sequence = await CreateSequenceAsync(editor); + + var job = await CreateAsync(editor, "proxies", sequence); + var failed = await WaitForAsync(editor, job.Id, "failed"); + Assert.Equal("decoder exploded", failed.Error); + Assert.Contains("decoder exploded", failed.LogTail); + + await ActAsync(editor, job.Id, "retry", HttpStatusCode.OK); + await WaitForAsync(editor, job.Id, "running"); + Assert.Equal("cancelled", (await ActAsync(editor, job.Id, "cancel", HttpStatusCode.OK)).State); + await Task.Delay(200); + Assert.Equal("cancelled", (await GetAsync(editor, job.Id)).State); + } + + [Test] + public async Task WaitingJobsChangePriorityAndRightsAreChecked() + { + var handler = new BlockingJobHandler(JobKind.Thumbs); + await using var server = await TestServer.StartAsync(context, o => o.Workers = 1, s => s.AddSingleton(handler)); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var (viewer, _, _) = await server.UserAsync("marco", "viewer"); + var sequence = await CreateSequenceAsync(editor); + + var first = await CreateAsync(editor, "thumbs", sequence); + await WaitForAsync(editor, first.Id, "running"); + var second = await CreateAsync(editor, "thumbs", sequence); + using (var lower = await editor.PostAsJsonAsync($"/api/v1/jobs/{second.Id}/priority", new JobPriorityRequest("background"), ProtocolJson.Default.JobPriorityRequest)) + Assert.Equal("background", (await lower.ReadAsync(ProtocolJson.Default.JobDto)).Priority); + using (var bad = await editor.PostAsJsonAsync($"/api/v1/jobs/{second.Id}/priority", new JobPriorityRequest("urgent"), ProtocolJson.Default.JobPriorityRequest)) + await bad.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_priority"); + + using (var foreign = await viewer.PostAsync($"/api/v1/jobs/{second.Id}/cancel", null)) await foreign.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using (var create = await viewer.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("thumbs", [sequence], null), ProtocolJson.Default.CreateJobRequest)) + await create.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using (var unknown = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("teleport", [sequence], null), ProtocolJson.Default.CreateJobRequest)) + await unknown.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_job_kind"); + using (var unavailable = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("deep-analyse", [sequence], null), ProtocolJson.Default.CreateJobRequest)) + await unavailable.ExpectErrorAsync(HttpStatusCode.Conflict, "job_unavailable"); + using (var render = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("render", [sequence], "{}"), ProtocolJson.Default.CreateJobRequest)) + await render.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_parameters"); + + var admin = await server.AdminAsync(); + using (var removed = await admin.PostAsync($"/api/v1/jobs/{second.Id}/cancel", null)) await removed.ExpectAsync(HttpStatusCode.OK); + handler.Release(); + await WaitForAsync(editor, first.Id, "done"); + } + + public static async Task CreateSequenceAsync(HttpClient client, string title = "Harbour sunset") + { + using var created = await client.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest(title, null), ProtocolJson.Default.CreateSequenceRequest); + await created.ExpectAsync(HttpStatusCode.Created); + return (await created.ReadAsync(ProtocolJson.Default.SequenceDto)).Id; + } + + public static async Task CreateAsync(HttpClient client, string kind, Guid target, string? parameters = null) + { + using var response = await client.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest(kind, [target], parameters), ProtocolJson.Default.CreateJobRequest); + await response.ExpectAsync(HttpStatusCode.Accepted); + return await response.ReadAsync(ProtocolJson.Default.JobDto); + } + + public static async Task GetAsync(HttpClient client, Guid id) + { + using var response = await client.GetAsync($"/api/v1/jobs/{id}"); + return await response.ReadAsync(ProtocolJson.Default.JobDto); + } + + public static async Task WaitForAsync(HttpClient client, Guid id, string state) + { + var deadline = DateTime.UtcNow.AddSeconds(15); + while (true) + { + var job = await GetAsync(client, id); + if (job.State == state) return job; + if (DateTime.UtcNow > deadline) Assert.Fail($"Job {id} is {job.State}, expected {state}"); + await Task.Delay(50); + } + } + + private static async Task ActAsync(HttpClient client, Guid id, string action, HttpStatusCode expected) + { + using var response = await client.PostAsync($"/api/v1/jobs/{id}/{action}", null); + if (expected != HttpStatusCode.OK) + { + await response.ExpectErrorAsync(expected, "invalid_state"); + return await GetAsync(client, id); + } + await response.ExpectAsync(expected); + return await response.ReadAsync(ProtocolJson.Default.JobDto); + } +} diff --git a/tests/Titano.Server.Tests/Jobs/RenderNodeTests.cs b/tests/Titano.Server.Tests/Jobs/RenderNodeTests.cs new file mode 100644 index 00000000..0b7610fc --- /dev/null +++ b/tests/Titano.Server.Tests/Jobs/RenderNodeTests.cs @@ -0,0 +1,133 @@ +using System.Net; +using System.Net.Http.Json; +using System.Text.Json; +using Microsoft.Extensions.DependencyInjection; +using Titano.Protocol; +using Titano.Protocol.Client; +using Titano.Server.Jobs; +using Titano.Testing; + +namespace Titano.Server.Tests.Jobs; + +[Category("server")] +public sealed class RenderNodeTests(TestContext context) +{ + private static readonly string HevcJob = JsonSerializer.Serialize( + new RenderJobParameters("4K HEVC", """{"codec":"hevc","bitrate":60}""", "hevc", 3840, 2160, UseProxies: false, null), ProtocolJson.Default.RenderJobParameters); + + [Test] + public async Task NodesClaimWhatTheyCanEncodeAndLoseJobsWhenSilent() + { + var clock = new ManualTimeProvider(); + await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60, s => s.AddSingleton(clock)); + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 51), "IMG_0001.CR3"); + var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); + + var studio = await RegisterAsync(editor, "studio-pc", "hevc", 8192); + var laptop = await RegisterAsync(editor, "laptop", "h264", 4096); + var spare = await RegisterAsync(editor, "spare-pc", "HEVC", 0); + using (var none = await editor.PostAsync($"/api/v1/nodes/{laptop.Id}/claim", null)) await none.ExpectAsync(HttpStatusCode.NoContent); + + ClaimedJob claimed; + using (var claim = await editor.PostAsync($"/api/v1/nodes/{studio.Id}/claim", null)) + { + await claim.ExpectAsync(HttpStatusCode.OK); + claimed = await claim.ReadAsync(ProtocolJson.Default.ClaimedJob); + } + Assert.Equal((job.Id, frame.SequenceId, "running"), (claimed.Job.Id, claimed.SequenceId, claimed.Job.State)); + Assert.Equal(frame.FrameId, claimed.Frames.Single().Id); + Assert.Equal(studio.Id.ToString(), claimed.Job.NodeId); + using (var second = await editor.PostAsync($"/api/v1/nodes/{spare.Id}/claim", null)) await second.ExpectAsync(HttpStatusCode.NoContent); + + using (var progress = await editor.PostAsJsonAsync($"/api/v1/nodes/{studio.Id}/jobs/{job.Id}/progress", new NodeProgress(120, 3600, 40, "encoding"), + ProtocolJson.Default.NodeProgress)) + await progress.ExpectAsync(HttpStatusCode.NoContent); + Assert.Equal(120L, (await JobApiTests.GetAsync(editor, job.Id)).ProgressDone); + + // studio-pc goes silent; the others keep heart-beating. + clock.Advance(TimeSpan.FromSeconds(90)); + foreach (var alive in new[] { laptop, spare }) + using (var beat = await editor.PostAsync($"/api/v1/nodes/{alive.Id}/heartbeat", null)) await beat.ExpectAsync(HttpStatusCode.NoContent); + await server.Services.GetRequiredService().SweepAsync(context.Cancellation); + + var requeued = await JobApiTests.GetAsync(editor, job.Id); + Assert.Equal("queued", requeued.State); + Assert.Contains("studio-pc stopped responding", requeued.LogTail); + using (var nodes = await editor.GetAsync("/api/v1/nodes")) + { + var states = (await nodes.ReadAsync(ProtocolJson.Default.ListRenderNodeDto)).ToDictionary(n => n.ClientName, n => n.State); + Assert.Equal(("offline", "idle"), (states["studio-pc"], states["laptop"])); + } + using (var late = await editor.PostAsJsonAsync($"/api/v1/nodes/{studio.Id}/jobs/{job.Id}/progress", new NodeProgress(200, 3600, 40, null), + ProtocolJson.Default.NodeProgress)) + await late.ExpectErrorAsync(HttpStatusCode.Conflict, "job_not_assigned"); + + using (var reassigned = await editor.PostAsync($"/api/v1/nodes/{spare.Id}/claim", null)) + { + var again = await reassigned.ReadAsync(ProtocolJson.Default.ClaimedJob); + Assert.Equal((job.Id, 2), (again.Job.Id, again.Job.Attempts)); + } + } + + [Test] + public async Task TheOutputUploadBecomesARenderAndFinishesTheJob() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024); + var (editor, _, token) = await server.UserAsync("alberto", "editor", renderNode: true); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 52), "IMG_0001.CR3"); + var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); + + using var client = new TitanoClient(server.HttpBase, new CertificatePinning([]), "studio-pc") { Token = token }; + var node = await client.RegisterNodeAsync(new RegisterNodeRequest("studio-pc", [new NodeEncoder("hevc", "NVENC HEVC", true, true)], 8192, 8192)); + var claimed = Assert.NotNull(await client.ClaimAsync(node.Id)); + await client.ReportNodeProgressAsync(node.Id, claimed.Job.Id, new NodeProgress(3600, 3600, 50, "muxing")); + + var output = Path.Combine(context.CreateTempDirectory("render"), "Harbour sunset - 4K HEVC.mp4"); + var video = Uploads.Photo(150_000, 53); + await File.WriteAllBytesAsync(output, video); + var render = await client.UploadRenderResultAsync(node.Id, job.Id, output, + new RenderResultRequest(Path.GetFileName(output), video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 144)); + Assert.Equal(("4K HEVC", "studio-pc", (long)video.Length), (render.PresetName, render.ProducedBy, render.Bytes)); + + var done = await JobApiTests.GetAsync(editor, job.Id); + Assert.Equal("done", done.State); + var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; + Assert.Equal(1, sequence.RenderedCount); + var file = Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Harbour sunset - 4K HEVC.mp4"); + await Http.BytesEqualAsync(video, File.ReadAllBytesAsync(file)); + using var renders = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}/renders"); + Assert.Equal(render.Id, (await renders.ReadAsync(ProtocolJson.Default.ListRenderDto)).Single().Id); + } + + [Test] + public async Task NodesReportFailuresAndNeedTheRight() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + var (plain, _, _) = await server.UserAsync("giulia", "editor"); + var sequence = await JobApiTests.CreateSequenceAsync(editor); + var job = await JobApiTests.CreateAsync(editor, "render", sequence, HevcJob); + var node = await RegisterAsync(editor, "studio-pc", "hevc", 8192); + using (var claim = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null)) await claim.ExpectAsync(HttpStatusCode.OK); + using (var failed = await editor.PostAsJsonAsync($"/api/v1/nodes/{node.Id}/jobs/{job.Id}/failed", new NodeJobFailure("NVENC session limit reached"), + ProtocolJson.Default.NodeJobFailure)) + await failed.ExpectAsync(HttpStatusCode.NoContent); + var state = await JobApiTests.GetAsync(editor, job.Id); + Assert.Equal(("failed", "NVENC session limit reached"), (state.State, state.Error)); + + using var refused = await plain.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("giulia-pc", [new NodeEncoder("hevc", "QSV", true, false)], 0, 0), + ProtocolJson.Default.RegisterNodeRequest); + await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using var foreign = await plain.PostAsync($"/api/v1/nodes/{node.Id}/heartbeat", null); + await foreign.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + } + + private static async Task RegisterAsync(HttpClient client, string name, string codec, int maxWidth) + { + using var response = await client.PostAsJsonAsync("/api/v1/nodes/register", + new RegisterNodeRequest(name, [new NodeEncoder(codec, codec.ToUpperInvariant() + " encoder", true, false)], maxWidth, maxWidth), ProtocolJson.Default.RegisterNodeRequest); + await response.ExpectAsync(HttpStatusCode.OK); + return await response.ReadAsync(ProtocolJson.Default.RenderNodeDto); + } +} diff --git a/tests/Titano.Server.Tests/Postgres/PostgresServerTests.cs b/tests/Titano.Server.Tests/Postgres/PostgresServerTests.cs new file mode 100644 index 00000000..511be137 --- /dev/null +++ b/tests/Titano.Server.Tests/Postgres/PostgresServerTests.cs @@ -0,0 +1,89 @@ +using System.Net; +using System.Net.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using Titano.Core.Model; +using Titano.Data; +using Titano.Data.Jobs; +using Titano.Protocol; +using Titano.Server.Configuration; +using Titano.Server.Tests.Jobs; +using Titano.Testing; + +namespace Titano.Server.Tests.Postgres; + +/// The server on PostgreSQL (TITANO_TEST_PG), each test in a private schema. +[Category("server")] +[RequiresEnvironment("TITANO_TEST_PG")] +public sealed class PostgresServerTests(TestContext context) +{ + [Test] + public async Task SignInUploadSyncAndJobsWorkOnPostgres() + { + await using var schema = await Schema.CreateAsync(context); + var handler = new BlockingJobHandler(JobKind.Thumbs); + await using var server = await TestServer.StartAsync(context, o => + { + o.Database = DatabaseKind.Postgres; + o.DbConnectionString = schema.ConnectionString; + o.ChunkSizeBytes = 64 * 1024; + }, s => s.AddSingleton(handler)); + Assert.Equal(Dialect.Postgres, server.Database.Dialect); + + var (editor, _, _) = await server.UserAsync("alberto", "editor", quotaBytes: 10_000_000); + var data = Uploads.Photo(150_000, 71); + var frame = await Uploads.UploadAsync(editor, data, sessionKey: "pg"); + using (var manifest = await editor.GetAsync($"/api/v1/sequences/{frame.SequenceId}/manifest")) + Assert.Equal(Uploads.Sha(data), (await manifest.ReadAsync(ProtocolJson.Default.SequenceManifest)).Frames.Single().Sha256); + using (var me = await editor.GetAsync("/api/v1/auth/me")) Assert.Equal(data.Length, (await me.ReadAsync(ProtocolJson.Default.UserDto)).UsedBytes); + + using (var stale = await editor.PatchAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}", new UpdateSequenceRequest(null, ["pg"], null, null, "{}", 99), + ProtocolJson.Default.UpdateSequenceRequest)) + await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "settings_conflict"); + + // Uploading queued a background thumbnail job for the sequence; it runs on the server's engine. + using var queued = await editor.GetAsync("/api/v1/jobs?kind=thumbs"); + var job = (await queued.ReadAsync(ProtocolJson.Default.PageJobDto)).Items.Single(); + await JobApiTests.WaitForAsync(editor, job.Id, "running"); + handler.Release(); + await JobApiTests.WaitForAsync(editor, job.Id, "done"); + + var admin = await server.AdminAsync(); + using var dashboard = await admin.GetAsync("/api/v1/server/dashboard"); + Assert.True((await dashboard.ReadAsync(ProtocolJson.Default.DashboardDto)).Database.StartsWith("PostgreSQL ", StringComparison.Ordinal)); + using var health = await server.Client.GetAsync("/health"); + Assert.Equal("ok", (await health.ReadAsync(ProtocolJson.Default.HealthStatus)).Checks["database"]); + } + + /// A throw-away schema on the test server, selected through Search Path. + private sealed class Schema : IAsyncDisposable + { + private readonly IDatabase _admin; + private readonly string _name; + + private Schema(IDatabase admin, string name, string connectionString) + { + _admin = admin; + _name = name; + ConnectionString = connectionString; + } + + public string ConnectionString { get; } + + public static async Task CreateAsync(TestContext context) + { + var baseConnection = Environment.GetEnvironmentVariable("TITANO_TEST_PG")!; + var admin = DatabaseFactory.Open(DatabaseOptions.Postgres(baseConnection)); + var name = "titano_s_" + Guid.NewGuid().ToString("N")[..16]; + await using (var session = await admin.OpenAsync(context.Cancellation)) + await session.ExecuteScriptAsync($"CREATE SCHEMA {name}", context.Cancellation); + return new Schema(admin, name, baseConnection.TrimEnd(';', ' ') + $";Search Path={name}"); + } + + public async ValueTask DisposeAsync() + { + await using (var session = await _admin.OpenAsync(CancellationToken.None)) + await session.ExecuteScriptAsync($"DROP SCHEMA IF EXISTS {_name} CASCADE", CancellationToken.None); + await _admin.DisposeAsync(); + } + } +} diff --git a/tests/Titano.Server.Tests/Security/AuthTests.cs b/tests/Titano.Server.Tests/Security/AuthTests.cs new file mode 100644 index 00000000..7bebadd8 --- /dev/null +++ b/tests/Titano.Server.Tests/Security/AuthTests.cs @@ -0,0 +1,227 @@ +using System.Net; +using System.Net.Http.Headers; +using System.Net.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests.Security; + +[Category("server")] +public sealed class AuthTests(TestContext context) +{ + [Test] + public async Task BootstrapAdminMustChangePasswordBeforeAnythingElse() + { + await using var server = await TestServer.StartAsync(context); + var login = await server.LoginAsync("admin", TestServer.AdminPassword); + Assert.True(login.MustChangePassword); + Assert.Equal("admin", login.User.Role); + var client = server.NewClient(login.Token); + + using (var blocked = await client.GetAsync("/api/v1/users")) await blocked.ExpectErrorAsync(HttpStatusCode.Forbidden, "password_change_required"); + using (var me = await client.GetAsync("/api/v1/auth/me")) await me.ExpectAsync(HttpStatusCode.OK); + using (var weak = await client.PostAsJsonAsync("/api/v1/auth/password", new ChangePasswordRequest(TestServer.AdminPassword, "short"), + ProtocolJson.Default.ChangePasswordRequest)) + await weak.ExpectErrorAsync(HttpStatusCode.BadRequest, "weak_password"); + using (var changed = await client.PostAsJsonAsync("/api/v1/auth/password", new ChangePasswordRequest(TestServer.AdminPassword, TestServer.Password), + ProtocolJson.Default.ChangePasswordRequest)) + await changed.ExpectAsync(HttpStatusCode.NoContent); + using var users = await client.GetAsync("/api/v1/users"); + await users.ExpectAsync(HttpStatusCode.OK); + Assert.Count(1, await users.ReadAsync(ProtocolJson.Default.ListUserSummaryDto)); + } + + [Test] + public async Task BootstrapWithoutPasswordWritesItToAFileNeverToTheLog() + { + await using var server = await TestServer.StartAsync(context, o => o.AdminPassword = null); + var file = Path.Combine(server.Options.DataPath, "initial-admin-password.txt"); + Assert.FileExists(file); + var password = File.ReadAllText(file).Trim(); + if (!OperatingSystem.IsWindows()) Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(file)); + var login = await server.LoginAsync("admin", password); + Assert.True(login.MustChangePassword); + foreach (var log in Directory.EnumerateFiles(server.Options.LogPath)) + { + using var reader = new StreamReader(new FileStream(log, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)); + Assert.False((await reader.ReadToEndAsync()).Contains(password, StringComparison.Ordinal), "the password reached the log"); + } + + var client = server.NewClient(login.Token); + using var changed = await client.PostAsJsonAsync("/api/v1/auth/password", new ChangePasswordRequest(password, TestServer.Password), + ProtocolJson.Default.ChangePasswordRequest); + await changed.ExpectAsync(HttpStatusCode.NoContent); + Assert.FileMissing(file); + } + + [Test] + public async Task WrongPasswordAndUnknownUserFailAlike() + { + await using var server = await TestServer.StartAsync(context); + using var wrong = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", "not-the-password", "tests"), ProtocolJson.Default.LoginRequest); + var a = await wrong.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); + using var unknown = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("nobody", "not-the-password", "tests"), ProtocolJson.Default.LoginRequest); + var b = await unknown.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); + Assert.Equal(a.Message, b.Message); + } + + [Test] + public async Task RepeatedFailuresLockTheAccountNameEvenWithTheRightPassword() + { + await using var server = await TestServer.StartAsync(context, o => + { + o.LoginAttemptsPerMinute = 100; + o.LockoutThreshold = 3; + }); + for (var i = 0; i < 3; i++) + { + using var failed = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", "wrong-password-x", "tests"), ProtocolJson.Default.LoginRequest); + await failed.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); + } + using var locked = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", TestServer.AdminPassword, "tests"), ProtocolJson.Default.LoginRequest); + await locked.ExpectErrorAsync(HttpStatusCode.TooManyRequests, "account_locked"); + Assert.True(locked.Headers.RetryAfter?.Delta > TimeSpan.Zero); + + for (var i = 0; i < 3; i++) + (await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("ghost", "wrong-password-x", "tests"), ProtocolJson.Default.LoginRequest)).Dispose(); + using var ghost = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("ghost", "wrong-password-x", "tests"), ProtocolJson.Default.LoginRequest); + await ghost.ExpectErrorAsync(HttpStatusCode.TooManyRequests, "account_locked"); + } + + [Test] + public async Task SignInsAreRateLimitedPerAddress() + { + await using var server = await TestServer.StartAsync(context, o => o.LoginAttemptsPerMinute = 5); + for (var i = 0; i < 5; i++) + (await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("user" + i, "wrong-password-x", "tests"), ProtocolJson.Default.LoginRequest)).Dispose(); + using var limited = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", TestServer.AdminPassword, "tests"), ProtocolJson.Default.LoginRequest); + await limited.ExpectErrorAsync(HttpStatusCode.TooManyRequests, "rate_limited"); + } + + [Test] + public async Task LogoutRevokesTheToken() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using (var me = await admin.GetAsync("/api/v1/auth/me")) await me.ExpectAsync(HttpStatusCode.OK); + using (var logout = await admin.PostAsync("/api/v1/auth/logout", null)) await logout.ExpectAsync(HttpStatusCode.NoContent); + using var after = await admin.GetAsync("/api/v1/auth/me"); + await after.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + Assert.Equal("Bearer", after.Headers.WwwAuthenticate.Single().Scheme); + } + + [Test] + public async Task TokensExpireUnlessUsedWithinTheirLifetime() + { + var clock = new ManualTimeProvider(); + await using var server = await TestServer.StartAsync(context, o => o.TokenLifetimeDays = 30, s => s.AddSingleton(clock)); + var admin = await server.AdminAsync(); + clock.Advance(TimeSpan.FromDays(20)); + using (var used = await admin.GetAsync("/api/v1/auth/me")) await used.ExpectAsync(HttpStatusCode.OK); + clock.Advance(TimeSpan.FromDays(20)); + using (var slid = await admin.GetAsync("/api/v1/auth/me")) await slid.ExpectAsync(HttpStatusCode.OK); + clock.Advance(TimeSpan.FromDays(31)); + using var expired = await admin.GetAsync("/api/v1/auth/me"); + await expired.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + } + + [Test] + public async Task TokensAreStoredOnlyAsHashes() + { + await using var server = await TestServer.StartAsync(context); + var login = await server.LoginAsync("admin", TestServer.AdminPassword); + await using var session = await server.Database.Database.OpenAsync(context.Cancellation); + var hashes = new List(); + await foreach (var row in session.QueryAsync("SELECT token_hash FROM tokens", [], context.Cancellation)) hashes.Add(row.GetString(0)); + Assert.Contains(Titano.Server.Security.TokenService.HashOf(login.Token!), hashes); + Assert.DoesNotContain(login.Token!, hashes); + } + + [Test] + public async Task DisablingAUserEndsTheirSessions() + { + await using var server = await TestServer.StartAsync(context); + var (editor, user, _) = await server.UserAsync("giulia", "editor"); + var admin = await server.AdminAsync(); + using (var disable = await admin.PatchAsJsonAsync($"/api/v1/users/{user.Id}", new UpdateUserRequest(null, null, null, true, null), ProtocolJson.Default.UpdateUserRequest)) + await disable.ExpectAsync(HttpStatusCode.OK); + using var me = await editor.GetAsync("/api/v1/auth/me"); + await me.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + using var login = await server.Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("giulia", TestServer.Password, "tests"), ProtocolJson.Default.LoginRequest); + await login.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); + } + + [Test] + public async Task PermissionsSeparateMissingSignInFromMissingRights() + { + await using var server = await TestServer.StartAsync(context); + using (var anonymous = await server.Client.GetAsync("/api/v1/users")) await anonymous.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + using (var anonymousSequences = await server.Client.GetAsync("/api/v1/sequences")) await anonymousSequences.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + + var (viewer, _, _) = await server.UserAsync("marco", "viewer"); + using (var users = await viewer.GetAsync("/api/v1/users")) await users.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using (var sequences = await viewer.GetAsync("/api/v1/sequences")) await sequences.ExpectAsync(HttpStatusCode.OK); + using (var upload = await viewer.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "a.jpg", 10, new string('a', 64), null, null), + ProtocolJson.Default.StartUploadRequest)) + await upload.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + using (var settings = await viewer.GetAsync("/api/v1/server/settings")) await settings.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + using (var start = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "a.jpg", 10, new string('a', 64), null, null), + ProtocolJson.Default.StartUploadRequest)) + await start.ExpectAsync(HttpStatusCode.Created); + using var edit = await uploader.PatchAsJsonAsync($"/api/v1/sequences/{Guid.NewGuid()}", new UpdateSequenceRequest("x", null, null, null, null, null), + ProtocolJson.Default.UpdateSequenceRequest); + await edit.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + } + + [Test] + public async Task CookieSessionsNeedTheCsrfHeaderForChanges() + { + await using var server = await TestServer.StartAsync(context); + await server.AdminAsync(); + var cookies = new CookieContainer(); + var browser = server.NewCookieClient(cookies); + using (var login = await browser.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", TestServer.Password, "admin-web", Cookie: true), + ProtocolJson.Default.LoginRequest)) + { + await login.ExpectAsync(HttpStatusCode.OK); + Assert.Null((await login.ReadAsync(ProtocolJson.Default.LoginResponse)).Token); + var session = login.Headers.GetValues("Set-Cookie").Single(c => c.StartsWith("titano_session=", StringComparison.Ordinal)); + Assert.Contains("httponly", session.ToLowerInvariant()); + Assert.Contains("secure", session.ToLowerInvariant()); + Assert.Contains("samesite=strict", session.ToLowerInvariant()); + } + using (var me = await browser.GetAsync("/api/v1/auth/me")) await me.ExpectAsync(HttpStatusCode.OK); + using (var forged = await browser.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("x", null), ProtocolJson.Default.CreateSequenceRequest)) + await forged.ExpectErrorAsync(HttpStatusCode.Forbidden, "csrf_failed"); + using (var wrong = new HttpRequestMessage(HttpMethod.Post, "/api/v1/sequences") { Content = JsonContent.Create(new CreateSequenceRequest("x", null), ProtocolJson.Default.CreateSequenceRequest) }) + { + wrong.Headers.Add("X-CSRF-Token", "not-the-token"); + using var response = await browser.SendAsync(wrong); + await response.ExpectErrorAsync(HttpStatusCode.Forbidden, "csrf_failed"); + } + var csrf = cookies.GetCookies(server.HttpsBase!)["titano_csrf"]!.Value; + using var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/sequences") { Content = JsonContent.Create(new CreateSequenceRequest("x", null), ProtocolJson.Default.CreateSequenceRequest) }; + request.Headers.Add("X-CSRF-Token", csrf); + using var created = await browser.SendAsync(request); + await created.ExpectAsync(HttpStatusCode.Created); + } + + [Test] + public async Task ErrorsHaveTheApiShapeAndHeader() + { + await using var server = await TestServer.StartAsync(context); + var admin = await server.AdminAsync(); + using (var missing = await server.Client.GetAsync("/api/v1/nothing-here")) await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + using (var badJson = await admin.PostAsync("/api/v1/sequences", new StringContent("{ not json", MediaTypeHeaderValue.Parse("application/json")))) + await badJson.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request"); + using (var badGuid = await admin.GetAsync($"/api/v1/sequences/{Guid.NewGuid()}")) await badGuid.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + using var italian = new HttpRequestMessage(HttpMethod.Get, "/api/v1/users"); + italian.Headers.AcceptLanguage.ParseAdd("it-IT"); + using var response = await server.Client.SendAsync(italian); + var error = await response.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized"); + Assert.Equal("Accedi per continuare.", error.Message); + } +} diff --git a/tests/Titano.Server.Tests/Storage/FileTests.cs b/tests/Titano.Server.Tests/Storage/FileTests.cs new file mode 100644 index 00000000..b76d4fb0 --- /dev/null +++ b/tests/Titano.Server.Tests/Storage/FileTests.cs @@ -0,0 +1,144 @@ +using System.Net; +using System.Net.Http.Headers; +using Microsoft.Extensions.DependencyInjection; +using Titano.Core.Model; +using Titano.Server.Storage; +using Titano.Testing; + +namespace Titano.Server.Tests.Storage; + +[Category("server")] +public sealed class FileTests(TestContext context) +{ + [Test] + public async Task OriginalsAreStreamedWithRangesAndEtags() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var data = Uploads.Photo(10_000, 21); + var frame = await Uploads.UploadAsync(editor, data); + + using (var full = await editor.GetAsync($"/api/v1/frames/{frame.FrameId}/original")) + { + await full.ExpectAsync(HttpStatusCode.OK); + Assert.Equal("bytes", full.Headers.AcceptRanges.Single()); + Assert.Equal($"\"{Uploads.Sha(data)}\"", full.Headers.ETag!.Tag); + await Http.BytesEqualAsync(data, full.Content.ReadAsByteArrayAsync()); + } + + using var range = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/frames/{frame.FrameId}/original"); + range.Headers.Range = new RangeHeaderValue(100, 199); + using (var partial = await editor.SendAsync(range)) + { + await partial.ExpectAsync(HttpStatusCode.PartialContent); + Assert.Equal((100L, 199L, 10_000L), (partial.Content.Headers.ContentRange!.From!.Value, partial.Content.Headers.ContentRange.To!.Value, + partial.Content.Headers.ContentRange.Length!.Value)); + await Http.BytesEqualAsync(data[100..200], partial.Content.ReadAsByteArrayAsync()); + } + + using var tail = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/frames/{frame.FrameId}/original"); + tail.Headers.Range = new RangeHeaderValue(9_990, null); + using (var end = await editor.SendAsync(tail)) await Http.BytesEqualAsync(data[9_990..], end.Content.ReadAsByteArrayAsync()); + + using var cached = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/frames/{frame.FrameId}/original"); + cached.Headers.IfNoneMatch.Add(new EntityTagHeaderValue($"\"{Uploads.Sha(data)}\"")); + using (var notModified = await editor.SendAsync(cached)) await notModified.ExpectAsync(HttpStatusCode.NotModified); + + var (viewer, _, _) = await server.UserAsync("marco", "viewer"); + using var refused = await viewer.GetAsync($"/api/v1/frames/{frame.FrameId}/original"); + await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + } + + [Test] + public async Task ThumbnailsAndProxiesComeFromTheLocatedFiles() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var first = await Uploads.UploadAsync(editor, Uploads.Photo(3000, 22), "a.jpg", sessionKey: "s"); + var second = await Uploads.UploadAsync(editor, Uploads.Photo(3000, 23), "b.jpg", sessionKey: "s"); + var sequence = (await server.Database.Sequences.GetAsync(first.SequenceId))!; + var folder = Path.Combine(server.Options.ArchivePath, sequence.Folder); + var pack = Uploads.Photo(FakeAssetLocator.ThumbnailSize * 2, 24); + Directory.CreateDirectory(Path.Combine(folder, ".titano")); + await File.WriteAllBytesAsync(Path.Combine(folder, ".titano", "thumbs.pack"), pack); + + using (var thumb = await editor.GetAsync($"/api/v1/frames/{second.FrameId}/thumb")) + { + await thumb.ExpectAsync(HttpStatusCode.OK); + Assert.Equal("image/jpeg", thumb.Content.Headers.ContentType!.MediaType); + await Http.BytesEqualAsync(pack[FakeAssetLocator.ThumbnailSize..(2 * FakeAssetLocator.ThumbnailSize)], thumb.Content.ReadAsByteArrayAsync()); + } + using var range = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/frames/{second.FrameId}/thumb"); + range.Headers.Range = new RangeHeaderValue(0, 9); + using (var partial = await editor.SendAsync(range)) + { + await partial.ExpectAsync(HttpStatusCode.PartialContent); + await Http.BytesEqualAsync(pack[FakeAssetLocator.ThumbnailSize..(FakeAssetLocator.ThumbnailSize + 10)], partial.Content.ReadAsByteArrayAsync()); + } + + using (var missing = await editor.GetAsync($"/api/v1/frames/{first.FrameId}/proxy")) + Assert.Equal("asset_missing", (await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details); + var proxy = Uploads.Photo(500, 25); + Directory.CreateDirectory(Path.Combine(folder, "proxies")); + await File.WriteAllBytesAsync(Path.Combine(folder, "proxies", "0000.jpg"), proxy); + using var found = await editor.GetAsync($"/api/v1/frames/{first.FrameId}/proxy"); + await Http.BytesEqualAsync(proxy, found.Content.ReadAsByteArrayAsync()); + } + + [Test] + public async Task PathsOutsideTheArchiveAreNeverServed() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(1000, 26)); + var secret = Path.Combine(Path.GetDirectoryName(server.Options.ArchivePath)!, "secret.txt"); + await File.WriteAllTextAsync(secret, "not for clients"); + + foreach (var hostile in new[] { "../secret.txt", "2026/../../secret.txt", "..\\secret.txt", secret, "/etc/passwd" }) + { + await using (var session = await server.Database.Database.OpenAsync(context.Cancellation)) + await session.ExecuteAsync("UPDATE frames SET relative_path = $1 WHERE id = $2", [hostile, frame.FrameId], context.Cancellation); + using var response = await editor.GetAsync($"/api/v1/frames/{frame.FrameId}/original"); + await response.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + } + + var locator = server.Services.GetRequiredService(); + locator.Override = new AssetLocation(secret, 0, 5, "text/plain"); + using (var proxy = await editor.GetAsync($"/api/v1/frames/{frame.FrameId}/proxy")) await proxy.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + locator.Override = new AssetLocation(Path.Combine(server.Options.ArchivePath, "..", "secret.txt"), 0, 5, "text/plain"); + using (var dotted = await editor.GetAsync($"/api/v1/frames/{frame.FrameId}/thumb")) await dotted.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + + if (!OperatingSystem.IsWindows()) + { + var link = Path.Combine(server.Options.ArchivePath, "link.jpg"); + File.CreateSymbolicLink(link, secret); + await using (var session = await server.Database.Database.OpenAsync(context.Cancellation)) + await session.ExecuteAsync("UPDATE frames SET relative_path = $1 WHERE id = $2", ["link.jpg", frame.FrameId], context.Cancellation); + using var linked = await editor.GetAsync($"/api/v1/frames/{frame.FrameId}/original"); + await linked.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + } + } + + [Test] + public async Task ExportsAreDownloadableWithRanges() + { + await using var server = await TestServer.StartAsync(context); + var (viewer, _, _) = await server.UserAsync("marco", "viewer"); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(1000, 27)); + var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; + var video = Uploads.Photo(4096, 28); + var relative = $"{sequence.Folder}/exports/Harbour sunset - 4K.mp4"; + Directory.CreateDirectory(Path.GetDirectoryName(Path.Combine(server.Options.ArchivePath, relative))!); + await File.WriteAllBytesAsync(Path.Combine(server.Options.ArchivePath, relative), video); + var render = new Render { Id = Guid.CreateVersion7(), SequenceId = sequence.Id, PresetName = "4K HEVC", OutputPath = relative, Bytes = video.Length, Created = DateTimeOffset.UtcNow }; + await server.Database.Renders.InsertAsync(render); + + using var request = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/renders/{render.Id}/file"); + request.Headers.Range = new RangeHeaderValue(1000, 1999); + using var response = await viewer.SendAsync(request); + await response.ExpectAsync(HttpStatusCode.PartialContent); + Assert.Equal("video/mp4", response.Content.Headers.ContentType!.MediaType); + await Http.BytesEqualAsync(video[1000..2000], response.Content.ReadAsByteArrayAsync()); + } +} diff --git a/tests/Titano.Server.Tests/Storage/UploadTests.cs b/tests/Titano.Server.Tests/Storage/UploadTests.cs new file mode 100644 index 00000000..bb072e69 --- /dev/null +++ b/tests/Titano.Server.Tests/Storage/UploadTests.cs @@ -0,0 +1,227 @@ +using System.Net; +using System.Net.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using Titano.Protocol; +using Titano.Protocol.Client; +using Titano.Server.Storage; +using Titano.Testing; + +namespace Titano.Server.Tests.Storage; + +[Category("server")] +public sealed class UploadTests(TestContext context) +{ + private const int Chunk = 64 * 1024; + + [Test] + public async Task ChunksInAnyOrderCommitAVerifiedFrame() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(Chunk * 3 + 1234, 1); + var start = await Uploads.StartAsync(uploader, data, sessionKey: "roof-2026-09-28"); + var id = Assert.NotNull(start.UploadId); + Assert.Equal(Chunk, start.ChunkSize); + Assert.Empty(start.Received); + + foreach (var index in new[] { 3, 0, 2, 1, 0 }) + { + using var put = await Uploads.PutChunkAsync(uploader, id, index, Uploads.Chunk(data, Chunk, index)); + await put.ExpectAsync(HttpStatusCode.OK); + Assert.Equal(index, (await put.ReadAsync(ProtocolJson.Default.ChunkReceived)).Index); + } + using (var state = await uploader.GetAsync($"/api/v1/uploads/{id}")) + { + var resume = await state.ReadAsync(ProtocolJson.Default.UploadState); + Assert.SequenceEqual([0, 1, 2, 3], resume.Received); + Assert.Equal("receiving", resume.State); + } + + using var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null); + await complete.ExpectAsync(HttpStatusCode.OK); + var frame = await complete.ReadAsync(ProtocolJson.Default.CompleteUploadResponse); + var ingest = server.Services.GetRequiredService(); + var request = Assert.NotNull(ingest.Requests.LastOrDefault()); + Assert.Equal("roof-2026-09-28", request.SessionKey); + Assert.Null(request.SequenceId); + Assert.Equal(Uploads.Sha(data), request.Sha256); + Assert.True(request.StagedPath.StartsWith(server.Options.StagingPath, StringComparison.Ordinal), request.StagedPath); + + var stored = Assert.NotNull(await server.Database.Frames.GetAsync(frame.FrameId)); + await Http.BytesEqualAsync(data, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, stored.RelativePath))); + Assert.False(server.Services.GetRequiredService().Exists(id), "the partial file is gone"); + Assert.Empty(Directory.EnumerateFiles(server.Options.StagingPath)); + using (var me = await uploader.GetAsync("/api/v1/auth/me")) Assert.Equal(data.Length, (await me.ReadAsync(ProtocolJson.Default.UserDto)).UsedBytes); + + // A completion whose response was lost can be repeated. + using var again = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null); + await again.ExpectAsync(HttpStatusCode.OK); + Assert.Equal(frame.FrameId, (await again.ReadAsync(ProtocolJson.Default.CompleteUploadResponse)).FrameId); + } + + [Test] + public async Task AnInterruptedUploadResumesWithItsReceivedChunks() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(Chunk * 4, 2); + var first = await Uploads.StartAsync(uploader, data); + foreach (var index in new[] { 0, 2 }) + { + using var put = await Uploads.PutChunkAsync(uploader, first.UploadId!.Value, index, Uploads.Chunk(data, Chunk, index)); + await put.ExpectAsync(HttpStatusCode.OK); + } + var resumed = await Uploads.StartAsync(uploader, data); + Assert.Equal(first.UploadId, resumed.UploadId); + Assert.SequenceEqual([0, 2], resumed.Received); + foreach (var index in new[] { 1, 3 }) + { + using var put = await Uploads.PutChunkAsync(uploader, first.UploadId!.Value, index, Uploads.Chunk(data, Chunk, index)); + await put.ExpectAsync(HttpStatusCode.OK); + } + using var complete = await uploader.PostAsync($"/api/v1/uploads/{first.UploadId}/complete", null); + await complete.ExpectAsync(HttpStatusCode.OK); + } + + [Test] + public async Task AKnownHashShortCircuitsTheUpload() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(5000, 3); + var frame = await Uploads.UploadAsync(uploader, data); + var again = await Uploads.StartAsync(uploader, data, expected: HttpStatusCode.OK); + Assert.True(again.AlreadyExists); + Assert.Null(again.UploadId); + Assert.Equal(frame.FrameId, again.FrameId); + } + + [Test] + public async Task TheProtocolClientUploadsAndDownloadsLikeTheUploader() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var folder = context.CreateTempDirectory("source"); + var path = Path.Combine(folder, "2026-09-28_18-02-11_0413.CR3"); + var data = Uploads.Photo(Chunk * 2 + 77, 4); + await File.WriteAllBytesAsync(path, data); + + using var client = new TitanoClient(server.HttpBase, new CertificatePinning([]), "Titano Uploader (tests)") { Token = token }; + var sequence = await client.CreateSequenceAsync(new CreateSequenceRequest("Harbour sunset", null)); + var progress = new List(); + var result = Assert.NotNull(await client.UploadFileAsync(path, sequence.Id, new DateTime(2026, 9, 28), progress: new SyncProgress(progress.Add))); + Assert.Equal(sequence.Id, result.SequenceId); + Assert.Equal(0, result.Index); + Assert.Equal(data.Length, progress[^1].BytesSent); + + var duplicate = Assert.NotNull(await client.UploadFileAsync(path, sequence.Id, null)); + Assert.Equal((result.FrameId, -1), (duplicate.FrameId, duplicate.Index)); + + using var downloaded = new MemoryStream(); + await client.DownloadFrameAsync(result.FrameId, "original", downloaded); + Assert.BytesEqual(data, downloaded.ToArray()); + var manifest = await client.GetManifestAsync(sequence.Id); + Assert.Equal(Uploads.Sha(data), manifest.Frames.Single().Sha256); + } + + [Test] + public async Task ADamagedChunkFailsTheHashCheck() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(Chunk * 2, 5); + var start = await Uploads.StartAsync(uploader, data); + var id = start.UploadId!.Value; + var damaged = Uploads.Chunk(data, Chunk, 1).ToArray(); + damaged[100] ^= 0xFF; + using (var a = await Uploads.PutChunkAsync(uploader, id, 0, Uploads.Chunk(data, Chunk, 0))) await a.ExpectAsync(HttpStatusCode.OK); + using (var b = await Uploads.PutChunkAsync(uploader, id, 1, damaged)) await b.ExpectAsync(HttpStatusCode.OK); + + using var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null); + await complete.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "hash_mismatch"); + using (var state = await uploader.GetAsync($"/api/v1/uploads/{id}")) Assert.Equal("failed", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State); + Assert.False(server.Services.GetRequiredService().Exists(id)); + Assert.Empty(await server.Database.Frames.FindBySha256Async(Uploads.Sha(data))); + Assert.Empty(server.Services.GetRequiredService().Requests); + + var retry = await Uploads.StartAsync(uploader, data); + Assert.NotEqual(id, retry.UploadId!.Value); + } + + [Test] + public async Task ChunksAndCompletionsAreValidated() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(Chunk + 10, 6); + var id = (await Uploads.StartAsync(uploader, data)).UploadId!.Value; + using (var small = await Uploads.PutChunkAsync(uploader, id, 0, new byte[10])) await small.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_size"); + using (var range = await Uploads.PutChunkAsync(uploader, id, 2, new byte[10])) await range.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_out_of_range"); + using (var early = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null)) await early.ExpectErrorAsync(HttpStatusCode.Conflict, "incomplete"); + + using (var name = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "../../etc/passwd", 10, Uploads.Sha(data), null, null), + ProtocolJson.Default.StartUploadRequest)) + await name.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_file_name"); + using (var hash = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "a.jpg", 10, "abc", null, null), ProtocolJson.Default.StartUploadRequest)) + await hash.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_hash"); + + var (other, _, _) = await server.UserAsync("intruder", "uploader"); + using (var foreign = await Uploads.PutChunkAsync(other, id, 0, Uploads.Chunk(data, Chunk, 0))) await foreign.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + using (var cancel = await uploader.DeleteAsync($"/api/v1/uploads/{id}")) await cancel.ExpectAsync(HttpStatusCode.NoContent); + Assert.False(server.Services.GetRequiredService().Exists(id)); + using var late = await Uploads.PutChunkAsync(uploader, id, 0, Uploads.Chunk(data, Chunk, 0)); + await late.ExpectErrorAsync(HttpStatusCode.Conflict, "upload_state"); + } + + [Test] + public async Task QuotaCountsCommittedAndPendingUploads() + { + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader", quotaBytes: 100_000); + var first = Uploads.Photo(80_000, 7); + var pending = await Uploads.StartAsync(uploader, first); + using (var over = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "b.jpg", 40_000, Uploads.Sha(Uploads.Photo(40_000, 8)), null, null), + ProtocolJson.Default.StartUploadRequest)) + await over.ExpectErrorAsync(HttpStatusCode.Forbidden, "quota_exceeded"); + using (var cancel = await uploader.DeleteAsync($"/api/v1/uploads/{pending.UploadId}")) await cancel.ExpectAsync(HttpStatusCode.NoContent); + await Uploads.UploadAsync(uploader, first); + using var after = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "c.jpg", 30_000, Uploads.Sha(Uploads.Photo(30_000, 9)), null, null), + ProtocolJson.Default.StartUploadRequest); + await after.ExpectErrorAsync(HttpStatusCode.Forbidden, "quota_exceeded"); + } + + [Test] + public async Task FilesAboveTheLimitAreRefused() + { + await using var server = await TestServer.StartAsync(context, o => o.MaxUploadBytes = 1000); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + using var response = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "big.jpg", 1001, new string('0', 64), null, null), + ProtocolJson.Default.StartUploadRequest); + var error = await response.ExpectErrorAsync(HttpStatusCode.RequestEntityTooLarge, "too_large"); + Assert.Equal("1000", error.Details); + } + + [Test] + public async Task AbandonedUploadsExpireAndLoseTheirFiles() + { + var clock = new ManualTimeProvider(); + await using var server = await TestServer.StartAsync(context, o => o.UploadRetentionHours = 48, s => s.AddSingleton(clock)); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var id = (await Uploads.StartAsync(uploader, Uploads.Photo(1000, 10))).UploadId!.Value; + var store = server.Services.GetRequiredService(); + Assert.True(store.Exists(id)); + + // Upload rows carry real timestamps; the sweep looks 48 h past the moved clock. + clock.Advance(TimeSpan.FromHours(49)); + await server.Services.GetRequiredService().SweepAsync(context.Cancellation); + Assert.False(store.Exists(id)); + using var state = await uploader.GetAsync($"/api/v1/uploads/{id}"); + Assert.Equal("cancelled", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State); + } + + /// Reports synchronously (Progress<T> posts to the thread pool and may arrive late). + private sealed class SyncProgress(Action report) : IProgress + { + public void Report(T value) => report(value); + } +} diff --git a/tests/Titano.Server.Tests/TestServer.cs b/tests/Titano.Server.Tests/TestServer.cs index 0a528bbc..d08cacbd 100644 --- a/tests/Titano.Server.Tests/TestServer.cs +++ b/tests/Titano.Server.Tests/TestServer.cs @@ -64,6 +64,8 @@ public sealed class TestServer : IAsyncDisposable Workers = 2, AdminUser = "admin", AdminPassword = AdminPassword, + // Tests sign in many times from one address; the rate-limit test sets the production value. + LoginAttemptsPerMinute = 1000, }; Directory.CreateDirectory(options.ArchivePath); configure?.Invoke(options); diff --git a/tests/Titano.Server.Tests/Uploads.cs b/tests/Titano.Server.Tests/Uploads.cs new file mode 100644 index 00000000..c1479ace --- /dev/null +++ b/tests/Titano.Server.Tests/Uploads.cs @@ -0,0 +1,57 @@ +using System.Net; +using System.Net.Http.Headers; +using System.Net.Http.Json; +using System.Security.Cryptography; +using Titano.Protocol; +using Titano.Testing; + +namespace Titano.Server.Tests; + +/// Raw-HTTP upload helpers (the protocol client is exercised separately). +internal static class Uploads +{ + public static byte[] Photo(int size, int seed) + { + var bytes = new byte[size]; + new Random(seed).NextBytes(bytes); + return bytes; + } + + public static string Sha(byte[] data) => Convert.ToHexStringLower(SHA256.HashData(data)); + + public static async Task StartAsync(HttpClient client, byte[] data, string fileName = "IMG_0001.CR3", Guid? sequenceId = null, + string? sessionKey = null, HttpStatusCode expected = HttpStatusCode.Created) + { + using var response = await client.PostAsJsonAsync("/api/v1/uploads", + new StartUploadRequest(sequenceId, fileName, data.Length, Sha(data), new DateTime(2026, 9, 28, 18, 2, 11), sessionKey), ProtocolJson.Default.StartUploadRequest); + await response.ExpectAsync(expected); + return await response.ReadAsync(ProtocolJson.Default.StartUploadResponse); + } + + public static async Task PutChunkAsync(HttpClient client, Guid uploadId, int index, ReadOnlyMemory data) + { + var content = new ByteArrayContent(data.ToArray()); + content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); + return await client.PutAsync($"/api/v1/uploads/{uploadId}/chunks/{index}", content); + } + + public static ReadOnlyMemory Chunk(byte[] data, int chunkSize, int index) => + data.AsMemory(index * chunkSize, Math.Min(chunkSize, data.Length - index * chunkSize)); + + /// Start, every chunk, complete; returns the committed frame. + public static async Task UploadAsync(HttpClient client, byte[] data, string fileName = "IMG_0001.CR3", Guid? sequenceId = null, + string? sessionKey = null) + { + var start = await StartAsync(client, data, fileName, sequenceId, sessionKey); + var id = Assert.NotNull(start.UploadId); + var chunks = (data.Length + start.ChunkSize - 1) / start.ChunkSize; + for (var i = 0; i < chunks; i++) + { + using var put = await PutChunkAsync(client, id, i, Chunk(data, start.ChunkSize, i)); + await put.ExpectAsync(HttpStatusCode.OK); + } + using var complete = await client.PostAsync($"/api/v1/uploads/{id}/complete", null); + await complete.ExpectAsync(HttpStatusCode.OK); + return await complete.ReadAsync(ProtocolJson.Default.CompleteUploadResponse); + } +}