- A merge leaves each second version out of Main as it files it (Copy stage keep-both and SameUnhashed versions, Verify stage versions), so a merge abandoned before its Details stage (details changed meanwhile, a stale stage, a cancel) no longer leaves both versions in Main for good, which a new plan could not undo (owner Q3). - A merge plan whose kept sequence has tombstones hashes the other's unhashed frames matched by size and time, so content the kept sequence deleted is listed as a last copy; a verify that still finds such content drops the journal and fails as a stale plan instead of failing on every retry. - Download originals uses a key of the job only when the holder of the server sequence's key is kept apart from it or linked elsewhere: a link a 404 forgot (pair Candidate) refills and re-links the local copy instead of duplicating every photo into a new sequence. - A 404 for a server sequence no local copy is linked to deletes its Candidate and Kept apart pairs, so Upload all local sends the local sequence again instead of skipping the only copy as a suspected one (owner Q8). Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
508 lines
25 KiB
C#
508 lines
25 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 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));
|
|
}
|
|
}
|