using Chronos.Core.Project; using Chronos.Data.Copies; using Chronos.Testing; namespace Chronos.Data.Tests.Copies; /// The detection rules (owner review 6, Q1; design §3.1, §3.2, §3.6): pairs, the Link matches setting, 1.1's gate, asking again. [Category("sync")] public sealed class CopyRulesTests { private static readonly DateTime First = new(2026, 9, 28, 18, 0, 0, 400); private static CopyScore Identical(int shared = 10, int unhashed = 0) => CopyScore.None with { Shared = shared, SharedUnhashed = unhashed, LocalPhotos = shared + unhashed, OtherPhotos = shared + unhashed, Containment = 1000, Overlap = 1000 }; private static CopyScore Partial(int shared, int onlyHere) => CopyScore.None with { Shared = shared, OnlyHere = onlyHere, LocalPhotos = shared + onlyHere, OtherPhotos = shared, Containment = 1000 }; /// 1.1's gate passing: both unlinked, same second, same camera, half of 10 shared. private static SameOriginalsInput Gate(int shared = 5) => new(true, First, First.AddMilliseconds(300), "EOS R5", "eos r5", 10, 10, shared); private static readonly SameOriginalsInput Closed = new(false, null, null, null, null, 0, 0, 0); private static FoundCopy KeptApart(int answeredShared, string? fingerprint = null) => new() { Id = Guid.NewGuid(), Kind = CopyKind.LocalServer, LocalId = Guid.NewGuid(), Server = "https://nas.test:8443", RemoteId = Guid.NewGuid(), Evidence = CopyEvidence.Hashes, State = CopyState.KeptApart, Score = Partial(answeredShared, 5), Fingerprint = "f", AnsweredShared = answeredShared, AnsweredFingerprint = fingerprint, }; [Test] public void APairNeedsALinkASessionKeyOrEnoughShared() { Assert.True(CopyRules.IsCopy(CopyEvidence.Link, CopyScore.None)); Assert.True(CopyRules.IsCopy(CopyEvidence.SessionKey, CopyScore.None)); Assert.False(CopyRules.IsCopy(CopyEvidence.Hashes, CopyScore.None)); Assert.True(CopyRules.IsCopy(CopyEvidence.Hashes, CopyScore.None with { Shared = 1, Containment = 100 })); Assert.False(CopyRules.IsCopy(CopyEvidence.Hashes, CopyScore.None with { Shared = 1, Containment = 99 })); // Tombstoned content is evidence too. Assert.True(CopyRules.IsCopy(CopyEvidence.Hashes, CopyScore.None with { SharedRemoved = 3, Containment = 300 })); Assert.True(CopyRules.IsCopy(CopyEvidence.SizeAndTime, CopyScore.None with { SharedUnhashed = 2, Containment = 1000 })); } [Test] public void AskAlwaysNeverLinks() { Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.AskAlways, CopyKind.LocalServer, Identical(), Gate())); Assert.Equal(CopyDecision.None, CopyRules.Decide(CopyLinking.AskAlways, CopyKind.LocalServer, CopyScore.None, Gate())); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.AskAlways, CopyKind.LocalServer, CopyScore.None, Closed, CopyEvidence.SessionKey)); } [Test] public void WhenIdenticalLinksOnlyTheSamePhotosKnownByHash() { Assert.Equal(CopyDecision.Link, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Identical(), Closed)); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Partial(10, 1), Gate())); // A size and time identity always asks. Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Identical(8, 2), Closed)); // Photos deleted on one side only are no identity. Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Identical() with { DeletedThere = 1, SharedRemoved = 1 }, Closed)); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Identical() with { DeletedHere = 1, SharedRemoved = 1 }, Closed)); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenIdentical, CopyKind.LocalServer, Identical() with { Differs = 1 }, Closed)); } [Test] public void IdenticalNeedsNothingDeletedOnOneSide() { Assert.True(Identical().Identical); Assert.False((Identical() with { DeletedHere = 1 }).Identical); Assert.False((Identical() with { DeletedThere = 1 }).Identical); Assert.False(CopyScore.None.Identical); } [Test] public void WhenHalfSharedKeeps11sGates() { Assert.Equal(CopyDecision.Link, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(5, 5), Gate())); // A different first-capture second, or another camera: asked. var otherSecond = Gate() with { RemoteFirst = First.AddSeconds(1) }; Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(5, 5), otherSecond)); var otherCamera = Gate() with { RemoteCamera = "EOS R6" }; Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(5, 5), otherCamera)); // Fewer than half of the smaller side, nothing hashed here, or a side linked already: asked. Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(4, 6), Gate(4))); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(5, 5), Gate() with { LocalHashed = 0 })); Assert.Equal(CopyDecision.Ask, CopyRules.Decide(CopyLinking.WhenHalfShared, CopyKind.LocalServer, Partial(5, 5), Gate() with { BothUnlinked = false })); } [Test] public void SameOriginalsIsThe11Rule() { Assert.True(CopyRules.SameOriginals(Gate())); // Half of the smaller side: 3 of a 6-frame server sequence is enough against 10 local hashes. Assert.True(CopyRules.SameOriginals(Gate(3) with { RemoteFrames = 6 })); Assert.False(CopyRules.SameOriginals(Gate(0) with { RemoteFrames = 0 })); Assert.False(CopyRules.SameOriginals(Gate() with { LocalFirst = null })); // Both without a camera model count as equal, as in 1.1. Assert.True(CopyRules.SameOriginals(Gate() with { LocalCamera = null, RemoteCamera = null })); } [Test] public void ALocalPairIsNeverLinkedByItself() { foreach (var linking in Enum.GetValues()) Assert.Equal(CopyDecision.Ask, CopyRules.Decide(linking, CopyKind.LocalLocal, Identical(), Gate())); } [Test] public void AKeptApartPairAsksAgainOnlyWhenItGrewALotOrBecameIdentical() { // Ten more shared photos at least, and a quarter of the answered count. Assert.False(CopyRules.AsksAgain(KeptApart(20), Partial(29, 5))); Assert.True(CopyRules.AsksAgain(KeptApart(20), Partial(30, 5))); Assert.False(CopyRules.AsksAgain(KeptApart(100), Partial(124, 5))); Assert.True(CopyRules.AsksAgain(KeptApart(100), Partial(125, 5))); // Identical now, and not when answered. Assert.True(CopyRules.AsksAgain(KeptApart(20, CopyRules.Fingerprint(Partial(20, 5), 1, 1)), Identical(20))); // Kept apart while identical: an identity is no news. Assert.False(CopyRules.AsksAgain(KeptApart(20, CopyRules.Fingerprint(Identical(20), 1, 1)), Identical(20))); // Only kept-apart pairs ask again. Assert.False(CopyRules.AsksAgain(KeptApart(20) with { State = CopyState.Linked }, Partial(90, 5))); } [Test] public void FingerprintsFollowTheScoreAndTheVersions() { var a = CopyRules.Fingerprint(Partial(5, 5), 3, 4); Assert.Equal(a, CopyRules.Fingerprint(Partial(5, 5), 3, 4)); Assert.NotEqual(a, CopyRules.Fingerprint(Partial(5, 5), 3, 5)); Assert.NotEqual(a, CopyRules.Fingerprint(Partial(6, 5), 3, 4)); var plan = CopyRules.PlanFingerprint(["send a", "fetch b"]); Assert.Equal(64, plan.Length); Assert.Equal(plan, CopyRules.PlanFingerprint(["send a", "fetch b"])); Assert.NotEqual(plan, CopyRules.PlanFingerprint(["fetch b", "send a"])); Assert.Equal("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", CopyRules.PlanFingerprint([])); } [Test] public void AProbeIsEvenlySpacedWithTheFirstAndTheLast() { var photos = Enumerable.Range(0, 1000).Select(i => new FramePhoto(i.ToString("x64"), i, null)).ToList(); var probe = CopyRules.Probe(photos); Assert.Count(64, probe); Assert.Same(photos[0], probe[0]); Assert.Same(photos[^1], probe[^1]); Assert.Count(64, probe.Distinct()); var gaps = probe.Zip(probe.Skip(1), (a, b) => b.Size - a.Size).ToList(); Assert.InRange(gaps.Min(), 15, 16); Assert.InRange(gaps.Max(), 15, 16); Assert.Count(10, CopyRules.Probe(photos.Take(10).ToList())); Assert.SequenceEqual([photos[0], photos[999]], CopyRules.Probe(photos, 2)); Assert.Empty(CopyRules.Probe([])); } [Test] public void HintsScoreRangeCameraIntervalAndTitle() { var start = new DateTime(2026, 9, 28, 18, 0, 0); var a = new CopyHintsInput(start, start.AddHours(2), "EOS R5", 5, "Harbour sunset"); Assert.Equal(100, CopyRules.Hints(a, a with { Camera = "eos r5", Title = "harbour" })); // Half of the shorter range shared: 20. Assert.Equal(20, CopyRules.Hints(a, new CopyHintsInput(start.AddHours(1), start.AddHours(3), null, null, null))); Assert.Equal(25, CopyRules.Hints(a, new CopyHintsInput(null, null, "EOS R5", null, null))); Assert.Equal(20, CopyRules.Hints(a, new CopyHintsInput(null, null, null, 5.4, null))); Assert.Equal(0, CopyRules.Hints(a, new CopyHintsInput(null, null, null, 6, "Sun"))); // A null Last reads as First: a sequence with its first capture inside the other's range overlaps fully. Assert.Equal(40, CopyRules.Hints(a, new CopyHintsInput(start.AddMinutes(30), null, null, null, null))); Assert.Equal(0, CopyRules.Hints(a, new CopyHintsInput(start.AddHours(3), null, null, null, null))); Assert.Equal(40, CopyRules.Hints(new CopyHintsInput(start, null, null, null, null), new CopyHintsInput(start, null, null, null, null))); } }