- A merge verify that finds a hashed photo the plan did not copy (held by a third sequence when planned) held by nothing now drops its journal and fails as a stale plan, so the retry plans again and lists the photo as a last copy instead of failing with "did not match after copying" forever. - A comparison settles no details of a pair being integrated, and the Integrate's Details stage refuses a line decided as the server's whose server value is now this PC's own, so a background push or pull no longer reverses the user's line-by-line choice (owner Q4). - A 404 for a server sequence no local copy is linked to deletes only its Candidate pairs; a Kept apart answer counts the hit as a linked pair does (two 404s GoneRecheck apart), so a moment's 404 neither re-asks nor auto-links a pair the user kept separate (owner Q1). Upload all local sends the local sequence once the deletion is confirmed. - Download originals into a local copy the server key names and that is paired with the server sequence links it first and fills it as a linked copy: its tombstones hold and its details are compared, not overwritten. - An upload of a sequence with a Candidate pair goes under a key of the job, and one that joins a server sequence this PC already knows compares its details instead of sending them all over the server's. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
536 lines
26 KiB
C#
536 lines
26 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, local.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 AMatchWhoseServerSequenceIsDeletedIsGoneAfterTheRefreshAndUploadAllSendsTheLocalOne()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var photos = f.NewPhotos(3);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = nas.Add("2026-09-28 Canon", photos);
|
|
remote.FirstCapture = local.FirstCapture;
|
|
remote.CameraModel = local.CameraModel;
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
Assert.Equal((CopyState.Candidate, local.Id), (pair.State, pair.LocalId));
|
|
Assert.Null((await f.Sync.Links.GetAsync(nas.Server, remote.Id, f.Ct))!.LocalId);
|
|
|
|
// Deleted on the server: no longer listed, and a 404 when asked for.
|
|
nas.Sequences.Remove(remote.Id);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
|
|
Assert.Null(await f.Sync.Copies.GetAsync(pair.Id, f.Ct));
|
|
var entries = (await f.Sync.ListAsync(nas.Server, f.Ct)).Where(e => e.Local?.Id == local.Id).ToList();
|
|
var (upload, skipped) = UploadAllRule.Select(entries, await f.Sync.Copies.ListAsync(f.Ct), new HashSet<Guid>(), new HashSet<Guid>());
|
|
Assert.Empty(skipped);
|
|
Assert.Equal(local.Id, upload.Single().Local!.Id);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AKeptApartServerSequenceAnswering404OnceKeepsTheAnswerAndIsNeverLinkedByItself()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
var photos = f.NewPhotos(3);
|
|
var local = await f.LocalAsync("Comet", photos);
|
|
var remote = nas.Add("2026-09-28 Canon", photos);
|
|
remote.FirstCapture = local.FirstCapture;
|
|
remote.CameraModel = local.CameraModel;
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.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));
|
|
|
|
// Moved to the server's trash and restored: one refresh gets a 404, the next lists it again.
|
|
nas.Sequences.Remove(remote.Id);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
Assert.Equal((CopyState.KeptApart, 1), ((await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.State, (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.RemoteGoneHits));
|
|
nas.Sequences[remote.Id] = remote;
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy { Linking = CopyLinking.WhenIdentical }, f.Ct);
|
|
|
|
// Keep separate is remembered (owner Q1): not asked again, and not linked although the photos are identical.
|
|
var after = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
Assert.Equal((pair.Id, CopyState.KeptApart, 0), (after.Id, after.State, after.RemoteGoneHits));
|
|
Assert.Null(await f.Sync.LinkOfAsync(nas.Server, local.Id, f.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceReadAsDeletedOnTheServerIsClearedWhenItIsListedAgainOrLinkedAgain()
|
|
{
|
|
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);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single();
|
|
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);
|
|
Assert.True((await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!.RemoteGone);
|
|
|
|
// Restored from the server's trash: listed again, it no longer reads "deleted on server".
|
|
nas.Sequences[remote.Id] = remote;
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
pair = (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!;
|
|
Assert.Equal((0, (DateTimeOffset?)null, false), (pair.RemoteGoneHits, pair.RemoteGoneAt, pair.RemoteGone));
|
|
Assert.Equal(CopyState.Candidate, pair.State);
|
|
|
|
// A pair still marked (the listing missed it) is cleared by a link to that very sequence: automatic photos may move again.
|
|
await using (var session = await f.Db.Database.OpenAsync(f.Ct))
|
|
await session.ExecuteAsync("UPDATE found_copies SET remote_gone_hits = 2, remote_gone_at = $1 WHERE id = $2", [DateTimeOffset.UtcNow, pair.Id], f.Ct);
|
|
await f.Sync.LinkAsync(nas.Server, remote.Id, local.Id, f.Ct);
|
|
pair = (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!;
|
|
Assert.Equal((0, false, CopyState.Linked), (pair.RemoteGoneHits, pair.RemoteGone, pair.State));
|
|
}
|
|
|
|
[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 ASweepOf404sConfirmsNoEarlierHitEither()
|
|
{
|
|
await using var f = await SyncFixture.CreateAsync(context);
|
|
var nas = new FakeSyncRemote { Server = HomeFolders.IdKey(Guid.NewGuid()) };
|
|
// One pair with a 404 counted more than ten minutes ago (its link already forgotten).
|
|
var first = f.NewPhotos(2);
|
|
var gone = await f.LocalAsync("Comet", first);
|
|
var goneRemote = nas.Add("Comet", first);
|
|
await f.Sync.LinkAsync(nas.Server, goneRemote.Id, gone.Id, f.Ct);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
nas.Sequences.Remove(goneRemote.Id);
|
|
await f.Sync.RefreshAsync(nas, new SyncPolicy(), f.Ct);
|
|
var pair = (await f.Sync.Copies.ListByServerAsync(nas.Server, f.Ct)).Single(p => p.LocalId == gone.Id);
|
|
Assert.Equal(1, pair.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);
|
|
|
|
// Then the server serves something else: every linked sequence answers 404 at once.
|
|
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);
|
|
|
|
pair = (await f.Sync.Copies.GetAsync(pair.Id, f.Ct))!;
|
|
Assert.Equal(1, pair.RemoteGoneHits);
|
|
Assert.False(pair.RemoteGone);
|
|
}
|
|
|
|
[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));
|
|
}
|
|
}
|