A merge could still trash photos it never verified, resume against a pair the user had answered meanwhile, and take different unhashed photos for copies; the dialog and the lists worded several facts wrongly or lost them on refresh. - Merge: a retry resumes only while the pair is still the job's; Verify requires the other archive online and its folder in place, stops on an unreadable photo, files a differing unhashed photo as a second version and must cover every frame before Trash; the plan hashes unmatched unhashed photos first, lists "Deleted in the other" and names the relinked servers; second versions stay discoverable (CopySides.VersionsAsync). - Integrate: a retry after a failure before the journal runs again. - Sync: a sequence back after a 404 stays Linked while its link holds; a local cull no longer asks for attention. - Block lines of both planners name the right sequence, archive, server and space through one formatter. - Compare dialog: one Details row per setting with worded values, Projects headings, Choose focuses the kept-sequence radios, the photo selection reaches rows outside the viewport, the Replace confirmation lists the losers per side, plan lines read as queued. - Matches and Library: counts first and grouped, integrating shown as a share, local matches name the other archive, the Library keeps its match and "deleted on server" statuses across a refresh. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
412 lines
19 KiB
C#
412 lines
19 KiB
C#
using Chronos.Core.IO;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Core.Project;
|
|
using Chronos.Data.Copies;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Protocol;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Sync;
|
|
|
|
/// <summary>
|
|
/// Sync with found copies (owner review 6, #73): no silent link, links by setting outside the gate, unlink, 404 marks,
|
|
/// deletion counts and the agreed details of an Integrate.
|
|
/// </summary>
|
|
[Category("sync")]
|
|
public sealed class SyncServiceCopyTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public async Task ARefreshLinksNothingByDefaultAndAsks()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var photos = f.NewPhotos(3);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("2026-09-28 Canon", photos);
|
|
remote.FirstCapture = local.FirstCapture;
|
|
remote.CameraModel = local.CameraModel;
|
|
var raised = new List<CopyFindResult>();
|
|
f.Sync.CopiesFound += (_, result) => raised.Add(result);
|
|
|
|
await f.RefreshAsync();
|
|
|
|
Assert.Null((await f.EntryAsync("Comet")).Link);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal(CopyState.Candidate, pair.State);
|
|
Assert.Equal((local.Id, remote.Id), (pair.LocalId, pair.RemoteId!.Value));
|
|
Assert.Equal(CopyEvidence.Hashes, pair.Evidence);
|
|
Assert.Equal(3, pair.Score.Shared);
|
|
Assert.Equal(pair.Id, raised.Single().New.Single().Id);
|
|
Assert.Empty(raised.Single().AutoLinked);
|
|
|
|
// Nothing moved: nothing is compared or announced again.
|
|
var manifests = f.Remote.ManifestCalls;
|
|
await f.RefreshAsync();
|
|
Assert.Equal(manifests, f.Remote.ManifestCalls);
|
|
Assert.Count(1, raised);
|
|
}
|
|
|
|
[Test]
|
|
public async Task IdenticalCopiesAreLinkedByThemselvesWhenTheSettingSaysSo()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
f.Remote.Capabilities.Add(ServerCapabilities.PhotoLookup);
|
|
var photos = f.NewPhotos(3);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
var raised = new List<CopyFindResult>();
|
|
f.Sync.CopiesFound += (_, result) => raised.Add(result);
|
|
|
|
await f.RefreshAsync(new SyncPolicy { Linking = CopyLinking.WhenIdentical });
|
|
|
|
var entry = await f.EntryAsync("Comet");
|
|
Assert.Equal(remote.Id, entry.Link?.RemoteId);
|
|
Assert.Equal(SyncStatus.InSync, entry.Status);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal(CopyState.Linked, pair.State);
|
|
Assert.Equal(pair.Id, raised.Single().AutoLinked.Single().Id);
|
|
Assert.Equal(local.Id, pair.LocalId);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AKeepApartAnsweredMeanwhileWinsOverTheLink()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
remote.FirstCapture = local.FirstCapture;
|
|
remote.CameraModel = local.CameraModel;
|
|
await f.RefreshAsync();
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.True(await f.Sync.Copies.SetStateAsync(pair.Id, CopyState.Candidate, CopyState.KeptApart,
|
|
new CopyAnswer(pair.Fingerprint, pair.Score.Shared, null, false, DateTimeOffset.UtcNow), f.Ct));
|
|
|
|
var linked = await f.Sync.AutoLinkAsync(f.Remote, new SyncPolicy { Linking = CopyLinking.WhenIdentical }, pair, remote.Dto(), local, null, f.Ct);
|
|
|
|
Assert.False(linked);
|
|
Assert.Null(await f.Sync.LinkOfAsync(f.Server, local.Id, f.Ct));
|
|
Assert.Equal(CopyState.KeptApart, (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.State);
|
|
}
|
|
|
|
[Test]
|
|
public async Task EveryLinkHasItsPair()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var local = await f.LocalAsync("Comet", f.NewPhotos(2));
|
|
var remote = f.Remote.Add("Harbour", f.NewPhotos(1));
|
|
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal((CopyEvidence.Link, CopyState.Linked), (pair.Evidence, pair.State));
|
|
Assert.Equal((local.Id, remote.Id), (pair.LocalId, pair.RemoteId!.Value));
|
|
Assert.False(pair.IsListed);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnUploadForAnIntegratedPairCanWaitInTheBackground()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var local = await f.LocalAsync("Comet", f.NewPhotos(1));
|
|
await using var engine = new JobEngine(f.Db, f.Sync.CreateJobHandlers(new SyncFixture.Connector(f.Remote)));
|
|
|
|
var background = await f.Sync.EnqueueUploadAsync(engine, f.Server, local, JobPriority.Background, f.Ct);
|
|
Assert.Equal(JobPriority.Background, background.Priority);
|
|
Assert.Equal(SyncTransferKind.Upload, SyncService.TransferKind(background));
|
|
}
|
|
|
|
[Test]
|
|
public async Task UnlinkKeepsTheServerSequenceAndKeepsThePairApart()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
await f.RefreshAsync();
|
|
Assert.Equal(SyncStatus.InSync, (await f.EntryAsync("Comet")).Status);
|
|
|
|
await f.Sync.UnlinkAsync(f.Server, remote.Id, f.Ct);
|
|
|
|
var link = await f.Sync.Links.GetAsync(f.Server, remote.Id, f.Ct);
|
|
Assert.NotNull(link);
|
|
Assert.Null(link.LocalId);
|
|
Assert.Null(await f.Sync.LinkOfAsync(f.Server, local.Id, f.Ct));
|
|
Assert.Equal(SyncState.LocalOnly, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SyncState);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal(CopyState.KeptApart, pair.State);
|
|
Assert.Equal(2, pair.AnsweredShared);
|
|
|
|
// Asked again only by a large later change: the next refresh leaves the two apart.
|
|
await f.RefreshAsync(new SyncPolicy { Linking = CopyLinking.WhenHalfShared });
|
|
Assert.Null((await f.Sync.ListAsync(f.Server, f.Ct)).Single(e => e.Local?.Id == local.Id).Link);
|
|
Assert.Equal(CopyState.KeptApart, (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.State);
|
|
}
|
|
|
|
[Test]
|
|
public async Task A404IsCountedOncePerRefreshAndTwiceReadsDeleted()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = nas.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(nas.Server, remote.Id, local.Id, f.Ct);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
nas.Sequences.Remove(remote.Id);
|
|
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
Assert.Null(await f.Sync.LinkOfAsync(nas.Server, local.Id, f.Ct));
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
Assert.Equal(1, pair.RemoteGoneHits);
|
|
Assert.False(pair.RemoteGone);
|
|
|
|
// Asked again no sooner than ten minutes after the first 404.
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
Assert.Equal(1, (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.RemoteGoneHits);
|
|
await using (var session = await f.Db.Database.OpenAsync(f.Ct))
|
|
await session.ExecuteAsync("UPDATE found_copies SET remote_gone_at = $1 WHERE id = $2", [DateTimeOffset.UtcNow.AddMinutes(-11), pair.Id], f.Ct);
|
|
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
pair = (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!;
|
|
Assert.Equal(2, pair.RemoteGoneHits);
|
|
Assert.True(pair.RemoteGone);
|
|
Assert.True(pair.NeedsAttention);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceBackOnTheServerIsAskedAboutAgain()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = nas.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(nas.Server, remote.Id, local.Id, f.Ct);
|
|
nas.Unlisted.Add(remote.Id);
|
|
nas.Sequences.Remove(remote.Id);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
Assert.Equal(1, (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single().RemoteGoneHits);
|
|
|
|
nas.Sequences[remote.Id] = remote;
|
|
nas.Unlisted.Remove(remote.Id);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
Assert.Equal(0, pair.RemoteGoneHits);
|
|
Assert.Null(pair.RemoteGoneAt);
|
|
Assert.Equal(CopyState.Candidate, pair.State);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceBackAfterAJobs404StaysLinked()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = nas.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(nas.Server, remote.Id, local.Id, f.Ct);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
// A transfer's 404: the pair is marked once, the link stays.
|
|
await f.Sync.Copies.MarkRemoteGoneAsync(nas.Server, remote.Id, local.Id, Guid.NewGuid(), DateTimeOffset.UtcNow, f.Ct);
|
|
Assert.Equal(1, (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single().RemoteGoneHits);
|
|
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
Assert.Equal((0, CopyState.Linked), (pair.RemoteGoneHits, pair.State));
|
|
Assert.Equal(local.Id, (await f.Sync.LinkOfAsync(nas.Server, local.Id, f.Ct))?.LocalId);
|
|
}
|
|
|
|
[Test]
|
|
public async Task EveryLinkAnswering404AtOnceMarksNothing()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var remotes = new List<FakeSequence>();
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
var photos = f.NewPhotos(1);
|
|
var local = await f.LocalAsync($"Card {i}", photos);
|
|
var remote = nas.Add($"Card {i}", photos);
|
|
await f.Sync.LinkAsync(nas.Server, remote.Id, local.Id, f.Ct);
|
|
remotes.Add(remote);
|
|
}
|
|
foreach (var remote in remotes) nas.Sequences.Remove(remote.Id);
|
|
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
Assert.Empty(await f.Sync.Links.ListAsync(nas.Server, f.Ct));
|
|
Assert.True((await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).All(p => p.RemoteGoneHits == 0));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AServerKnownOnlyByItsAddressMarksNothing()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
f.Remote.Sequences.Remove(remote.Id);
|
|
|
|
await f.RefreshAsync();
|
|
|
|
Assert.Null(await f.Sync.LinkOfAsync(f.Server, local.Id, f.Ct));
|
|
Assert.True((await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).All(p => p.RemoteGoneHits == 0));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceForgottenOnAServerKnownByItsAddressIsFoundAgainWhenItIsBack()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
f.Remote.Capabilities.Add(ServerCapabilities.PhotoLookup);
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
await f.RefreshAsync();
|
|
f.Remote.Sequences.Remove(remote.Id);
|
|
await f.RefreshAsync();
|
|
Assert.Null(await f.Sync.LinkOfAsync(f.Server, local.Id, f.Ct));
|
|
|
|
// Back on the server: nothing remembers the forgotten link, so the two are found and asked about again.
|
|
f.Remote.Sequences[remote.Id] = remote;
|
|
await f.RefreshAsync();
|
|
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal((local.Id, remote.Id, CopyState.Candidate), (pair.LocalId, pair.RemoteId!.Value, pair.State));
|
|
Assert.Null(await f.Sync.LinkOfAsync(f.Server, local.Id, f.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ALinkedPairWhoseLinkIsGoneIsAskedAboutAgain()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
f.Remote.Capabilities.Add(ServerCapabilities.PhotoLookup);
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
await f.RefreshAsync();
|
|
// The link removed by another hand, the pair's row left as it was.
|
|
await f.Sync.Links.DeleteAsync(f.Server, remote.Id, f.Ct);
|
|
var raised = new List<CopyFindResult>();
|
|
f.Sync.CopiesFound += (_, result) => raised.Add(result);
|
|
|
|
await f.RefreshAsync();
|
|
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal((CopyState.Candidate, false), (pair.State, pair.AutoPhotos));
|
|
Assert.Contains(pair.Id, raised.SelectMany(r => r.New).Select(p => p.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeletionCountsFollowEachComparison()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var photos = f.NewPhotos(3);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = f.Remote.Add("Comet", photos);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
await f.RefreshAsync();
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(f.Server, f.Ct)).Single();
|
|
Assert.Equal((3, 0, 0), (pair.Score.Shared, pair.Score.DeletedHere, pair.Score.DeletedThere));
|
|
|
|
// The server deletes a photo this PC still holds.
|
|
var gone = remote.Frames[1];
|
|
remote.Frames.Remove(gone);
|
|
remote.FramesVersion++;
|
|
remote.Removed.Add(new RemovedPhotoDto(gone.Sha256, null, "deleted", DateTimeOffset.UtcNow));
|
|
await f.RefreshAsync();
|
|
|
|
pair = (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!;
|
|
Assert.Equal((0, 1), (pair.Score.DeletedHere, pair.Score.DeletedThere));
|
|
Assert.True(pair.IsListed);
|
|
Assert.True(pair.NeedsAttention);
|
|
|
|
// A photo deleted on this PC only: counted, never a warning (the user's own cull).
|
|
var culled = pair with { Score = pair.Score with { DeletedHere = 2, DeletedThere = 0 } };
|
|
Assert.False(culled.NeedsAttention);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AgreedDetailsTakeTheServersOwnChangeSinceThePlan()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var (local, remote, planLocal, planRemote) = await PlannedAsync(f);
|
|
var final = planLocal with { Title = "Comet agreed" };
|
|
// The server's light analysis of the photos just filed changes its settings after the plan.
|
|
f.Remote.EditSettings(remote.Id, SyncFixture.Window41);
|
|
|
|
var (applied, updated) = await f.Sync.ApplyAgreedAsync(f.Remote, remote.Id, final, planLocal, planRemote, local.SettingsVersion, f.Ct);
|
|
|
|
Assert.Equal("Comet agreed", remote.Title);
|
|
Assert.True(SyncRules.SameSettings(SyncFixture.Window41, remote.SettingsJson));
|
|
var stored = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!;
|
|
Assert.Equal("Comet agreed", stored.Title);
|
|
Assert.True(SyncRules.SameSettings(SyncFixture.Window41, stored.SettingsJson));
|
|
Assert.Equal((stored.SettingsVersion, remote.SettingsVersion), (applied.SettingsVersion, updated.SettingsVersion));
|
|
var link = (await f.Sync.Links.GetAsync(f.Server, remote.Id, f.Ct))!;
|
|
Assert.Equal((stored.SettingsVersion, remote.SettingsVersion), (link.BaseLocalSettings, link.BaseRemoteSettings));
|
|
Assert.Count(1, f.Remote.Updates);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AgreedDetailsAreSentAgainAfterARefusedEdit()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var (local, remote, planLocal, planRemote) = await PlannedAsync(f);
|
|
var final = planLocal with { Title = "Comet agreed" };
|
|
// Unhashed on the server: its frames are read after the manifest, and the server changes right then.
|
|
remote.Unhashed = true;
|
|
f.Remote.OnceBeforeFrames = () =>
|
|
{
|
|
f.Remote.EditSettings(remote.Id, SyncFixture.Window41);
|
|
return Task.CompletedTask;
|
|
};
|
|
|
|
await f.Sync.ApplyAgreedAsync(f.Remote, remote.Id, final, planLocal, planRemote, local.SettingsVersion, f.Ct);
|
|
|
|
Assert.Equal("Comet agreed", remote.Title);
|
|
Assert.True(SyncRules.SameSettings(SyncFixture.Window41, remote.SettingsJson));
|
|
Assert.Equal("Comet agreed", (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.Title);
|
|
Assert.Count(1, f.Remote.Updates);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AgreedDetailsAreRefusedAfterAnEditOnThisPc()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var (local, remote, planLocal, planRemote) = await PlannedAsync(f);
|
|
var final = planLocal with { Title = "Comet agreed" };
|
|
var edited = await f.EditLocalSettingsAsync(local.Id, SyncFixture.Window41);
|
|
|
|
await Assert.ThrowsAsync<SyncConflictChangedException>(() =>
|
|
f.Sync.ApplyAgreedAsync(f.Remote, remote.Id, final, planLocal, planRemote, local.SettingsVersion, f.Ct));
|
|
// Shown at the new version, the content still moved since the plan.
|
|
await Assert.ThrowsAsync<SyncConflictChangedException>(() =>
|
|
f.Sync.ApplyAgreedAsync(f.Remote, remote.Id, final, planLocal, planRemote, edited.SettingsVersion, f.Ct));
|
|
|
|
Assert.Empty(f.Remote.Updates);
|
|
Assert.Equal("Comet", remote.Title);
|
|
Assert.True(SyncRules.SameSettings(SyncFixture.Window41, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson));
|
|
}
|
|
|
|
/// <summary>A linked pair with the same settings on both sides, and each side's portable payload as an Integrate's plan reads it.</summary>
|
|
private static async Task<(Sequence Local, FakeSequence Remote, SyncPayload PlanLocal, SyncPayload PlanRemote)> PlannedAsync(SyncFixture f)
|
|
{
|
|
var photos = f.NewPhotos(2);
|
|
var local = await f.LocalAsync("Comet", photos, SyncFixture.Window33);
|
|
var remote = f.Remote.Add("Comet", photos, SyncFixture.Window33);
|
|
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
|
local = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!;
|
|
var none = new FramePhotos([]);
|
|
return (local, remote, CopyPayload.Portable(SyncPayload.Of(local), none), CopyPayload.Portable(SyncPayload.Of(remote.Dto(), remote.SettingsJson), none));
|
|
}
|
|
}
|