Files
Chronos/tests/Chronos.Server.Tests/Api/ProjectTests.cs
T
Alby96andClaude Opus 5.5 e2ecc409a3 feat(server): the server keeps its sequences' projects, pushed and pulled like a PC's archive
Owner review 2, phase 5b (R8): a server is a project home. A workspace can
list a sequence's projects, make, rename and delete them, read their
versions and push new ones through /api/v1/sequences/{sid}/projects. The
endpoints run on the archive's ProjectService exactly as a desktop's archive
does (sidecars first, then the index, under the sequence's lease), so no
version is stored apart and a desktop sharing the archive sees the same
projects.

- Protocol: project, version, create, rename, version page, push answer
  (outcome, stored version, head, plus code and message on 409/422) and
  home frames DTOs, the projectChanged event, the "projects" capability and
  the ChronosClient calls; a push returns its outcome without throwing on
  409 or 422. ProjectWire maps them to and from the model for both sides.
- Server: Read lists and reads, Edit makes, renames and pushes, Delete (the
  sequence's owner, the project's maker or an admin) deletes; refusals with
  stable codes, 503 while the sequence is busy, offline or moved; the
  pushing account becomes the version's author; creations, renames and
  deletions audited, pushes logged.
- ProjectService tells the host what each call changed, compared under the
  lease, so projectChanged also follows Main's external versions; a Main
  version mirrored into the settings sends sequenceChanged too, for older
  clients. ProjectCatchUp takes settings a PATCH, an analysis or a
  conversion wrote into Main at once, for sequences that have a Main.
- Renders of a project version: POST /jobs checks the project and version
  against the sequence and pins a project alone to its head; render nodes
  get the version's settings placed on the frames they claim; the render
  records the project and version.
- Admin panel: the sequence page lists its projects (Main marked, head,
  last change, versions on demand) with Rename and Delete for the others,
  live on projectChanged. It edits no settings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 11:15:19 +01:00

557 lines
37 KiB
C#

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;
/// <summary>
/// The server as the home of its sequences' projects (owner review 2, R8): <c>/api/v1/sequences/{sid}/projects</c> 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 <c>projectChanged</c>
/// event (Main taking settings a <c>PATCH</c> wrote among them), the capability, and the leases and offline archive.
/// </summary>
[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);
}
/// <summary>
/// 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.
/// </summary>
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<EventHub>().Subscribe();
// Main made at the first read.
var main = (await client.ListProjectsAsync(sid)).Single();
await NextAsync<ProjectChangedEvent>(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<ProjectChangedEvent>(events, e => e.ProjectId == vertical.Id && e.Change == ProjectChanges.Created && e.HeadVersionId == vertical.HeadVersionId);
await client.RenameProjectAsync(sid, vertical.Id, "Vertical social");
await NextAsync<ProjectChangedEvent>(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<ProjectChangedEvent>(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<ProjectChangedEvent>(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<ProjectChangedEvent>(events, e => e.ProjectId == main.Id && e.Change == ProjectChanges.Pushed && e.HeadVersionId == toMain.Id);
var mirrored = await NextAsync<SequenceChangedEvent>(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<ProjectChangedEvent>(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<ProjectChangedEvent>(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<ChronosDatabase>(),
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);
}
/// <summary>A render job's parameters for an H.264 render node, naming a project and a version.</summary>
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);
/// <summary>A version made from <paramref name="parent"/> with <paramref name="settings"/> in portable form, as a workspace commits it.</summary>
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 };
/// <summary>A call the server refuses with <paramref name="status"/> and <paramref name="code"/>.</summary>
private static async Task<ChronosApiException> RefusedAsync(HttpStatusCode status, string code, Func<Task> call)
{
var refused = await Assert.ThrowsAsync<ChronosApiException>(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;
}
/// <summary>The first event of <typeparamref name="T"/> that <paramref name="match"/> takes, those before it passed over.</summary>
private static async Task<T> NextAsync<T>(EventHub.Subscription events, Func<T, bool> 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<EventHub>();
var until = DateTime.UtcNow + Wait;
while (hub.SubscriberCount < count)
{
Assert.True(DateTime.UtcNow < until, "the WebSocket did not subscribe");
await Task.Delay(20);
}
}
/// <summary>A sequence of <paramref name="photos"/> JPEG photos a minute apart, filed by the archive engine, once its jobs are done.</summary>
private static async Task<Guid> 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 });
}
}