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.Protocol; using Chronos.Protocol.Client; 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 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 }); } }