Files
Chronos/tests/Chronos.App.Tests/Editor/EditorSessionTests.cs
T
Alby96andClaude Opus 5.5 2a8344aee0 feat(editor): integrate the phase 4 crop, orientation and look packages
Joins the preview crop interaction (P3) and the step controls (P4):
- "Optimise" on the Camera step now advises on the turned view
  (SequenceContext.ForCamera) when the camera is turned or flipped, so it
  keeps the transposed aspect a quarter turn wrote instead of putting the
  unturned one back.
- The capture gains edit-camera-crop (a moved 9:16 box with its handles),
  edit-camera-straighten (turned right, straightened 3°, with the grid)
  and edit-exposure-look (Sepia at 60 % with the compare wipe), each
  undone after; SampleData holds the three project changes.
- The crop-margin, offset X and crop tooltip strings and
  Export.Render.AspectFromPreset are no longer used: removed from en/it
  and pruned from the other cultures. Editor.Camera.OffsetY stays, as the
  advisor's horizon placement still names it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 20:44:30 +01:00

595 lines
27 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.IO;
using System.Text.Json;
using Chronos.App.Editor;
using Chronos.Core.Advice;
using Chronos.Core.Analysis;
using Chronos.Core.Imaging.Geometry;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Protocol;
using Chronos.Testing;
namespace Chronos.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 AnEditMadeBeforeInsertedFramesWereReadIsSavedOnTheFramesItNamed()
{
var (session, source) = OpenShort();
await using (session)
{
Assert.True(session.SetExcluded([3], true));
Assert.True(await session.FlushAsync());
// Two earlier photos are inserted (a download, an import, a scan): the stored exclusion moved with its frame.
var frames = session.Content.Frames;
InsertEarlier(source, 2);
source.Stored = source.Stored with { ExcludedFrames = [5] };
source.FailNextSave = new FramesChangedException("frames changed");
// The editor still shows the frames it read when the user excludes another one.
Assert.True(session.SetExcluded([6], true));
Assert.True(await session.FlushAsync());
Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again");
Assert.SequenceEqual([5, 8], source.Stored.ExcludedFrames);
Assert.SequenceEqual([frames[3].Id, frames[6].Id], session.Project.ExcludedFrames.Select(i => session.Content.Frames[i].Id));
Assert.True(session.Undo());
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames");
Assert.True(session.Undo());
Assert.Empty(session.Project.ExcludedFrames);
}
}
[Test]
public async Task AReadAfterFramesWereInsertedMovesTheOpenProjectWithThem()
{
var (session, source) = OpenShort();
await using (session)
{
Assert.True(session.SetExcluded([3], true));
Assert.True(session.SetHero(4));
Assert.True(await session.FlushAsync());
InsertEarlier(source, 2);
source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 };
await session.ReloadAsync();
Assert.SequenceEqual([5], session.Project.ExcludedFrames);
Assert.Equal(6, session.Project.HeroFrame);
Assert.True(session.Undo());
Assert.Null(session.Project.HeroFrame);
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "the step before Set hero names the same frame");
Assert.True(await session.FlushAsync());
Assert.SequenceEqual([5], source.Stored.ExcludedFrames);
Assert.Null(source.Stored.HeroFrame);
}
}
[Test]
public async Task ARenderAfterFramesWereInsertedEmbedsThePositionsOfTheFramesTheUserChose()
{
var (session, source) = OpenShort();
await using (session)
{
Assert.True(session.SetExcluded([3], true));
Assert.True(session.SetHero(4));
Assert.True(await session.FlushAsync());
var frames = session.Content.Frames;
// Two earlier photos are inserted and the index moves the stored positions; the user renders without an edit.
InsertEarlier(source, 2);
source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 };
await session.EnsureFramesAsync();
var requests = session.RenderRequests(session.Project.Export);
Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again");
var parameters = JsonSerializer.Deserialize(requests[0].ParametersJson!, ProtocolJson.Default.RenderJobParameters)!;
var embedded = ProjectSettings.FromJson(parameters.SettingsJson!);
Assert.SequenceEqual([5], embedded.ExcludedFrames);
Assert.Equal(6, embedded.HeroFrame);
Assert.Equal(frames[3].Id, session.Content.Frames[embedded.ExcludedFrames[0]].Id);
Assert.Equal(frames[4].Id, session.Content.Frames[embedded.HeroFrame!.Value].Id);
Assert.True(session.Undo());
Assert.Null(session.Project.HeroFrame);
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames");
// Frames that did not change are not read again.
var loads = source.Loads;
await session.EnsureFramesAsync();
Assert.Equal(loads, source.Loads);
}
}
[Test]
public async Task AServerSequenceWhoseFramesChangedIsOutdatedBeforeItsRender()
{
var sequence = EditorFixture.Sequence(12);
var content = EditorFixture.Content(sequence, deep: false);
var source = new FakeSequenceSource(sequence, content) { IsRemote = true };
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
await using (session)
{
InsertEarlier(source, 1);
await session.EnsureFramesAsync();
Assert.True(source.IsOutdated);
Assert.True(session.IsReadOnly);
Assert.Equal(0, source.Loads, "its proxies are not the server's frames: nothing is read");
Assert.Equal(12, session.Content.Count);
}
}
[Test]
public async Task ReadsThatOverlapFollowTheFramesInTheOrderTheyWereRead()
{
var (session, source) = OpenShort();
await using (session)
{
Assert.True(session.SetExcluded([3], true));
Assert.True(await session.FlushAsync());
var frames = session.Content.Frames;
// A job ends after an earlier photo was inserted, and its read of the sequence is slow to complete.
InsertEarlier(source, 1);
source.Stored = source.Stored with { ExcludedFrames = [4] };
var slow = new TaskCompletionSource();
source.NextLoadGate = slow.Task;
var first = session.ReloadAsync();
// Another job ends after two more were inserted: its read waits for the first one and follows its frames.
InsertEarlier(source, 2);
source.Stored = source.Stored with { ExcludedFrames = [6] };
var second = session.ReloadAsync();
slow.SetResult();
await Task.WhenAll(first, second);
Assert.Equal(frames.Count + 3, session.Content.Count);
Assert.SequenceEqual([6], session.Project.ExcludedFrames);
Assert.Equal(frames[3].Id, session.Content.Frames[6].Id);
}
}
/// <summary>A short sequence without its analysis, whose frame ids are all different (the synthetic ids repeat every 64 frames).</summary>
private static (EditorSession Session, FakeSequenceSource Source) OpenShort()
{
var sequence = EditorFixture.Sequence(12);
var content = EditorFixture.Content(sequence, deep: false);
var source = new FakeSequenceSource(sequence, content);
return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source);
}
/// <summary>Photos captured before the first frame join the source's sequence, as an insertion renumbers it.</summary>
private static void InsertEarlier(FakeSequenceSource source, int count)
{
var first = source.Content.Frames[0];
var early = Enumerable.Range(0, count).Select(i => first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(i - count) });
IReadOnlyList<Frame> frames = [.. early.Concat(source.Content.Frames).Select((f, i) => f with { Index = i })];
source.Content = source.Content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) };
}
[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);
}
}
// ---- Orientation and framing (owner review 1, R5/R6) ----
/// <summary>A project with a manual aspect (the advice never decides it) and a crop.</summary>
private static ProjectSettings WithAspect(string aspect, double[]? crop = null)
{
var project = new ProjectSettings();
return project with { Camera = project.Camera with { Aspect = project.Camera.Aspect.WithManual(aspect), Crop = crop } };
}
[Test]
public async Task EachOrientationPressIsOneUndoStepAndTurnsTheCropWithThePicture()
{
var (session, _) = Open(WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]));
await using (session)
{
Assert.True(session.Orient(OrientationOp.RotateRight));
Assert.Equal(90, session.Project.Camera.Rotate);
Assert.Equal("9:16", session.Project.Camera.Aspect.Manual, "the proportions turn with the picture");
Assert.SequenceEqual([0.5, 0.1, 0.3, 0.4], session.Project.Camera.Crop!, "the crop keeps the content");
Assert.True(session.Orient(OrientationOp.Mirror));
Assert.True(session.Project.Camera.Mirror);
Assert.SequenceEqual([0.2, 0.1, 0.3, 0.4], session.Project.Camera.Crop!, "mirror maps x to 1 − x − w");
Assert.True(session.Undo());
Assert.False(session.Project.Camera.Mirror, "one press, one step");
Assert.Equal(90, session.Project.Camera.Rotate);
Assert.True(session.Undo());
Assert.Equal(0, session.Project.Camera.Rotate);
Assert.SequenceEqual([0.1, 0.2, 0.4, 0.3], session.Project.Camera.Crop!);
}
}
[Test]
public async Task OptimiseAfterATurnAdvisesTheAspectOfTheTurnedView()
{
var (session, _) = Open();
await using (session)
{
session.Edit(p => Advisor.Apply(p, session.Advice));
var advised = EditorSettings.Aspect.Effective(session.Project, null);
Assert.True(advised is "16:9" or "9:16", "the analysis advises a video aspect");
Assert.True(session.Orient(OrientationOp.RotateRight));
var turned = EditorSettings.Aspect.Effective(session.Project, null);
Assert.NotEqual(advised, turned, "the turn transposes the advised aspect");
session.Optimise(AdvisorSection.Camera);
Assert.Equal(turned, EditorSettings.Aspect.Effective(session.Project, null), "the advice is worked out on the turned view");
}
}
[Test]
public async Task ATurnSeenThroughAMirrorTurnsThePictureTheWayTheUserPressed()
{
var (session, _) = Open(WithAspect("16:9"));
await using (session)
{
session.Orient(OrientationOp.RotateRight);
Assert.Equal(90, session.Project.Camera.Rotate, "clockwise as stored");
session.Orient(OrientationOp.Mirror);
session.Orient(OrientationOp.RotateRight);
Assert.Equal(0, session.Project.Camera.Rotate, "through one mirror, a clockwise press is an anticlockwise stored turn");
session.Orient(OrientationOp.Flip);
session.Orient(OrientationOp.RotateRight);
Assert.Equal(90, session.Project.Camera.Rotate, "mirror and flip together are a half turn: the sense is kept");
Assert.True(session.Project.Camera is { Mirror: true, Flip: true });
}
}
[Test]
public async Task FourRightTurnsGiveBackTheSameCanonicalText()
{
var keyed = WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]);
keyed = keyed with { Camera = keyed.Camera with { Keyframes = [new CameraKey(4, 0.3, 0.6, 1.5, 2)], Straighten = 1.5 } };
var (session, _) = Open(keyed);
await using (session)
{
var before = session.Project.ToJson();
for (var i = 0; i < 4; i++) Assert.True(session.Orient(OrientationOp.RotateRight));
Assert.Equal(before, session.Project.ToJson());
Assert.Equal(ProjectSettings.CurrentVersion, session.Project.RequiredFormat, "a straighten needs format 2");
}
}
[Test]
public async Task AnAspectChangeRefitsALockedCropAroundItsCentre()
{
var (session, _) = Open(WithAspect("16:9"));
await using (session)
{
var ratio = session.CropLockRatio(session.Project);
var box = CropFrame.Clamp(new RectD(0.2, 0.2, 0.5, 0.5 / ratio), ratio);
Assert.True(session.Edit(p => p with { Camera = p.Camera with { Crop = CropFrame.ToCrop(box) } }));
Assert.True(session.Edit(p => EditorSettings.Aspect.WithManual(p, "9:16")));
var refitted = CropFrame.Of(session.Project.Camera.Crop);
Assert.Approximately(session.CropLockRatio(session.Project), refitted.Width / refitted.Height, 1e-9, "locked to the new proportions");
Assert.Approximately(box.CenterX, refitted.CenterX, 1e-9, "the same centre");
Assert.Approximately(box.CenterY, refitted.CenterY, 1e-9);
Assert.Approximately(box.Width * box.Height, refitted.Width * refitted.Height, 1e-9, "the same area");
Assert.True(session.Undo());
Assert.SequenceEqual(CropFrame.ToCrop(box)!, session.Project.Camera.Crop!, "the aspect and the refit are one step");
}
}
[Test]
public async Task ALegacyCropPlacedByOffsetsIsLeftForTheRenderToFit()
{
var legacy = WithAspect("16:9", [0, 0, 1, 0.8]);
legacy = legacy with { Camera = legacy.Camera with { OffsetX = 0.5 } };
var (session, _) = Open(legacy);
await using (session)
{
Assert.True(session.Edit(p => EditorSettings.Aspect.WithManual(p, "1:1")));
Assert.SequenceEqual([0.0, 0, 1, 0.8], session.Project.Camera.Crop!);
Assert.Equal(0.5, session.Project.Camera.OffsetX);
}
}
[Test]
public async Task ResetFramingClearsTheCropAndTheOrientationAndKeepsTheKeyframes()
{
var framed = WithAspect("9:16", [0.2, 0, 0.3, 1]);
var key = new CameraKey(3, 0.4, 0.5, 2, 0);
framed = framed with
{
Camera = framed.Camera with { OffsetX = 0.2, OffsetY = -0.1, Rotate = 270, Mirror = true, Flip = true, Straighten = -3.5, Keyframes = [key] },
Look = new LookSettings { Filter = "sepia" },
};
var (session, _) = Open(framed);
await using (session)
{
Assert.True(EditorSession.HasFraming(session.Project.Camera));
Assert.True(session.ResetFraming());
var camera = session.Project.Camera;
Assert.Null(camera.Crop);
Assert.True(camera is { OffsetX: 0, OffsetY: 0, Rotate: 0, Mirror: false, Flip: false, Straighten: 0 });
Assert.SequenceEqual([key], camera.Keyframes, "keyframes stay");
Assert.Equal("9:16", camera.Aspect.Manual, "the aspect is not framing");
Assert.Equal("sepia", session.Project.Look?.Filter, "nor the look");
Assert.False(EditorSession.HasFraming(camera));
Assert.False(session.ResetFraming(), "nothing left to clear");
Assert.True(session.Undo());
Assert.Equal(270, session.Project.Camera.Rotate, "one step");
}
}
[Test]
public async Task ASequencePresetKeepsTheOrientationAndTheLook()
{
var turned = new ProjectSettings() with { Look = new LookSettings { Filter = "mono", Strength = 0.5 } };
turned = turned with { Camera = turned.Camera with { Rotate = 90, Mirror = true, Straighten = 2 } };
var (session, _) = Open(turned);
await using (session)
{
Assert.True(session.ApplyPreset(session.Presets.First(p => p.Id == "social-vertical")));
Assert.True(session.Project.Camera is { Rotate: 90, Mirror: true, Straighten: 2 });
Assert.Equal("mono", session.Project.Look?.Filter);
Assert.Equal(0.5, session.Project.Look?.Strength);
}
}
[Test]
public async Task AReadOnlyProjectIsNeitherTurnedNorReset()
{
var (session, source) = Open(WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]));
await using (session)
{
source.IsReadOnly = true;
Assert.False(session.Orient(OrientationOp.RotateLeft));
Assert.False(session.ResetFraming());
Assert.Equal(0, session.Project.Camera.Rotate);
Assert.NotNull(session.Project.Camera.Crop);
}
}
}