Files
Chronos/tests/Chronos.Server.Tests/Api/ProjectTests.cs
T
Alby96andClaude Opus 5.5 fca6c8dfea feat(server): route renders by settings format and adapted size; gate older servers
Owner review 1, phase 4 (P5). A render job now carries the output size its
settings give (RenderSize, proportions win) and the settings format it needs,
resolved on the server before the job is split, so only nodes that read that
format and whose encoder takes the frame claim it, and a job no online node
can read no longer waits for one. Nodes and the server announce the format
they read; settings of a newer Chronos fail saying so.

Encoder size limits are read as long edge x short edge: Media Foundation's
software H.264 encoder, announced as 4096x2304, accepts portrait 2160x3840
(probed on this PC), so EncoderSelector and the provider take either
orientation and cap a portrait frame against the turned limit.

On the desktop, Sync and Send-and-render are disabled with the
NeedsNewerServer tooltip while the server reads an older format than the
working settings need.

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

782 lines
53 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.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;
/// <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 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<Guid>();
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<string> 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");
}
/// <summary>Settings whose export names its files with <paramref name="template"/>: as large as a test needs.</summary>
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);
}
/// <summary>
/// Owner review 1, phase 4: the server announces the settings format it reads, and takes the versions of the formats it
/// reads (1, and 2 with a turn or a look), refusing a newer one with 422 <c>newer_format</c>, nothing stored.
/// </summary>
[Test]
public async Task TheServerTakesTheSettingsFormatsItAnnounces()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
using (var anonymous = new ChronosClient(server.HttpBase, new CertificatePinning([]), "tests"))
Assert.Equal(ProjectSettings.CurrentVersion, (await anonymous.GetInfoAsync(context.Cancellation)).SettingsFormat);
Assert.Equal(2, ProjectSettings.CurrentVersion);
var (http, _, token) = await server.UserAsync("alberto", "editor");
using var alberto = Client(server, token);
var sid = await SequenceAsync(server, token, 2);
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));
var plain = Version(head, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 } }, home);
Assert.Equal(1, plain.SettingsFormat);
var v2 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, plain)).Version);
var turned = Version(v2, new ProjectSettings { Camera = new CameraSettings { Rotate = 90, Mirror = true }, Look = new LookSettings { Filter = "sepia" } }, home);
Assert.Equal(2, turned.SettingsFormat);
var v3 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, turned)).Version);
Assert.Equal(2, ProjectContent.FormatOf(v3.SettingsJson));
var mirrored = ProjectSettings.FromJson(Assert.NotNull((await server.Database.Sequences.GetAsync(sid))!.SettingsJson));
Assert.Equal((90, true, "sepia"), (mirrored.Camera.Rotate, mirrored.Camera.Mirror, mirrored.Look?.Filter), "Main's head is the sequence's settings");
const string future = """{"version":3,"camera":{"rotate":90}}""";
var newer = Version(v3, new ProjectSettings(), home) with { SettingsJson = future, ContentHash = ProjectContent.Hash(future), SettingsFormat = 3 };
using (var raw = await http.PostAsJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions", newer, ProtocolJson.Default.ProjectVersionDto))
await raw.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, ProjectErrors.NewerFormat);
Assert.Equal(3, (await alberto.GetProjectAsync(sid, main.Id)).HeadNumber);
}
[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 });
}
}