using System.Net; using System.Net.Http.Json; using System.Text.Json; using Microsoft.Extensions.DependencyInjection; using Chronos.Core.Archiving; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Projects; using Chronos.Data.Repositories; using Chronos.Protocol; using Chronos.Protocol.Client; using Chronos.Server.Api; using Chronos.Server.Events; using Chronos.Server.Storage; using Chronos.Server.Tests.Jobs; using Chronos.Testing; namespace Chronos.Server.Tests.Api; /// /// The server as the home of its sequences' projects (owner review 2, R8): /api/v1/sequences/{sid}/projects through /// the protocol client, as a desktop's workspace uses it (list, create, rename, delete, head, versions, push and the frames /// positions are placed on), two clients pushing to one project, the permissions, the audit, the projectChanged /// event (Main taking settings a PATCH wrote among them), the capability, and the leases and offline archive. /// [Category("server")] public sealed class ProjectTests(TestContext context) { private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(30)); [Test] public async Task ProjectsAreListedMadeRenamedAndDeleted() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 3); // Main comes first, made from the sequence's settings the first time the projects are read. var main = Assert.NotNull((await client.ListProjectsAsync(sid, context.Cancellation)).SingleOrDefault()); Assert.Equal((true, "Main", 1, sid), (main.IsMain, main.Name, main.HeadNumber, main.SequenceId)); var mainHead = await client.GetProjectHeadAsync(sid, main.Id, context.Cancellation); Assert.Equal(("imported", "imported", (Guid?)mainHead.Id), (main.HeadKind, mainHead.Kind, main.HeadVersionId)); var vertical = await client.CreateProjectAsync(sid, new CreateProjectRequest(" Vertical social "), context.Cancellation); Assert.Equal(("Vertical social", false, 1, "alberto"), (vertical.Name, vertical.IsMain, vertical.HeadNumber, vertical.CreatedBy)); var first = await client.GetProjectHeadAsync(sid, vertical.Id, context.Cancellation); Assert.Equal(("imported", mainHead.ContentHash), (first.Kind, first.ContentHash)); Assert.SequenceEqual([main.Id, vertical.Id], (await client.ListProjectsAsync(sid, context.Cancellation)).Select(p => p.Id)); // The sidecars are the truth: the project's record and its first version are in the sequence's folder. var folder = new ArchivePaths(server.Options.ArchivePath).Sequence((await server.Database.Sequences.GetAsync(sid))!.Folder); Assert.FileExists(folder.ProjectRecordPath(vertical.Id)); Assert.FileExists(folder.VersionPath(vertical.Id, 1, first.Id)); await RefusedAsync(HttpStatusCode.Conflict, ProjectErrors.NameTaken, () => client.CreateProjectAsync(sid, new CreateProjectRequest("VERTICAL SOCIAL"))); await RefusedAsync(HttpStatusCode.BadRequest, ProjectErrors.InvalidName, () => client.CreateProjectAsync(sid, new CreateProjectRequest(" "))); await RefusedAsync(HttpStatusCode.BadRequest, ProjectErrors.InvalidName, () => client.CreateProjectAsync(sid, new CreateProjectRequest(new string('x', 61)))); Assert.Equal("version", (await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.CreateProjectAsync(sid, new CreateProjectRequest("Copy", Guid.CreateVersion7())))).Error.Details); Assert.Equal("sequence", (await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.ListProjectsAsync(Guid.CreateVersion7()))).Error.Details); // A project made from a version holds that version's settings. var copy = await client.CreateProjectAsync(sid, new CreateProjectRequest("4K landscape", first.Id), context.Cancellation); Assert.Equal(first.ContentHash, (await client.GetProjectHeadAsync(sid, copy.Id, context.Cancellation)).ContentHash); var renamed = await client.RenameProjectAsync(sid, vertical.Id, "Vertical", context.Cancellation); Assert.Equal(("Vertical", vertical.Id), (renamed.Name, renamed.Id)); await RefusedAsync(HttpStatusCode.Conflict, ProjectErrors.NameTaken, () => client.RenameProjectAsync(sid, copy.Id, "vertical")); await RefusedAsync(HttpStatusCode.Conflict, ProjectErrors.MainCannotBeDeleted, () => client.DeleteProjectAsync(sid, main.Id)); await client.DeleteProjectAsync(sid, copy.Id, context.Cancellation); Assert.SequenceEqual([main.Id, vertical.Id], (await client.ListProjectsAsync(sid, context.Cancellation)).Select(p => p.Id)); Assert.Equal("project", (await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.GetProjectAsync(sid, copy.Id))).Error.Details); await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.RenameProjectAsync(sid, copy.Id, "Back")); // Deleted into the sequence's projects' trash with its versions, never erased; they can still be read, while it has no // head: a workspace's copy of it reads as gone. Assert.False(Directory.Exists(folder.ProjectDirectory(copy.Id)), "the project's folder left"); Assert.Contains(Directory.EnumerateDirectories(folder.ProjectsTrashDirectory), d => Path.GetFileName(d).StartsWith(copy.Id.ToString("N"), StringComparison.Ordinal)); Assert.Equal("project", (await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.GetProjectHeadAsync(sid, copy.Id))).Error.Details); Assert.Equal(1, (await client.ListProjectVersionsAsync(sid, copy.Id, ct: context.Cancellation)).Items.Single().Number); // The name of a deleted project is free again. Assert.Equal("4K landscape", (await client.CreateProjectAsync(sid, new CreateProjectRequest("4K landscape"), context.Cancellation)).Name); // A project of another sequence is not this one's. var other = await SequenceAsync(server, token, 1, "other"); Assert.Equal("project", (await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.GetProjectHeadAsync(other, vertical.Id))).Error.Details); // Creations, renames and deletions are audited, by whom and on what. var audit = (await server.Database.Audit.ListAsync(null, 100)).Items; Assert.Contains(audit, a => a is { Action: "project_created", Username: "alberto" } && a.TargetId == vertical.Id.ToString()); Assert.Contains(audit, a => a.Action == "project_renamed" && a.TargetId == vertical.Id.ToString() && a.Details!.EndsWith("Vertical social → Vertical", StringComparison.Ordinal)); Assert.Contains(audit, a => a.Action == "project_deleted" && a.TargetId == copy.Id.ToString()); } [Test] public async Task TwoClientsPushToOneProject() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); await PushesAsync(server); } /// /// Two PCs push to Main (also run on PostgreSQL): a fast-forward, the same push again, a divergence answered with the head /// and then replayed, the refusals that store nothing, the history a page at a time, and Main's mirror into the sequence. /// internal static async Task PushesAsync(TestServer server) { var (_, _, albertoToken) = await server.UserAsync("alberto", "editor"); var (giuliaHttp, _, giuliaToken) = await server.UserAsync("giulia", "editor"); using var alberto = Client(server, albertoToken); using var giulia = Client(server, giuliaToken); var sid = await SequenceAsync(server, albertoToken, 3); var main = (await alberto.ListProjectsAsync(sid)).Single(p => p.IsMain); var head = await alberto.GetProjectHeadAsync(sid, main.Id); var home = ProjectWire.ToHomeFrames(await alberto.GetProjectFramesAsync(sid)); Assert.Equal(3, home.Frames.Count); // A fast-forward: numbered head + 1, by the account that pushed it, as the workspace made it. var mine = Version(head, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 }, ExcludedFrames = [1] }, home, "warmer"); var stored = await alberto.PushProjectVersionAsync(sid, main.Id, mine); var v2 = Assert.NotNull(stored.Version); Assert.Equal((ProjectPushOutcomes.Stored, 2, "alberto", "Chronos on PC-A", "warmer"), (stored.Outcome, v2.Number, v2.Author, v2.ClientName, v2.Note)); Assert.Equal((mine.Id, mine.ContentHash, (Guid?)head.Id, (Guid?)v2.Id), (v2.Id, v2.ContentHash, v2.ParentId, stored.Head?.Id)); Assert.Null(stored.Code); Assert.NotNull(v2.StoredAt); Assert.True(ProjectContent.Verifies(v2.SettingsJson, v2.ContentHash), "the stored settings match their hash"); // The same push again (its answer was lost): answered as the first time, nothing new. var again = await alberto.PushProjectVersionAsync(sid, main.Id, mine); Assert.Equal((ProjectPushOutcomes.AlreadyStored, v2.Id, 2), (again.Outcome, again.Version?.Id, again.Version?.Number)); // The other PC pushed from version 1: diverged, with the head to replay on; stored once replayed. var theirs = Version(head, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = -0.5 } }, home); var diverged = await giulia.PushProjectVersionAsync(sid, main.Id, theirs); Assert.Equal((ProjectPushOutcomes.Diverged, ProjectErrors.Diverged, (Guid?)v2.Id), (diverged.Outcome, diverged.Code, diverged.Head?.Id)); Assert.Null(diverged.Version); Assert.False(string.IsNullOrWhiteSpace(diverged.Message), "the refusal says why"); using (var raw = await giuliaHttp.PostAsJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions", theirs, ProtocolJson.Default.ProjectVersionDto)) await raw.ExpectErrorAsync(HttpStatusCode.Conflict, ProjectErrors.Diverged); var replayed = theirs with { Id = Guid.CreateVersion7(), ParentId = v2.Id }; var v3 = Assert.NotNull((await giulia.PushProjectVersionAsync(sid, main.Id, replayed)).Version); Assert.Equal((3, "giulia"), (v3.Number, v3.Author)); // Refused, nothing stored: settings that do not match their hash, of a newer format, or not portable; another project's id. var damaged = Version(v3, new ProjectSettings(), home) with { ContentHash = new string('0', 64) }; var mismatch = await alberto.PushProjectVersionAsync(sid, main.Id, damaged); Assert.Equal((ProjectPushOutcomes.HashMismatch, ProjectErrors.HashMismatch, 3), (mismatch.Outcome, mismatch.Code, mismatch.Head?.Number)); using (var raw = await giuliaHttp.PostAsJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions", damaged, ProtocolJson.Default.ProjectVersionDto)) await raw.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, ProjectErrors.HashMismatch); const string future = """{"version":99,"exposure":{"exposureOffsetEv":1}}"""; var newer = await alberto.PushProjectVersionAsync(sid, main.Id, Version(v3, new ProjectSettings(), home) with { SettingsJson = future, ContentHash = ProjectContent.Hash(future) }); Assert.Equal((ProjectPushOutcomes.NewerFormat, ProjectErrors.NewerFormat), (newer.Outcome, newer.Code)); var positional = new ProjectSettings { ExcludedFrames = [0] }.ToJson(); var invalid = await alberto.PushProjectVersionAsync(sid, main.Id, Version(v3, new ProjectSettings(), home) with { SettingsJson = positional, ContentHash = ProjectContent.Hash(positional) }); Assert.Equal((ProjectPushOutcomes.Invalid, ProjectErrors.InvalidVersion), (invalid.Outcome, invalid.Code)); var vertical = await alberto.CreateProjectAsync(sid, new CreateProjectRequest("Vertical")); var foreign = await alberto.PushProjectVersionAsync(sid, vertical.Id, mine with { ParentId = vertical.HeadVersionId }); Assert.Equal(ProjectPushOutcomes.Invalid, foreign.Outcome); Assert.Equal(3, (await alberto.GetProjectAsync(sid, main.Id)).HeadNumber); await RefusedAsync(HttpStatusCode.BadRequest, "bad_request", () => alberto.PushProjectVersionAsync(sid, main.Id, mine with { Id = Guid.Empty })); // The history, newest first a page at a time, and oldest first above a number (what a workspace pulls). var page = await alberto.ListProjectVersionsAsync(sid, main.Id, limit: 2); Assert.SequenceEqual([3, 2], page.Items.Select(v => v.Number), "newest first"); Assert.Equal((true, 3), (page.More, page.HeadNumber)); var rest = await alberto.ListProjectVersionsAsync(sid, main.Id, before: 2, limit: 2); Assert.SequenceEqual([1], rest.Items.Select(v => v.Number)); Assert.False(rest.More); var pulled = await giulia.ListProjectVersionsAsync(sid, main.Id, after: 1); Assert.SequenceEqual([v2.Id, v3.Id], pulled.Items.Select(v => v.Id)); var read = Assert.NotNull(await giulia.GetProjectVersionAsync(sid, main.Id, v2.Id)); Assert.Equal((v2.Number, v2.ContentHash, v2.SettingsJson, v2.Author), (read.Number, read.ContentHash, read.SettingsJson, read.Author)); Assert.Null(await giulia.GetProjectVersionAsync(sid, main.Id, Guid.CreateVersion7())); Assert.Null(await giulia.GetProjectVersionAsync(sid, vertical.Id, v2.Id)); await RefusedAsync(HttpStatusCode.BadRequest, "bad_request", () => giulia.ListProjectVersionsAsync(sid, main.Id, before: 2, after: 1)); // Main's head is the sequence's settings: version 3's, placed on its frames (an older client reads them there). var sequence = await alberto.GetSequenceAsync(sid); var settings = ProjectSettings.FromJson(Assert.NotNull((await server.Database.Sequences.GetAsync(sid))!.SettingsJson)); Assert.Equal(-0.5, settings.Exposure.ExposureOffsetEv); Assert.Empty(settings.ExcludedFrames); Assert.True(sequence.SettingsVersion > 1, "the settings version moved with the mirror"); var listed = (await alberto.ListProjectsAsync(sid)).Single(p => p.IsMain); Assert.Equal((3, (Guid?)v3.Id, "commit", "giulia", "Chronos on PC-A"), (listed.HeadNumber, listed.HeadVersionId, listed.HeadKind, listed.HeadAuthor, listed.HeadClientName)); } [Test] public async Task ReadersReadEditorsChangeAndDeletingNeedsTheOwner() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, ownerToken) = await server.UserAsync("alberto", "editor"); var (_, _, otherToken) = await server.UserAsync("giulia", "editor"); var (viewerHttp, _, viewerToken) = await server.UserAsync("ospite", "viewer"); var (uploaderHttp, _, _) = await server.UserAsync("studio-pc", "uploader"); var admin = await server.AdminAsync(); using var owner = Client(server, ownerToken); using var other = Client(server, otherToken); using var viewer = Client(server, viewerToken); var sid = await SequenceAsync(server, ownerToken, 2); var main = (await owner.ListProjectsAsync(sid)).Single(); var head = await owner.GetProjectHeadAsync(sid, main.Id); // Read to read; Edit to make, rename and push; uploaders read nothing. Assert.Equal(main.Id, (await viewer.ListProjectsAsync(sid)).Single().Id); Assert.Equal(head.Id, (await viewer.GetProjectHeadAsync(sid, main.Id)).Id); await RefusedAsync(HttpStatusCode.Forbidden, "forbidden", () => viewer.CreateProjectAsync(sid, new CreateProjectRequest("Mine"))); var home = ProjectWire.ToHomeFrames(await viewer.GetProjectFramesAsync(sid)); await RefusedAsync(HttpStatusCode.Forbidden, "forbidden", () => viewer.PushProjectVersionAsync(sid, main.Id, Version(head, new ProjectSettings(), home))); using (var refused = await uploaderHttp.GetAsync($"/api/v1/sequences/{sid}/projects")) await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var gone = await viewerHttp.DeleteAsync($"/api/v1/sequences/{sid}/projects/{main.Id}")) await gone.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); // Deleting: the sequence's owner, the project's maker or an admin. var byOwner = await owner.CreateProjectAsync(sid, new CreateProjectRequest("Owner's")); var byOther = await other.CreateProjectAsync(sid, new CreateProjectRequest("Giulia's")); var third = await owner.CreateProjectAsync(sid, new CreateProjectRequest("Third")); await RefusedAsync(HttpStatusCode.Forbidden, "forbidden", () => other.DeleteProjectAsync(sid, byOwner.Id)); await other.DeleteProjectAsync(sid, byOther.Id); await owner.DeleteProjectAsync(sid, byOwner.Id); using (var deleted = await admin.DeleteAsync($"/api/v1/sequences/{sid}/projects/{third.Id}")) await deleted.ExpectAsync(HttpStatusCode.NoContent); Assert.SequenceEqual([main.Id], (await viewer.ListProjectsAsync(sid)).Select(p => p.Id)); } [Test] public async Task EveryChangeIsToldAndMainTakesSettingsAPatchWrote() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); using var events = server.Services.GetRequiredService().Subscribe(); // Main made at the first read. var main = (await client.ListProjectsAsync(sid)).Single(); await NextAsync(events, e => e.ProjectId == main.Id && e is { Change: ProjectChanges.Created, HeadNumber: 1 } && e.SequenceId == sid); // The API's own changes. var vertical = await client.CreateProjectAsync(sid, new CreateProjectRequest("Vertical")); await NextAsync(events, e => e.ProjectId == vertical.Id && e.Change == ProjectChanges.Created && e.HeadVersionId == vertical.HeadVersionId); await client.RenameProjectAsync(sid, vertical.Id, "Vertical social"); await NextAsync(events, e => e.ProjectId == vertical.Id && e.Change == ProjectChanges.Renamed); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); var pushed = Assert.NotNull((await client.PushProjectVersionAsync(sid, vertical.Id, Version(await client.GetProjectHeadAsync(sid, vertical.Id), new ProjectSettings { HeroFrame = 1 }, home))).Version); await NextAsync(events, e => e.ProjectId == vertical.Id && e.Change == ProjectChanges.Pushed && e.HeadVersionId == pushed.Id && e.HeadNumber == 2); await client.DeleteProjectAsync(sid, vertical.Id); await NextAsync(events, e => e.ProjectId == vertical.Id && e.Change == ProjectChanges.Deleted); // A push to Main is a settings change too, for the clients that read the sequence's settings. var toMain = Assert.NotNull((await client.PushProjectVersionAsync(sid, main.Id, Version(await client.GetProjectHeadAsync(sid, main.Id), new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.2 } }, home))).Version); await NextAsync(events, e => e.ProjectId == main.Id && e.Change == ProjectChanges.Pushed && e.HeadVersionId == toMain.Id); var mirrored = await NextAsync(events, e => e.SequenceId == sid && e.Change == "settings"); Assert.Equal((await client.GetSequenceAsync(sid)).SettingsVersion, mirrored.SettingsVersion); // An older client (or a desktop's sync) PATCHes the settings: Main takes them as an external version at once, told // without anyone reading the projects. var sequence = await client.GetSequenceAsync(sid); var patched = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } }.ToJson(); await client.UpdateSequenceAsync(sid, new UpdateSequenceRequest(null, null, null, null, patched, sequence.SettingsVersion)); var external = await NextAsync(events, e => e.ProjectId == main.Id && e.Change == ProjectChanges.Pushed && e.HeadNumber == 3); var head = await client.GetProjectHeadAsync(sid, main.Id); Assert.Equal(("external", 3, external.HeadVersionId), (head.Kind, head.Number, (Guid?)head.Id)); Assert.Equal(0.7, ProjectSettings.FromJson(head.SettingsJson).Exposure.ExposureOffsetEv); // A tags edit changes no settings: no new version. sequence = await client.GetSequenceAsync(sid); await client.UpdateSequenceAsync(sid, new UpdateSequenceRequest(null, ["harbour"], null, null, null, sequence.SettingsVersion)); Assert.Equal(3, (await client.GetProjectHeadAsync(sid, main.Id)).Number); // The event reaches a client over the WebSocket like the others. using var listening = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation); listening.CancelAfter(Wait); var received = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var connected = new TaskCompletionSource(); var reader = Task.Run(async () => { var stream = client.EventsAsync(listening.Token).GetAsyncEnumerator(listening.Token); var first = stream.MoveNextAsync(); connected.TrySetResult(); try { for (var more = await first; more; more = await stream.MoveNextAsync()) { if (stream.Current is ProjectChangedEvent { Change: ProjectChanges.Created } e && e.SequenceId == sid) received.TrySetResult(e); } } catch (OperationCanceledException) { } finally { await stream.DisposeAsync(); } }); await connected.Task; await WaitForSubscribersAsync(server, 2); var landscape = await client.CreateProjectAsync(sid, new CreateProjectRequest("4K landscape")); var told = await received.Task.WaitAsync(Wait); Assert.Equal((landscape.Id, 1, landscape.HeadVersionId), (told.ProjectId, told.HeadNumber, told.HeadVersionId)); await listening.CancelAsync(); await reader; } [Test] public async Task ASequenceWithoutPhotosKeepsNoProjectsAndWritesNothing() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (http, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var archive = (await server.Database.Archives.ListAsync()).Single().RootPath; var before = Files(archive); var empty = new List(); for (var i = 0; i < 2; i++) { using var made = await http.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest($"Empty {i}", null), ProtocolJson.Default.CreateSequenceRequest); empty.Add(Assert.NotNull(await made.Content.ReadFromJsonAsync(ProtocolJson.Default.SequenceDto)).Id); } // No folder yet: it lists no projects and makes none, and nothing lands at the archive's root for either. foreach (var sid in empty) { Assert.Empty(await client.ListProjectsAsync(sid)); await RefusedAsync(HttpStatusCode.Conflict, ProjectErrors.SequenceEmpty, () => client.CreateProjectAsync(sid, new CreateProjectRequest("Vertical"))); Assert.Null((await server.Database.Sequences.GetAsync(sid))!.SettingsJson); } Assert.SequenceEqual(before, Files(archive), "nothing was written in the archive"); Assert.Empty(await server.Database.Projects.ListBySequenceAsync(empty[0], includeDeleted: true)); static List Files(string root) => [.. Directory.EnumerateFiles(root, "*", SearchOption.AllDirectories).Select(f => Path.GetRelativePath(root, f)).Order(StringComparer.Ordinal)]; } [Test] public async Task AFullSizeVersionIsStoredAndOneTooLargeIsToldSo() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); var main = (await client.ListProjectsAsync(sid)).Single(); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); var head = await client.GetProjectHeadAsync(sid, main.Id); // Well above the 16 MiB the push once took: stored. var large = Version(head, Named(new string('n', 24 << 20)), home); var stored = await client.PushProjectVersionAsync(sid, main.Id, large); Assert.Equal((ProjectPushOutcomes.Stored, 2), (stored.Outcome, stored.Version?.Number)); // Above what a version may hold: the push is refused as too large (413), never as a server out of reach. var tooLarge = Version(Assert.NotNull(stored.Version), Named(new string('n', ProjectSidecars.MaxVersionBytes + (2 << 20))), home); var refused = await client.PushProjectVersionAsync(sid, main.Id, tooLarge); Assert.Equal((ProjectPushOutcomes.TooLarge, ProjectErrors.TooLarge), (refused.Outcome, refused.Code)); Assert.Equal(2, (await client.GetProjectHeadAsync(sid, main.Id)).Number); } [Test] public async Task AVersionsPageIsCappedInBytesAndAServerHomePagesOn() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); var main = (await client.ListProjectsAsync(sid)).Single(); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); var head = await client.GetProjectHeadAsync(sid, main.Id); for (var i = 0; i < 4; i++) head = Assert.NotNull((await client.PushProjectVersionAsync(sid, main.Id, Version(head, Named(new string((char)('a' + i), 1_500_000)), home))).Version); // Five versions asked for at once, four of 1.5 MB: the page stops short of the cap and says more follow. var page = await client.ListProjectVersionsAsync(sid, main.Id, limit: 10); Assert.True(page.Items.Count is > 0 and < 5, $"{page.Items.Count} versions in one page"); Assert.True(page.More, "more follow"); Assert.LessOrEqual(page.Items.Sum(v => (long)v.SettingsJson.Length), ProjectEndpoints.PageSettingsChars + 1_600_000); // The summary form leaves the settings out, so the panel's page is never cut short. var summary = await server.NewClient(token).GetFromJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions?limit=10&summary=true", ProtocolJson.Default.ProjectVersionPageDto); Assert.Equal((5, false), (summary!.Items.Count, summary.More)); // A workspace reads them all, page after page. var reached = new ServerProjectHome(client, sid); Assert.SequenceEqual([5, 4, 3, 2, 1], (await reached.HistoryAsync(main.Id, null, 10, context.Cancellation)).Select(v => v.Number)); Assert.SequenceEqual([2, 3, 4, 5], (await reached.VersionsAfterAsync(main.Id, 1, 10, context.Cancellation)).Select(v => v.Number)); } [Test] public async Task AnAccountMadeAgainUnderAMakersNameDeletesNothingOfTheirs() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, ownerToken) = await server.UserAsync("alberto", "editor"); var (_, giulia, giuliaToken) = await server.UserAsync("giulia", "editor"); var admin = await server.AdminAsync(); using var owner = Client(server, ownerToken); var sid = await SequenceAsync(server, ownerToken, 2); Assert.NotEmpty(await owner.ListProjectsAsync(sid)); string made; using (var first = Client(server, giuliaToken)) made = (await first.CreateProjectAsync(sid, new CreateProjectRequest("Giulia's"))).Id.ToString(); // The account removed and another made with the same name: the project is no longer "theirs". using (var removed = await admin.DeleteAsync($"/api/v1/users/{giulia.Id}")) Assert.True(removed.IsSuccessStatusCode, $"{removed.StatusCode}"); var (_, _, againToken) = await server.UserAsync("giulia", "editor"); using var again = Client(server, againToken); await RefusedAsync(HttpStatusCode.Forbidden, "forbidden", () => again.DeleteProjectAsync(sid, Guid.Parse(made))); // Its own projects it deletes as before. var own = await again.CreateProjectAsync(sid, new CreateProjectRequest("Mine")); await again.DeleteProjectAsync(sid, own.Id); } [Test] public async Task APatchMadeAfterTheSharedSettingsFileStaysMainsHead() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); // A project.json another program shared before Main was ever made (nobody read the projects yet). var archive = (await server.Database.Archives.ListAsync()).Single().RootPath; var row = (await server.Database.Sequences.GetAsync(sid))!; var folder = new ArchivePaths(archive).Sequence(row.Folder); Directory.CreateDirectory(Path.GetDirectoryName(folder.ProjectPath)!); File.WriteAllText(folder.ProjectPath, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.2 } }.ToJson()); // The PATCH is the newest word: Main is born with it, and the sequence keeps it. var sequence = await client.GetSequenceAsync(sid); var patched = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } }.ToJson(); await client.UpdateSequenceAsync(sid, new UpdateSequenceRequest(null, null, null, null, patched, sequence.SettingsVersion)); var main = (await client.ListProjectsAsync(sid)).Single(); Assert.Equal(0.7, ProjectSettings.FromJson((await client.GetProjectHeadAsync(sid, main.Id)).SettingsJson).Exposure.ExposureOffsetEv); Assert.Equal(0.7, ProjectSettings.FromJson((await server.Database.Sequences.GetAsync(sid))!.SettingsJson!).Exposure.ExposureOffsetEv); Assert.Equal(0.7, ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)).Exposure.ExposureOffsetEv); } [Test] public async Task ASequencePatchedBeforeTheServerKeptProjectsKeepsItsSettingsWhenMainIsBorn() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); var row = (await server.Database.Sequences.GetAsync(sid))!; var folder = new ArchivePaths((await server.Database.Archives.ListAsync()).Single().RootPath).Sequence(row.Folder); Directory.CreateDirectory(Path.GetDirectoryName(folder.ProjectPath)!); File.WriteAllText(folder.ProjectPath, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.2 } }.ToJson()); // An earlier release's PATCH (the desktop's sync of a linked copy) wrote the index alone, after project.json. var patched = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } }.ToJson(); Assert.Equal(SequenceEditOutcome.Updated, (await server.Database.Sequences.EditAsync(sid, new SequenceEdit { SettingsJson = patched }, row.SettingsVersion, context.Cancellation)).Outcome); // Upgraded, the first list makes Main: the index's settings stay in force, project.json's are version 1. var main = (await client.ListProjectsAsync(sid, context.Cancellation)).Single(); Assert.Equal((2, "external"), (main.HeadNumber, main.HeadKind)); var versions = (await client.ListProjectVersionsAsync(sid, main.Id, ct: context.Cancellation)).Items; Assert.SequenceEqual([2, 1], versions.Select(v => v.Number)); Assert.Equal(0.7, ProjectSettings.FromJson((await client.GetProjectHeadAsync(sid, main.Id, context.Cancellation)).SettingsJson).Exposure.ExposureOffsetEv); var first = Assert.NotNull(await client.GetProjectVersionAsync(sid, main.Id, versions[1].Id, context.Cancellation)); Assert.Equal("imported", first.Kind); Assert.Equal(0.2, ProjectSettings.FromJson(first.SettingsJson).Exposure.ExposureOffsetEv); Assert.Equal(0.7, ProjectSettings.FromJson((await server.Database.Sequences.GetAsync(sid))!.SettingsJson!).Exposure.ExposureOffsetEv); Assert.Equal(0.7, ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)).Exposure.ExposureOffsetEv); // Read again, nothing moves. Assert.Equal(2, (await client.ListProjectsAsync(sid, context.Cancellation)).Single().HeadNumber); } [Test] public async Task AServerHomeHoldsOnlyWhatItsFilesHold() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); var reached = new ServerProjectHome(client, sid); var vertical = await reached.CreateAsync("Vertical", null, null, context.Cancellation); var head = await reached.HeadAsync(vertical.Id, context.Cancellation); Assert.True(await reached.HoldsAsync(vertical.Id, head, context.Cancellation), "stored"); // Its file gone (the index row still there): not held. var archive = (await server.Database.Archives.ListAsync()).Single().RootPath; var file = Directory.EnumerateFiles(archive, ArchiveLayout.ProjectVersionFileName(head.Number, head.Id), SearchOption.AllDirectories).Single(); File.Delete(file); Assert.False(await reached.HoldsAsync(vertical.Id, head, context.Cancellation), "its file is gone"); // A project deleted: none of its versions are held. var square = await reached.CreateAsync("Square", null, null, context.Cancellation); var squareHead = await reached.HeadAsync(square.Id, context.Cancellation); await reached.DeleteAsync(square.Id, context.Cancellation); Assert.False(await reached.HoldsAsync(square.Id, squareHead, context.Cancellation), "deleted"); } /// Settings whose export names its files with : as large as a test needs. private static ProjectSettings Named(string template) => new() { Export = new ExportSettings { NameTemplate = template } }; [Test] public async Task TheServerSaysItKeepsProjects() { await using var server = await TestServer.StartAsync(context); using var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), "tests"); Assert.Contains(ServerCapabilities.Projects, (await client.GetInfoAsync(context.Cancellation)).Capabilities); } [Test] public async Task TheFramesOfAHomeAreOfOneFramesVersionWithTheAliasesOfItsConversions() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 3); var frames = await client.GetProjectFramesAsync(sid, context.Cancellation); var sequence = await client.GetSequenceAsync(sid, context.Cancellation); Assert.Equal((sid, sequence.FramesVersion, 3), (frames.SequenceId, frames.FramesVersion, frames.Frames.Count)); Assert.SequenceEqual([0, 1, 2], frames.Frames.Select(f => f.Index)); Assert.Null(frames.Aliases); await RefusedAsync(HttpStatusCode.NotFound, "not_found", () => client.GetProjectFramesAsync(Guid.CreateVersion7())); // A conversion's tombstones join the original's encoding to its replacement's; deletions join nothing. var replaced = new string('a', 64); await server.Database.FrameRemovals.SyncSequenceAsync(sid, [ new FrameRemoval(sid, replaced, frames.Frames[1].Sha256, RemovalReason.Replaced, DateTimeOffset.UtcNow), new FrameRemoval(sid, new string('b', 64), null, RemovalReason.Deleted, DateTimeOffset.UtcNow), ]); frames = await client.GetProjectFramesAsync(sid, context.Cancellation); var alias = Assert.NotNull(frames.Aliases).Single(); Assert.Equal((replaced, frames.Frames[1].Sha256, "replaced"), (alias.Sha256, alias.Replacement, alias.Reason)); // A position parked on the encoding a conversion replaced finds the frame that holds its replacement. var home = ProjectWire.ToHomeFrames(frames); Assert.Equal(1, home.Photos.IndexOf(new FramePhoto(replaced, 1, null))); Assert.SequenceEqual(frames.Frames.Select(f => f.Id), home.Frames.Select(f => f.Id)); } [Test] public async Task ABusyOfflineOrMovedSequenceRefusesChangesAndStillLists() { await using var server = await TestServer.StartAsync(context, services: s => { ArchiveModule.Register(s); // A short lease wait: a sequence another writer holds refuses at once. s.AddSingleton(sp => new ArchiveService(sp.GetRequiredService(), new ArchiveServiceOptions { Owner = ArchiveModule.Owner, LeaseWait = TimeSpan.FromMilliseconds(200) })); }); var (_, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 2); var main = (await client.ListProjectsAsync(sid)).Single(); var head = await client.GetProjectHeadAsync(sid, main.Id); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); var version = Version(head, new ProjectSettings { HeroFrame = 0 }, home); var paths = new ArchivePaths(server.Options.ArchivePath); async Task RefusedNowAsync(string code) { await RefusedAsync(HttpStatusCode.ServiceUnavailable, code, () => client.PushProjectVersionAsync(sid, main.Id, version)); await RefusedAsync(HttpStatusCode.ServiceUnavailable, code, () => client.CreateProjectAsync(sid, new CreateProjectRequest("Later"))); // Reads answer from the index meanwhile. Assert.Equal(main.Id, (await client.ListProjectsAsync(sid)).Single().Id); Assert.Equal(head.Id, (await client.GetProjectHeadAsync(sid, main.Id)).Id); } using (Assert.NotNull(LeaseFile.TryAcquire(paths.LocksDirectory, $"seq-{sid:N}", "tests"))) await RefusedNowAsync("sequence_busy"); File.Move(paths.ManifestPath, paths.ManifestPath + ".away"); try { await RefusedNowAsync("archive_offline"); } finally { File.Move(paths.ManifestPath + ".away", paths.ManifestPath); } var folder = (await server.Database.Sequences.GetAsync(sid))!.Folder; Directory.Move(paths.FromRelative(folder), paths.FromRelative(folder + " moved")); try { await RefusedNowAsync("folder_moved"); } finally { Directory.Move(paths.FromRelative(folder + " moved"), paths.FromRelative(folder)); } // Nothing was lost: the same push is stored now. Assert.Equal(ProjectPushOutcomes.Stored, (await client.PushProjectVersionAsync(sid, main.Id, version)).Outcome); } [Test] public async Task ARenderNodeGetsAProjectVersionPlacedAndItsRenderRecordsIt() { await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024, ArchiveModule.Register); var (editor, _, token) = await server.UserAsync("alberto", "editor", renderNode: true); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 3); var other = await SequenceAsync(server, token, 1, "other"); var vertical = await client.CreateProjectAsync(sid, new CreateProjectRequest("Vertical")); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); // The second photo left out, parked by photo in the version. var excluding = Version(await client.GetProjectHeadAsync(sid, vertical.Id), new ProjectSettings { ExcludedFrames = [1], HeroFrame = 2 }, home); Assert.Contains("pendingFrames", excluding.SettingsJson); var v2 = Assert.NotNull((await client.PushProjectVersionAsync(sid, vertical.Id, excluding)).Version); var node = await client.RegisterNodeAsync(new RegisterNodeRequest("studio-pc", [new NodeEncoder("h264", "Media Foundation H.264", true, false)], 4096, 4096)); var job = await JobApiTests.CreateAsync(editor, "render", sid, H264(vertical.Id, v2.Id)); var claimed = Assert.NotNull(await client.ClaimAsync(node.Id)); Assert.Equal((job.Id, sid, 3), (claimed.Job.Id, claimed.SequenceId, claimed.Frames.Count)); // The node renders the version's settings with their positions placed on the frames it was sent. var placed = ProjectSettings.FromJson(claimed.SettingsJson); Assert.SequenceEqual([1], placed.ExcludedFrames); Assert.Equal(2, placed.HeroFrame); Assert.True(placed.PendingFrames is null or { Count: 0 }, "nothing waits"); var output = Path.Combine(context.CreateTempDirectory("render"), "Vertical.mp4"); var video = Uploads.Photo(100_000, 61); await File.WriteAllBytesAsync(output, video); var render = await client.UploadRenderResultAsync(node.Id, job.Id, output, new RenderResultRequest("Vertical.mp4", video.Length, Uploads.Sha(video), "1080p", "h264", 1920, 1080, 25, 4)); var row = Assert.NotNull(await server.Database.Renders.GetAsync(render.Id)); Assert.Equal(((Guid?)vertical.Id, (Guid?)v2.Id), (row.ProjectId, row.ProjectVersionId)); // A project alone renders its head as it is when the job is queued: the job names that version. var pinned = await JobApiTests.CreateAsync(editor, "render", sid, H264(vertical.Id, null)); var parameters = JsonSerializer.Deserialize((await server.Database.Jobs.GetAsync(pinned.Id))!.ParametersJson!, ProtocolJson.Default.RenderJobParameters)!; Assert.Equal(((Guid?)vertical.Id, (Guid?)v2.Id), (parameters.ProjectId, parameters.ProjectVersionId)); // A version alone names its project. var named = await JobApiTests.CreateAsync(editor, "render", sid, H264(null, v2.Id)); Assert.Equal((Guid?)vertical.Id, JsonSerializer.Deserialize((await server.Database.Jobs.GetAsync(named.Id))!.ParametersJson!, ProtocolJson.Default.RenderJobParameters)!.ProjectId); // What is not the sequence's is refused; an old client naming neither renders the sequence's settings as before. using (var unknown = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("render", [sid], H264(null, Guid.CreateVersion7())), ProtocolJson.Default.CreateJobRequest)) Assert.Equal("version", (await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details); using (var foreign = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("render", [other], H264(vertical.Id, v2.Id)), ProtocolJson.Default.CreateJobRequest)) Assert.Equal("project", (await foreign.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details); var main = (await client.ListProjectsAsync(sid)).Single(p => p.IsMain); using (var mismatched = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("render", [sid], H264(main.Id, v2.Id)), ProtocolJson.Default.CreateJobRequest)) Assert.Equal("version", (await mismatched.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details); var plain = await JobApiTests.CreateAsync(editor, "render", sid, H264(null, null)); Assert.Equal(H264(null, null), (await server.Database.Jobs.GetAsync(plain.Id))!.ParametersJson); } [Test] public async Task TheServerRendersAProjectVersionAndRecordsIt() { await using var server = await TestServer.StartAsync(context, services: s => { ArchiveModule.Register(s); ProcessingModule.Register(s); }); var (editor, _, token) = await server.UserAsync("alberto", "editor"); using var client = Client(server, token); var sid = await SequenceAsync(server, token, 4); var vertical = await client.CreateProjectAsync(sid, new CreateProjectRequest("Vertical")); var home = ProjectWire.ToHomeFrames(await client.GetProjectFramesAsync(sid)); var v2 = Assert.NotNull((await client.PushProjectVersionAsync(sid, vertical.Id, Version(await client.GetProjectHeadAsync(sid, vertical.Id), new ProjectSettings { ExcludedFrames = [2] }, home))).Version); const string avi = """{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"overrides":{"width":96,"height":64},"nameTemplate":"vertical"}"""; var job = await JobApiTests.CreateAsync(editor, "render", sid, JsonSerializer.Serialize(new RenderJobParameters("MJPEG", avi, "mjpeg", 96, 64, false, null, vertical.Id, v2.Id), ProtocolJson.Default.RenderJobParameters)); await JobApiTests.WaitForAsync(editor, job.Id, "done"); var render = (await server.Database.Renders.ListBySequenceAsync(sid)).Single(); Assert.Equal(((Guid?)vertical.Id, (Guid?)v2.Id), (render.ProjectId, render.ProjectVersionId)); // Rendered with the version's settings, its positions placed on the sequence's frames. Assert.SequenceEqual([2], ProjectSettings.FromJson(Assert.NotNull(render.SettingsJson)).ExcludedFrames); } /// A render job's parameters for an H.264 render node, naming a project and a version. private static string H264(Guid? projectId, Guid? versionId) => JsonSerializer.Serialize(new RenderJobParameters("1080p", """{"codec":"h264","bitrate":20}""", "h264", 1920, 1080, false, null, projectId, versionId), ProtocolJson.Default.RenderJobParameters); /// A version made from with in portable form, as a workspace commits it. private static ProjectVersionDto Version(ProjectVersionDto parent, ProjectSettings settings, HomeFrames home, string? note = null) { var portable = ProjectContent.ToPortable(settings, home.Photos); return new ProjectVersionDto(Guid.CreateVersion7(), parent.ProjectId, parent.Id, parent.Number + 1, "commit", null, "Chronos on PC-A", note, portable, ProjectContent.Hash(portable), ProjectContent.FormatOf(portable), home.FramesVersion, null, DateTimeOffset.UtcNow, null); } private static ChronosClient Client(TestServer server, string token) => new(server.HttpBase, new CertificatePinning([]), "tests") { Token = token }; /// A call the server refuses with and . private static async Task RefusedAsync(HttpStatusCode status, string code, Func call) { var refused = await Assert.ThrowsAsync(call); Assert.Equal((status, code), (refused.Status, refused.Error.Code), refused.Message); Assert.False(string.IsNullOrWhiteSpace(refused.Error.Message), "the refusal says why"); return refused; } /// The first event of that takes, those before it passed over. private static async Task NextAsync(EventHub.Subscription events, Func match) where T : ServerEvent { using var timeout = new CancellationTokenSource(Wait); try { while (true) { if (await events.Reader.ReadAsync(timeout.Token) is T typed && match(typed)) return typed; } } catch (OperationCanceledException) { Assert.Fail($"No {typeof(T).Name} as expected within {Wait.TotalSeconds} s"); throw; } } private static async Task WaitForSubscribersAsync(TestServer server, int count) { var hub = server.Services.GetRequiredService(); var until = DateTime.UtcNow + Wait; while (hub.SubscriberCount < count) { Assert.True(DateTime.UtcNow < until, "the WebSocket did not subscribe"); await Task.Delay(20); } } /// A sequence of JPEG photos a minute apart, filed by the archive engine, once its jobs are done. private static async Task SequenceAsync(TestServer server, string token, int photos, string session = "harbour") { var uploader = server.NewClient(token); Guid id = default; for (var i = 0; i < photos; i++) { id = (await Uploads.UploadAsync(uploader, Photo(i + session.Length * 10), $"IMG_{i + 1:0000}.JPG", sessionKey: session, capturedAt: new DateTime(2026, 9, 28, 18, i, 11))).SequenceId; } var until = DateTime.UtcNow + Wait; foreach (var state in new[] { JobState.Queued, JobState.Running, JobState.Queued, JobState.Running }) { while ((await server.Database.Jobs.ListAsync(state)).Items.Any(j => j.Kind != JobKind.Render)) { Assert.True(DateTime.UtcNow < until, $"jobs still {state}"); await Task.Delay(50); } } return id; } private static byte[] Photo(int seed) { const int width = 96, height = 64; var pixels = new byte[width * height * 3]; for (var i = 0; i < pixels.Length; i++) pixels[i] = (byte)((i * 7 + seed * 31) % 251); return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); } }