Lays down every contract the later parcels of owner review 1 phase 5 build on, so they compile against shared types without touching each other's files. - Settings format 3: export.playback (direction, loops, fades, hold), omitted at its default and member by member; RequiredFormat is 3 only while used. - OutputProgram public API with a forward-only body; still-frame job parameters (StillFrame, StillPhoto) routed to format-3 nodes only. - Render.Sha256/Kind, RenderCopy, RenderKind; JobKind.VideoCopy = 24. - Migration 0010 (sqlite, postgres): renders.sha256/kind, ix_renders_created, render_copies without a foreign key. - Videos protocol DTOs, client calls, ServerCapabilities.Videos (declared, not announced yet), ServerSettingsDto.VideosPath. - IVideoLibrary with a NotImplemented stub registered on the server; TrashKind.Videos, VideoTrashNames, VideoErrors. - en and it strings for the whole phase, five icons, decisions 1-22 and the open-question defaults; tests that used format 3 as "newer" now use 4. Refs #21 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
782 lines
53 KiB
C#
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(3, 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":4,"camera":{"rotate":90}}""";
|
|
var newer = Version(v3, new ProjectSettings(), home) with { SettingsJson = future, ContentHash = ProjectContent.Hash(future), SettingsFormat = 4 };
|
|
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 });
|
|
}
|
|
}
|