Files
Chronos/tests/Titano.App.Tests/Editor/EditorFixture.cs
T
Claude 757695f037 fix(editor): server jobs, stale proxies and read-only accounts in the remote editor
- A server sequence whose cached frames are no longer the server's (a load, a 409
  merge or a frames change event finds other frame ids) turns read-only and says
  why; opening it, or a sequence without cached proxies, queues the proxy
  download and opens it when done. Signed out reads "Connect to the server".
- Server jobs show queued, running (with a bar), paused and analysing glyphs in
  the header with Cancel; a failed or cancelled one raises a toast with Retry.
  Progress alone no longer refreshes the whole editor.
- The server job list is read by state and kind to its last page; "Add to queue"
  sets the job's priority; the event listener survives any failure and always
  releases its frames and connection.
- An account that may render but not edit picks the preset to render without
  changing the project; preset cards and their batch boxes say why they wait.
- Export tab of a server sequence: no local encoder, notices or folder; no Jobs
  history link. Sync at 12 px beside a folder that keeps 96 px and trims.
- Restore's Undo puts back the project from before the restore, only while that
  restore is the editor's last change.
- Export "Sync" of a render that ends while the session is down is queued for the
  saved session's server; skips are logged; sync follows the engine before it
  starts.
- Capture: sequence-remote-export, -running and -readonly, and
  sequence-export-copies.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-05 22:15:34 +00:00

176 lines
6.6 KiB
C#

using System.Globalization;
using Titano.App.Editor;
using Titano.Core.Analysis;
using Titano.Core.Analysis.Deep;
using Titano.Core.Diagnostics.Synthetic;
using Titano.Core.Imaging;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Core.Render.Diagnostics;
using Titano.Data.Archiving.Jobs;
namespace Titano.App.Tests.Editor;
/// <summary>A synthetic sunset with flicker and two exposure steps, as the editor tests open it.</summary>
internal static class EditorFixture
{
private static readonly Lazy<SyntheticSequence> Shared = new(() => Sequence());
static EditorFixture() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
public static SyntheticSequence Sunset => Shared.Value;
public static SyntheticSequence Sequence(int frames = 72) => SyntheticSequence.Create(new SyntheticSequenceOptions
{
Width = 96,
Height = 64,
FrameCount = frames,
StartEv = 0,
EndEv = -2,
FlickerEv = 0.25,
ExposureSteps = [new SyntheticExposureStep(24, -1), new SyntheticExposureStep(48, -1)],
StartKelvin = 5200,
EndKelvin = 3400,
});
/// <summary>The sequence as <see cref="ISequenceSource.LoadAsync"/> returns it, with a deep analysis when asked.</summary>
public static SequenceContent Content(SyntheticSequence sequence, ProjectSettings? project = null, bool deep = true)
{
var id = Guid.CreateVersion7();
var frames = sequence.Frames.Select(f => f with { SequenceId = id }).ToList();
var row = new Sequence
{
Id = id,
ArchiveId = Guid.CreateVersion7(),
Title = "Harbour sunset",
Folder = "2026/2026-09-28 Synthetic",
CameraMake = sequence.Options.CameraMake,
CameraModel = sequence.Options.CameraModel,
FirstCapture = frames[0].CapturedAt,
LastCapture = frames[^1].CapturedAt,
FrameCount = frames.Count,
MedianInterval = sequence.Options.IntervalSeconds,
};
var report = deep ? DeepAnalyzer.AnalyzeAsync(new Frames(sequence)).GetAwaiter().GetResult() : null;
return new SequenceContent(row, frames, project ?? new ProjectSettings(), LightAnalyzer.Analyze(frames), report, sequence.Options.Width,
sequence.Options.Height, null, [], []);
}
/// <summary>Synthetic frames as the deep analysis reads them.</summary>
private sealed class Frames(SyntheticSequence sequence) : IFrameSource
{
public int Count => sequence.Count;
public LightFrame Metadata(int index) => LightFrame.From(sequence.Metadata[index], index);
public ValueTask<ImageBuffer?> LoadAsync(int index, int maxLongEdge, CancellationToken cancellationToken) =>
ValueTask.FromResult<ImageBuffer?>(sequence.Render(index));
}
}
/// <summary>
/// An in-memory <see cref="ISequenceSource"/>: synthetic pixels, a stored project with the same merge rule as the
/// archive, recorded jobs. <see cref="ExternalEdit"/> simulates someone else changing the stored project before a save.
/// </summary>
internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceContent content) : ISequenceSource
{
private readonly SyntheticFrameSource _pixels = new(sequence);
public ProjectSettings Stored { get; set; } = content.Project;
public SequenceContent Content { get; set; } = content;
public List<ArchiveJobRequest> Submitted { get; } = [];
/// <summary>A server sequence: renders become one job per preset.</summary>
public bool IsRemote { get; init; }
public bool IsReadOnly { get; set; }
public bool IsOutdated { get; private set; }
/// <summary>Jobs cancelled and retried through the source.</summary>
public List<Guid> Cancelled { get; } = [];
public List<Guid> Retried { get; } = [];
/// <summary>Jobs <see cref="ListJobsAsync"/> returns.</summary>
public List<Job> Jobs { get; } = [];
public int Saves { get; private set; }
public int Decodes { get; private set; }
/// <summary>Applied to the stored project before the next save reads it.</summary>
public Func<ProjectSettings, ProjectSettings>? ExternalEdit { get; set; }
/// <summary>Thrown by the next save.</summary>
public Exception? FailNextSave { get; set; }
/// <summary>Awaited by every decode (tests of cancellation).</summary>
public Task DecodeGate { get; set; } = Task.CompletedTask;
public Task<SequenceContent> LoadAsync(CancellationToken cancellationToken) => Task.FromResult(Content with { Project = Stored });
public async ValueTask<ImageBuffer?> DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
{
await DecodeGate.WaitAsync(cancellationToken);
Decodes++;
return await _pixels.GetFrameAsync(index, maxLongEdge, purpose, cancellationToken);
}
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
{
if (FailNextSave is { } failure)
{
FailNextSave = null;
return Task.FromException<ProjectSettings>(failure);
}
if (ExternalEdit is { } edit)
{
Stored = edit(Stored);
ExternalEdit = null;
}
Stored = ProjectMerge.SameValues(Stored, basis) ? project : ProjectMerge.Merge(basis, project, Stored);
Saves++;
return Task.FromResult(Stored);
}
public Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
{
Submitted.Add(request);
return Task.FromResult(Guid.CreateVersion7());
}
public event Action<Job>? JobChanged;
public event Action? ReadOnlyChanged;
/// <summary>The server's frames changed under the proxies (as a server sequence finds out).</summary>
public void MarkOutdated()
{
IsOutdated = IsReadOnly = true;
ReadOnlyChanged?.Invoke();
}
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken)
{
Cancelled.Add(jobId);
return Task.CompletedTask;
}
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken)
{
Retried.Add(jobId);
return Task.CompletedTask;
}
public Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) => Task.FromResult<IReadOnlyList<Job>>([.. Jobs]);
/// <summary>A job of the sequence changed (as the engine or the server reports it).</summary>
public void Report(Job job) => JobChanged?.Invoke(job);
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
}