using System.Globalization;
using System.Text.Json.Nodes;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Archiving;
using Chronos.Data.Projects;
using Chronos.Data.Tests.Archiving;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Data.Tests.Workspaces;
using Chronos.Testing;
namespace Chronos.Data.Tests.Projects;
/// The merge of projects (owner review 2, R8): one photo under two names, and settings of a newer Chronos.
public sealed class ProjectMergeTests
{
private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0);
private static FramePhoto Photo(int n) => new(n.ToString("x64", CultureInfo.InvariantCulture), 1000 + n, Start.AddSeconds(10 * n));
private static PendingFrame Waiting(FramePhoto photo, bool excluded = false, bool hero = false) =>
new() { Sha256 = photo.Sha256, Size = photo.Size, CapturedAt = photo.CapturedAt, Excluded = excluded, Hero = hero };
[Test]
public void ATurnOnOneSideAndALookOnTheOtherMergeIntoFormatTwo()
{
var basis = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.2 } };
var ours = basis with { Camera = basis.Camera with { Rotate = 90, Straighten = 1.5 } };
var theirs = basis with { Look = new LookSettings { Filter = "sepia", Strength = 0.6 } };
var result = ProjectMerge.MergeWithConflicts(basis, ours, theirs);
Assert.False(result.HasConflicts);
Assert.Equal((90, 1.5), (result.Merged.Camera.Rotate, result.Merged.Camera.Straighten));
Assert.Equal("sepia", result.Merged.Look?.Filter);
Assert.Equal(2, result.Merged.Version);
Assert.Contains("\"version\": 2", result.Merged.ToJson());
// One side takes the turn away while the other keeps the look: the format the members need, not the one taken.
var undone = ProjectMerge.MergeWithConflicts(result.Merged, result.Merged with { Camera = basis.Camera }, result.Merged with { Look = null }).Merged;
Assert.Equal(1, ProjectContent.FormatOf(undone.ToJson()));
Assert.Equal(basis.ToJson(), undone.ToJson());
}
[Test]
public void BothSidesCroppingGiveOneCropConflict()
{
var basis = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto().WithManual("9:16") } };
var ours = basis with { Camera = basis.Camera with { Crop = [0.1, 0, 0.3, 0.9] } };
var theirs = basis with { Camera = basis.Camera with { Crop = [0.5, 0.05, 0.2, 0.6] } };
var result = ProjectMerge.MergeWithConflicts(basis, ours, theirs);
// The box is one value: never the x of one side and the width of the other.
Assert.SequenceEqual(["camera.crop"], result.Conflicts.Select(c => c.Path));
Assert.SequenceEqual([0.1, 0, 0.3, 0.9], Assert.NotNull(result.Merged.Camera.Crop));
Assert.SequenceEqual([0.5, 0.05, 0.2, 0.6], Assert.NotNull(
ProjectMerge.MergeWithConflicts(basis, ours, theirs, new HashSet { "camera.crop" }).Merged.Camera.Crop));
// With a mirror on their side too, the crop and the mirror are one conflict: their crop is in the mirrored frame.
var mirrored = theirs with { Camera = theirs.Camera with { Mirror = true } };
var coupled = ProjectMerge.MergeWithConflicts(basis, ours, mirrored);
Assert.SequenceEqual(["camera.mirror"], coupled.Conflicts.Select(c => c.Path));
Assert.SequenceEqual([0.1, 0, 0.3, 0.9], Assert.NotNull(coupled.Merged.Camera.Crop), "ours: our crop");
Assert.False(coupled.Merged.Camera.Mirror, "and unmirrored");
var taken = ProjectMerge.MergeWithConflicts(basis, ours, mirrored, new HashSet { "camera.mirror" }).Merged;
Assert.SequenceEqual([0.5, 0.05, 0.2, 0.6], Assert.NotNull(taken.Camera.Crop));
Assert.True(taken.Camera.Mirror);
}
///
/// A turn of a project without a crop changes only the orientation and the aspect (nothing else to move), so member by
/// member a crop or keyframes the other side placed in the unturned frame would apply to the turned one: one conflict.
///
[Test]
public void ATurnOnOneSideAndAFramingOnTheOtherAreOneConflict()
{
var basis = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto().WithManual("16:9") } };
var turned = basis with { Camera = Chronos.Core.Imaging.Geometry.OrientationEdit.Apply(basis.Camera, Chronos.Core.Imaging.Geometry.OrientationOp.RotateRight) };
Assert.Null(turned.Camera.Crop);
var cropped = basis with { Camera = basis.Camera with { Crop = [0.1, 0.2, 0.6, 0.3375] } };
foreach (var (ours, theirs) in new[] { (turned, cropped), (cropped, turned) })
{
var result = ProjectMerge.MergeWithConflicts(basis, ours, theirs);
Assert.SequenceEqual(["camera.rotate"], result.Conflicts.Select(c => c.Path));
Assert.Equal(ours.ToJson(), result.Merged.ToJson(), "ours whole: the orientation and the framing of one side");
var other = ProjectMerge.MergeWithConflicts(basis, ours, theirs, new HashSet { "camera.rotate" }).Merged;
Assert.Equal(theirs.ToJson(), other.ToJson());
}
// Keyframes placed in the unturned frame, on the camera and on a photo that waits.
var keyed = basis with
{
Camera = basis.Camera with { Keyframes = [new CameraKey(0, 0.8, 0.5, 2, 0)] },
};
Assert.SequenceEqual(["camera.rotate"], ProjectMerge.MergeWithConflicts(basis, turned, keyed).Conflicts.Select(c => c.Path));
var photo = Photo(1);
var waiting = basis with { PendingFrames = [Waiting(photo) with { Keyframes = [new CameraKey(0, 0.8, 0.5, 2, 0)] }] };
Assert.SequenceEqual(["camera.rotate"], ProjectMerge.MergeWithConflicts(basis, waiting, turned).Conflicts.Select(c => c.Path));
// Anything else on the other side merges with the turn as before.
var brighter = basis with { Exposure = basis.Exposure with { ExposureOffsetEv = 0.3 } };
var merged = ProjectMerge.MergeWithConflicts(basis, turned, brighter);
Assert.False(merged.HasConflicts);
Assert.Equal((90, 0.3), (merged.Merged.Camera.Rotate, merged.Merged.Exposure.ExposureOffsetEv));
}
[Test]
public void AFormatThreeSideIsNeverMerged()
{
var basis = new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } };
var newer = ProjectSettings.FromJson("""{ "version": 4, "camera": { "rotate": 180 }, "look": { "filter": "film" } }""", allowNewer: true);
var mine = basis with { Look = new LookSettings { Filter = "warm" } };
Assert.Throws(() => ProjectMerge.MergeWithConflicts(basis, mine, newer));
Assert.Throws(() => ProjectMerge.MergeWithConflicts(basis, newer, mine));
Assert.Equal(4, ProjectMerge.MergeWithConflicts(basis, basis, newer).Merged.Version);
}
[Test]
public void EntriesOfOnePhotoMergeAsOneWithThePositionsOfBoth()
{
var frames = new FramePhotos([(0, Photo(1)), (1, Photo(2)), (2, Photo(3))]);
var basis = new ProjectSettings();
// A version stored with an exclusion and the hero of one photo in two entries (renamed alike since they were saved).
var ours = new ProjectSettings { PendingFrames = [Waiting(Photo(2), excluded: true), Waiting(Photo(2), hero: true)] };
var theirs = basis with { Stack = new StackSettings { Mode = StackSetting.Median } };
var merged = ProjectMerge.MergeWithConflicts(basis, ours, theirs);
Assert.Empty(merged.Conflicts);
var entry = Assert.NotNull(merged.Merged.PendingFrames).Single();
Assert.True(entry.Excluded && entry.Hero);
Assert.Equal(StackSetting.Median, merged.Merged.Stack.Mode);
var placed = ProjectSettings.FromJson(ProjectContent.Place(merged.Merged.ToJson(), frames));
Assert.SequenceEqual([1], placed.ExcludedFrames);
Assert.Equal((int?)1, placed.HeroFrame);
// The same through the merge's other side, and when the other side changed the photo's flags.
Assert.True(ProjectMerge.Merge(basis, theirs, ours).PendingFrames!.Single() is { Excluded: true, Hero: true });
var unexcluded = new ProjectSettings { PendingFrames = [Waiting(Photo(2), hero: true)] };
var both = ProjectMerge.MergeWithConflicts(ours, ours, unexcluded);
Assert.Empty(both.Conflicts);
Assert.True(both.Merged.PendingFrames!.Single() is { Excluded: false, Hero: true });
}
[Test]
public void APhotoNamedAlikeOnEverySideMergesAsOnePhoto()
{
// Saved here before the photo was hashed (by size and capture time) and stored at the home after (by SHA-256): once each
// side names it as the frames hold it now, undoing the exclusion here is a change of this side only.
var unhashed = new FramePhoto(null, Photo(2).Size, Photo(2).CapturedAt);
var frames = new FramePhotos([(0, Photo(1)), (1, Photo(2)), (2, Photo(3))]);
var basis = new ProjectSettings { PendingFrames = [Waiting(unhashed, excluded: true)] };
var theirs = new ProjectSettings { PendingFrames = [Waiting(Photo(2), excluded: true)], Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } };
var ours = new ProjectSettings();
ProjectSettings Named(ProjectSettings settings) => ProjectSettings.FromJson(ProjectContent.Rebind(ProjectContent.Canonical(settings.ToJson()), frames));
var merged = ProjectMerge.MergeWithConflicts(Named(basis), Named(ours), Named(theirs));
Assert.Empty(merged.Conflicts);
Assert.Null(merged.Merged.PendingFrames);
Assert.Equal(0.7, merged.Merged.Exposure.ExposureOffsetEv);
}
[Test]
public void SettingsOfANewerChronosAreNeverMergedWithThisOnes()
{
var basis = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.1 } };
var newer = ProjectSettings.FromJson("""{ "version": 4, "exposure": { "exposureOffsetEv": 0.5 }, "grade": { "look": "film" } }""", allowNewer: true);
var mine = basis with { Stack = new StackSettings { Mode = StackSetting.Median } };
// Both changed: refused, whichever side the newer one is, in a replay too.
Assert.Throws(() => ProjectMerge.MergeWithConflicts(basis, mine, newer));
Assert.Throws(() => ProjectMerge.Merge(basis, newer, mine));
Assert.Throws(() => ProjectMerge.Replay(basis, [mine], newer));
Assert.Throws(() => new ProjectMerge.Rebase(basis, newer).Apply(mine));
// A side that did not change takes the other's as they are: nothing is merged.
var taken = ProjectMerge.MergeWithConflicts(basis, basis, newer);
Assert.Empty(taken.Conflicts);
Assert.True(taken.Merged.IsNewerFormat);
Assert.Equal(newer.ToJson(), taken.Merged.ToJson());
Assert.Equal(mine.ToJson(), ProjectMerge.Merge(newer, mine, newer).ToJson());
Assert.Equal(basis.ToJson(), ProjectMerge.Merge(newer, newer, basis).ToJson());
Assert.Equal(newer.ToJson(), ProjectMerge.Replay(basis, [basis], newer).Commits.Single().ToJson());
}
}
/// A newer Chronos sharing the archive (owner review 2, R8): what it writes when it stores a version.
internal static class NewerChronos
{
///
/// A version of settings format + 1 on top of , written
/// as that Chronos's push writes it: the version file, then the record's head (the index adopts it from the sidecars).
/// It holds a member this Chronos does not know (a grade) and an exposure offset of 1.5.
///
public static ProjectVersion Push(ArchiveFixture fx, Sequence sequence, ProjectVersion head)
{
var folder = fx.Paths.Sequence(sequence.Folder);
var settings = JsonNode.Parse(head.SettingsJson)!.AsObject();
settings["version"] = ProjectSettings.CurrentVersion + 1;
settings["grade"] = new JsonObject { ["look"] = "film" };
settings["exposure"] = new JsonObject { ["exposureOffsetEv"] = 1.5 };
var text = ProjectContent.Canonical(settings.ToJsonString());
var version = new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = head.ProjectId,
ParentId = head.Id,
Number = head.Number + 1,
Kind = ProjectVersionKind.Commit,
ClientName = "a newer Chronos",
SettingsJson = text,
ContentHash = ProjectContent.Hash(text),
SettingsFormat = ProjectSettings.CurrentVersion + 1,
FramesVersion = head.FramesVersion,
CreatedAt = DateTimeOffset.UtcNow,
StoredAt = DateTimeOffset.UtcNow,
};
ProjectSidecars.WriteVersion(folder.VersionPath(head.ProjectId, version.Number, version.Id), version);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(head.ProjectId));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(head.ProjectId), record with { Head = new ProjectHead(version.Id, version.Number), Updated = DateTimeOffset.UtcNow });
return version;
}
}
/// Main's catch-up merge (owner review 2, R8): a mirror cut short meets settings written meanwhile.
[Category("projects")]
public abstract class MainMergeTests(TestContext context) : DatabaseTest(context)
{
private async Task FixtureAsync() => Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
[Test]
public async Task WhereBothChangedTheSettingsWrittenMeanwhileWinAndThePushStaysInMainsHistory()
{
var fx = await FixtureAsync();
var (sequence, frames) = await ProjectServiceTests.UploadedAsync(fx, 4);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(first, new ProjectSettings
{
Stack = new StackSettings { Mode = StackSetting.Median },
Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 },
}, frames), fx.Ct)).Version!;
// The push's mirror cut short, and another path writes an offset of its own and an exclusion meanwhile.
var reverted = await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, new ProjectSettings());
await fx.Db.Projects.SetMirroredAsync(main.Id, first.Id, reverted.SettingsVersion, fx.Ct);
await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 1.25 }, ExcludedFrames = [3] });
// One merge version on the push: the settings written meanwhile win where both changed, the push's offset stays in its version.
var history = await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Imported], history.Select(v => v.Kind));
Assert.Equal((pushed.Id, pushed.Id), (history[0].ParentId, history[1].Id));
Assert.Equal(0.5, ProjectSettings.FromJson(history[1].SettingsJson).Exposure.ExposureOffsetEv);
var settings = ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!);
Assert.Equal((1.25, StackSetting.Median), (settings.Exposure.ExposureOffsetEv, settings.Stack.Mode));
Assert.SequenceEqual([3], settings.ExcludedFrames);
Assert.SequenceEqual([3], ProjectSettings.FromJson(ProjectContent.Place(history[0].SettingsJson, ProjectServiceTests.Photos(frames))).ExcludedFrames);
}
[Test]
public async Task AMergeACrashCutBeforeItsMirrorIsFinishedNextTimeWithNoOtherVersion()
{
foreach (var rebuild in new[] { false, true })
{
var fx = await FixtureAsync();
var (sequence, frames) = await ProjectServiceTests.UploadedAsync(fx, 4);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(first, new ProjectSettings
{
Stack = new StackSettings { Mode = StackSetting.Median },
Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 },
}, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = new ProjectHead(first.Id, 1) });
// The push's mirror cut short, another path's settings meanwhile, and the catch-up's merge cut before its mirror.
var reverted = await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, new ProjectSettings());
await fx.Db.Projects.SetMirroredAsync(main.Id, first.Id, reverted.SettingsVersion, fx.Ct);
var theirs = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 1.25 }, ExcludedFrames = [3] };
await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, theirs);
File.WriteAllText(folder.ProjectPath, theirs.ToJson());
projects.Cut = step =>
{
if (step == "catchup.merge") throw new CutException(step);
};
await Assert.ThrowsAsync(() => projects.ListAsync(sequence.Id, fx.Ct));
projects.Cut = null;
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Imported],
(await fx.Db.Projects.ListVersionsAsync(main.Id, null, 10, fx.Ct)).Select(v => v.Kind));
Assert.Equal(StackSetting.None, ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)).Stack.Mode);
// The next catch-up (by this index, or by one rebuilt from the sidecars) mirrors that merge version and adds none.
if (rebuild)
{
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
}
foreach (var _ in new[] { 1, 2 })
{
var history = await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Imported], history.Select(v => v.Kind));
Assert.Equal(pushed.Id, history[0].ParentId);
}
foreach (var settings in new[] { ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!),
ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)) })
{
Assert.Equal((1.25, StackSetting.Median), (settings.Exposure.ExposureOffsetEv, settings.Stack.Mode));
Assert.SequenceEqual([3], settings.ExcludedFrames);
}
}
}
[Test]
public async Task TwoOutsideEditsInARowAreNoMergeForAnyIndex()
{
foreach (var rebuild in new[] { true, false })
{
var fx = await FixtureAsync();
var (sequence, frames) = await ProjectServiceTests.UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(first, new ProjectSettings { ExcludedFrames = [0] }, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Another PC's index that met Main mirrored at version 2.
var (other, _) = await fx.OtherWriterAsync();
await other.Projects.ListAsync(sequence.Id, fx.Ct);
// An older path edits the settings twice, the second time back to what version 2 holds: two external versions.
foreach (var excluded in new[] { new[] { 0, 1 }, new[] { 0 } })
{
var settings = new ProjectSettings { ExcludedFrames = [.. excluded] };
await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, settings);
File.WriteAllText(folder.ProjectPath, settings.ToJson());
await projects.ListAsync(sequence.Id, fx.Ct);
}
var latest = (await projects.HeadAsync(main.Id, fx.Ct)).Id;
Assert.Equal(latest, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id)).Mirrored?.Id);
// As an older build leaves the record (naming the push as mirrored): the shape of the history decides nothing.
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = new ProjectHead(pushed.Id, pushed.Number) });
var service = other;
if (rebuild)
{
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
service = fx.Service;
}
await service.Projects.ListAsync(sequence.Id, fx.Ct);
var history = await service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.External, ProjectVersionKind.External, ProjectVersionKind.Commit, ProjectVersionKind.Imported],
history.Select(v => v.Kind));
Assert.Equal(latest, history[0].Id);
Assert.SequenceEqual([0], ProjectSettings.FromJson(ProjectContent.Place(history[0].SettingsJson, ProjectServiceTests.Photos(frames))).ExcludedFrames);
Assert.SequenceEqual([0], ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)).ExcludedFrames);
}
}
[Test]
public async Task AnOutsideEditAfterAPushWhoseRecordLagsStaysInForce()
{
var fx = await FixtureAsync();
var (sequence, frames) = await ProjectServiceTests.UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var second = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(first, new ProjectSettings { ExcludedFrames = [0] }, frames), fx.Ct)).Version!;
var third = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(second, new ProjectSettings
{
ExcludedFrames = [0],
Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 },
}, frames), fx.Ct)).Version!;
// Version 3's mirror wrote project.json but not the record (it still names version 2); then an older path edits project.json.
var folder = fx.Paths.Sequence(sequence.Folder);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = new ProjectHead(second.Id, 2) });
File.WriteAllText(folder.ProjectPath, new ProjectSettings { ExcludedFrames = [0], Exposure = new ExposureSettings { ExposureOffsetEv = 1.0 } }.ToJson());
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
// The outside edit stays in force; version 3's offset stays in the history.
var history = await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Commit, ProjectVersionKind.Imported], history.Select(v => v.Kind));
Assert.Equal((third.Id, 0.5), (history[1].Id, ProjectSettings.FromJson(history[1].SettingsJson).Exposure.ExposureOffsetEv));
foreach (var settings in new[] { ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!),
ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)) })
{
Assert.Equal(1.0, settings.Exposure.ExposureOffsetEv);
Assert.SequenceEqual([0], settings.ExcludedFrames);
}
Assert.Count(4, await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
}
[Test]
public async Task AnEditMadeOnlyInProjectJsonIsNeverWrittenOverByAMirror()
{
var fx = await FixtureAsync();
var (sequence, frames) = await ProjectServiceTests.UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var second = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [0] },
frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Another PC (an older client) edits project.json only, and this index has not scanned it: a push to Main merges it first.
File.WriteAllText(folder.ProjectPath, new ProjectSettings { ExcludedFrames = [0], Exposure = new ExposureSettings { ExposureOffsetEv = 1.0 } }.ToJson());
var third = (await projects.PushAsync(main.Id, ProjectServiceTests.Draft(second, new ProjectSettings
{
ExcludedFrames = [0, 2],
Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 },
}, frames), fx.Ct)).Version!;
var history = await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Commit, ProjectVersionKind.Imported], history.Select(v => v.Kind));
Assert.Equal((third.Id, 0.5), (history[1].Id, ProjectSettings.FromJson(history[1].SettingsJson).Exposure.ExposureOffsetEv));
foreach (var settings in new[] { ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!),
ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)) })
{
// Where both changed the outside edit wins; the push's other change is in force too.
Assert.Equal(1.0, settings.Exposure.ExposureOffsetEv);
Assert.SequenceEqual([0, 2], settings.ExcludedFrames);
}
Assert.Count(4, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
// The merge's mirror wrote project.json and the record but not the index (still at version 3), and project.json is
// edited again: the mirror completing it keeps the edit as an external version.
var head = await projects.HeadAsync(main.Id, fx.Ct);
var stale = await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [0, 2], Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 } });
await fx.Db.Projects.SetMirroredAsync(main.Id, third.Id, stale.SettingsVersion, fx.Ct);
File.WriteAllText(folder.ProjectPath, new ProjectSettings { ExcludedFrames = [1], Exposure = new ExposureSettings { ExposureOffsetEv = -1 } }.ToJson());
history = await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.Equal((ProjectVersionKind.External, head.Id), (history[0].Kind, history[0].ParentId));
foreach (var settings in new[] { ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!),
ProjectSettings.FromJson(File.ReadAllText(folder.ProjectPath)) })
{
Assert.Equal(-1, settings.Exposure.ExposureOffsetEv);
Assert.SequenceEqual([1], settings.ExcludedFrames);
}
Assert.Count(5, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
}
[Test]
public async Task ANewerChronosHeadOfMainIsNotMergedWithSettingsWrittenMeanwhile()
{
var fx = await FixtureAsync();
var (sequence, _) = await ProjectServiceTests.UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var newer = NewerChronos.Push(fx, sequence, await projects.HeadAsync(main.Id, fx.Ct));
await ProjectServiceTests.WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Mean } });
// Both are left as they are: the newer head stays the head, the settings stay those written.
Assert.Equal(newer.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Count(2, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
var settings = ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!);
Assert.Equal((StackSetting.Mean, 0.0), (settings.Stack.Mode, settings.Exposure.ExposureOffsetEv));
}
}
public sealed class SqliteMainMergeTests(TestContext context) : MainMergeTests(context)
{
protected override Backend Backend => Backend.SqliteFile;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresMainMergeTests(TestContext context) : MainMergeTests(context)
{
protected override Backend Backend => Backend.Postgres;
}