Files
Chronos/tests/Titano.App.Tests/Editor/RemoteSequenceSourceTests.cs
T
Claude 678a827b42 fix(editor): name the frames version in the remote editor's saves
The desktop editor of a server sequence relied on the server's
sequenceChanged event to go read-only when frames changed. Scans publish
none, and an event missed while the socket reconnected was never noticed,
so a save made meanwhile passed the settings-version check and wrote
positions in the old order over the ones the server had moved.

The PATCH now carries expectedFramesVersion, the frames version of the
proxies the editor holds. On 409 the editor reads the manifest: other
frames make it outdated (read-only, Get proxies; the edit stays pending),
the same frames at a new version retry at that version. After a lost event
socket the frames are compared again. Servers that predate the field
ignore it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 19:14:04 +00:00

611 lines
30 KiB
C#

using System.IO;
using System.Net.Http;
using Titano.App.Editor;
using Titano.Core.Codecs.Jpeg;
using Titano.Core.Diagnostics.Synthetic;
using Titano.Core.Imaging;
using Titano.Core.Imaging.Decoders;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Data.Processing;
using Titano.Data.Sync;
using Titano.Protocol;
using Titano.Testing;
namespace Titano.App.Tests.Editor;
/// <summary>
/// A server sequence in the editor (BRIEF §14.5): proxies from the cache, the project from the server with its
/// version, saves that merge a change made meanwhile on the server, and analyses and renders posted as server jobs.
/// </summary>
public sealed class RemoteSequenceSourceTests(TestContext context)
{
private const string Server = "https://nas.test:8443";
[Test]
public async Task TheProjectComesFromTheServerAndFramesFromTheProxies()
{
var (source, api, _) = Open(frames: 6, cached: 5);
await using (source)
{
api.SettingsJson = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.4 } }.ToJson();
var content = await source.LoadAsync(context.Cancellation);
Assert.True(source.IsRemote);
Assert.Equal(6, content.Count);
Assert.Equal(0.4, content.Project.Exposure.ExposureOffsetEv);
Assert.Equal(3, content.Sequence.SettingsVersion);
Assert.Null(content.ExportsFolder, "renders of a server sequence are not on this PC");
Assert.Equal(string.Empty, content.Renders.Single().OutputPath);
Assert.Empty(content.SavedCopies);
Assert.Null(content.Deep, "never analysed on the server");
using (var frame = await source.DecodeAsync(2, 32, DecodePurpose.Thumbnail, context.Cancellation))
{
Assert.NotNull(frame);
Assert.LessOrEqual(Math.Max(frame!.Width, frame.Height), 32);
}
Assert.Null(await source.DecodeAsync(5, 32, DecodePurpose.Render, context.Cancellation), "a frame without a cached proxy");
Assert.Null(await source.DecodeAsync(9, 32, DecodePurpose.Render, context.Cancellation));
}
}
[Test]
public async Task TheServersAnalysisIsUsedWhenItDescribesTheseFrames()
{
var sunset = EditorFixture.Sequence(8);
var (source, api, _) = Open(sunset);
await using (source)
{
api.Report = EditorFixture.Content(sunset).Deep!.ToJson();
Assert.NotNull((await source.LoadAsync(context.Cancellation)).Deep);
api.Report = EditorFixture.Content(EditorFixture.Sequence(9)).Deep!.ToJson();
Assert.Null((await source.LoadAsync(context.Cancellation)).Deep, "a report of other frames is not shown");
}
}
[Test]
public async Task SavesSendTheVersionTheyWereMadeFrom()
{
var (source, api, _) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
var first = content.Project with { Exposure = content.Project.Exposure with { ExposureOffsetEv = 0.5 } };
var stored = await source.SaveProjectAsync(first, content.Project, context.Cancellation);
Assert.True(ProjectMerge.SameValues(first, stored));
var second = stored with { Exposure = stored.Exposure with { ExposureOffsetEv = 0.7 } };
await source.SaveProjectAsync(second, stored, context.Cancellation);
Assert.SequenceEqual([3, 4], api.Edits.Select(e => e.Request.ExpectedSettingsVersion ?? -1));
Assert.True(api.Edits.All(e => e.Accepted));
Assert.Equal(5, api.SettingsVersion);
Assert.Equal(0.7, ProjectSettings.FromJson(api.SettingsJson!).Exposure.ExposureOffsetEv);
Assert.Null(api.Edits[0].Request.Title, "only the settings travel");
Assert.Null(api.Edits[0].Request.Tags);
// Nothing changed, nothing sent.
Assert.True(ProjectMerge.SameValues(second, await source.SaveProjectAsync(second, second, context.Cancellation)));
Assert.Count(2, api.Edits);
}
}
[Test]
public async Task AChangeMadeOnTheServerMeanwhileIsMergedNotOverwritten()
{
var (source, api, _) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
api.EditsBefore.Enqueue(json =>
{
var theirs = ProjectSettings.FromJson(json ?? "{}");
return (theirs with { Camera = theirs.Camera with { OffsetY = -0.2 } }).ToJson();
});
var mine = content.Project with { Exposure = content.Project.Exposure with { ExposureOffsetEv = 0.5 } };
var merged = await source.SaveProjectAsync(mine, content.Project, context.Cancellation);
Assert.Equal(0.5, merged.Exposure.ExposureOffsetEv);
Assert.Equal(-0.2, merged.Camera.OffsetY, "the server's change is kept");
Assert.SequenceEqual([false, true], api.Edits.Select(e => e.Accepted), "the 409 is followed by a merged edit");
Assert.Equal(4, api.Edits[1].Request.ExpectedSettingsVersion);
var stored = ProjectSettings.FromJson(api.SettingsJson!);
Assert.Equal(0.5, stored.Exposure.ExposureOffsetEv);
Assert.Equal(-0.2, stored.Camera.OffsetY);
}
}
[Test]
public async Task ASettingBothChangedWaitsForTheUsersChoice()
{
var (source, api, _) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
api.EditsBefore.Enqueue(json =>
{
var theirs = ProjectSettings.FromJson(json ?? "{}");
return (theirs with { Exposure = theirs.Exposure with { ExposureOffsetEv = 0.3 } }).ToJson();
});
var mine = content.Project with { Exposure = content.Project.Exposure with { ExposureOffsetEv = 0.5 } };
var conflict = await Assert.ThrowsAsync<ProjectConflictException>(() => source.SaveProjectAsync(mine, content.Project, context.Cancellation));
var difference = Assert.Contains(conflict.Differences, _ => true);
Assert.Equal(("exposure.exposureOffsetEv", "0.5", "0.3"), (difference.Path, difference.Mine, difference.Theirs));
Assert.Equal(0.3, conflict.Server.Exposure.ExposureOffsetEv);
// Asked again without overwriting anything until the editor names the server's settings as its basis.
await Assert.ThrowsAsync<ProjectConflictException>(() => source.SaveProjectAsync(mine, content.Project, context.Cancellation));
Assert.SequenceEqual([false], api.Edits.Select(e => e.Accepted));
Assert.Equal(0.3, ProjectSettings.FromJson(api.SettingsJson!).Exposure.ExposureOffsetEv);
var kept = await source.SaveProjectAsync(mine, conflict.Server, context.Cancellation);
Assert.Equal(0.5, kept.Exposure.ExposureOffsetEv);
Assert.Equal(0.5, ProjectSettings.FromJson(api.SettingsJson!).Exposure.ExposureOffsetEv);
}
}
[Test]
public async Task KeepMineSavesTheEditorsValuesWithTheServersOtherChanges()
{
var (source, api, _) = Open();
var content = await source.LoadAsync(context.Cancellation);
await using var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
var found = new TaskCompletionSource<ProjectConflictException>(TaskCreationOptions.RunContinuationsAsynchronously);
session.ConflictFound += conflict => found.TrySetResult(conflict);
api.EditsBefore.Enqueue(ChangedOnTheServer);
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 } });
var conflict = await found.Task.WaitAsync(TimeSpan.FromSeconds(10));
Assert.Same(conflict, session.Conflict);
Assert.False(await session.FlushAsync(), "the change waits for the choice");
Assert.True(session.ResolveConflict(keepMine: true));
Assert.True(await session.FlushAsync());
Assert.Null(session.Conflict);
var stored = ProjectSettings.FromJson(api.SettingsJson!);
Assert.Equal((0.5, -0.2), (stored.Exposure.ExposureOffsetEv, stored.Camera.OffsetY), "the editor's offset and the server's framing");
Assert.True(ProjectMerge.SameValues(stored, session.Project));
Assert.False(session.ResolveConflict(keepMine: false), "settled once");
}
[Test]
public async Task TakeServerShowsTheServersValuesAndCtrlZBringsTheEditorsBack()
{
var (source, api, _) = Open();
var content = await source.LoadAsync(context.Cancellation);
await using var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
var found = new TaskCompletionSource<ProjectConflictException>(TaskCreationOptions.RunContinuationsAsynchronously);
session.ConflictFound += conflict => found.TrySetResult(conflict);
api.EditsBefore.Enqueue(ChangedOnTheServer);
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 }, HeroFrame = 2 });
await found.Task.WaitAsync(TimeSpan.FromSeconds(10));
Assert.True(session.ResolveConflict(keepMine: false));
Assert.True(await session.FlushAsync());
var stored = ProjectSettings.FromJson(api.SettingsJson!);
Assert.Equal((0.3, -0.2, (int?)2), (stored.Exposure.ExposureOffsetEv, stored.Camera.OffsetY, stored.HeroFrame),
"the server's values where both changed; the editor's other change is saved");
Assert.True(ProjectMerge.SameValues(stored, session.Project));
Assert.True(session.Undo());
Assert.True(await session.FlushAsync());
stored = ProjectSettings.FromJson(api.SettingsJson!);
Assert.Equal((0.5, -0.2), (stored.Exposure.ExposureOffsetEv, stored.Camera.OffsetY), "undo brings the editor's value back, the server's framing stays");
}
[Test]
public async Task AReloadDoesNotMergeOverAConflictingChange()
{
var (source, api, _) = Open();
var content = await source.LoadAsync(context.Cancellation);
await using var session = new EditorSession(source, content, [], TimeSpan.FromHours(1));
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 } });
// An analysis ends on the server while someone there set the same setting; this editor's change was not sent yet.
api.SettingsJson = ChangedOnTheServer(api.SettingsJson);
api.SettingsVersion++;
api.FailNextEdit = new HttpRequestException("offline");
var found = 0;
session.ConflictFound += _ => Interlocked.Increment(ref found);
await session.ReloadAsync(context.Cancellation);
Assert.Equal(0.5, session.Project.Exposure.ExposureOffsetEv, "not merged over");
Assert.False(await session.FlushAsync(), "the retry meets the server's change and asks");
Assert.Equal(1, Volatile.Read(ref found));
Assert.Equal(0.3, ProjectSettings.FromJson(api.SettingsJson!).Exposure.ExposureOffsetEv);
}
[Test]
public async Task ConflictsThatKeepComingAreReported()
{
var (source, api, _) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
for (var i = 1; i <= 3; i++)
{
var offset = i / 10.0;
api.EditsBefore.Enqueue(json =>
{
var theirs = ProjectSettings.FromJson(json ?? "{}");
return (theirs with { Camera = theirs.Camera with { OffsetX = offset } }).ToJson();
});
}
var conflict = await Assert.ThrowsAsync<EditorException>(() => source.SaveProjectAsync(content.Project with { HeroFrame = 2 }, content.Project, context.Cancellation));
Assert.Equal(Loc.L("Editor.Error.SaveConflict"), conflict.Message, "the toast shows the editor's own sentence");
Assert.False(api.Edits.Any(e => e.Accepted));
}
}
[Test]
public async Task TheHeroTravelsAsAFrameOfTheSequence()
{
var (source, api, remote) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
var hero = await source.SaveProjectAsync(content.Project with { HeroFrame = 2 }, content.Project, context.Cancellation);
var other = await source.SaveProjectAsync(hero with { Exposure = hero.Exposure with { ExposureOffsetEv = 0.1 } }, hero, context.Cancellation);
await source.SaveProjectAsync(other with { HeroFrame = null }, other, context.Cancellation);
Assert.SequenceEqual([remote.Frames[2].Id, (Guid?)null, Guid.Empty], api.Edits.Select(e => e.Request.HeroFrameId));
}
}
[Test]
public async Task AnAccountWithoutTheEditRightOnlyLooks()
{
var (source, api, _) = Open(readOnly: true);
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
Assert.True(source.IsReadOnly);
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
await using (session)
{
Assert.True(session.IsReadOnly);
Assert.False(session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 } }));
Assert.False(session.SetHero(3));
Assert.Empty(session.OptimiseAll());
Assert.False(session.Undo());
Assert.True(await session.FlushAsync(), "nothing waits for a save");
}
// The source refuses a change as well; the same project is no change.
var refused = await Assert.ThrowsAsync<EditorException>(() =>
source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation));
Assert.Equal(Loc.L("Editor.Error.RemoteReadOnly"), refused.Message);
Assert.True(ProjectMerge.SameValues(content.Project, await source.SaveProjectAsync(content.Project, content.Project, context.Cancellation)));
Assert.Empty(api.Edits);
}
}
[Test]
public async Task AnalysesAndRendersArePostedToTheServerOnePerPreset()
{
var (source, api, remote) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
await using (session)
{
Assert.True(session.IsRemote);
await session.SubmitAsync(session.AnalysisRequest());
var export = session.Project.Export with { Preset = new Auto<string>().WithManual("4k-hevc"), Batch = ["1440p-h264", "4k-h264"] };
// The preset, then each batch preset.
var renders = session.RenderRequests(export);
Assert.Count(3, renders);
foreach (var request in renders) await session.SubmitAsync(request);
Assert.SequenceEqual(["deep-analyse", "render", "render", "render"], api.Posted.Select(p => p.Kind));
Assert.True(api.Posted.All(p => p.Target.SequenceEqual([remote.Sequence.Id])));
var presets = api.Posted.Skip(1).Select(p => ProcessingJobs.ReadRender(p.ParametersJson).Export).ToList();
Assert.True(presets.All(e => e.Batch.Count == 0), "a server job renders one preset");
Assert.SequenceEqual(["4k-hevc", "1440p-h264", "4k-h264"], presets.Select(e => e.Preset.Manual));
}
}
}
[Test]
public void ThisPcRendersABatchAsOneJob()
{
var content = EditorFixture.Content(EditorFixture.Sunset);
var session = new EditorSession(new FakeSequenceSource(EditorFixture.Sunset, content), content, []);
var requests = session.RenderRequests(session.Project.Export with { Batch = ["1440p-h264", "4k-h264"] });
Assert.Count(1, requests);
Assert.Count(2, ProcessingJobs.ReadRender(requests[0].ParametersJson).Export.Batch);
}
[Test]
public async Task TheServersJobEventsReachTheEditor()
{
var (source, api, remote) = Open();
await using (source)
{
await source.LoadAsync(context.Cancellation);
var seen = new List<Job>();
source.JobChanged += job =>
{
lock (seen) seen.Add(job);
};
var id = await source.SubmitAsync(ProcessingJobs.DeepAnalysis([remote.Sequence.Id]), context.Cancellation);
Assert.Equal(JobState.Queued, Last(seen).State);
api.Jobs[id] = api.Job(id, "deep-analyse", "running");
api.Publish(new JobStateEvent(id, "running", null));
await WaitAsync(() => Last(seen).State == JobState.Running);
api.Publish(new JobProgressEvent(id, 10, 20, 2.5, 4));
await WaitAsync(() => Last(seen).ProgressDone == 10);
Assert.Equal(TimeSpan.FromSeconds(4), Last(seen).Eta);
// Another client's job on another sequence is not this editor's business.
var foreign = Guid.CreateVersion7();
api.Jobs[foreign] = api.Job(foreign, "render", "running", Guid.CreateVersion7());
api.Publish(new JobStateEvent(foreign, "running", null));
api.Jobs[id] = api.Job(id, "deep-analyse", "done", done: 20, total: 20);
api.Publish(new JobStateEvent(id, "done", null));
await WaitAsync(() => Last(seen).State == JobState.Done);
lock (seen) Assert.False(seen.Any(j => j.Id == foreign));
var other = Guid.CreateVersion7();
api.Jobs[other] = api.Job(other, "render", "queued");
api.Jobs[foreign] = api.Job(foreign, "render", "queued", Guid.CreateVersion7());
Assert.SequenceEqual([other], (await source.ListJobsAsync(context.Cancellation)).Select(j => j.Id), "active jobs of this sequence only");
// A late progress event of the finished job does not bring it back to running.
api.Publish(new JobProgressEvent(id, 19, 20, 2.5, 1));
api.Jobs[other] = api.Job(other, "render", "running");
api.Publish(new JobStateEvent(other, "running", null));
await WaitAsync(() => Last(seen).Id == other);
lock (seen) Assert.Equal(JobState.Done, seen.Last(j => j.Id == id).State);
}
Assert.True(api.Disposed, "closing the editor closes its connection");
}
[Test]
public async Task ASequenceGoneFromTheServerReadsAsMissing()
{
var (source, api, _) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
api.Gone = true;
Assert.Equal(Loc.L("Editor.Error.Missing"), (await Assert.ThrowsAsync<EditorException>(() => source.LoadAsync(context.Cancellation))).Message);
var gone = await Assert.ThrowsAsync<EditorException>(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation));
Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message);
}
}
[Test]
public async Task ProxiesOfOtherFramesAreNotEdited()
{
var (source, api, remote) = Open();
await using (source)
{
// A frame added on the server since the proxies were fetched: positions in the project would point elsewhere.
api.Frames = [.. remote.Frames.Select(f => f.Id), Guid.CreateVersion7()];
await Assert.ThrowsAsync<ProxiesOutdatedException>(() => source.LoadAsync(context.Cancellation));
Assert.True(source.IsOutdated);
Assert.True(source.IsReadOnly);
}
(source, api, remote) = Open();
await using (source)
{
// The same frames in another order are other frames too.
api.Frames = [.. remote.Frames.Select(f => f.Id).Reverse()];
await Assert.ThrowsAsync<ProxiesOutdatedException>(() => source.LoadAsync(context.Cancellation));
}
}
[Test]
public async Task FramesChangedOnTheServerWhileOpenStopSavesAndRenders()
{
var (source, api, remote) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
var changes = 0;
source.ReadOnlyChanged += () => Interlocked.Increment(ref changes);
// A change that keeps the frames (settings, a new version number) changes nothing.
api.FramesVersion = 2;
api.Publish(new SequenceChangedEvent(remote.Sequence.Id, "settings", 2, api.SettingsVersion));
await Task.Delay(200);
Assert.False(source.IsOutdated, "the same frames");
api.Frames = [.. remote.Frames.Skip(1).Select(f => f.Id)];
api.FramesVersion = 3;
api.Publish(new SequenceChangedEvent(Guid.CreateVersion7(), "frames", 7, 1));
api.Publish(new SequenceChangedEvent(remote.Sequence.Id, "frames", 3, api.SettingsVersion));
// The flag is set before the event is raised: wait for the event, which comes last.
await WaitAsync(() => Volatile.Read(ref changes) > 0);
Assert.True(source.IsOutdated);
Assert.True(source.IsReadOnly);
Assert.Equal(1, Volatile.Read(ref changes));
await Assert.ThrowsAsync<ProxiesOutdatedException>(() =>
source.SaveProjectAsync(content.Project with { HeroFrame = 2 }, content.Project, context.Cancellation));
await Assert.ThrowsAsync<ProxiesOutdatedException>(() =>
source.SubmitAsync(ProcessingJobs.Render(remote.Sequence, new ExportSettings(), 1920, 1080), context.Cancellation));
await source.SubmitAsync(ProcessingJobs.DeepAnalysis([remote.Sequence.Id]), context.Cancellation);
Assert.Empty(api.Edits);
Assert.SequenceEqual(["deep-analyse"], api.Posted.Select(p => p.Kind), "an analysis reads the server's own frames");
}
}
[Test]
public async Task SavesNameTheirFramesAndTheServerRefusesThemOnceItsFramesChanged()
{
var (source, api, remote) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
var stored = await source.SaveProjectAsync(content.Project with { ExcludedFrames = [1] }, content.Project, context.Cancellation);
// A new frames version over the same frames: the save goes through at that version.
api.FramesVersion = 2;
stored = await source.SaveProjectAsync(stored with { HeroFrame = 2 }, stored, context.Cancellation);
Assert.SequenceEqual([1, 1, 2], api.Edits.Select(e => e.Request.ExpectedFramesVersion ?? -1));
Assert.SequenceEqual([true, false, true], api.Edits.Select(e => e.Accepted));
// An earlier photo reaches the server (a scan, an upload) and its positions move with their frames, before
// any event reaches this editor: the server refuses the edit made on the old frames, which stays unsaved.
api.Frames = [Guid.CreateVersion7(), .. remote.Frames.Select(f => f.Id)];
api.FramesVersion = 3;
api.SettingsJson = (ProjectSettings.FromJson(api.SettingsJson!) with { ExcludedFrames = [2], HeroFrame = 3 }).ToJson();
var refused = await Assert.ThrowsAsync<ProxiesOutdatedException>(() =>
source.SaveProjectAsync(stored with { ExcludedFrames = [1, 4] }, stored, context.Cancellation));
Assert.Equal(Loc.L("Editor.Error.FramesChanged"), refused.Message);
Assert.True(source.IsOutdated);
Assert.False(api.Edits[^1].Accepted);
Assert.SequenceEqual([2], ProjectSettings.FromJson(api.SettingsJson!).ExcludedFrames, "the server keeps the positions it moved");
}
}
[Test]
public async Task FramesChangedWhileTheEventsWereLostAreFoundOnReconnecting()
{
var (source, api, remote) = Open();
await using (source)
{
await source.LoadAsync(context.Cancellation);
api.DropEvents();
api.Frames = [.. remote.Frames.Skip(1).Select(f => f.Id)];
api.FramesVersion = 2;
// The listener reconnects after its first delay (2 s) and compares the frames again.
await WaitAsync(() => source.IsOutdated);
Assert.True(source.IsReadOnly);
}
}
[Test]
public async Task AConflictFoundOnOtherFramesIsNotMergedOntoThem()
{
var (source, api, remote) = Open();
await using (source)
{
var content = await source.LoadAsync(context.Cancellation);
api.EditsBefore.Enqueue(json =>
{
api.Frames = [.. remote.Frames.Select(f => f.Id), Guid.CreateVersion7()];
return json ?? "{}";
});
await Assert.ThrowsAsync<ProxiesOutdatedException>(() =>
source.SaveProjectAsync(content.Project with { ExcludedFrames = [1] }, content.Project, context.Cancellation));
Assert.SequenceEqual([false], api.Edits.Select(e => e.Accepted));
Assert.True(source.IsOutdated);
}
}
[Test]
public async Task QueuedRendersKeepTheirPriorityAndJobsCanBeCancelledAndRetried()
{
var (source, api, remote) = Open();
await using (source)
{
await source.LoadAsync(context.Cancellation);
var seen = new List<Job>();
source.JobChanged += job =>
{
lock (seen) seen.Add(job);
};
var render = ProcessingJobs.Render(remote.Sequence, new ExportSettings(), 1920, 1080);
var now = await source.SubmitAsync(render, context.Cancellation);
var later = await source.SubmitAsync(render with { Priority = JobPriority.Normal }, context.Cancellation);
Assert.SequenceEqual([(later, "normal")], api.Priorities, "Render now stays at the user's priority; Add to queue waits behind it");
await source.CancelJobAsync(now, context.Cancellation);
Assert.Equal(JobState.Cancelled, Last(seen).State);
Assert.Equal("cancelled", api.Jobs[now].State);
await source.RetryJobAsync(now, context.Cancellation);
Assert.Equal((now, JobState.Queued), (Last(seen).Id, Last(seen).State));
}
}
[Test]
public async Task TheEventListenerOutlivesAFailureAndClosingReleasesTheConnection()
{
var (source, api, remote) = Open();
await using (source)
{
await source.LoadAsync(context.Cancellation);
var seen = new List<Job>();
source.JobChanged += job =>
{
lock (seen) seen.Add(job);
};
var id = await source.SubmitAsync(ProcessingJobs.DeepAnalysis([remote.Sequence.Id]), context.Cancellation);
api.Jobs[id] = api.Job(id, "deep-analyse", "running");
// A failure the listener has no special case for (a body that is not a job) does not end it.
api.FailNextJobRead = new ArgumentNullException("dto");
api.Publish(new JobStateEvent(id, "running", null));
api.Publish(new JobStateEvent(id, "running", null));
await WaitAsync(() => Last(seen).State == JobState.Running);
}
Assert.True(api.Disposed);
}
private (RemoteSequenceSource Source, FakeRemoteSequenceApi Api, RemoteSequence Remote) Open(int frames = 6, int cached = int.MaxValue,
bool readOnly = false) =>
Open(EditorFixture.Sequence(frames), cached, readOnly);
/// <summary>A server sequence whose first <paramref name="cached"/> proxies are on this PC (synthetic JPEGs).</summary>
private (RemoteSequenceSource Source, FakeRemoteSequenceApi Api, RemoteSequence Remote) Open(SyntheticSequence sunset, int cached = int.MaxValue,
bool readOnly = false)
{
var folder = context.CreateTempDirectory("proxies");
var sequence = new Sequence
{
Id = Guid.CreateVersion7(),
ArchiveId = Guid.Empty,
Title = "Harbour sunset",
Folder = "2026/2026-09-28 Synthetic",
FrameCount = sunset.Count,
Origin = SequenceOrigin.Server,
SyncState = SyncState.RemoteOnly,
};
var frames = sunset.Frames.Select((f, i) => f with { Id = Guid.CreateVersion7(), SequenceId = sequence.Id, Flags = i < cached ? f.Flags : f.Flags | FrameFlags.Missing })
.ToList();
var files = new string?[frames.Count];
for (var i = 0; i < files.Length && i < cached; i++)
{
using var image = sunset.Render(i);
files[i] = Path.Combine(folder, frames[i].Id.ToString("N") + ".jpg");
File.WriteAllBytes(files[i]!, JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90 }));
}
var remote = new RemoteSequence(Server, sequence, frames, files);
var api = new FakeRemoteSequenceApi(sequence, [.. frames.Select(f => f.Id)]) { SettingsJson = new ProjectSettings().ToJson() };
return (new RemoteSequenceSource(remote, api, DecoderFactory.CreateClient(null), readOnly), api, remote);
}
/// <summary>Someone on the server sets the exposure offset to 0.3 and moves the framing.</summary>
private static string ChangedOnTheServer(string? json)
{
var theirs = ProjectSettings.FromJson(json ?? "{}");
return (theirs with { Exposure = theirs.Exposure with { ExposureOffsetEv = 0.3 }, Camera = theirs.Camera with { OffsetY = -0.2 } }).ToJson();
}
private static Job Last(List<Job> seen)
{
lock (seen) return seen[^1];
}
private static async Task WaitAsync(Func<bool> condition)
{
for (var i = 0; i < 200; i++)
{
try
{
if (condition()) return;
}
catch (ArgumentOutOfRangeException)
{
// Nothing seen yet.
}
await Task.Delay(25);
}
Assert.True(condition(), "timed out waiting");
}
}