Files
Chronos/tests/Chronos.Data.Tests/Sync/SyncServiceCopyTests.cs
T
Alby96andClaude Opus 5.5 fe752a0a21 fix(copies): address the owner review 6 findings
The review of the found-copies work showed pairs that could stick, jobs that
could act on a pair the user had answered otherwise, and detection gaps:

- forgetting a link on an address-keyed server deletes the pair and Candidate
  rows of that remote and resets the probe, so the sequence is found again
  when it is back; a Linked/Integrated row with no link is asked again
- 404s count only on id-keyed servers, at most once per recheck interval
- probes store the server's newest update time (copy_probes.server_newest,
  migration 0012) instead of comparing with this PC's clock; the lookup
  sample carries hashed photos by size and capture time too, for servers
  that have not hashed their copy
- the older-server gate no longer re-compares unchanged manifests
- a failed Integrate keeps its job id so a retry resumes only an untouched
  pair; cancel and stale plans release the pair (ReleaseAsync)
- automatic photo transfers never create or retarget a sequence
- a first upload files photos the server holds elsewhere into the new
  sequence
- Unlink re-compares before keeping apart; Trash here names only true last
  copies; Drop... trashes one version on both sides after re-checking the
  other
- a merge keeping the pair's other sequence swaps the dialog's columns and
  re-keys Different choices; Upload all reads every pair

Each fix has a regression test where it makes sense.

Refs #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 13:12:00 +01:00

387 lines
18 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 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);
}
[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));
}
}