Owner review 2, R8. Round 2's checkers left five desktop problems: - A workspace copy whose project.chronos a newer Chronos wrote (a format this one does not know) was listed as damaged and offered for Discard. It is now listed as "Newer Chronos" with its own tooltip, named from what of its file still reads. It never opens, is never checked out over, and Remove local copy refuses it with a sentence that says why. - Discard of any copy moved only the files Chronos knows. It now moves every file and folder of the copy aside (only the media are deleted) and removes the folder only when nothing else came into it. - Discarding a damaged copy asked to type its folder's GUID. It now asks for the name the copy is still known by (its file, else the library's index; the project's name, else the sequence's title), else for the number of its files. The heading never shows the id. - A conflict at a path where the working state had gone back to the base value listed the local version's value. The conflict now lists the working state's value in every case. Where the working state already holds the library's value there is nothing to ask: that path takes the library's value in the replayed versions too, so they agree. - EditorSession.ReloadAsync, ResolveConflict and TakeOverAsync threw NewerSettingsException on every reload when an edit was not stored yet and the stored project became a newer Chronos's. The edit is now kept in versions/.replaced (outside the chain, never sent), a toast says so, the pending save is dropped and the newer settings are shown read-only. When the edit cannot be kept aside, the editor stays as it is and nothing is dropped. The SequenceViewModel wiring now has a view-model test: the copy's facts in Open in workspace, the refused-folder toast and its Choose folder action, and the picker for a newer copy and a damaged one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
323 lines
20 KiB
C#
323 lines
20 KiB
C#
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Data.Projects;
|
||
using Chronos.Data.Tests.Archiving;
|
||
using Chronos.Data.Tests.Infrastructure;
|
||
using Chronos.Data.Workspaces;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.Data.Tests.Workspaces;
|
||
|
||
/// <summary>
|
||
/// Settling a workspace conflict and restoring a version (owner review 2, R8): a choice applies only to the conflicts the
|
||
/// user was shown, what a choice replaces stays in a version, a restore loses nothing while a conflict waits, and only a
|
||
/// restore the working state still shows makes a "restore" version.
|
||
/// </summary>
|
||
[Category("workspace")]
|
||
public abstract class WorkspaceConflictTests(TestContext context) : DatabaseTest(context)
|
||
{
|
||
private async Task<WorkspaceFixture> FixtureAsync(int frames = 5)
|
||
{
|
||
var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
|
||
return Own(await WorkspaceFixture.CreateAsync(Context, archive, frames));
|
||
}
|
||
|
||
/// <summary>The working state edited as the editor does: read, changed, stored.</summary>
|
||
private static async Task EditAsync(WorkspaceSync sync, Guid projectId, Func<ProjectSettings, ProjectSettings> edit, CancellationToken ct)
|
||
{
|
||
var session = await sync.OpenAsync(projectId, ct);
|
||
await sync.SaveAsync(projectId, edit(session.Working), ct);
|
||
}
|
||
|
||
private static ProjectSettings Offset(ProjectSettings s, double ev) => s with { Exposure = s.Exposure with { ExposureOffsetEv = ev } };
|
||
|
||
private static ProjectSettings Stack(ProjectSettings s, StackSetting mode) => s with { Stack = new StackSettings { Mode = mode } };
|
||
|
||
/// <summary>Two workspaces of Main; the first has sent an offset of 0.5 and a Median stack, the second changed the offset to 1 and was asked.</summary>
|
||
private static async Task<(WorkspaceFixture Fx, WorkspaceSync One, WorkspaceSync Two, Guid Id, WorkspaceConflict Shown)> AskedAsync(WorkspaceFixture fx)
|
||
{
|
||
var (_, one) = fx.Workspace("one");
|
||
var (_, two) = fx.Workspace("two");
|
||
var id = (await fx.CheckoutAsync(one)).ProjectId;
|
||
await fx.CheckoutAsync(two, id);
|
||
await EditAsync(one, id, s => Stack(Offset(s, 0.5), StackSetting.Median), fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, 1.0), fx.Ct);
|
||
var pulled = await two.PullAsync(id, fx.Home, fx.Ct);
|
||
var shown = Assert.NotNull(pulled.Status.Conflict);
|
||
Assert.Equal("exposure.exposureOffsetEv", shown.Differences.Single().Path, "the stack only one side changed merges");
|
||
return (fx, one, two, id, shown);
|
||
}
|
||
|
||
[Test]
|
||
public async Task AChoiceSettlesOnlyTheConflictsTheUserWasShown()
|
||
{
|
||
var (fx, _, two, id, shown) = await AskedAsync(await FixtureAsync());
|
||
|
||
// Later: editing goes on, and the stack, which the library changed too, is set here. Nobody was shown that one.
|
||
await EditAsync(two, id, s => Stack(s, StackSetting.StarTrails), fx.Ct);
|
||
var asked = await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct);
|
||
Assert.Equal(WorkspaceState.Conflict, asked.Status.State);
|
||
var again = Assert.NotNull(asked.Status.Conflict);
|
||
Assert.SequenceEqual(["exposure.exposureOffsetEv", "stack.mode"], again.Differences.Select(d => d.Path).Order(StringComparer.Ordinal));
|
||
var working = (await two.OpenAsync(id, fx.Ct)).Working;
|
||
Assert.Equal((1.0, StackSetting.StarTrails), (working.Exposure.ExposureOffsetEv, working.Stack.Mode), "nothing was settled");
|
||
|
||
// Asked again with both, take the library's: its values; this side's are kept in a version all the same.
|
||
Assert.Null(asked.Kept, "nothing settled, nothing to take back");
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: again, cancellationToken: fx.Ct);
|
||
Assert.Null(settled.Status.Conflict);
|
||
working = (await two.OpenAsync(id, fx.Ct)).Working;
|
||
Assert.Equal((0.5, StackSetting.Median), (working.Exposure.ExposureOffsetEv, working.Stack.Mode));
|
||
// What keeping this side's values would have left, for the editor's undo of the take.
|
||
var kept = Assert.NotNull(settled.Kept);
|
||
Assert.Equal((1.0, StackSetting.StarTrails), (kept.Exposure.ExposureOffsetEv, kept.Stack.Mode));
|
||
var replaced = Path.Combine(two.Store.Find(id)!.VersionsDirectory, WorkspaceProject.ReplacedFolder);
|
||
Assert.True(Directory.GetFiles(replaced).Select(ProjectSidecars.ReadVersion).Any(v =>
|
||
ProjectSettings.FromJson(v.SettingsJson) is { Stack.Mode: StackSetting.StarTrails, Exposure.ExposureOffsetEv: 1.0 }), "the values taken over stay in a version");
|
||
}
|
||
|
||
[Test]
|
||
public async Task TakingTheLibrarysValuesOverUnsavedChangesSendsNoVersion()
|
||
{
|
||
var (fx, _, two, id, shown) = await AskedAsync(await FixtureAsync());
|
||
// Unsaved too: a setting only this side changed.
|
||
await EditAsync(two, id, s => s with { Motion = s.Motion with { TargetShutterAngle = s.Motion.TargetShutterAngle.WithManual(90) } }, fx.Ct);
|
||
var history = await fx.Home.HistoryAsync(id, null, 10, fx.Ct);
|
||
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct);
|
||
Assert.Null(settled.Status.Conflict);
|
||
Assert.Empty(two.Unpushed(id), "no version of the working state is made, so none repeating the head is sent");
|
||
Assert.Equal(WorkspaceState.Modified, settled.Status.State, "the change only this side made waits, unsaved as it was");
|
||
var working = (await two.OpenAsync(id, fx.Ct)).Working;
|
||
Assert.Equal((0.5, StackSetting.Median, 90.0), (working.Exposure.ExposureOffsetEv, working.Stack.Mode, working.Motion.TargetShutterAngle.Resolve(0)));
|
||
Assert.Equal(1.0, Assert.NotNull(settled.Kept).Exposure.ExposureOffsetEv);
|
||
Assert.Empty((await two.PushAsync(id, fx.Home, fx.Ct)).Pushed);
|
||
Assert.Equal(history.Count, (await fx.Home.HistoryAsync(id, null, 10, fx.Ct)).Count, "the library's history holds no empty version");
|
||
|
||
// The value taken over stays in a version file set aside, outside the versions to send.
|
||
var replaced = Path.Combine(two.Store.Find(id)!.VersionsDirectory, WorkspaceProject.ReplacedFolder);
|
||
Assert.Contains(Directory.GetFiles(replaced).Select(ProjectSidecars.ReadVersion), v => ProjectSettings.FromJson(v.SettingsJson).Exposure.ExposureOffsetEv == 1.0);
|
||
}
|
||
|
||
[Test]
|
||
public async Task AConflictListsTheWorkingStatesValueAndOneAnswerSettlesIt()
|
||
{
|
||
var fx = await FixtureAsync();
|
||
var (_, one) = fx.Workspace("one");
|
||
var (_, two) = fx.Workspace("two");
|
||
var id = (await fx.CheckoutAsync(one)).ProjectId;
|
||
await fx.CheckoutAsync(two, id);
|
||
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
// This side saved 0.8 as a version, then went on to 1 without saving.
|
||
await EditAsync(two, id, s => Offset(s, 0.8), fx.Ct);
|
||
await two.CommitAsync(id, "warmer", cancellationToken: fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, 1.0), fx.Ct);
|
||
|
||
var shown = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
|
||
var difference = shown.Differences.Single();
|
||
Assert.Equal(("exposure.exposureOffsetEv", 1.0, 0.5), (difference.Path, Number(difference.Mine), Number(difference.Theirs)),
|
||
"this side's value is the one the editor shows");
|
||
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct);
|
||
Assert.Null(settled.Status.Conflict, "one answer settles what was shown");
|
||
Assert.Equal(0.5, (await two.OpenAsync(id, fx.Ct)).Working.Exposure.ExposureOffsetEv);
|
||
Assert.Equal(1.0, Assert.NotNull(settled.Kept).Exposure.ExposureOffsetEv);
|
||
Assert.Equal("warmer", two.Unpushed(id).Single().Note, "the saved version is replayed, nothing more");
|
||
}
|
||
|
||
[Test]
|
||
public async Task KeepMineKeepsTheWorkingStatesValueItListed()
|
||
{
|
||
var fx = await FixtureAsync();
|
||
var (_, one) = fx.Workspace("one");
|
||
var (_, two) = fx.Workspace("two");
|
||
var id = (await fx.CheckoutAsync(one)).ProjectId;
|
||
await fx.CheckoutAsync(two, id);
|
||
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, 0.8), fx.Ct);
|
||
await two.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, 1.0), fx.Ct);
|
||
|
||
var shown = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: shown, cancellationToken: fx.Ct);
|
||
Assert.Null(settled.Status.Conflict);
|
||
Assert.Equal(1.0, (await two.OpenAsync(id, fx.Ct)).Working.Exposure.ExposureOffsetEv, "the value listed as this side's is kept");
|
||
}
|
||
|
||
[Test]
|
||
public async Task AWorkingStateBackAtTheBaseValueIsListedAndKeptAsItIs()
|
||
{
|
||
var fx = await FixtureAsync();
|
||
var (_, one) = fx.Workspace("one");
|
||
var (_, two) = fx.Workspace("two");
|
||
var id = (await fx.CheckoutAsync(one)).ProjectId;
|
||
await fx.CheckoutAsync(two, id);
|
||
var basis = (await two.OpenAsync(id, fx.Ct)).Working.Exposure.ExposureOffsetEv;
|
||
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
// This side saved 0.8 as a version, then went back to the base value without saving.
|
||
await EditAsync(two, id, s => Offset(s, 0.8), fx.Ct);
|
||
await two.CommitAsync(id, "warmer", cancellationToken: fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, basis), fx.Ct);
|
||
|
||
var shown = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
|
||
var difference = shown.Differences.Single();
|
||
Assert.Equal(("exposure.exposureOffsetEv", basis, 0.5), (difference.Path, Number(difference.Mine) ?? 0, Number(difference.Theirs)),
|
||
"this side's value is the working state's, not the version's 0.8");
|
||
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: shown, cancellationToken: fx.Ct);
|
||
Assert.Null(settled.Status.Conflict, "one answer settles what was shown");
|
||
Assert.Equal(basis, (await two.OpenAsync(id, fx.Ct)).Working.Exposure.ExposureOffsetEv, "the value listed as this side's is the one kept");
|
||
Assert.True(settled.Status.Modified, "the saved version keeps its own value; the working state's is not saved yet");
|
||
Assert.Equal("warmer", two.Unpushed(id).Single().Note);
|
||
await two.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await two.PushAsync(id, fx.Home, fx.Ct);
|
||
Assert.Equal(basis, ProjectSettings.FromJson((await fx.Home.HeadAsync(id, fx.Ct)).SettingsJson).Exposure.ExposureOffsetEv, "the library ends with the value kept");
|
||
}
|
||
|
||
[Test]
|
||
public async Task AWorkingStateHoldingTheLibrarysValueIsNoConflictAndItsVersionAgrees()
|
||
{
|
||
var fx = await FixtureAsync();
|
||
var (_, one) = fx.Workspace("one");
|
||
var (_, two) = fx.Workspace("two");
|
||
var id = (await fx.CheckoutAsync(one)).ProjectId;
|
||
await fx.CheckoutAsync(two, id);
|
||
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
// This side saved 0.8 and a stack as a version, then set the offset to the library's own 0.5 without saving.
|
||
await EditAsync(two, id, s => Stack(Offset(s, 0.8), StackSetting.Mean), fx.Ct);
|
||
await two.CommitAsync(id, "local", cancellationToken: fx.Ct);
|
||
await EditAsync(two, id, s => Offset(s, 0.5), fx.Ct);
|
||
|
||
var pulled = await two.PullAsync(id, fx.Home, fx.Ct);
|
||
Assert.Null(pulled.Status.Conflict, "nothing to choose: the working state holds the library's value");
|
||
var working = (await two.OpenAsync(id, fx.Ct)).Working;
|
||
Assert.Equal((0.5, StackSetting.Mean), (working.Exposure.ExposureOffsetEv, working.Stack.Mode), "the working state is unchanged");
|
||
var replayed = ProjectSettings.FromJson(two.Unpushed(id).Single().SettingsJson);
|
||
Assert.Equal((0.5, StackSetting.Mean), (replayed.Exposure.ExposureOffsetEv, replayed.Stack.Mode), "the replayed version agrees with the working state");
|
||
Assert.True(pulled.Status is { State: WorkspaceState.Ahead, Modified: false }, "nothing left unsaved");
|
||
await two.PushAsync(id, fx.Home, fx.Ct);
|
||
var head = ProjectSettings.FromJson((await fx.Home.HeadAsync(id, fx.Ct)).SettingsJson);
|
||
Assert.Equal((0.5, StackSetting.Mean), (head.Exposure.ExposureOffsetEv, head.Stack.Mode));
|
||
}
|
||
|
||
private static double? Number(string? json) => json is null ? null : double.Parse(json, System.Globalization.CultureInfo.InvariantCulture);
|
||
|
||
[Test]
|
||
public async Task KeepMineIsAskedAgainWhenTheLibraryMovedOnASettingThisSideChanged()
|
||
{
|
||
var (fx, one, two, id, shown) = await AskedAsync(await FixtureAsync());
|
||
await EditAsync(two, id, s => s with { Motion = s.Motion with { TargetShutterAngle = s.Motion.TargetShutterAngle.WithManual(90) } }, fx.Ct);
|
||
|
||
// Meanwhile the other workspace sends a change of that same setting.
|
||
await one.PullAsync(id, fx.Home, fx.Ct);
|
||
await EditAsync(one, id, s => s with { Motion = s.Motion with { TargetShutterAngle = s.Motion.TargetShutterAngle.WithManual(270) } }, fx.Ct);
|
||
await one.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await one.PushAsync(id, fx.Home, fx.Ct);
|
||
|
||
var asked = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: shown, cancellationToken: fx.Ct);
|
||
var again = Assert.NotNull(asked.Status.Conflict, "the library's newer change is asked about, not overwritten");
|
||
Assert.Equal(2, again.Differences.Count);
|
||
Assert.Contains(again.Differences, d => d.Path.StartsWith("motion.targetShutterAngle", StringComparison.Ordinal));
|
||
Assert.Equal(270.0, ProjectSettings.FromJson((await fx.Home.HeadAsync(id, fx.Ct)).SettingsJson).Motion.TargetShutterAngle.Resolve(0));
|
||
|
||
var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: again, cancellationToken: fx.Ct);
|
||
Assert.Equal(WorkspaceState.Modified, settled.Status.State, "this side's values are the working state, on the library's head");
|
||
Assert.Null(settled.Kept, "keeping mine replaces nothing of this side's");
|
||
await two.CommitAsync(id, cancellationToken: fx.Ct);
|
||
await two.PushAsync(id, fx.Home, fx.Ct);
|
||
var head = ProjectSettings.FromJson((await fx.Home.HeadAsync(id, fx.Ct)).SettingsJson);
|
||
Assert.Equal((1.0, 90.0, StackSetting.Median), (head.Exposure.ExposureOffsetEv, head.Motion.TargetShutterAngle.Resolve(0), head.Stack.Mode));
|
||
}
|
||
|
||
[Test]
|
||
public async Task SyncAsksAboutWhatDiffersNowWhileAConflictWaits()
|
||
{
|
||
var (fx, _, two, id, _) = await AskedAsync(await FixtureAsync());
|
||
|
||
// Edited during Later: the next pull lists the stack too.
|
||
await EditAsync(two, id, s => Stack(s, StackSetting.Mean), fx.Ct);
|
||
var refreshed = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
|
||
Assert.SequenceEqual(["exposure.exposureOffsetEv", "stack.mode"], refreshed.Differences.Select(d => d.Path).Order(StringComparer.Ordinal));
|
||
|
||
// This side takes the library's values by hand: nothing conflicts any more, and the pull settles it.
|
||
await EditAsync(two, id, s => Stack(Offset(s, 0.5), StackSetting.Median), fx.Ct);
|
||
var pulled = await two.PullAsync(id, fx.Home, fx.Ct);
|
||
Assert.Null(pulled.Status.Conflict);
|
||
Assert.Equal(WorkspaceState.InSync, pulled.Status.State);
|
||
Assert.Null(await two.CommitAsync(id, cancellationToken: fx.Ct), "nothing new to save, and no conflict refuses a version");
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARestoreWhileAConflictWaitsKeepsTheUnsavedChangesAsAVersion()
|
||
{
|
||
var (fx, _, two, id, _) = await AskedAsync(await FixtureAsync());
|
||
var first = (await fx.Home.HistoryAsync(id, null, 10, fx.Ct)).Single(v => v.Number == 1);
|
||
|
||
// Later, then an edit stored but saved as no version, then History › Restore.
|
||
await EditAsync(two, id, s => Stack(s, StackSetting.Mean), fx.Ct);
|
||
var restored = await two.RestoreAsync(id, first.Id, fx.Home, fx.Ct);
|
||
Assert.Equal((0.0, StackSetting.None), (restored.Exposure.ExposureOffsetEv, restored.Stack.Mode));
|
||
var kept = Assert.Contains(two.Unpushed(id), v => ProjectSettings.FromJson(v.SettingsJson) is { Stack.Mode: StackSetting.Mean, Exposure.ExposureOffsetEv: 1.0 });
|
||
Assert.Equal(ProjectVersionKind.Commit, kept.Kind);
|
||
Assert.NotNull((await two.StatusAsync(id, fx.Home, fx.Ct)).Conflict, "the conflict still waits");
|
||
|
||
// Settled for this side, the saved edit reaches the library under the restore.
|
||
var asked = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
|
||
await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: asked, cancellationToken: fx.Ct);
|
||
await two.PushAsync(id, fx.Home, fx.Ct);
|
||
Assert.Contains(await fx.Home.HistoryAsync(id, null, 10, fx.Ct), v => ProjectSettings.FromJson(v.SettingsJson).Stack.Mode == StackSetting.Mean);
|
||
}
|
||
|
||
[Test]
|
||
public async Task OnlyARestoreTheWorkingStateStillShowsMakesARestoreVersion()
|
||
{
|
||
var fx = await FixtureAsync();
|
||
var (_, sync) = fx.Workspace();
|
||
var id = (await fx.CheckoutAsync(sync)).ProjectId;
|
||
var original = await fx.Home.HeadAsync(id, fx.Ct);
|
||
await EditAsync(sync, id, s => Offset(s, 0.3), fx.Ct);
|
||
var warm = Assert.NotNull(await sync.CommitAsync(id, cancellationToken: fx.Ct));
|
||
|
||
// Restoring the version the project is changes nothing: the next version is a plain one.
|
||
await sync.RestoreAsync(id, warm.Id, fx.Home, fx.Ct);
|
||
await EditAsync(sync, id, s => Stack(s, StackSetting.Mean), fx.Ct);
|
||
var next = Assert.NotNull(await sync.CommitAsync(id, cancellationToken: fx.Ct));
|
||
Assert.Equal((ProjectVersionKind.Commit, (Guid?)null), (next.Kind, next.RestoredFrom));
|
||
|
||
// A restore taken back (the editor's Undo writes the state from before it again), then another edit: no restore either.
|
||
var before = (await sync.OpenAsync(id, fx.Ct)).Working;
|
||
await sync.RestoreAsync(id, original.Id, fx.Home, fx.Ct);
|
||
await sync.SaveAsync(id, before, fx.Ct);
|
||
await EditAsync(sync, id, s => s with { ExcludedFrames = [1] }, fx.Ct);
|
||
var after = Assert.NotNull(await sync.CommitAsync(id, cancellationToken: fx.Ct));
|
||
Assert.Equal((ProjectVersionKind.Commit, (Guid?)null), (after.Kind, after.RestoredFrom));
|
||
|
||
// A restore the working state still shows, edited further: a restore of it.
|
||
await sync.RestoreAsync(id, original.Id, fx.Home, fx.Ct);
|
||
await EditAsync(sync, id, s => s with { HeroFrame = 2 }, fx.Ct);
|
||
var restore = Assert.NotNull(await sync.CommitAsync(id, cancellationToken: fx.Ct));
|
||
Assert.Equal((ProjectVersionKind.Restore, (Guid?)original.Id), (restore.Kind, restore.RestoredFrom));
|
||
}
|
||
}
|
||
|
||
public sealed class SqliteWorkspaceConflictTests(TestContext context) : WorkspaceConflictTests(context)
|
||
{
|
||
protected override Backend Backend => Backend.SqliteFile;
|
||
}
|
||
|
||
[RequiresEnvironment(PgTestServer.Variable)]
|
||
public sealed class PostgresWorkspaceConflictTests(TestContext context) : WorkspaceConflictTests(context)
|
||
{
|
||
protected override Backend Backend => Backend.Postgres;
|
||
}
|