CI / Build and test (push) Successful in 13m44s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 16s
Release / Build, test and publish (push) Successful in 26m34s
CI / PostgreSQL 16 integration (push) Failing after 17m36s
CI / PostgreSQL 17 integration (push) Failing after 15m36s
CI / Docker image (push) Successful in 1m12s
Release / Server image (push) Failing after 15s
The same time-lapse on a server and on this PC under different ids, or twice on this PC, is recognised, compared and settled as the owner asked in owner review 6. Matches are found after each sync refresh, through the server's new photo lookup, and after the jobs that change photos. The default is to ask every time. Server › Matches offers: - Keep apart, which is remembered; - Link only and Unlink; - the Compare dialog: photos, details line by line, projects and the plan. Integrate completes both sides. Photos default to Union, projects are copied across, and a losing version goes to the trash only after a hash check. Afterwards new photos move by themselves, and deletions wait for the user. A merge of two local sequences verifies every photo before the other sequence goes to its archive's trash. Upload all local skips suspected matches and flags them. Migration 0012 adds the found_copies and copy_probes tables. Jobs 25 (Integrate) and 26 (MergeSequences) are new, and so are the server capabilities photo-lookup and upload-into. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
229 lines
13 KiB
C#
229 lines
13 KiB
C#
using Chronos.Core.Project;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Protocol;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Sync;
|
|
|
|
/// <summary>The photo-by-photo comparison of two copies (owner review 6, #73; design §4.1).</summary>
|
|
[Category("sync")]
|
|
public sealed class CopyComparisonTests
|
|
{
|
|
private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0, 250);
|
|
|
|
private static string Sha(int n) => Convert.ToHexStringLower(BitConverter.GetBytes((long)n)).PadLeft(64, 'a');
|
|
|
|
/// <summary>Photo n: its own SHA-256, size and a sub-second capture time 5 s after the one before.</summary>
|
|
private static CopyPhotoInput Photo(int n, int index = -1, bool hashed = true, bool unusable = false, string? name = null, DateTime? at = null, long? size = null) =>
|
|
new(Guid.NewGuid(), index < 0 ? n : index, name ?? $"IMG_{n:0000}.JPG", hashed ? Sha(n) : null, size ?? 1000 + n, at ?? Start.AddSeconds(5 * n), unusable);
|
|
|
|
private static CopySideInput Side(params CopyPhotoInput[] photos) => new(photos, []);
|
|
|
|
private static CopySideInput Side(IEnumerable<CopyPhotoInput> photos, params RemovedPhotoDto[] removed) => new([.. photos], removed);
|
|
|
|
private static RemovedPhotoDto Deleted(int n) => new(Sha(n), null, "deleted", DateTimeOffset.UnixEpoch);
|
|
|
|
private static RemovedPhotoDto Replaced(int n, int by) => new(Sha(n), Sha(by), "replaced", DateTimeOffset.UnixEpoch);
|
|
|
|
private static int Count(CopyComparisonResult result, PhotoClass c) => result.Of(c).Count();
|
|
|
|
[Test]
|
|
public void IdenticalCopiesAreAllSame()
|
|
{
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2), Photo(3)), Side(Photo(1), Photo(2), Photo(3)));
|
|
Assert.Equal(3, Count(result, PhotoClass.Same));
|
|
Assert.Equal((3, 0, 0, 1000, 1000), (result.Score.Shared, result.Score.OnlyHere, result.Score.OnlyThere, result.Score.Containment, result.Score.Overlap));
|
|
Assert.True(result.Score.Identical);
|
|
Assert.True(result.Score.ByHash);
|
|
Assert.Count(9, result.Totals);
|
|
}
|
|
|
|
[Test]
|
|
public void ASubsetReadsFullyContainedAndASupersetToo()
|
|
{
|
|
// The Uploader sent part of the card: the server holds a subset.
|
|
var all = Enumerable.Range(1, 10).Select(n => Photo(n)).ToArray();
|
|
var part = Enumerable.Range(1, 4).Select(n => Photo(n)).ToArray();
|
|
var subset = CopyComparer.Compare(Side(all), Side(part));
|
|
Assert.Equal((4, 6, 0, 1000, 400), (subset.Score.Shared, subset.Score.OnlyHere, subset.Score.OnlyThere, subset.Score.Containment, subset.Score.Overlap));
|
|
Assert.False(subset.Score.Identical);
|
|
var superset = CopyComparer.Compare(Side(part), Side(all));
|
|
Assert.Equal((4, 0, 6, 1000), (superset.Score.Shared, superset.Score.OnlyHere, superset.Score.OnlyThere, superset.Score.Containment));
|
|
}
|
|
|
|
[Test]
|
|
public void AConvertedPhotoIsConvertedNotOnlyOnOneSide()
|
|
{
|
|
// This PC replaced photo 2 by a converted file (photo 50's content); the server still holds the original.
|
|
var here = Side([Photo(1), Photo(50, index: 1, at: Start.AddSeconds(10))], Replaced(2, 50));
|
|
var result = CopyComparer.Compare(here, Side(Photo(1), Photo(2)));
|
|
var converted = Assert.Contains(result.Photos, p => p.Class == PhotoClass.Converted);
|
|
Assert.Equal((Sha(50), Sha(2)), (converted.Here!.Sha256, converted.There!.Sha256));
|
|
Assert.Equal((2, 0, 0), (result.Score.Shared, result.Score.OnlyHere, result.Score.OnlyThere));
|
|
Assert.True(result.Score.Identical);
|
|
}
|
|
|
|
[Test]
|
|
public void ATombstonedPhotoIsDeletedOnThatSideNotOnlyOnTheOther()
|
|
{
|
|
var result = CopyComparer.Compare(Side([Photo(1), Photo(2)], Deleted(3)), Side([Photo(1), Photo(3)], Deleted(2)));
|
|
Assert.Equal(Sha(2), Assert.Contains(result.Photos, p => p.Class == PhotoClass.DeletedThere).Key);
|
|
Assert.Equal(Sha(3), Assert.Contains(result.Photos, p => p.Class == PhotoClass.DeletedHere).Key);
|
|
Assert.Equal((0, 0, 1, 1, 2), (result.Score.OnlyHere, result.Score.OnlyThere, result.Score.DeletedHere, result.Score.DeletedThere, result.Score.SharedRemoved));
|
|
Assert.False(result.Score.Identical);
|
|
Assert.Equal(1000, result.Score.Containment);
|
|
}
|
|
|
|
[Test]
|
|
public void CopiesOfOnePhotoInsideASideCountOnce()
|
|
{
|
|
var copy = Photo(2) with { FrameId = Guid.NewGuid(), Index = 5, FileName = "IMG_0002 (1).JPG" };
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2), copy), Side(Photo(1), Photo(2)));
|
|
Assert.Equal((2, 2, 2), (result.Score.Shared, result.Score.LocalPhotos, result.Score.OtherPhotos));
|
|
var same = Assert.Contains(result.Photos, p => p.Key == Sha(2));
|
|
Assert.Equal((2, 1), (same.HereOccurrences, same.ThereOccurrences));
|
|
Assert.True(result.Score.Identical);
|
|
}
|
|
|
|
[Test]
|
|
public void AnUnhashedPhotoMatchesBySizeAndMillisecond()
|
|
{
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2, hashed: false)), Side(Photo(1), Photo(2)));
|
|
var unhashed = Assert.Contains(result.Photos, p => p.Class == PhotoClass.SameUnhashed);
|
|
Assert.Equal(Sha(2), unhashed.Key);
|
|
Assert.Equal((1, 1), (result.Score.Shared, result.Score.SharedUnhashed));
|
|
Assert.True(result.Score.Identical);
|
|
Assert.False(result.Score.ByHash);
|
|
}
|
|
|
|
[Test]
|
|
public void UnhashedLeftoversStayOnTheirSide()
|
|
{
|
|
// Another size at the same time is another photo: unlike CompareOriginals, nothing is assumed to match.
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2, hashed: false, size: 7)), Side(Photo(1), Photo(3, hashed: false)));
|
|
Assert.Equal((1, 0, 1, 1), (result.Score.Shared, result.Score.SharedUnhashed, result.Score.OnlyHere, result.Score.OnlyThere));
|
|
Assert.True(Assert.Contains(result.Photos, p => p.Class == PhotoClass.OnlyHere).Key.StartsWith("u:7:", StringComparison.Ordinal));
|
|
}
|
|
|
|
[Test]
|
|
public void DiffersPairsOnePhotoPerSideWithTheSameNameAndSubSecondInstant()
|
|
{
|
|
// Photo 2 edited on one side: another SHA-256, same name, same sub-second capture time.
|
|
var edited = Photo(2) with { Sha256 = Sha(99), Size = 4242 };
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2)), Side(Photo(1), edited));
|
|
var differs = Assert.Contains(result.Photos, p => p.Class == PhotoClass.Differs);
|
|
Assert.Equal((Sha(2), Sha(99), 1002L), (differs.Here!.Sha256, differs.There!.Sha256, differs.Bytes));
|
|
Assert.Equal((1, 0, 0), (result.Score.Differs, result.Score.OnlyHere, result.Score.OnlyThere));
|
|
Assert.False(result.Score.Identical);
|
|
var total = Assert.Contains(result.Totals, t => t.Class == PhotoClass.Differs);
|
|
Assert.Equal((1002L, 4242L), (total.HereBytes, total.ThereBytes));
|
|
|
|
// Another name, or another millisecond, is no pair.
|
|
Assert.Equal(0, CopyComparer.Compare(Side(Photo(2)), Side(edited with { FileName = "DSC_0002.JPG" })).Score.Differs);
|
|
Assert.Equal(0, CopyComparer.Compare(Side(Photo(2)), Side(edited with { CapturedAt = edited.CapturedAt!.Value.AddMilliseconds(1) })).Score.Differs);
|
|
}
|
|
|
|
[Test]
|
|
public void WholeSecondCaptureTimesNeverPairAsDiffers()
|
|
{
|
|
// A camera that records whole seconds: two different photos at one second with one name are not one photo edited.
|
|
var at = new DateTime(2026, 9, 28, 18, 0, 0);
|
|
var result = CopyComparer.Compare(Side(Photo(1, at: at, name: "IMG_0001.JPG")), Side(Photo(2, at: at, name: "IMG_0001.JPG")));
|
|
Assert.Equal((0, 1, 1), (result.Score.Differs, result.Score.OnlyHere, result.Score.OnlyThere));
|
|
}
|
|
|
|
[Test]
|
|
public void BurstsNeverPairAsDiffers()
|
|
{
|
|
// Two photos of a burst at one instant on each side: which is which cannot be told, so nothing pairs.
|
|
var at = Start.AddMilliseconds(130);
|
|
var result = CopyComparer.Compare(
|
|
Side(Photo(1, at: at, name: "IMG_0001.JPG"), Photo(2, at: at, name: "IMG_0001.JPG")),
|
|
Side(Photo(3, at: at, name: "IMG_0001.JPG"), Photo(4, at: at, name: "IMG_0001.JPG")));
|
|
Assert.Equal((0, 2, 2), (result.Score.Differs, result.Score.OnlyHere, result.Score.OnlyThere));
|
|
}
|
|
|
|
[Test]
|
|
public void TwoVersionsAfterAKeepBothAreVersions()
|
|
{
|
|
// A Union keep-both left both versions of photo 2 on both sides, at its one capture instant.
|
|
var version = Photo(2) with { FrameId = Guid.NewGuid(), Index = 3, Sha256 = Sha(99), Size = 4242 };
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2), version), Side(Photo(1), Photo(2), version with { FrameId = Guid.NewGuid() }));
|
|
Assert.Equal(2, Count(result, PhotoClass.Versions));
|
|
Assert.Equal((3, 2), (result.Score.Shared, result.Score.Versions));
|
|
Assert.True(result.Score.Identical);
|
|
|
|
// At a whole second they stay Same.
|
|
var at = new DateTime(2026, 9, 28, 18, 0, 10);
|
|
var whole = CopyComparer.Compare(Side(Photo(2, at: at), version with { CapturedAt = at }), Side(Photo(2, at: at), version with { CapturedAt = at }));
|
|
Assert.Equal((2, 0), (Count(whole, PhotoClass.Same), whole.Score.Versions));
|
|
}
|
|
|
|
[Test]
|
|
public void AnUnusableFrameHoldsNothingAndMarksTheRepair()
|
|
{
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2, unusable: true)), Side(Photo(1), Photo(2), Photo(3, unusable: true)));
|
|
var brought = Assert.Contains(result.Photos, p => p.Key == Sha(2));
|
|
Assert.Equal((PhotoClass.OnlyThere, true, false), (brought.Class, brought.RepairsHere, brought.RepairsThere));
|
|
Assert.DoesNotContain(Sha(3), result.Photos.Select(p => p.Key));
|
|
Assert.Equal((1, 2), (result.Score.LocalPhotos, result.Score.OtherPhotos));
|
|
|
|
// A Missing or Corrupt frame there is repaired by this PC's copy.
|
|
var other = CopyComparer.Compare(Side(Photo(1), Photo(2)), Side(Photo(1), Photo(2, unusable: true)));
|
|
var sent = Assert.Contains(other.Photos, p => p.Key == Sha(2));
|
|
Assert.Equal((PhotoClass.OnlyHere, true), (sent.Class, sent.RepairsThere));
|
|
}
|
|
|
|
[Test]
|
|
public void BytesArePerClassAndSide()
|
|
{
|
|
var result = CopyComparer.Compare(Side(Photo(1), Photo(2)), Side(Photo(1), Photo(3)));
|
|
Assert.Equal((1001L, 1001L), Totals(PhotoClass.Same));
|
|
Assert.Equal((1002L, 0L), Totals(PhotoClass.OnlyHere));
|
|
Assert.Equal((0L, 1003L), Totals(PhotoClass.OnlyThere));
|
|
Assert.Equal(1003L, Assert.Contains(result.Photos, p => p.Class == PhotoClass.OnlyThere).Bytes);
|
|
|
|
(long, long) Totals(PhotoClass c)
|
|
{
|
|
var total = result.Totals.Single(t => t.Class == c);
|
|
return (total.HereBytes, total.ThereBytes);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TheResultDoesNotDependOnTheOrderOfTheInputs()
|
|
{
|
|
var edited = Photo(7) with { Sha256 = Sha(97) };
|
|
CopyPhotoInput[] here = [Photo(1), Photo(2), Photo(3, hashed: false), Photo(4), Photo(5), Photo(6), Photo(7), Photo(8, unusable: true)];
|
|
CopyPhotoInput[] there = [Photo(1), Photo(3), Photo(4, hashed: false), Photo(6), edited, Photo(8), Photo(9)];
|
|
var removedHere = new[] { Deleted(9) };
|
|
var removedThere = new[] { Deleted(5) };
|
|
var a = CopyComparer.Compare(Side(here, removedHere), Side(there, removedThere));
|
|
var b = CopyComparer.Compare(Side(Enumerable.Reverse(here), removedHere), Side(Enumerable.Reverse(there), removedThere));
|
|
Assert.Equal(a.Score, b.Score);
|
|
Assert.SequenceEqual(a.Photos.Select(p => (p.Class, p.Key, p.Here?.FrameId, p.There?.FrameId)), b.Photos.Select(p => (p.Class, p.Key, p.Here?.FrameId, p.There?.FrameId)));
|
|
Assert.Equal((2, 2, 1, 1, 1, 1, 1), (a.Score.Shared, a.Score.SharedUnhashed, a.Score.Differs, a.Score.DeletedHere, a.Score.DeletedThere, a.Score.OnlyHere, a.Score.OnlyThere));
|
|
}
|
|
|
|
[Test]
|
|
public void DeletionsCountWhatTheOtherSideTombstonedAndNoLongerHolds()
|
|
{
|
|
var tombstones = SyncTombstones.FromDtos([Deleted(3)], [Deleted(2), Deleted(1)]);
|
|
FramePhoto[] here = [new(Sha(1), 1, null), new(Sha(2), 2, null), new(Sha(2), 2, null)];
|
|
FramePhoto[] there = [new(Sha(1), 1, null), new(Sha(3), 3, null)];
|
|
Assert.Equal((1, 1), CopyComparer.Deletions(here, there, tombstones));
|
|
Assert.Equal((0, 0), CopyComparer.Deletions(here, there, SyncTombstones.None));
|
|
}
|
|
|
|
[Test]
|
|
public void TombstonesFromDtosReadBothSides()
|
|
{
|
|
var tombstones = SyncTombstones.FromDtos([Replaced(2, 50), Deleted(4)], [Deleted(5)]);
|
|
Assert.Equal(tombstones.Canonical(Sha(50)), tombstones.Canonical(Sha(2)));
|
|
Assert.True(tombstones.DeletedLocally(Sha(4)));
|
|
Assert.False(tombstones.DeletedLocally(Sha(2)));
|
|
Assert.True(tombstones.DeletedRemotely(Sha(5)));
|
|
Assert.True(SyncTombstones.FromDtos([], null).IsEmpty);
|
|
}
|
|
}
|