Files
Chronos/tests/Titano.App.Tests/Editor/EditorFixture.cs
T
Claude 827b224ee3 fix(editor): read inserted frames before a render embeds the project
A render queued before the editor had seen frames inserted under it (a sync
download, an import of earlier photos, a scan without an event) embedded the
project's positions in the old frame order. Render now checks first that the
frames read are still the sequence's (ISequenceSource.FramesCurrentAsync: the
row's frames version on this PC, the manifest on a server). On this PC the
sequence is read again and the positions follow the frames; a server
sequence whose frames changed turns outdated and the render is not queued.

Reads of the sequence no longer overlap: a read waits for the one under way,
saves that meet new frames read them through the same slot, and they save
the project as it is once its positions followed. The frame on screen stays
on its photo when frames are inserted or removed before it.

Tests: the event-loss test waits for the listener's subscription before
dropping the stream, and the conflict tests flush once more after the
choice when a retry started before it was still failing.

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

212 lines
7.9 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);
/// <summary>The frames the session read last (opened with, or loaded since).</summary>
private IReadOnlyList<Frame> _read = content.Frames;
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;
/// <summary>Thrown by the next load (the sequence read again after a job).</summary>
public Exception? FailNextLoad { get; set; }
/// <summary>Awaited by the next load once it has read the sequence (a read that is slow to complete).</summary>
public Task? NextLoadGate { get; set; }
/// <summary>Times the sequence was read (<see cref="LoadAsync"/>).</summary>
public int Loads { get; private set; }
public async Task<SequenceContent> LoadAsync(CancellationToken cancellationToken)
{
if (FailNextLoad is { } failure)
{
FailNextLoad = null;
throw failure;
}
Loads++;
var content = Content with { Project = Stored };
if (NextLoadGate is { } gate)
{
NextLoadGate = null;
await gate;
}
_read = content.Frames;
return content;
}
/// <summary>Whether <see cref="Content"/> holds the frames read last; a server sequence becomes outdated when not.</summary>
public Task<bool> FramesCurrentAsync(CancellationToken cancellationToken)
{
var current = _read.Select(f => f.Id).SequenceEqual(Content.Frames.Select(f => f.Id));
if (!current && IsRemote) MarkOutdated();
return Task.FromResult(current);
}
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;
}