- Tests for undo after adopted changes, run ending, saver retries and stop, the local source refusing unsaved writes, re-solves without decoding and equal to a fresh preparation, 1:1 pictures, waveform, crop margins and the values of the Optimise toast; the Windows smoke test checks Render, Batch, the waveform, 1:1, the window title and the hidden idle job bar. - The capture sample has a manual value and camera keyframes; the capture adds the overlays, the waveform, the Optimise toast and Export.html's tool state. - Crop margins live in a WPF-free class; a discarded change stops retrying. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
266 lines
12 KiB
C#
266 lines
12 KiB
C#
using System.IO;
|
|
using System.Text.Json;
|
|
using Titano.App.Editor;
|
|
using Titano.Core.Advice;
|
|
using Titano.Core.Analysis;
|
|
using Titano.Core.Model;
|
|
using Titano.Core.Project;
|
|
using Titano.Protocol;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.App.Tests.Editor;
|
|
|
|
public sealed class EditorSessionTests
|
|
{
|
|
private static (EditorSession Session, FakeSequenceSource Source) Open(ProjectSettings? project = null, bool deep = true)
|
|
{
|
|
var content = EditorFixture.Content(EditorFixture.Sunset, project, deep);
|
|
var source = new FakeSequenceSource(EditorFixture.Sunset, content);
|
|
return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source);
|
|
}
|
|
|
|
[Test]
|
|
public async Task EditsAreSavedAndUndoable()
|
|
{
|
|
var (session, source) = Open();
|
|
await using (session)
|
|
{
|
|
Assert.True(session.Edit(p => EditorSettings.Deflicker.WithManual(p, true)));
|
|
await session.FlushAsync();
|
|
Assert.True(source.Stored.Exposure.Deflicker is { IsAuto: false, Manual: true });
|
|
|
|
Assert.True(session.Undo());
|
|
await session.FlushAsync();
|
|
Assert.True(source.Stored.Exposure.Deflicker.IsAuto, "undo is saved too");
|
|
Assert.True(session.Redo());
|
|
await session.FlushAsync();
|
|
Assert.False(source.Stored.Exposure.Deflicker.IsAuto);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task RapidEditsSaveOnce()
|
|
{
|
|
var (session, source) = Open();
|
|
await using (session)
|
|
{
|
|
Assert.False(session.HasPendingSave);
|
|
for (var i = 1; i <= 20; i++) session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = i / 20.0 } }, "offset");
|
|
Assert.True(session.HasPendingSave, "closing the window waits for this save");
|
|
await session.FlushAsync();
|
|
Assert.False(session.HasPendingSave);
|
|
Assert.Equal(1, source.Saves);
|
|
Assert.Equal(1.0, source.Stored.Exposure.ExposureOffsetEv);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AChangeStoredMeanwhileIsMergedIntoTheEditor()
|
|
{
|
|
var (session, source) = Open();
|
|
await using (session)
|
|
{
|
|
source.ExternalEdit = p => p with { Camera = p.Camera with { OffsetY = -0.2 } };
|
|
session.Edit(p => p with { HeroFrame = 5 });
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.Equal(5, session.Project.HeroFrame);
|
|
Assert.Equal(-0.2, session.Project.Camera.OffsetY, "their change shows up in the editor");
|
|
Assert.True(session.Undo());
|
|
Assert.Null(session.Project.HeroFrame);
|
|
Assert.Equal(-0.2, session.Project.Camera.OffsetY, "undo keeps their change");
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.Equal(-0.2, source.Stored.Camera.OffsetY, "and the undone project stored over it keeps it too");
|
|
Assert.True(session.Redo());
|
|
Assert.Equal(-0.2, session.Project.Camera.OffsetY);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AdviceFromAReloadSurvivesUndo()
|
|
{
|
|
var (session, source) = Open(deep: false);
|
|
await using (session)
|
|
{
|
|
session.Edit(p => p with { HeroFrame = 2 });
|
|
Assert.True(await session.FlushAsync());
|
|
// The deep analysis finished: its advice is stored, the editor reads it back.
|
|
source.Content = EditorFixture.Content(EditorFixture.Sunset, deep: true) with { Sequence = session.Content.Sequence };
|
|
var advice = Advisor.Recommend(source.Content.Light, source.Content.Deep, SequenceContext.FromFrames(source.Content.Frames));
|
|
source.Stored = Advisor.Apply(source.Stored, advice);
|
|
await session.ReloadAsync();
|
|
Assert.True(session.Project.Exposure.Deflicker.HasAdvice);
|
|
|
|
Assert.True(session.Undo());
|
|
Assert.Null(session.Project.HeroFrame);
|
|
Assert.True(session.Project.Exposure.Deflicker.HasAdvice, "undo does not wipe the advice");
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.True(source.Stored.Exposure.Deflicker.HasAdvice, "nor does the save that follows");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFailedSaveStaysPendingUntilItIsStored()
|
|
{
|
|
var (session, source) = Open();
|
|
await using (session)
|
|
{
|
|
var reported = 0;
|
|
session.SaveFailed += _ => reported++;
|
|
source.FailNextSave = new IOException("share offline");
|
|
session.Edit(p => p with { HeroFrame = 1 });
|
|
Assert.False(await session.FlushAsync(), "the flush reports the failure");
|
|
Assert.Equal(1, reported);
|
|
Assert.True(session.HasPendingSave, "closing the window must not drop the edit");
|
|
Assert.NotNull(session.LastSaveError);
|
|
Assert.Null(source.Stored.HeroFrame);
|
|
|
|
Assert.True(await session.FlushAsync(), "the retry stores it without another edit");
|
|
Assert.Equal(1, source.Stored.HeroFrame);
|
|
Assert.False(session.HasPendingSave);
|
|
Assert.Null(session.LastSaveError);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task OptimiseSectionTakesTheHeavierDecisionsAsOneStep()
|
|
{
|
|
// The user turned deflicker off by hand; the analysis measured flicker, so Optimise returns it to Auto (on).
|
|
var start = new ProjectSettings();
|
|
start = start with { Exposure = start.Exposure with { Deflicker = start.Exposure.Deflicker.WithManual(false) } };
|
|
var (session, _) = Open(start);
|
|
await using (session)
|
|
{
|
|
var advice = session.Advice.Find(AdvisorParameters.Deflicker);
|
|
Assert.NotNull(advice);
|
|
Assert.Equal(true, advice!.Value);
|
|
session.Edit(p => Advisor.Apply(p, session.Advice));
|
|
Assert.False(EditorSettings.Deflicker.Effective(session.Project, null), "advice never overrides a manual value");
|
|
|
|
var changes = session.Optimise(AdvisorSection.Exposure);
|
|
Assert.True(EditorSettings.Deflicker.Effective(session.Project, null));
|
|
Assert.True(session.Project.Exposure.Deflicker.IsAuto);
|
|
var change = Assert.Contains(changes, c => c.Parameter == AdvisorParameters.Deflicker);
|
|
Assert.Equal(false, change.Before);
|
|
Assert.Equal(true, change.After);
|
|
|
|
Assert.True(session.Undo());
|
|
Assert.False(session.Project.Exposure.Deflicker.IsAuto, "one undo restores the manual choice");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task WithoutAnalysisOptimiseChangesNothingItCannotMeasure()
|
|
{
|
|
var (session, _) = Open(deep: false);
|
|
await using (session)
|
|
{
|
|
Assert.True(session.Advice.Find(AdvisorParameters.Deflicker)!.IsMissingData);
|
|
var changes = session.Optimise(AdvisorSection.Exposure);
|
|
Assert.DoesNotContain(AdvisorParameters.Deflicker, changes.Select(c => c.Parameter));
|
|
Assert.False(session.Project.Exposure.Deflicker.HasAdvice);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ResetReturnsTheSectionToAuto()
|
|
{
|
|
var (session, _) = Open();
|
|
await using (session)
|
|
{
|
|
session.Edit(p => EditorSettings.Stabilize.WithManual(p, true));
|
|
session.Edit(p => EditorSettings.ShutterAngle.WithManual(p, 90.0));
|
|
session.Edit(p => EditorSettings.Deflicker.WithManual(p, true));
|
|
Assert.False(EditorSettings.IsSectionAuto(session.Project, AdvisorSection.Motion));
|
|
Assert.True(session.ResetSection(AdvisorSection.Motion));
|
|
Assert.True(EditorSettings.IsSectionAuto(session.Project, AdvisorSection.Motion));
|
|
Assert.False(session.Project.Exposure.Deflicker.IsAuto, "other sections keep their values");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ExclusionsAndHeroAreFrameIndices()
|
|
{
|
|
var (session, _) = Open();
|
|
await using (session)
|
|
{
|
|
Assert.True(session.SetExcluded([5, 3, 400], excluded: true));
|
|
Assert.SequenceEqual([3, 5], session.Project.ExcludedFrames);
|
|
Assert.True(session.SetExcluded([3], excluded: false));
|
|
Assert.SequenceEqual([5], session.Project.ExcludedFrames);
|
|
Assert.False(session.SetHero(999));
|
|
Assert.True(session.SetHero(10));
|
|
Assert.Equal(10, session.Project.HeroFrame);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task RenderRequestsEmbedTheProjectAndTheExport()
|
|
{
|
|
var (session, source) = Open();
|
|
await using (session)
|
|
{
|
|
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.7 } });
|
|
var export = session.ExportFor("4k-hevc");
|
|
Assert.Empty(export.Batch);
|
|
var request = session.RenderRequest(export with { Batch = ["1080p-h264"] });
|
|
Assert.Equal(JobKind.Render, request.Kind);
|
|
Assert.SequenceEqual([session.Content.Sequence.Id], request.Targets);
|
|
Assert.Equal(JobPriority.User, request.Priority);
|
|
var parameters = JsonSerializer.Deserialize(request.ParametersJson!, ProtocolJson.Default.RenderJobParameters)!;
|
|
Assert.Equal("hevc", parameters.Codec);
|
|
Assert.Equal(3840, parameters.Width);
|
|
Assert.Contains("1080p-h264", parameters.PresetJson);
|
|
var embedded = ProjectSettings.FromJson(parameters.SettingsJson!);
|
|
Assert.Equal(0.7, embedded.Exposure.ExposureOffsetEv);
|
|
Assert.Equal("4k-hevc", embedded.Export.Preset.Manual);
|
|
|
|
await session.SubmitAsync(request);
|
|
await session.SubmitAsync(session.AnalysisRequest());
|
|
Assert.Equal(2, source.Submitted.Count);
|
|
Assert.Equal(JobKind.DeepAnalyse, source.Submitted[1].Kind);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequencePresetKeepsTheUsersFramesAndNaming()
|
|
{
|
|
var (session, _) = Open();
|
|
await using (session)
|
|
{
|
|
session.SetExcluded([1, 2], excluded: true);
|
|
session.SetHero(9);
|
|
session.Edit(p => p with { Export = p.Export with { NameTemplate = "{title}", Overrides = new ExportOverrides { Width = 640 } } });
|
|
var preset = session.Presets.First(p => p.Id == "social-vertical");
|
|
Assert.True(session.ApplyPreset(preset));
|
|
Assert.Equal("9:16", session.Project.Camera.Aspect.Manual);
|
|
Assert.Equal("vertical-1080x1920", session.Project.Export.Preset.Manual);
|
|
Assert.Null(session.Project.Export.Overrides.Width, "the preset's own values");
|
|
Assert.SequenceEqual([1, 2], session.Project.ExcludedFrames);
|
|
Assert.Equal(9, session.Project.HeroFrame);
|
|
Assert.Equal("{title}", session.Project.Export.NameTemplate);
|
|
Assert.True(session.Undo());
|
|
Assert.Equal(640, session.Project.Export.Overrides.Width);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReloadBringsNewAnalysisAndKeepsUserValues()
|
|
{
|
|
var (session, source) = Open(deep: false);
|
|
await using (session)
|
|
{
|
|
Assert.Null(session.Content.Deep);
|
|
session.Edit(p => p with { HeroFrame = 2 });
|
|
source.Content = EditorFixture.Content(EditorFixture.Sunset, deep: true) with { Sequence = session.Content.Sequence };
|
|
source.Stored = Advisor.Apply(source.Stored, session.Advice);
|
|
var changed = 0;
|
|
session.ContentChanged += () => changed++;
|
|
await session.ReloadAsync();
|
|
Assert.Equal(1, changed);
|
|
Assert.NotNull(session.Content.Deep);
|
|
Assert.False(session.Advice.Find(AdvisorParameters.Deflicker)!.IsMissingData, "advice from the new analysis");
|
|
Assert.Equal(2, session.Project.HeroFrame);
|
|
}
|
|
}
|
|
}
|