feat(copies): pure comparison, detection rules, details payload and comparison sides
Detection, Integrate and Merge need one comparison of two copies of a time-lapse, so this adds it: CopyComparer classifies every photo (same, converted, same unhashed, deleted here/there, differs, two versions, only here/there) with strict Differs and Versions rules so whole-second capture times and bursts never pair, unusable frames held as nothing and marked for repair, and the score of design 3.2. CopyRules ports 1.1's same-originals gate exactly for "Link when half shared" and holds the Decide table, ask-again thresholds, fingerprints, hints and the probe sample. CopyPayload compares details in portable form (same photo at another index is no line) and merges the chosen sides into one payload that must parse as a project. CopySides reads both sides from the index and a server and answers the last-copy check across every archive. SyncTombstones gains FromDtos for local pairs. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
283d04d9cd
commit
f6f81e2c37
9 files changed
+1465
No files matched your search
@@ -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:<size>:<capture ms>") 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);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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:<size>:<capture millisecond>".</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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user