feat(copies): detection and sync integration (owner review 6, P1b)

A refresh no longer links copies by content behind the user's back. After the
gate is released, CopyFinder looks for copies whose ids differ: the server's
photo lookup (or 1.1's gate and the hints on an older server), session keys,
and an exact comparison by manifest, bounded per refresh and remembered in
copy_probes so nothing is compared twice while neither side moves. What a pair
becomes is the Link matches setting's call: asked by default, linked by itself
only as the setting allows, through a compare-and-set that a Keep apart wins.
Local detection finds copies inside this PC's archives and never links them.

SyncService gives every link its pair, adds Unlink (kept apart, observation
kept), marks pairs whose server sequence answers 404 (once per refresh, twice
reads deleted, never on an address key or in a 404 sweep), keeps deletion
counts current at each comparison, writes an Integrate's agreed details to both
sides by content (ApplyAgreedAsync) and queues uploads at a given priority.
CopyReviewBuilder assembles what the Compare dialog shows.

Refs #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-17 10:25:25 +01:00
1 parent 9912baf78a
commit ade908cb6d
11 files changed
+2035 -89

No files matched your search

@@ -0,0 +1,341 @@
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 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));
}
}