merge: P1a pure comparison, detection rules, details payload and sides

Brings in the owner review 6 parcel P1a: CopyComparison, CopyRules,
CopyPayload and CopySides with their Data tests.

Refs #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-16 20:44:06 +01:00
commit e2a4647281
9 files changed
+1465

No files matched your search

+236
View File
@@ -0,0 +1,236 @@
using System.Globalization;
using System.Text.Json;
using System.Text.Json.Nodes;
using Chronos.Core.Project;
using Chronos.Data.Sync;
namespace Chronos.Data.Copies;
/// <summary>
/// The details of two copies line by line (owner review 6, Q4; design §4.3): title, tags, rating, notes and settings, the
/// settings compared in their portable form (frame positions by photo), so the same choice on the same photo at another
/// position is no difference; and the one payload both sides get once every line is chosen. Pure.
/// </summary>
public static class CopyPayload
{
/// <summary>The one line every difference of the frame positions (exclusions, hero, keyframes by photo) collapses into.</summary>
public const string PendingFramesPath = "pendingFrames";
private const string Title = SyncRules.MetadataPath + "title";
private const string Tags = SyncRules.MetadataPath + "tags";
private const string Rating = SyncRules.MetadataPath + "rating";
private const string Notes = SyncRules.MetadataPath + "notes";
/// <summary>
/// The payload with its settings in portable form (<see cref="ProjectContent.ToPortable(string, FramePhotos)"/> on
/// <paramref name="photos"/>, the frames its positions name). Settings that are not a project are kept normalised as they are.
/// </summary>
public static SyncPayload Portable(SyncPayload payload, FramePhotos photos)
{
ArgumentNullException.ThrowIfNull(payload);
ArgumentNullException.ThrowIfNull(photos);
var settings = SyncRules.NormalizeSettings(payload.SettingsJson);
try
{
return payload with { SettingsJson = ProjectContent.ToPortable(settings, photos) };
}
catch (JsonException)
{
return payload with { SettingsJson = settings };
}
}
/// <summary>
/// Every difference of title, tags, rating, notes and settings, settings compared in their portable form (positions by
/// photo, each side's settings made portable with its own photos), so the same exclusion at index 10 here and 12 there is
/// no line. Lines under "pendingFrames" collapse into one line "pendingFrames" (Frame positions).
/// </summary>
public static IReadOnlyList<DetailLine> Lines(SyncPayload here, FramePhotos herePhotos, SyncPayload there, FramePhotos therePhotos)
{
ArgumentNullException.ThrowIfNull(here);
ArgumentNullException.ThrowIfNull(there);
var mine = Portable(here, herePhotos);
var theirs = Portable(there, therePhotos);
return Collapse(SyncRules.Differences(mine, theirs, int.MaxValue), mine, theirs);
}
/// <summary>
/// The one payload both sides get, in portable form: here's values, with there's at every path chosen
/// <see cref="CopySide.Other"/>. Every line must be chosen. Each side places it on its own frames at write time
/// (<see cref="ProjectContent.Place"/>, under its lease).
/// </summary>
/// <exception cref="ArgumentException">A line has no choice.</exception>
/// <exception cref="InvalidDataException">The merged settings are not a project this Chronos reads: nothing is to be applied.</exception>
public static SyncPayload Merge(SyncPayload herePortable, SyncPayload therePortable, IReadOnlyDictionary<string, CopySide> choices,
IReadOnlyList<DetailLine> lines)
{
ArgumentNullException.ThrowIfNull(herePortable);
ArgumentNullException.ThrowIfNull(therePortable);
ArgumentNullException.ThrowIfNull(choices);
ArgumentNullException.ThrowIfNull(lines);
if (lines.FirstOrDefault(l => !choices.ContainsKey(l.Path)) is { } unchosen)
throw new ArgumentException($"The detail '{unchosen.Path}' has no side chosen.", nameof(choices));
var (title, tags, rating, notes) = (herePortable.Title, herePortable.Tags, herePortable.Rating, herePortable.Notes);
var settings = Parse(SyncRules.NormalizeSettings(herePortable.SettingsJson));
var other = Parse(SyncRules.NormalizeSettings(therePortable.SettingsJson));
foreach (var line in lines.Where(l => choices[l.Path] == CopySide.Other).DistinctBy(l => l.Path, StringComparer.Ordinal))
{
switch (line.Path)
{
case Title:
title = therePortable.Title;
break;
case Tags:
tags = therePortable.Tags;
break;
case Rating:
rating = therePortable.Rating;
break;
case Notes:
notes = therePortable.Notes;
break;
case "settings":
settings = other?.DeepClone();
break;
default:
settings = Set(settings, other, line.Path);
break;
}
}
var json = settings?.ToJsonString() ?? string.Empty;
string merged;
try
{
// Read as a project (never a newer Chronos's: its values may mean something else), then written canonically.
_ = ProjectSettings.FromJson(json);
merged = ProjectContent.Canonical(json);
}
catch (JsonException ex)
{
throw new InvalidDataException("The merged settings are not a project.", ex);
}
return new SyncPayload(title, tags, rating, notes, merged);
}
/// <summary>
/// Adds the excluded flag, by photo, for the incoming versions of a Union keep-both (design §5e): each key (a canonical
/// SHA-256, or "u:&lt;size&gt;:&lt;capture ms&gt;") becomes an excluded pending frame, or marks the one already naming it.
/// </summary>
/// <exception cref="InvalidDataException">The settings are of a newer Chronos.</exception>
/// <exception cref="JsonException">The settings are not a project.</exception>
public static SyncPayload ExcludeVersions(SyncPayload portable, IReadOnlyCollection<string> photoKeys)
{
ArgumentNullException.ThrowIfNull(portable);
ArgumentNullException.ThrowIfNull(photoKeys);
if (photoKeys.Count == 0) return portable;
var settings = ProjectSettings.FromJson(SyncRules.NormalizeSettings(portable.SettingsJson));
var pending = (settings.PendingFrames ?? []).ToList();
foreach (var key in photoKeys.Distinct(StringComparer.Ordinal))
{
if (Photo(key) is not { } photo) continue;
var at = pending.FindIndex(p => p.Occurrence == 0 && Names(p, photo));
if (at >= 0) pending[at] = pending[at] with { Excluded = true };
else pending.Add(new PendingFrame { Sha256 = photo.Sha256, Size = photo.Size, CapturedAt = photo.CapturedAt, Excluded = true });
}
return portable with { SettingsJson = ProjectContent.Canonical((settings with { PendingFrames = pending }).ToJson()) };
}
/// <summary>Paths whose value moved between two payloads of one side (the apply-time check of design §5c step 5).</summary>
public static IReadOnlySet<string> Moved(SyncPayload before, SyncPayload after)
{
ArgumentNullException.ThrowIfNull(before);
ArgumentNullException.ThrowIfNull(after);
return Collapse(SyncRules.Differences(before, after, int.MaxValue), before, after).Select(l => l.Path).ToHashSet(StringComparer.Ordinal);
}
private static List<DetailLine> Collapse(IReadOnlyList<SettingsDifference> differences, SyncPayload here, SyncPayload there)
{
var lines = new List<DetailLine>(differences.Count);
var pending = false;
foreach (var difference in differences)
{
if (difference.Path == PendingFramesPath || difference.Path.StartsWith(PendingFramesPath + ".", StringComparison.Ordinal))
{
if (pending) continue;
pending = true;
lines.Add(new DetailLine(PendingFramesPath, PendingOf(here), PendingOf(there)));
continue;
}
lines.Add(new DetailLine(difference.Path, difference.Mine, difference.Theirs));
}
return lines;
static string? PendingOf(SyncPayload payload) =>
Parse(SyncRules.NormalizeSettings(payload.SettingsJson)) is JsonObject project && project[PendingFramesPath] is { } node ? node.ToJsonString() : null;
}
private static JsonNode? Parse(string json)
{
try
{
return JsonNode.Parse(json);
}
catch (JsonException)
{
return JsonValue.Create(json);
}
}
/// <summary>Sets <paramref name="path"/> of <paramref name="target"/> to the value it has in <paramref name="source"/>; removes it where the source has none.</summary>
private static JsonNode? Set(JsonNode? target, JsonNode? source, string path)
{
var names = path.Split('.');
var value = source;
var present = true;
foreach (var name in names)
{
if (value is JsonObject o && o.TryGetPropertyValue(name, out var child))
{
value = child;
continue;
}
present = false;
break;
}
if (target is not JsonObject root)
{
if (!present) return target;
root = new JsonObject();
target = root;
}
var parent = root;
for (var i = 0; i < names.Length - 1; i++)
{
if (parent[names[i]] is JsonObject next)
{
parent = next;
continue;
}
if (!present) return target;
var created = new JsonObject();
parent[names[i]] = created;
parent = created;
}
if (present) parent[names[^1]] = value?.DeepClone();
else parent.Remove(names[^1]);
return target;
}
/// <summary>The photo a key names (<see cref="CopyComparer.UnhashedKey"/>); null for an unhashed photo without a capture time.</summary>
private static FramePhoto? Photo(string key)
{
if (!key.StartsWith(CopyComparer.UnhashedPrefix, StringComparison.Ordinal)) return key.Length == 0 ? null : new FramePhoto(key.ToLowerInvariant(), 0, null);
var parts = key[CopyComparer.UnhashedPrefix.Length..].Split(':');
return parts.Length == 2 && long.TryParse(parts[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var size)
&& long.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var ms)
? new FramePhoto(null, size, new DateTime(ms * TimeSpan.TicksPerMillisecond, DateTimeKind.Unspecified))
: null;
}
private static bool Names(PendingFrame entry, FramePhoto photo) => photo.IsHashed
? string.Equals(entry.Sha256, photo.Sha256, StringComparison.OrdinalIgnoreCase)
: string.IsNullOrEmpty(entry.Sha256) && entry.Size == photo.Size && entry.CapturedAt is { } at
&& CopyComparer.Millisecond(at) == CopyComparer.Millisecond(photo.CapturedAt!.Value);
}
+186
View File
@@ -0,0 +1,186 @@
using System.Globalization;
using System.Security.Cryptography;
using System.Text;
using Chronos.Core.Project;
namespace Chronos.Data.Copies;
/// <summary>
/// The decisions of detection that need no I/O (owner review 6, #73; design §3.1, §3.2): whether two copies are a pair, what
/// the Link matches setting does with one, 1.1's same-originals gate, when a kept-apart pair asks again, fingerprints, hints
/// and the probe sample. Pure and thread-safe.
/// </summary>
public static class CopyRules
{
/// <summary>A pair at all needs this much of the smaller side shared (per mille), besides at least one photo.</summary>
public const int MinContainment = 100;
/// <summary>The photos a probe samples of a sequence by default.</summary>
public const int ProbeSize = 64;
private const string FingerprintVersion = "c1";
/// <summary>A pair at all: a link, a session key, or (Shared + SharedUnhashed + SharedRemoved) ≥ 1 and Containment ≥ 100.</summary>
public static bool IsCopy(CopyEvidence evidence, CopyScore score)
{
ArgumentNullException.ThrowIfNull(score);
if (evidence is CopyEvidence.Link or CopyEvidence.SessionKey) return true;
return score.Shared + score.SharedUnhashed + score.SharedRemoved >= 1 && score.Containment >= MinContainment;
}
/// <summary>
/// What detection does with a pair that has no answer (state Candidate or new), by the setting (design §3.2): a local↔local
/// pair is never linked (it would need a merge); WhenIdentical links exactly the same photos known by SHA-256 on both sides;
/// WhenHalfShared links by 1.1's rule (<see cref="SameOriginals"/>). Everything else that is a pair asks.
/// </summary>
/// <param name="evidence">The pair's evidence (a back-reference makes a pair without shared photos); Hashes by default.</param>
public static CopyDecision Decide(CopyLinking linking, CopyKind kind, CopyScore score, SameOriginalsInput gate, CopyEvidence evidence = CopyEvidence.Hashes)
{
ArgumentNullException.ThrowIfNull(score);
ArgumentNullException.ThrowIfNull(gate);
if (kind == CopyKind.LocalServer)
{
var link = linking switch
{
CopyLinking.WhenIdentical => score.Identical && score.ByHash,
CopyLinking.WhenHalfShared => SameOriginals(gate),
_ => false,
};
if (link) return CopyDecision.Link;
}
return IsCopy(evidence, score) ? CopyDecision.Ask : CopyDecision.None;
}
/// <summary>
/// 1.1's <c>SyncService.SameOriginalsAsync</c> rule with the gates of <c>MatchByContentAsync</c>, ported exactly (owner Q1
/// "today's rule"): both unlinked, the same first-capture second, camera models equal ignoring case, at least one local
/// hash, and at least half of the smaller side's originals shared by canonical SHA-256.
/// </summary>
public static bool SameOriginals(SameOriginalsInput gate)
{
ArgumentNullException.ThrowIfNull(gate);
if (!gate.BothUnlinked || gate.LocalFirst is not { } local || gate.RemoteFirst is not { } remote) return false;
if (Second(local) != Second(remote)) return false;
if (!string.Equals(gate.LocalCamera, gate.RemoteCamera, StringComparison.OrdinalIgnoreCase)) return false;
if (gate.LocalHashed <= 0) return false;
return gate.SharedCanonical > 0 && 2L * gate.SharedCanonical >= Math.Min(gate.LocalHashed, gate.RemoteFrames);
}
/// <summary>
/// A kept-apart pair asks again (design §3.6): it became Identical (it was not when the user answered), or Shared grew by
/// at least max(10, 25 % of the shared count the user answered).
/// </summary>
public static bool AsksAgain(FoundCopy answered, CopyScore now)
{
ArgumentNullException.ThrowIfNull(answered);
ArgumentNullException.ThrowIfNull(now);
if (answered.State != CopyState.KeptApart) return false;
var wasIdentical = WasIdentical(answered.AnsweredFingerprint) ?? answered.Score.Identical;
if (now.Identical && !wasIdentical) return true;
var before = answered.AnsweredShared ?? answered.Score.Shared;
var grown = now.Shared - before;
return grown >= 10 && 4L * grown >= before;
}
/// <summary>
/// What a comparison found, as text: the counts and both sides' frames versions. Equal fingerprints mean nothing moved
/// since (detection skips the comparison; a kept-apart answer stands).
/// </summary>
public static string Fingerprint(CopyScore score, int localFramesVersion, int otherFramesVersion)
{
ArgumentNullException.ThrowIfNull(score);
return string.Join(':', FingerprintVersion,
Text(score.Shared), Text(score.SharedUnhashed), Text(score.SharedRemoved), Text(score.OnlyHere), Text(score.OnlyThere), Text(score.Differs),
Text(score.DeletedHere), Text(score.DeletedThere), Text(score.Versions), Text(score.LocalPhotos), Text(score.OtherPhotos),
Text(localFramesVersion), Text(otherFramesVersion));
static string Text(int value) => value.ToString(CultureInfo.InvariantCulture);
}
/// <summary>The SHA-256 (lower-case hex) of a plan's lines joined by '\n': equal plans have equal fingerprints.</summary>
public static string PlanFingerprint(IEnumerable<string> lines)
{
ArgumentNullException.ThrowIfNull(lines);
return Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(string.Join('\n', lines))));
}
/// <summary>
/// How alike two sequences look, 0–100 (design §3.1): 40 × the capture-range overlap fraction of the shorter range, 25 when
/// the camera models are equal ignoring case, 20 when the median intervals are within 10 %, 15 when the titles share a word
/// of at least 4 letters (ignoring case). A null Last is read as First (a sequence without a last capture yet).
/// </summary>
public static int Hints(CopyHintsInput a, CopyHintsInput b)
{
ArgumentNullException.ThrowIfNull(a);
ArgumentNullException.ThrowIfNull(b);
var score = (int)Math.Round(40 * Overlap(a, b), MidpointRounding.AwayFromZero);
if (!string.IsNullOrWhiteSpace(a.Camera) && string.Equals(a.Camera.Trim(), b.Camera?.Trim(), StringComparison.OrdinalIgnoreCase)) score += 25;
if (a.MedianInterval is > 0 and var x && b.MedianInterval is > 0 and var y && Math.Abs(x - y) <= 0.1 * Math.Max(x, y)) score += 20;
if (Words(a.Title).Overlaps(Words(b.Title))) score += 15;
return Math.Clamp(score, 0, 100);
}
/// <summary>Up to <paramref name="max"/> photo keys, evenly spaced over the sequence, the first and the last included.</summary>
public static IReadOnlyList<FramePhoto> Probe(IReadOnlyList<FramePhoto> photos, int max = ProbeSize)
{
ArgumentNullException.ThrowIfNull(photos);
if (max <= 0 || photos.Count == 0) return [];
if (photos.Count <= max) return [.. photos];
if (max == 1) return [photos[0]];
var sample = new FramePhoto[max];
var last = photos.Count - 1;
for (var i = 0; i < max; i++) sample[i] = photos[(int)((long)i * last / (max - 1))];
return sample;
}
private static DateTime Second(DateTime time) => new(time.Ticks - time.Ticks % TimeSpan.TicksPerSecond, DateTimeKind.Unspecified);
/// <summary>Whether a fingerprint (<see cref="Fingerprint"/>) records an Identical score; null for one in another form.</summary>
private static bool? WasIdentical(string? fingerprint)
{
if (fingerprint is null) return null;
var parts = fingerprint.Split(':');
if (parts.Length != 14 || parts[0] != FingerprintVersion) return null;
var counts = new int[parts.Length - 1];
for (var i = 1; i < parts.Length; i++)
{
if (!int.TryParse(parts[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out counts[i - 1])) return null;
}
// shared, shared unhashed, removed, only here, only there, differs, deleted here, deleted there, versions, …
return counts[3] == 0 && counts[4] == 0 && counts[5] == 0 && counts[6] == 0 && counts[7] == 0 && counts[0] + counts[1] > 0;
}
/// <summary>The fraction of the shorter capture range the two ranges share (a single instant within the other's range: 1).</summary>
private static double Overlap(CopyHintsInput a, CopyHintsInput b)
{
if (a.First is not { } aFirst || b.First is not { } bFirst) return 0;
var (aFrom, aTo) = Range(aFirst, a.Last);
var (bFrom, bTo) = Range(bFirst, b.Last);
var from = aFrom > bFrom ? aFrom : bFrom;
var to = aTo < bTo ? aTo : bTo;
if (to < from) return 0;
var shorter = Math.Min((aTo - aFrom).Ticks, (bTo - bFrom).Ticks);
return shorter <= 0 ? 1 : Math.Min(1, (double)(to - from).Ticks / shorter);
static (DateTime From, DateTime To) Range(DateTime first, DateTime? last) => last is { } l && l >= first ? (first, l) : (first, first);
}
/// <summary>The words of at least 4 letters of a title, lower-case.</summary>
private static HashSet<string> Words(string? title)
{
var words = new HashSet<string>(StringComparer.Ordinal);
if (string.IsNullOrWhiteSpace(title)) return words;
var word = new StringBuilder();
foreach (var c in title + " ")
{
if (char.IsLetterOrDigit(c))
{
word.Append(char.ToLowerInvariant(c));
continue;
}
if (word.ToString() is var w && w.Count(char.IsLetter) >= 4) words.Add(w);
word.Clear();
}
return words;
}
}
+74
View File
@@ -0,0 +1,74 @@
using Chronos.Core.Model;
using Chronos.Data.Repositories;
using Chronos.Data.Sync;
using Chronos.Protocol;
namespace Chronos.Data.Copies;
/// <summary>
/// The two sides of a comparison as <see cref="CopyComparer"/> reads them (owner review 6, #73; design §4.2): a local
/// sequence's frames and tombstones, a server sequence's manifest with its frames' capture times, and the last-copy check
/// the planners make before anything goes to a trash.
/// </summary>
public sealed class CopySides(ChronosDatabase db)
{
/// <summary>Frames whose file holds nothing usable: the other side's copy repairs them.</summary>
public const FrameFlags UnusableFlags = FrameFlags.Missing | FrameFlags.Corrupt;
/// <summary>Parameters per statement of <see cref="HeldElsewhereAsync"/>.</summary>
private const int Batch = 500;
private readonly ChronosDatabase _db = db ?? throw new ArgumentNullException(nameof(db));
private readonly DbAccess _access = new(db.Database);
/// <summary>A local sequence: every frame row in index order and its tombstones (<see cref="SyncTombstones.ToDto"/>).</summary>
public async Task<CopySideInput> LocalAsync(Guid id, CancellationToken ct)
{
var frames = await Processing.SequenceFrames.ListAsync(_db, id, ct).ConfigureAwait(false);
var removals = await _db.FrameRemovals.ListBySequenceAsync(id, ct).ConfigureAwait(false);
return new CopySideInput(
[.. frames.Select(f => new CopyPhotoInput(f.Id, f.Index, f.FileName, f.Sha256, f.Size, f.CapturedAt, (f.Flags & UnusableFlags) != 0))],
SyncTombstones.ToDto(removals));
}
/// <summary>
/// A server sequence: its manifest (content, flags, tombstones) with the capture times of its frame rows (the manifest
/// has none). A frame the listing no longer has keeps no capture time.
/// </summary>
public async Task<CopySideInput> RemoteAsync(ISyncRemote remote, Guid id, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(remote);
var manifest = await remote.GetManifestAsync(id, ct).ConfigureAwait(false);
var rows = await remote.ListFramesAsync(id, ct).ConfigureAwait(false);
var captured = new Dictionary<Guid, DateTime?>(rows.Count);
foreach (var row in rows) captured[row.Id] = row.CapturedAt;
return new CopySideInput(
[.. manifest.Frames.Select(f => new CopyPhotoInput(f.Id, f.Index, f.FileName, f.Sha256.Length == 0 ? null : f.Sha256, f.Size,
captured.GetValueOrDefault(f.Id), (f.Flags & (long)UnusableFlags) != 0))],
manifest.Removed ?? []);
}
/// <summary>
/// The raw SHA-256 (lower-case) of <paramref name="sha256"/> that a usable frame (not Missing or Corrupt) of any sequence
/// of this index other than <paramref name="except"/> holds: what is not the last copy of its photo. Batched.
/// </summary>
public async Task<IReadOnlySet<string>> HeldElsewhereAsync(IReadOnlyCollection<string> sha256, IReadOnlyCollection<Guid> except, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(sha256);
ArgumentNullException.ThrowIfNull(except);
var held = new HashSet<string>(StringComparer.Ordinal);
var wanted = sha256.Where(s => !string.IsNullOrEmpty(s)).Select(s => s.ToLowerInvariant()).Distinct(StringComparer.Ordinal).ToList();
var excluded = except.Distinct().ToList();
foreach (var chunk in wanted.Chunk(Math.Max(1, Batch - excluded.Count)))
{
var p = new SqlParameters();
var not = excluded.Count == 0 ? string.Empty : $" AND sequence_id NOT IN ({string.Join(", ", excluded.Select(id => p.Add(id)))})";
var hashes = string.Join(", ", chunk.Select(sha => p.Add(sha)));
var rows = await _access.ListAsync(
$"SELECT DISTINCT sha256 FROM frames WHERE sha256 IN ({hashes}) AND (flags & {(int)UnusableFlags}) = 0{not}",
p.ToArray(), r => r.GetString(0), ct).ConfigureAwait(false);
foreach (var sha in rows) held.Add(sha.ToLowerInvariant());
}
return held;
}
}
+280
View File
@@ -0,0 +1,280 @@
using System.Globalization;
using Chronos.Core.Project;
using Chronos.Data.Copies;
namespace Chronos.Data.Sync;
/// <summary>
/// The photo-by-photo comparison of two copies of one time-lapse (owner review 6, #73; design §4.1): which photos both hold,
/// which only one holds, which one side deleted, which differ and which a Union kept in two versions. Detection, the Compare
/// dialog, Integrate and Merge all read this one comparison. Pure: no I/O, thread-safe, O(n log n).
/// </summary>
public static class CopyComparer
{
/// <summary>The unhashed key prefix: "u:&lt;size&gt;:&lt;capture millisecond&gt;".</summary>
internal const string UnhashedPrefix = "u:";
/// <summary>
/// Compares <paramref name="here"/> (this PC, or the kept sequence of a merge) with <paramref name="there"/> (the server,
/// or the other local sequence). Each photo lands in exactly one class; unusable frames (Missing or Corrupt) hold nothing
/// and mark the photo the other side brings as a repair.
/// </summary>
public static CopyComparisonResult Compare(CopySideInput here, CopySideInput there)
{
ArgumentNullException.ThrowIfNull(here);
ArgumentNullException.ThrowIfNull(there);
// 1. Tombstones of both sides; unusable frames left out of their side's holdings.
var tombstones = SyncTombstones.FromDtos(here.Removed ?? [], there.Removed);
var mine = Holdings(here.Photos, tombstones);
var theirs = Holdings(there.Photos, tombstones);
var brokenHere = Broken(here.Photos, tombstones);
var brokenThere = Broken(there.Photos, tombstones);
var theirsByKey = theirs.ToDictionary(h => h.Key, StringComparer.Ordinal);
var done = new HashSet<Holding>(ReferenceEqualityComparer.Instance);
var photos = new List<ComparedPhoto>(mine.Count + theirs.Count);
// 3. Same and Converted: one canonical key on both sides.
foreach (var h in mine)
{
if (!h.Hashed || !theirsByKey.TryGetValue(h.Key, out var t)) continue;
var (hereFrame, thereFrame, same) = Pick(h, t);
photos.Add(new ComparedPhoto(same ? PhotoClass.Same : PhotoClass.Converted, h.Key, hereFrame, thereFrame, h.Occurrences, t.Occurrences, hereFrame.Size));
done.Add(h);
done.Add(t);
}
// 4. SameUnhashed: one side not hashed, the same size and capture millisecond (FramePhoto.Matches), one to one.
var bySizeAndTime = new Dictionary<(long Size, long Ms), List<Holding>>();
foreach (var t in theirs)
{
if (done.Contains(t) || t.Ms is not { } ms) continue;
if (!bySizeAndTime.TryGetValue((t.First.Size, ms), out var list)) bySizeAndTime[(t.First.Size, ms)] = list = [];
list.Add(t);
}
foreach (var h in mine)
{
if (done.Contains(h) || h.Ms is not { } ms || !bySizeAndTime.TryGetValue((h.First.Size, ms), out var candidates)) continue;
var t = candidates.FirstOrDefault(c => !done.Contains(c) && (!h.Hashed || !c.Hashed));
if (t is null) continue;
var key = h.Hashed ? h.Key : t.Hashed ? t.Key : h.Key;
photos.Add(new ComparedPhoto(PhotoClass.SameUnhashed, key, h.First, t.First, h.Occurrences, t.Occurrences, h.First.Size));
done.Add(h);
done.Add(t);
}
// 5. Deleted there / deleted here: held by one side, tombstoned by the other, which does not hold it.
foreach (var h in mine.Where(h => !done.Contains(h) && h.Hashed && tombstones.DeletedRemotely(h.Key)))
{
photos.Add(new ComparedPhoto(PhotoClass.DeletedThere, h.Key, h.First, null, h.Occurrences, 0, h.First.Size));
done.Add(h);
}
foreach (var t in theirs.Where(t => !done.Contains(t) && t.Hashed && tombstones.DeletedLocally(t.Key)))
{
photos.Add(Brought(PhotoClass.DeletedHere, t, brokenHere));
done.Add(t);
}
// 6. Differs, strictly: one hashed photo per side at one sub-second instant, with the same file name.
var hereAt = HashedAt(mine.Where(h => !done.Contains(h)));
var thereAt = HashedAt(theirs.Where(t => !done.Contains(t)));
foreach (var (ms, onHere) in hereAt)
{
if (onHere.Count != 1 || !SubSecond(ms) || !thereAt.TryGetValue(ms, out var onThere) || onThere.Count != 1) continue;
var (h, t) = (onHere[0], onThere[0]);
if (!string.Equals(h.First.FileName, t.First.FileName, StringComparison.OrdinalIgnoreCase)) continue;
photos.Add(new ComparedPhoto(PhotoClass.Differs, h.Key, h.First, t.First, h.Occurrences, t.Occurrences, h.First.Size));
done.Add(h);
done.Add(t);
}
// 7. Versions: a sub-second instant holding exactly the same two shared photos on both sides (a Union keep-both).
MarkVersions(photos, mine, theirs);
// 8. The rest is on one side only (unhashed leftovers are not assumed to match).
foreach (var h in mine.Where(h => !done.Contains(h)))
photos.Add(new ComparedPhoto(PhotoClass.OnlyHere, h.Key, h.First, null, h.Occurrences, 0, h.First.Size, RepairsThere: Repairs(h, brokenThere)));
foreach (var t in theirs.Where(t => !done.Contains(t))) photos.Add(Brought(PhotoClass.OnlyThere, t, brokenHere));
photos.Sort(Order);
return new CopyComparisonResult(photos, Totals(photos), Score(photos, mine.Count, theirs.Count));
}
/// <summary>
/// For linked pairs at each reconcile: only the deletion counts, cheaply. Deleted there: distinct photos this side holds
/// that the other side tombstoned and does not hold; deleted here the other way round (as <see cref="SyncRules.CompareOriginals(IReadOnlyCollection{FramePhoto}, IReadOnlyCollection{FramePhoto}, SyncTombstones)"/>
/// leaves them out).
/// </summary>
public static (int DeletedHere, int DeletedThere) Deletions(IReadOnlyCollection<FramePhoto> here, IReadOnlyCollection<FramePhoto> there, SyncTombstones tombstones)
{
ArgumentNullException.ThrowIfNull(here);
ArgumentNullException.ThrowIfNull(there);
ArgumentNullException.ThrowIfNull(tombstones);
if (tombstones.IsEmpty) return (0, 0);
var mine = here.Select(tombstones.Canonical).ToList();
var theirs = there.Select(tombstones.Canonical).ToList();
var minePhotos = new FramePhotos(mine.Select((p, i) => (i, p)));
var theirPhotos = new FramePhotos(theirs.Select((p, i) => (i, p)));
return (Count(theirs, tombstones.DeletedLocally, minePhotos), Count(mine, tombstones.DeletedRemotely, theirPhotos));
static int Count(List<FramePhoto> side, Func<string?, bool> deleted, FramePhotos other) =>
side.Where(p => p.IsHashed && deleted(p.Sha256) && other.IndexOf(p) is null).Select(p => p.Sha256!.ToLowerInvariant()).Distinct(StringComparer.Ordinal).Count();
}
/// <summary>The key of an unhashed photo by its size and capture time; a photo without a time is keyed by its frame (it matches nothing).</summary>
internal static string UnhashedKey(long size, DateTime? capturedAt, Guid frameId) => capturedAt is { } at
? string.Create(CultureInfo.InvariantCulture, $"{UnhashedPrefix}{size}:{Millisecond(at)}")
: string.Create(CultureInfo.InvariantCulture, $"{UnhashedPrefix}{size}:{frameId:N}");
internal static long Millisecond(DateTime time) => time.Ticks / TimeSpan.TicksPerMillisecond;
/// <summary>A capture millisecond with a sub-second part: the camera records real sub-second times.</summary>
private static bool SubSecond(long ms) => ms % 1000 != 0;
/// <summary>One photo of one side: its key and the frames holding it, in index order (the first stands for it).</summary>
private sealed class Holding(string key, bool hashed, List<CopyPhotoInput> frames)
{
public string Key { get; } = key;
public bool Hashed { get; } = hashed;
public List<CopyPhotoInput> Frames { get; } = frames;
public CopyPhotoInput First => Frames[0];
public int Occurrences => Frames.Count;
public long? Ms => First.CapturedAt is { } at ? Millisecond(at) : null;
}
/// <summary>2. A side's usable frames grouped by photo key (copies of one photo inside a side count once), in index order.</summary>
private static List<Holding> Holdings(IReadOnlyList<CopyPhotoInput> photos, SyncTombstones tombstones)
{
ArgumentNullException.ThrowIfNull(photos);
var result = new List<Holding>();
var byKey = new Dictionary<string, Holding>(StringComparer.Ordinal);
foreach (var frame in photos.Where(p => p is { Unusable: false }).OrderBy(p => p.Index).ThenBy(p => p.FrameId))
{
var hashed = !string.IsNullOrEmpty(frame.Sha256);
var key = Key(frame, tombstones);
if (byKey.TryGetValue(key, out var holding))
{
holding.Frames.Add(frame);
continue;
}
byKey[key] = holding = new Holding(key, hashed, [frame]);
result.Add(holding);
}
return result;
}
private static string Key(CopyPhotoInput frame, SyncTombstones tombstones) => string.IsNullOrEmpty(frame.Sha256)
? UnhashedKey(frame.Size, frame.CapturedAt, frame.FrameId)
: tombstones.Canonical(frame.Sha256)!;
/// <summary>The keys of a side's unusable frames: canonical SHA-256 and size and capture time, so a photo either way marks a repair.</summary>
private static HashSet<string> Broken(IReadOnlyList<CopyPhotoInput> photos, SyncTombstones tombstones)
{
var broken = new HashSet<string>(StringComparer.Ordinal);
foreach (var frame in photos.Where(p => p is { Unusable: true }))
{
broken.Add(Key(frame, tombstones));
if (frame.CapturedAt is not null) broken.Add(UnhashedKey(frame.Size, frame.CapturedAt, frame.FrameId));
}
return broken;
}
private static bool Repairs(Holding brought, HashSet<string> broken) =>
broken.Count > 0 && (broken.Contains(brought.Key) || (brought.First.CapturedAt is not null
&& broken.Contains(UnhashedKey(brought.First.Size, brought.First.CapturedAt, brought.First.FrameId))));
/// <summary>A photo only the other side holds (or holds and this side deleted).</summary>
private static ComparedPhoto Brought(PhotoClass c, Holding t, HashSet<string> brokenHere) =>
new(c, t.Key, null, t.First, 0, t.Occurrences, t.First.Size, RepairsHere: Repairs(t, brokenHere));
/// <summary>The frames standing for a photo both hold: one with the same raw SHA-256 on each side when there is one (Same), else the first (Converted).</summary>
private static (CopyPhotoInput Here, CopyPhotoInput There, bool Same) Pick(Holding h, Holding t)
{
foreach (var mine in h.Frames)
{
var theirs = t.Frames.FirstOrDefault(f => string.Equals(f.Sha256, mine.Sha256, StringComparison.OrdinalIgnoreCase));
if (theirs is not null) return (mine, theirs, true);
}
return (h.First, t.First, false);
}
/// <summary>The hashed photos left at each capture millisecond.</summary>
private static SortedDictionary<long, List<Holding>> HashedAt(IEnumerable<Holding> holdings)
{
var at = new SortedDictionary<long, List<Holding>>();
foreach (var h in holdings)
{
if (!h.Hashed || h.Ms is not { } ms) continue;
if (!at.TryGetValue(ms, out var list)) at[ms] = list = [];
list.Add(h);
}
return at;
}
private static void MarkVersions(List<ComparedPhoto> photos, List<Holding> mine, List<Holding> theirs)
{
var hereAt = KeysAt(mine);
var thereAt = KeysAt(theirs);
var shared = photos.Where(p => p.Class is PhotoClass.Same or PhotoClass.Converted).Select(p => p.Key).ToHashSet(StringComparer.Ordinal);
for (var i = 0; i < photos.Count; i++)
{
var p = photos[i];
if (p.Class is not (PhotoClass.Same or PhotoClass.Converted) || p.Here!.CapturedAt is not { } hereTime || p.There!.CapturedAt is not { } thereTime) continue;
var ms = Millisecond(hereTime);
if (ms != Millisecond(thereTime) || !SubSecond(ms)) continue;
if (!hereAt.TryGetValue(ms, out var onHere) || !thereAt.TryGetValue(ms, out var onThere)) continue;
if (onHere.Count == 2 && onThere.Count == 2 && onHere.SetEquals(onThere) && onHere.All(shared.Contains)) photos[i] = p with { Class = PhotoClass.Versions };
}
static Dictionary<long, HashSet<string>> KeysAt(List<Holding> side)
{
var at = new Dictionary<long, HashSet<string>>();
foreach (var h in side)
{
if (h.Ms is not { } ms) continue;
if (!at.TryGetValue(ms, out var keys)) at[ms] = keys = new HashSet<string>(StringComparer.Ordinal);
keys.Add(h.Key);
}
return at;
}
}
/// <summary>Capture order, then key and class: the same for any order of the inputs.</summary>
private static int Order(ComparedPhoto a, ComparedPhoto b)
{
var byTime = ((a.Here ?? a.There)!.CapturedAt ?? DateTime.MaxValue).CompareTo((b.Here ?? b.There)!.CapturedAt ?? DateTime.MaxValue);
if (byTime != 0) return byTime;
var byKey = string.CompareOrdinal(a.Key, b.Key);
return byKey != 0 ? byKey : a.Class.CompareTo(b.Class);
}
private static PhotoClassTotal[] Totals(List<ComparedPhoto> photos) =>
[
.. Enum.GetValues<PhotoClass>().Select(c =>
{
var of = photos.Where(p => p.Class == c).ToList();
return new PhotoClassTotal(c, of.Count, of.Sum(p => p.Here?.Size ?? 0), of.Sum(p => p.There?.Size ?? 0));
}),
];
/// <summary>10. The counts and ratios of design §3.2 (Versions counted in Shared).</summary>
private static CopyScore Score(List<ComparedPhoto> photos, int localPhotos, int otherPhotos)
{
int Of(PhotoClass c) => photos.Count(p => p.Class == c);
var versions = Of(PhotoClass.Versions);
var shared = Of(PhotoClass.Same) + Of(PhotoClass.Converted) + versions;
var unhashed = Of(PhotoClass.SameUnhashed);
var (deletedHere, deletedThere) = (Of(PhotoClass.DeletedHere), Of(PhotoClass.DeletedThere));
var removed = deletedHere + deletedThere;
var smaller = Math.Min(localPhotos, otherPhotos);
var union = localPhotos + otherPhotos - (shared + unhashed);
var containment = smaller == 0 ? 0 : (int)Math.Min(1000, 1000L * (shared + unhashed + removed) / smaller);
var overlap = union <= 0 ? 0 : (int)Math.Min(1000, 1000L * (shared + unhashed) / union);
return new CopyScore(shared, unhashed, removed, Of(PhotoClass.OnlyHere), Of(PhotoClass.OnlyThere), Of(PhotoClass.Differs), deletedHere, deletedThere,
versions, localPhotos, otherPhotos, containment, overlap, 0);
}
}
+12
View File
@@ -42,6 +42,18 @@ public sealed class SyncTombstones
/// <summary>No photo removed on either side.</summary>
public static SyncTombstones None { get; } = new([], null);
/// <summary>
/// The tombstones of two copies both given as the manifest carries them (<see cref="ToDto"/>): a local pair compared
/// with each other (owner review 6, #73), <paramref name="here"/> standing for "this PC".
/// </summary>
public static SyncTombstones FromDtos(IEnumerable<RemovedPhotoDto> here, IEnumerable<RemovedPhotoDto>? there)
{
ArgumentNullException.ThrowIfNull(here);
return new SyncTombstones(here.Where(r => r is not null).Select(r => new FrameRemoval(Guid.Empty, r.Sha256, r.Replacement,
string.Equals(r.Reason, Wire(RemovalReason.Replaced), StringComparison.OrdinalIgnoreCase) ? RemovalReason.Replaced : RemovalReason.Deleted, r.At)),
there?.Where(r => r is not null));
}
/// <summary>Whether either side removed or replaced anything.</summary>
public bool IsEmpty => _deletedLocally.Count == 0 && _deletedRemotely.Count == 0 && _canonical.Count == 0;
@@ -0,0 +1,139 @@
using System.Globalization;
using Chronos.Core.Project;
using Chronos.Data.Copies;
using Chronos.Data.Sync;
using Chronos.Testing;
namespace Chronos.Data.Tests.Copies;
/// <summary>The details of two copies line by line and the one payload both get (owner review 6, Q4; design §4.3, §5e).</summary>
[Category("sync")]
public sealed class CopyPayloadTests
{
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, 'b');
private static FramePhoto Photo(int n) => new(Sha(n), 1000 + n, Start.AddSeconds(5 * n));
/// <summary>Photos 0–19 at indices 0–19.</summary>
private static readonly FramePhotos Here = new(Enumerable.Range(0, 20).Select(i => (i, Photo(i))));
/// <summary>Two photos more before them (100, 101): photo n at index n + 2.</summary>
private static readonly FramePhotos There = new(new[] { (0, Photo(100)), (1, Photo(101)) }.Concat(Enumerable.Range(0, 20).Select(i => (i + 2, Photo(i)))));
private static SyncPayload Payload(ProjectSettings settings, string? title = "Harbour", params string[] tags) =>
new(title, tags, 3, null, settings.ToJson());
private static IReadOnlyDictionary<string, CopySide> Choose(IEnumerable<DetailLine> lines, CopySide side, params (string Path, CopySide Side)[] except)
{
var choices = lines.ToDictionary(l => l.Path, _ => side, StringComparer.Ordinal);
foreach (var (path, chosen) in except) choices[path] = chosen;
return choices;
}
[Test]
public void TheSameExclusionAtAnotherIndexIsNoLine()
{
var here = Payload(new ProjectSettings { ExcludedFrames = [10], HeroFrame = 3 });
var there = Payload(new ProjectSettings { ExcludedFrames = [12], HeroFrame = 5 });
Assert.Empty(CopyPayload.Lines(here, Here, there, There));
// Another photo excluded there: one line, the frame positions.
var other = Payload(new ProjectSettings { ExcludedFrames = [11], HeroFrame = 5 });
var lines = CopyPayload.Lines(here, Here, other, There);
var line = Assert.Contains(lines, l => l.Path == CopyPayload.PendingFramesPath);
Assert.Count(1, lines);
Assert.Contains(Sha(10), line.Here);
Assert.Contains(Sha(9), line.There);
}
[Test]
public void FramePositionsCollapseIntoOneLine()
{
var here = Payload(new ProjectSettings { ExcludedFrames = [1, 2], HeroFrame = 3 }, "Harbour", "dusk");
var there = Payload(new ProjectSettings { ExcludedFrames = [9], HeroFrame = 7, Stack = new StackSettings { Length = 15 } }, "Harbour at dusk", "dusk", "sea");
var lines = CopyPayload.Lines(here, Here, there, There);
Assert.Count(4, lines);
Assert.True(lines.Select(l => l.Path).ToHashSet().SetEquals(["sequence.title", "sequence.tags", CopyPayload.PendingFramesPath, "stack.length"]));
var stack = lines.Single(l => l.Path == "stack.length");
Assert.Equal(("9", "15"), (stack.Here, stack.There));
}
[Test]
public void MergeTakesTheChosenSideOfEachLine()
{
var here = Payload(new ProjectSettings { ExcludedFrames = [1], Stack = new StackSettings { Length = 9 }, Export = new ExportSettings { NameTemplate = "{title}" } },
"Harbour", "dusk");
var there = Payload(new ProjectSettings { ExcludedFrames = [9], Stack = new StackSettings { Length = 15 }, Export = new ExportSettings { NameTemplate = "{date}" } },
"Harbour at dusk", "dusk", "sea");
var lines = CopyPayload.Lines(here, Here, there, There);
var choices = Choose(lines, CopySide.ThisPc, ("sequence.title", CopySide.Other), ("stack.length", CopySide.Other), (CopyPayload.PendingFramesPath, CopySide.Other));
var merged = CopyPayload.Merge(CopyPayload.Portable(here, Here), CopyPayload.Portable(there, There), choices, lines);
Assert.Equal("Harbour at dusk", merged.Title);
Assert.SequenceEqual(["dusk"], merged.Tags);
var settings = ProjectSettings.FromJson(merged.SettingsJson!);
Assert.Equal((15, "{title}"), (settings.Stack.Length, settings.Export.NameTemplate));
// Portable: placed on this PC's frames, the exclusion is there's photo 7 (index 9 there).
Assert.SequenceEqual([7], ProjectSettings.FromJson(ProjectContent.Place(merged.SettingsJson!, Here)).ExcludedFrames);
Assert.SequenceEqual([9], ProjectSettings.FromJson(ProjectContent.Place(merged.SettingsJson!, There)).ExcludedFrames);
// Every line this PC's: the merged payload is this PC's.
var mine = CopyPayload.Merge(CopyPayload.Portable(here, Here), CopyPayload.Portable(there, There), Choose(lines, CopySide.ThisPc), lines);
Assert.Empty(CopyPayload.Lines(mine, new FramePhotos([]), CopyPayload.Portable(here, Here), new FramePhotos([])));
}
[Test]
public void AnUnchosenLineThrows()
{
var here = Payload(new ProjectSettings(), "Harbour");
var there = Payload(new ProjectSettings { Stack = new StackSettings { Length = 15 } }, "Harbour at dusk");
var lines = CopyPayload.Lines(here, Here, there, There);
var choices = new Dictionary<string, CopySide> { ["sequence.title"] = CopySide.Other };
Assert.Throws<ArgumentException>(() => CopyPayload.Merge(here, there, choices, lines));
}
[Test]
public void AMergeThatIsNoProjectIsRefused()
{
var here = Payload(new ProjectSettings());
var there = new SyncPayload("Harbour", [], 3, null, "not a project");
var lines = CopyPayload.Lines(here, Here, there, There);
Assert.Equal("settings", Assert.Contains(lines, l => l.Path == "settings").Path);
Assert.Throws<InvalidDataException>(() => CopyPayload.Merge(here, there, Choose(lines, CopySide.Other), lines));
var kept = CopyPayload.Merge(here, there, Choose(lines, CopySide.ThisPc), lines);
Assert.Equal(9, ProjectSettings.FromJson(kept.SettingsJson!).Stack.Length);
}
[Test]
public void ExcludeVersionsExcludesByPhoto()
{
var portable = CopyPayload.Portable(Payload(new ProjectSettings { HeroFrame = 4 }), Here);
var unhashed = string.Create(CultureInfo.InvariantCulture, $"u:777:{Start.AddSeconds(500).Ticks / TimeSpan.TicksPerMillisecond}");
var excluded = CopyPayload.ExcludeVersions(portable, [Sha(99), Sha(4), unhashed]);
var pending = ProjectSettings.FromJson(excluded.SettingsJson!).PendingFrames!;
Assert.True(pending.Single(p => p.Sha256 == Sha(99)).Excluded);
// The hero's photo keeps its hero flag and is excluded too.
var hero = pending.Single(p => p.Sha256 == Sha(4));
Assert.True(hero.Excluded && hero.Hero);
var byTime = pending.Single(p => string.IsNullOrEmpty(p.Sha256));
Assert.Equal((777L, Start.AddSeconds(500)), (byTime.Size, byTime.CapturedAt!.Value));
// Placed on frames holding the version, it is excluded there.
var frames = new FramePhotos([(0, Photo(1)), (1, new FramePhoto(Sha(99), 5, Start)), (2, Photo(4))]);
var placed = ProjectSettings.FromJson(ProjectContent.Place(excluded.SettingsJson!, frames));
Assert.SequenceEqual([1, 2], placed.ExcludedFrames.Order());
Assert.Equal(2, placed.HeroFrame);
Assert.Same(portable, CopyPayload.ExcludeVersions(portable, []));
}
[Test]
public void MovedNamesThePathsThatChanged()
{
var before = CopyPayload.Portable(Payload(new ProjectSettings { ExcludedFrames = [1] }), Here);
var after = CopyPayload.Portable(Payload(new ProjectSettings { ExcludedFrames = [2], Stack = new StackSettings { Length = 3 } }, "Pier"), Here);
Assert.True(CopyPayload.Moved(before, after).SetEquals(["sequence.title", CopyPayload.PendingFramesPath, "stack.length"]));
Assert.Empty(CopyPayload.Moved(before, before));
}
}
@@ -0,0 +1,180 @@
using Chronos.Core.Project;
using Chronos.Data.Copies;
using Chronos.Testing;
namespace Chronos.Data.Tests.Copies;
/// <summary>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.</summary>
[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 };
/// <summary>1.1's gate passing: both unlinked, same second, same camera, half of 10 shared.</summary>
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<CopyLinking>())
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)));
}
}
@@ -0,0 +1,130 @@
using Chronos.Core.Model;
using Chronos.Data.Copies;
using Chronos.Data.Sync;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Data.Tests.Sync;
using Chronos.Protocol;
using Chronos.Testing;
namespace Chronos.Data.Tests.Copies;
/// <summary>The two sides of a comparison read from the index and from a server, and the last-copy check (owner review 6, #73; design §4.2).</summary>
[Category("sync")]
public abstract class CopySidesTests(TestContext context) : RepositoryTest(context)
{
private static string Sha(int n) => Convert.ToHexStringLower(BitConverter.GetBytes((long)n)).PadLeft(64, 'c');
private async Task<(Archive Archive, Sequence Sequence)> SequenceAsync(ChronosDatabase db, Archive? archive = null)
{
if (archive is null)
{
archive = TestData.Archive("A" + Guid.NewGuid().ToString("N")[..6]);
await db.Archives.UpsertAsync(archive, Ct);
}
var sequence = TestData.Sequence(archive.Id);
await db.Sequences.UpsertAsync(sequence, Ct);
return (archive, sequence);
}
private async Task<Frame> FrameAsync(ChronosDatabase db, Guid sequenceId, int index, string? sha, FrameFlags flags = FrameFlags.None)
{
var frame = TestData.Frame(sequenceId, index) with { Sha256 = sha, Flags = flags };
await db.Frames.InsertAsync(frame, Ct);
return frame;
}
[Test]
public async Task ALocalSideHoldsItsFramesTombstonesAndUnusableFlags()
{
var db = await OpenChronosAsync();
var (_, sequence) = await SequenceAsync(db);
var frames = new[]
{
await FrameAsync(db, sequence.Id, 0, Sha(0)),
await FrameAsync(db, sequence.Id, 1, Sha(1), FrameFlags.Missing),
await FrameAsync(db, sequence.Id, 2, Sha(2), FrameFlags.Corrupt | FrameFlags.Excluded),
await FrameAsync(db, sequence.Id, 3, null),
await FrameAsync(db, sequence.Id, 4, Sha(4), FrameFlags.Excluded),
};
await db.FrameRemovals.SyncSequenceAsync(sequence.Id,
[
new FrameRemoval(sequence.Id, Sha(8), null, RemovalReason.Deleted, TestData.Now),
new FrameRemoval(sequence.Id, Sha(9), Sha(4), RemovalReason.Replaced, TestData.Now.AddMinutes(1)),
], Ct);
var side = await new CopySides(db).LocalAsync(sequence.Id, Ct);
Assert.SequenceEqual(frames.Select(f => f.Id), side.Photos.Select(p => p.FrameId));
Assert.SequenceEqual([false, true, true, false, false], side.Photos.Select(p => p.Unusable));
Assert.Null(side.Photos[3].Sha256);
Assert.Equal((frames[0].FileName, frames[0].Size, frames[0].CapturedAt), (side.Photos[0].FileName, side.Photos[0].Size, side.Photos[0].CapturedAt));
Assert.SequenceEqual([(Sha(8), (string?)null, "deleted"), (Sha(9), Sha(4), "replaced")], side.Removed.Select(r => (r.Sha256, r.Replacement, r.Reason)));
// Compared with a copy holding every photo, the unusable frames are repaired and the converted one is the same photo.
var there = new CopySideInput([.. Enumerable.Range(0, 5).Select(i => new CopyPhotoInput(Guid.NewGuid(), i, frames[i].FileName,
i == 4 ? Sha(9) : Sha(i), frames[i].Size, frames[i].CapturedAt, false))], []);
var result = CopyComparer.Compare(side, there);
Assert.Equal((2, 1, 2), (result.Score.Shared, result.Score.SharedUnhashed, result.Score.OnlyThere));
Assert.True(result.Of(PhotoClass.OnlyThere).All(p => p.RepairsHere));
Assert.Equal(Sha(9), Assert.Contains(result.Photos, p => p.Class == PhotoClass.Converted).There!.Sha256);
}
[Test]
public async Task ARemoteSideTakesCaptureTimesFromTheFrameRows()
{
var db = await OpenChronosAsync();
using var remote = new FakeSyncRemote();
var at = new DateTime(2026, 9, 28, 18, 0, 0, 120);
var sequence = remote.Add("Harbour", []);
sequence.AddFrame([1, 2, 3], "IMG_0001.JPG", at);
sequence.AddFrame([4, 5, 6], "IMG_0002.JPG", at.AddSeconds(5));
sequence.Removed.Add(new RemovedPhotoDto(Sha(7), null, "deleted", TestData.Now));
var side = await new CopySides(db).RemoteAsync(remote, sequence.Id, Ct);
Assert.SequenceEqual(sequence.Frames.Select(f => (f.Id, f.FileName, f.Sha256, (long)f.Bytes.Length, f.CapturedAt)),
side.Photos.Select(p => (p.FrameId, p.FileName, p.Sha256!, p.Size, p.CapturedAt)));
Assert.True(side.Photos.All(p => !p.Unusable));
Assert.SequenceEqual([Sha(7)], side.Removed.Select(r => r.Sha256));
// A server that never hashed its originals lists none: they compare by size and time.
sequence.Unhashed = true;
Assert.True((await new CopySides(db).RemoteAsync(remote, sequence.Id, Ct)).Photos.All(p => p.Sha256 is null));
}
[Test]
public async Task HeldElsewhereLooksAcrossEveryArchiveOfTheIndex()
{
var db = await OpenChronosAsync();
var (_, mine) = await SequenceAsync(db);
var (other, inOther) = await SequenceAsync(db);
var (_, alsoInOther) = await SequenceAsync(db, other);
await FrameAsync(db, mine.Id, 0, Sha(1));
await FrameAsync(db, mine.Id, 1, Sha(2));
await FrameAsync(db, mine.Id, 2, Sha(3));
await FrameAsync(db, inOther.Id, 0, Sha(1));
await FrameAsync(db, alsoInOther.Id, 0, Sha(2), FrameFlags.Missing);
await FrameAsync(db, alsoInOther.Id, 1, Sha(4));
var sides = new CopySides(db);
var held = await sides.HeldElsewhereAsync([Sha(1).ToUpperInvariant(), Sha(2), Sha(3), Sha(4), string.Empty], [mine.Id], Ct);
// Photo 2's other frame is missing: it holds nothing. Photo 3 is only in the compared sequence.
Assert.True(held.SetEquals([Sha(1), Sha(4)]));
Assert.True((await sides.HeldElsewhereAsync([Sha(1), Sha(4)], [mine.Id, inOther.Id, alsoInOther.Id], Ct)).Count == 0);
Assert.True((await sides.HeldElsewhereAsync([Sha(1)], [], Ct)).SetEquals([Sha(1)]));
Assert.Empty(await sides.HeldElsewhereAsync([], [mine.Id], Ct));
// Batched: more hashes than one statement takes.
var many = Enumerable.Range(100, 1200).Select(Sha).Append(Sha(4)).ToList();
Assert.True((await sides.HeldElsewhereAsync(many, [mine.Id], Ct)).SetEquals([Sha(4)]));
}
}
public sealed class SqliteCopySidesTests(TestContext context) : CopySidesTests(context)
{
protected override Backend Backend => Backend.SqliteMemory;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresCopySidesTests(TestContext context) : CopySidesTests(context)
{
protected override Backend Backend => Backend.Postgres;
}
@@ -0,0 +1,228 @@
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);
}
}