A merge that finds the other changed drops its journal so the retry plans again. Unlink and Keep apart name the local side and leave a link that now joins another sequence alone; Link only and the Integrate job refuse to touch a link or a pair another integration holds. A sweep of 404s asks the server once. To trash... trashes from the kept sequence after a swap and every trash re-checks for new last copies. The Compare dialog and Settings choices fit in every language, Details segments say which value they take, twins need their sibling at the other home, and a linked row keeps three buttons. Captures updated for the dialog and Settings scenes. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
546 lines
34 KiB
C#
546 lines
34 KiB
C#
using System.Globalization;
|
|
using System.IO;
|
|
using Chronos.App.Infrastructure;
|
|
using Chronos.App.Server;
|
|
using Chronos.App.Server.Copies;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Copies;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Testing;
|
|
using Chronos.Ui.Controls;
|
|
|
|
namespace Chronos.App.Tests.Server;
|
|
|
|
/// <summary>Words, glyphs and actions of a match (owner review 6, #73, design §8.1), and the sync rows a match marks.</summary>
|
|
[Serial]
|
|
public sealed class CopyTextTests
|
|
{
|
|
private const string Nas = "https://nas.local:8443";
|
|
private static readonly CopyRights SignedIn = new(Nas, "Studio NAS", CanIntegrate: true, CanUpload: true);
|
|
|
|
private static readonly Sequence Local = new()
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
ArchiveId = Guid.CreateVersion7(),
|
|
Title = "Lighthouse 2026-08-13",
|
|
Folder = "2026/lighthouse",
|
|
FrameCount = 1_204,
|
|
TotalBytes = 18_200_000_000,
|
|
Status = SequenceStatus.ProxiesBuilt,
|
|
};
|
|
|
|
private static readonly SyncLink Link = new()
|
|
{
|
|
Server = Nas,
|
|
RemoteId = Guid.CreateVersion7(),
|
|
Title = "Lighthouse 2026-08-13",
|
|
TotalBytes = 18_200_000_000,
|
|
RemoteStatus = SequenceStatus.ProxiesBuilt,
|
|
};
|
|
|
|
[Test]
|
|
public void EachStateOffersTheActionsOfTheTable()
|
|
{
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Integrate, CopyAction.KeepApart], CopyText.Actions(Copy(CopyState.Candidate)));
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Merge, CopyAction.KeepApart], CopyText.Actions(Copy(CopyState.Candidate, CopyKind.LocalLocal)));
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.AskAgain], CopyText.Actions(Copy(CopyState.KeptApart)));
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Integrate, CopyAction.Unlink], CopyText.Actions(Copy(CopyState.Linked)));
|
|
// Three buttons at most: a linked pair with photos deleted there reaches Integrate through Compare… or Review.
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Unlink, CopyAction.Review], CopyText.Actions(Copy(CopyState.Linked, deletedThere: 3)));
|
|
foreach (var state in Enum.GetValues<CopyState>())
|
|
{
|
|
foreach (var copy in new[] { Copy(state), Copy(state, deletedThere: 3), Copy(state, gone: true), Copy(state, CopyKind.LocalLocal, deletedThere: 3) })
|
|
Assert.LessOrEqual(CopyText.Actions(copy).Count, 3, $"{state}: at most three row buttons");
|
|
}
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Unlink], CopyText.Actions(Copy(CopyState.Integrated)));
|
|
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Unlink, CopyAction.Review], CopyText.Actions(Copy(CopyState.Integrated, deletedThere: 3)));
|
|
Assert.SequenceEqual([CopyAction.Pause], CopyText.Actions(Copy(CopyState.Integrating), JobState.Running));
|
|
Assert.SequenceEqual([CopyAction.Resume], CopyText.Actions(Copy(CopyState.Integrating), JobState.Paused));
|
|
|
|
// The server deleted its copy: keep it here, send it again or move it to the trash; once kept, only send again.
|
|
Assert.SequenceEqual([CopyAction.KeepHere, CopyAction.UploadAgain, CopyAction.ToTrash], CopyText.Actions(Copy(CopyState.Linked, gone: true)));
|
|
Assert.SequenceEqual([CopyAction.UploadAgain], CopyText.Actions(Copy(CopyState.KeptApart, gone: true)));
|
|
}
|
|
|
|
[Test]
|
|
public void TheStateGlyphFollowsWhatThePairAsksFor()
|
|
{
|
|
Assert.Equal(StatusKind.Warning, CopyText.State(Copy(CopyState.Candidate)).Kind);
|
|
Assert.Equal(StatusKind.Offline, CopyText.State(Copy(CopyState.KeptApart)).Kind);
|
|
Assert.Equal(StatusKind.Synced, CopyText.State(Copy(CopyState.Linked)).Kind);
|
|
Assert.Equal(StatusKind.Running, CopyText.State(Copy(CopyState.Integrating), progress: (3, 10)).Kind);
|
|
Assert.Equal(StatusKind.Done, CopyText.State(Copy(CopyState.Integrated)).Kind);
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Copies.State.DeletedThere", "3")),
|
|
Head(CopyText.State(Copy(CopyState.Integrated, deletedThere: 3))));
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Copies.State.DeletedOther", "3")),
|
|
Head(CopyText.State(Copy(CopyState.Integrated, CopyKind.LocalLocal, deletedThere: 3))));
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Copies.State.RemoteGone")), Head(CopyText.State(Copy(CopyState.Linked, gone: true))));
|
|
Assert.Equal((StatusKind.Offline, Loc.L("Server.Copies.State.KeptHere")), Head(CopyText.State(Copy(CopyState.KeptApart, gone: true))));
|
|
// The candidate's tooltip says how much the two share.
|
|
Assert.Contains("98", CopyText.State(Copy(CopyState.Candidate)).ToolTip);
|
|
}
|
|
|
|
[Test]
|
|
public void AnActionThatCannotRunSaysWhy()
|
|
{
|
|
var candidate = Copy(CopyState.Candidate);
|
|
Assert.Null(CopyText.Blocked(candidate, CopyAction.Integrate, SignedIn));
|
|
// A pair of another server needs that server signed in; the answers that move nothing never do.
|
|
var signedOut = new CopyRights(null, null, false, false);
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.SignIn", Nas), CopyText.Blocked(candidate, CopyAction.Compare, signedOut));
|
|
Assert.Null(CopyText.Blocked(candidate, CopyAction.KeepApart, signedOut));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.NeedsNewerServer"), CopyText.Blocked(candidate, CopyAction.Integrate, SignedIn with { CanIntegrate = false }));
|
|
Assert.Equal(Loc.L("Errors.Copies.Busy"), CopyText.Blocked(candidate, CopyAction.Integrate, SignedIn with { Busy = true }));
|
|
Assert.Null(CopyText.Blocked(candidate, CopyAction.Compare, SignedIn with { Busy = true }));
|
|
var gone = Copy(CopyState.Linked, gone: true);
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.UploadAll.NoRight"), CopyText.Blocked(gone, CopyAction.UploadAgain, SignedIn with { CanUpload = false }));
|
|
// A local pair needs no server.
|
|
Assert.Null(CopyText.Blocked(Copy(CopyState.Candidate, CopyKind.LocalLocal), CopyAction.Merge, signedOut));
|
|
// The tooltip of a disabled button is its reason.
|
|
Assert.Equal(Loc.L("Errors.Copies.Busy"), CopyText.ToolTip(candidate, CopyAction.Integrate, SignedIn with { Busy = true }));
|
|
}
|
|
|
|
[Test]
|
|
public void AttentionComesFirstThenTheStrongerHints()
|
|
{
|
|
var kept = View(Copy(CopyState.KeptApart) with { Score = Score(hints: 900) }, "Aurora");
|
|
var weak = View(Copy(CopyState.Candidate) with { Score = Score(hints: 100) }, "Bridge");
|
|
var strong = View(Copy(CopyState.Candidate) with { Score = Score(hints: 800) }, "Comet");
|
|
Assert.SequenceEqual(["Comet", "Bridge", "Aurora"], CopyText.Sorted([kept, weak, strong]).Select(p => p.Here.Title));
|
|
Assert.True(CopyText.Matches(strong, "com"));
|
|
Assert.True(CopyText.Matches(strong, "Comet (nas)"));
|
|
Assert.False(CopyText.Matches(strong, "Aurora"));
|
|
}
|
|
|
|
[Test]
|
|
public void EveryWordResolvesInEnglishAndItalianAndLabelsStayShort()
|
|
{
|
|
var missing = new List<string>();
|
|
void OnMissing(string key) => missing.Add(key);
|
|
Loc.MissingKey += OnMissing;
|
|
try
|
|
{
|
|
foreach (var culture in new[] { "en", "it" })
|
|
{
|
|
Loc.SetCulture(CultureInfo.GetCultureInfo(culture));
|
|
var gone = Copy(CopyState.Linked, gone: true);
|
|
foreach (var action in Enum.GetValues<CopyAction>())
|
|
{
|
|
var label = CopyText.Label(action);
|
|
Assert.LessOrEqual(label.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length, 3, $"{culture}: \"{label}\" is at most three words");
|
|
Assert.False(string.IsNullOrWhiteSpace(CopyText.ToolTip(gone, action, SignedIn)), $"{culture}: {action} has a tooltip");
|
|
}
|
|
foreach (var c in Enum.GetValues<PhotoClass>())
|
|
{
|
|
Assert.False(string.IsNullOrWhiteSpace(CopyText.Class(c)), $"{culture}: {c}");
|
|
foreach (var policy in Enum.GetValues<CopyPhotoPolicy>())
|
|
{
|
|
foreach (var merge in new[] { false, true })
|
|
Assert.False(string.IsNullOrWhiteSpace(CopyText.ClassToolTip(c, policy, merge)), $"{culture}: {c} has a tooltip under {policy}");
|
|
}
|
|
}
|
|
foreach (var block in Enum.GetValues<CopyBlock>())
|
|
Assert.False(string.IsNullOrWhiteSpace(CopyText.Block(block, "Lighthouse", "Studio NAS", "2 GB", 2)), $"{culture}: {block}");
|
|
foreach (var state in Enum.GetValues<CopyState>())
|
|
{
|
|
foreach (var copy in new[] { Copy(state), Copy(state, deletedThere: 2), Copy(state, gone: true), Copy(state, CopyKind.LocalLocal, deletedThere: 2) })
|
|
{
|
|
var (_, text, tip) = CopyText.State(copy, "Studio NAS", (1, 4));
|
|
Assert.False(string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(tip), $"{culture}: {state}");
|
|
}
|
|
}
|
|
foreach (var why in Enum.GetValues<UploadSkip>())
|
|
Assert.False(string.IsNullOrWhiteSpace(SyncText.State(Entry(SyncStatus.LocalOnly, link: null), new SyncMark(null, why)).ToolTip), $"{culture}: {why}");
|
|
Assert.False(string.IsNullOrWhiteSpace(SyncText.ToolTip(Entry(SyncStatus.InSync), SyncAction.Compare)), $"{culture}: Compare has a tooltip");
|
|
Assert.Equal(Loc.L("Server.Copies.Detail.OtherSetting"), SyncText.DetailLabel("nothing.known"));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Loc.MissingKey -= OnMissing;
|
|
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
|
}
|
|
Assert.Empty(missing);
|
|
}
|
|
|
|
[Test]
|
|
public void ASyncRowInAMatchSaysSoAndOffersCompare()
|
|
{
|
|
var entry = Entry(SyncStatus.LocalOnly, link: null);
|
|
// The Matches chip lists pairs, never sync rows.
|
|
Assert.False(SyncText.Matches(entry, SyncFilter.FoundCopies, string.Empty));
|
|
|
|
var editor = SyncRights.Of((long)RolePermissions.Default(UserRole.Editor));
|
|
var candidate = new SyncMark(Copy(CopyState.Candidate), null, "Studio NAS");
|
|
var (kind, text, tip) = SyncText.State(entry, candidate);
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Sync.State.CopyFound")), (kind, text));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.State.CopyFound", "Studio NAS"), tip);
|
|
Assert.SequenceEqual([SyncAction.Compare, SyncAction.Upload], SyncText.Actions(entry, editor, candidate));
|
|
|
|
// A linked row offers Compare last; one without a pair, nothing more.
|
|
var linked = Entry(SyncStatus.InSync);
|
|
Assert.SequenceEqual([SyncAction.Compare], SyncText.Actions(linked, editor, new SyncMark(Copy(CopyState.Linked), null)));
|
|
Assert.Empty(SyncText.Actions(linked, editor, default));
|
|
|
|
// Deleted on the server, or kept here after that.
|
|
Assert.Equal(Loc.L("Server.Sync.State.RemoteGone"), SyncText.State(linked, new SyncMark(Copy(CopyState.Linked, gone: true), null)).Text);
|
|
Assert.Equal(Loc.L("Server.Sync.State.KeptHere"), SyncText.State(linked, new SyncMark(Copy(CopyState.KeptApart, gone: true), null)).Text);
|
|
|
|
// Upload all local left it out: "skipped", with the reason, under the Warning glyph (design §6.4).
|
|
var skipped = SyncText.State(entry, new SyncMark(null, UploadSkip.KeptApart));
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Sync.State.Skipped")), (skipped.Kind, skipped.Text));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.State.Skipped", Loc.L("Tooltips.Server.Sync.Skip.KeptApart")), skipped.ToolTip);
|
|
// A transfer still shows first.
|
|
var upload = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.UploadCommit, State = JobState.Running };
|
|
Assert.Equal(SyncText.State(entry with { Transfer = upload }), SyncText.State(entry with { Transfer = upload }, candidate));
|
|
}
|
|
|
|
[Test]
|
|
public void ASkipForASuspectedMatchNamesWhereTheMatchLies()
|
|
{
|
|
var mark = new SyncMark(null, UploadSkip.SuspectedCopy, "Studio NAS");
|
|
// A match on another server than the signed-in one is named by that server.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.Skip.SuspectedCopy", "Lab NAS"),
|
|
SyncText.SkipReason(UploadSkip.SuspectedCopy, mark with { SkippedMatch = new SkippedMatch("Lab NAS", false) }));
|
|
// One in another archive of this PC says "in", not "on".
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.Skip.SuspectedCopyLocal", "Old archive"),
|
|
SyncText.SkipReason(UploadSkip.SuspectedCopy, mark with { SkippedMatch = new SkippedMatch("Old archive", true) }));
|
|
// Unknown: the signed-in server.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.Skip.SuspectedCopy", "Studio NAS"), SyncText.SkipReason(UploadSkip.SuspectedCopy, mark));
|
|
// A job on it may integrate or merge it: the words say neither alone.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.Skip.Busy"), SyncText.SkipReason(UploadSkip.Busy, mark));
|
|
}
|
|
|
|
[Test]
|
|
public void ARowWhoseMatchTheServerDeletedOffersWhatTheMatchesRowDoes()
|
|
{
|
|
var entry = Entry(SyncStatus.LocalOnly, link: null);
|
|
var editor = SyncRights.Of((long)RolePermissions.Default(UserRole.Editor));
|
|
var gone = new SyncMark(Copy(CopyState.Linked, gone: true), null, "Studio NAS");
|
|
Assert.SequenceEqual([SyncAction.KeepHere, SyncAction.UploadAgain, SyncAction.ToTrash], SyncText.Actions(entry, editor, gone));
|
|
// Kept here: only Upload again.
|
|
Assert.SequenceEqual([SyncAction.UploadAgain], SyncText.Actions(entry, editor, new SyncMark(Copy(CopyState.KeptApart, gone: true), null)));
|
|
foreach (var action in new[] { SyncAction.KeepHere, SyncAction.UploadAgain, SyncAction.ToTrash })
|
|
{
|
|
var row = new SyncRowAction(action, () => Task.CompletedTask);
|
|
Assert.Equal(Loc.L("Server.Copies.Action." + action), row.Text);
|
|
Assert.False(string.IsNullOrWhiteSpace(SyncText.ToolTip(entry, action, editor, gone)), $"{action} has a tooltip");
|
|
}
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.UploadAgain", "Studio NAS"), SyncText.ToolTip(entry, SyncAction.UploadAgain, editor, gone));
|
|
// Without the upload right, Upload again is offered disabled with the reason.
|
|
var reader = SyncRights.Of((long)RolePermissions.Default(UserRole.Viewer));
|
|
Assert.False(SyncText.IsEnabled(SyncAction.UploadAgain, reader));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Sync.UploadAll.NoRight"), SyncText.ToolTip(entry, SyncAction.UploadAgain, reader, gone));
|
|
}
|
|
|
|
[Test]
|
|
public void TheOwnerReview6TextsFitTheirPlaces()
|
|
{
|
|
// Integrating: the share in the cell, "x of y" in the tooltip.
|
|
var (_, text, tip) = CopyText.State(Copy(CopyState.Integrating), progress: (1_234, 2_400));
|
|
Assert.Equal(Loc.L("Server.Copies.State.Integrating", "51"), text);
|
|
Assert.Contains(Loc.L("Server.Copies.State.Progress", "1,234", "2,400"), tip);
|
|
Assert.Equal(Loc.L("Server.Copies.State.Integrating", "0"), CopyText.State(Copy(CopyState.Integrating)).Text);
|
|
|
|
// The count comes first, so a trimmed cell keeps what tells two pairs apart.
|
|
Assert.True(CopyText.Where(Facts("Lighthouse", "Main archive", 1_204), isServer: false).StartsWith("1,204", StringComparison.Ordinal));
|
|
// A server that deleted its sequence is named alone, never "0 photos".
|
|
Assert.Equal("Studio NAS", CopyText.Where(Facts(string.Empty, "Studio NAS", 0), isServer: true, gone: true));
|
|
|
|
// The frame positions read as the setting they are, with the count of photos they place.
|
|
Assert.Equal(Loc.L("Server.Copies.Detail.Positions"), SyncText.DetailLabel(CopyPayload.PendingFramesPath));
|
|
Assert.Equal(Loc.Plural("Shell.Status.Photos", 2), SyncText.DetailValue(CopyPayload.PendingFramesPath, "{\"a\":{},\"b\":{}}"));
|
|
Assert.Equal("Lighthouse", SyncText.DetailValue("sequence.title", "Lighthouse"));
|
|
Assert.Equal("41", SyncText.DetailValue("exposure.deflickerWindow.manual", "41"));
|
|
Assert.Equal(Loc.L("Server.Copies.Detail.Changed"), SyncText.DetailValue("exposure.curve", "{\"points\":[[0,0],[1,1]]}"));
|
|
// The members of one setting are one row and one choice.
|
|
Assert.Equal(SyncText.DetailSetting("exposure.deflickerWindow.isAuto"), SyncText.DetailSetting("exposure.deflickerWindow.manual"));
|
|
var row = new CopyDetailRow([new DetailLine("exposure.deflickerWindow.isAuto", "true", "false"), new DetailLine("exposure.deflickerWindow.manual", "41", "33")],
|
|
isMerge: false, () => { });
|
|
Assert.SequenceEqual(["exposure.deflickerWindow.isAuto", "exposure.deflickerWindow.manual"], row.Paths);
|
|
Assert.Equal(string.Join(Loc.Separator, Loc.L("Server.Setting.Auto"), "41"), row.HereText);
|
|
|
|
// A match between this PC's archives names the other archive, not the server.
|
|
var local = new SyncMark(Copy(CopyState.Candidate, CopyKind.LocalLocal), null, "Studio NAS", OtherWhere: "Old archive");
|
|
Assert.Equal(Loc.L("Tooltips.Library.Status.CopyFoundLocal", "Old archive"), SyncText.State(Entry(SyncStatus.LocalOnly, link: null), local).ToolTip);
|
|
|
|
// The Library card of a sequence whose server copy was deleted says so.
|
|
var gone = View(Copy(CopyState.Linked, gone: true), "Lighthouse");
|
|
var status = CopyListViewModel.LibraryStatus(gone, Local.Id);
|
|
Assert.Equal(Loc.L("Library.Status.RemoteGone"), status.Text);
|
|
|
|
// A plan line is what will happen (queued), a warning leads.
|
|
Assert.Equal(StatusKind.Queued, new CopyPlanLine("Receives 2 photos").Kind);
|
|
Assert.Equal(StatusKind.Warning, new CopyPlanLine("Only copy", IsWarning: true).Kind);
|
|
}
|
|
|
|
[Test]
|
|
public void TheReplaceConfirmationListsEachSidesLosersUnderItsHeading()
|
|
{
|
|
var trashed = new List<PhotoStep>
|
|
{
|
|
new("a", PhotoAction.TrashHere, Guid.NewGuid(), "IMG_0001.JPG", 10, "a"),
|
|
new("b", PhotoAction.TrashHere, Guid.NewGuid(), "IMG_0002.JPG", 10, "b"),
|
|
new("c", PhotoAction.TrashThere, Guid.NewGuid(), "IMG_0003.JPG", 10, "c"),
|
|
};
|
|
var lasts = new List<LastCopy> { new("b", CopySide.ThisPc, "IMG_0002.JPG", 10) };
|
|
|
|
var lines = CopyDialogViewModel.ReplaceLines(lasts, trashed, "Studio NAS").Split(Environment.NewLine);
|
|
|
|
Assert.SequenceEqual(
|
|
[
|
|
Loc.L("Server.Copies.Plan.OnThisPc"),
|
|
" " + Loc.L("Server.Copies.Confirm.LastCopy", "IMG_0002.JPG"),
|
|
// A replaced version under an "Only copy:" line carries its own prefix (owner review 6, verification round 5).
|
|
" " + Loc.L("Server.Copies.Confirm.Replaced", "IMG_0001.JPG"),
|
|
Loc.L("Server.Copies.Plan.OnServer", "Studio NAS"),
|
|
" " + Loc.L("Server.Copies.Confirm.Replaced", "IMG_0003.JPG"),
|
|
], lines);
|
|
|
|
// To trash… and Delete on server…: the only copies first, the photos held elsewhere each with their prefix, once.
|
|
var trash = CopyDialogViewModel.Lines(lasts, ["IMG_0002.JPG", "IMG_0001.JPG", "IMG_0001.JPG"]).Split(Environment.NewLine);
|
|
Assert.SequenceEqual(
|
|
[
|
|
Loc.L("Server.Copies.Confirm.LastCopy", "IMG_0002.JPG"),
|
|
Loc.L("Server.Copies.Confirm.Elsewhere", "IMG_0001.JPG"),
|
|
], trash);
|
|
|
|
// A merge's facts are not photos held elsewhere: they carry no prefix, after the only copies.
|
|
var facts = CopyDialogViewModel.Lines(lasts, ["1 render moved"], elsewhere: false).Split(Environment.NewLine);
|
|
Assert.SequenceEqual(
|
|
[
|
|
Loc.L("Server.Copies.Confirm.LastCopy", "IMG_0002.JPG"),
|
|
"1 render moved",
|
|
], facts);
|
|
}
|
|
|
|
[Test]
|
|
public void AMergeNamesItsSidesByRoleAndAsksForAVersionOfEachDifferentPhoto()
|
|
{
|
|
// Class words: by role once a sequence is kept, oriented from the kept one; by place before.
|
|
var onlyHere = new CopyClassRow(new PhotoClassTotal(PhotoClass.OnlyHere, 38, 570_000_000, 0), CopyPhotoPolicy.Union, isMerge: true);
|
|
Assert.Equal(Loc.L("Server.Copies.Class.OnlyKept"), onlyHere.Text);
|
|
var raised = new List<string?>();
|
|
onlyHere.PropertyChanged += (_, e) => raised.Add(e.PropertyName);
|
|
onlyHere.Swapped = true;
|
|
Assert.Equal(Loc.L("Server.Copies.Class.OnlyOther"), onlyHere.Text);
|
|
Assert.Contains(nameof(CopyClassRow.Text), raised);
|
|
raised.Clear();
|
|
onlyHere.Places = ("Main archive", "Studio archive");
|
|
Assert.Equal(Loc.L("Server.Copies.Class.OnlyHere"), onlyHere.Text);
|
|
Assert.Contains(nameof(CopyClassRow.Text), raised);
|
|
Assert.Equal(Loc.L("Server.Copies.Class.DeletedOther"), CopyText.Class(PhotoClass.DeletedThere, merge: true));
|
|
Assert.Equal(Loc.L("Server.Copies.Class.Differs"), CopyText.Class(PhotoClass.Differs, merge: true));
|
|
Assert.Equal(Loc.L("Server.Copies.Class.OnlyHere"), new CopyClassRow(new PhotoClassTotal(PhotoClass.OnlyHere, 1, 1, 0)).Text);
|
|
|
|
// Choose each in a merge: its own tooltip, no Leave, and the unchosen block leads to the photos.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs.ChooseMerge"),
|
|
CopyText.ClassToolTip(PhotoClass.Differs, CopyPhotoPolicy.ChoosePerPhoto, isMerge: true));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs.Choose"), CopyText.ClassToolTip(PhotoClass.Differs, CopyPhotoPolicy.ChoosePerPhoto));
|
|
Assert.SequenceEqual([PhotoChoice.KeepBoth, PhotoChoice.TakeHere, PhotoChoice.TakeThere],
|
|
CopyDialogViewModel.VersionChoices(merge: true).Select(o => o.Value));
|
|
Assert.Contains(PhotoChoice.Leave, CopyDialogViewModel.VersionChoices(merge: false).Select(o => o.Value));
|
|
Assert.True(CopyText.HasChoose(CopyBlock.PhotosUnchosen));
|
|
|
|
// A version choice not made yet is read out as such, not as Leave.
|
|
var photo = new ComparedPhoto(PhotoClass.Differs, "k",
|
|
new CopyPhotoInput(Guid.NewGuid(), 0, "IMG_0004.JPG", "a", 10, null, false), new CopyPhotoInput(Guid.NewGuid(), 0, "IMG_0004.JPG", "b", 12, null, false),
|
|
1, 1, 10);
|
|
var row = new CopyPhotoRow(photo, isMerge: true, canBring: false, canChoose: true, CopyDialogViewModel.VersionChoices(true), null, () => { }, null);
|
|
Assert.Equal(Loc.L("Server.Copies.ControlFor", "IMG_0004.JPG", Loc.L("Server.Copies.Version.None")), row.ChoiceAccessibleName);
|
|
Assert.False(row.InMain);
|
|
}
|
|
|
|
[Test]
|
|
public void ThePairWordsFollowWhatTheRunReallyDoes()
|
|
{
|
|
// An Integrate that left photos out moves new photos only by hand; one that left nothing out, by itself.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.State.IntegratedByHand"), CopyText.State(Copy(CopyState.Integrated)).ToolTip);
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.State.Integrated"), CopyText.State(Copy(CopyState.Integrated) with { AutoPhotos = true }).ToolTip);
|
|
|
|
// A pair of this PC's archives is merged, with the same "x of y".
|
|
var (_, text, tip) = CopyText.State(Copy(CopyState.Integrating, CopyKind.LocalLocal), progress: (1, 4));
|
|
Assert.Equal(Loc.L("Server.Copies.State.Merging", "25"), text);
|
|
Assert.Equal(string.Join(Environment.NewLine, Loc.L("Tooltips.Server.Copies.State.Merging"), Loc.L("Server.Copies.State.Progress", "1", "4")), tip);
|
|
// The row follows a merge's progress as it follows an Integrate's.
|
|
Assert.True(CopyListViewModel.Follows(JobKind.MergeSequences));
|
|
Assert.True(CopyListViewModel.Follows(JobKind.Integrate));
|
|
Assert.False(CopyListViewModel.Follows(JobKind.UploadCommit));
|
|
|
|
// A class says what the chosen policy does with it, and a merge says it its own way.
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs"), CopyText.ClassToolTip(PhotoClass.Differs));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs.ThisPcWins"), CopyText.ClassToolTip(PhotoClass.Differs, CopyPhotoPolicy.ThisPcWins));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs.KeptWins"), CopyText.ClassToolTip(PhotoClass.Differs, CopyPhotoPolicy.ThisPcWins, isMerge: true));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.OnlyHere.Choose"), CopyText.ClassToolTip(PhotoClass.OnlyHere, CopyPhotoPolicy.ChoosePerPhoto));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.OnlyThere.Merge"), CopyText.ClassToolTip(PhotoClass.OnlyThere, CopyPhotoPolicy.ChoosePerPhoto, isMerge: true));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.SameUnhashed.Integrate"), CopyText.ClassToolTip(PhotoClass.SameUnhashed));
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.SameUnhashed"), CopyText.ClassToolTip(PhotoClass.SameUnhashed, isMerge: true));
|
|
|
|
// The class row follows the dialog's policy, and a merge keeping the other sequence reads its classes from the kept side.
|
|
var differs = new CopyClassRow(new PhotoClassTotal(PhotoClass.Differs, 2, 51_400_000, 51_800_000));
|
|
differs.Policy = CopyPhotoPolicy.OtherWins;
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.Differs.OtherWins"), differs.ToolTip);
|
|
var onlyHere = new CopyClassRow(new PhotoClassTotal(PhotoClass.OnlyHere, 38, 570_000_000, 0), CopyPhotoPolicy.Union, isMerge: true) { Swapped = true };
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Class.OnlyThere.Merge"), onlyHere.ToolTip);
|
|
|
|
// The size cell shows the bytes of the side that holds them; both sides in the tooltip when both do.
|
|
var onlyThere = new CopyClassRow(new PhotoClassTotal(PhotoClass.OnlyThere, 3, 0, 45_000_000));
|
|
Assert.Equal(Formatting.Bytes(45_000_000), onlyThere.BytesText);
|
|
Assert.Equal(Loc.L("Server.Copies.Detail.Server") + " " + Formatting.Bytes(45_000_000), onlyThere.BytesToolTip);
|
|
Assert.Equal(Formatting.Bytes(51_400_000), differs.BytesText);
|
|
Assert.Equal(string.Join(Loc.Separator, Loc.L("Server.Copies.Detail.ThisPc") + " " + Formatting.Bytes(51_400_000),
|
|
Loc.L("Server.Copies.Detail.Server") + " " + Formatting.Bytes(51_800_000)), differs.BytesToolTip);
|
|
}
|
|
|
|
[Test]
|
|
public void ASyncRowOfAPairWhoseMatchDeletedPhotosSaysSoAndOffersReview()
|
|
{
|
|
var entry = Entry(SyncStatus.InSync);
|
|
var editor = SyncRights.Of((long)RolePermissions.Default(UserRole.Editor));
|
|
foreach (var state in new[] { CopyState.Linked, CopyState.Integrated })
|
|
{
|
|
var mark = new SyncMark(Copy(state, deletedThere: 3), null);
|
|
Assert.Equal((StatusKind.Warning, Loc.L("Server.Copies.State.DeletedThere", "3"), Loc.Plural("Tooltips.Server.Copies.State.DeletedThere", 3)),
|
|
SyncText.State(entry, mark));
|
|
Assert.SequenceEqual([SyncAction.Compare, SyncAction.Review], SyncText.Actions(entry, editor, mark).TakeLast(2));
|
|
Assert.False(string.IsNullOrWhiteSpace(SyncText.ToolTip(entry, SyncAction.Review)));
|
|
}
|
|
// Nothing deleted: the ordinary sync state, Compare last.
|
|
Assert.Equal(SyncText.State(entry), SyncText.State(entry, new SyncMark(Copy(CopyState.Linked), null)));
|
|
Assert.Equal(SyncAction.Compare, SyncText.Actions(entry, editor, new SyncMark(Copy(CopyState.Linked), null))[^1]);
|
|
}
|
|
|
|
[Test]
|
|
public void TheMatchStatusComesRightAfterTheAnalysisStatus()
|
|
{
|
|
var analysed = new Chronos.Ui.Visuals.CardStatus(StatusKind.Analysed, "Analysed");
|
|
var proxies = new Chronos.Ui.Visuals.CardStatus(StatusKind.Done, "Proxies");
|
|
var synced = new Chronos.Ui.Visuals.CardStatus(StatusKind.Synced, "Synced");
|
|
var match = new Chronos.Ui.Visuals.CardStatus(StatusKind.Warning, "Also elsewhere");
|
|
Assert.SequenceEqual([analysed, match, proxies, synced], Chronos.App.Library.SequenceItem.WithMatch([analysed, proxies, synced], match));
|
|
Assert.SequenceEqual([analysed, proxies], Chronos.App.Library.SequenceItem.WithMatch([analysed, proxies], null));
|
|
}
|
|
|
|
[Test]
|
|
public void TheMatchWordsNeverUseTheNounCopy()
|
|
{
|
|
// Design §1.1: the duplicates report owns "copy/copie"; a match is a sequence twice. The photo-level "last copy"
|
|
// and the verb "copy" stay.
|
|
string[] areas = ["Server.Copies.", "Server.Sync.Skip.", "Server.Sync.State.", "Library.Status.", "Settings.Copy", "Errors.Copies."];
|
|
string[] allowed =
|
|
[
|
|
"Server.Copies.Projects.CopyAcross", "Server.Copies.Plan.LastCopies.one", "Server.Copies.Plan.LastCopies.other",
|
|
"Server.Copies.Confirm.LastCopy", "Tooltips.Server.Copies.ToTrashSequence", "Tooltips.Server.Copies.Bring",
|
|
];
|
|
var noun = new System.Text.RegularExpressions.Regex(@"\b(copy|copie)\b", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
|
|
var found = new List<string>();
|
|
foreach (var culture in new[] { "en", "it" })
|
|
{
|
|
foreach (var file in Directory.EnumerateFiles(Path.Combine(TestContext.RepositoryRoot, "i18n", culture), "*.resx"))
|
|
{
|
|
foreach (var data in System.Xml.Linq.XDocument.Load(file).Root!.Elements("data"))
|
|
{
|
|
var name = (string)data.Attribute("name")!;
|
|
var bare = name.StartsWith("Tooltips.", StringComparison.Ordinal) ? name["Tooltips.".Length..] : name;
|
|
if (!areas.Any(a => bare.StartsWith(a, StringComparison.Ordinal)) || allowed.Contains(name)) continue;
|
|
if (noun.IsMatch((string?)data.Element("value") ?? string.Empty)) found.Add($"{culture}: {name}");
|
|
}
|
|
}
|
|
}
|
|
Assert.Empty(found);
|
|
}
|
|
|
|
[Test]
|
|
public void APlanCountsAsSecondVersionsOnlyThoseKeptBesideTheirPair()
|
|
{
|
|
// Union keeps "a" beside its pair; This PC wins replaces "b" (its loser goes to the trash on the same side).
|
|
var steps = new List<PhotoStep>
|
|
{
|
|
new("a", PhotoAction.SendVersion, Guid.NewGuid(), "IMG_0001.JPG", 10, "a"),
|
|
new("b", PhotoAction.SendVersion, Guid.NewGuid(), "IMG_0002.JPG", 10, "b"),
|
|
new("b", PhotoAction.TrashThere, Guid.NewGuid(), "IMG_0002.JPG", 10, "b2"),
|
|
new("c", PhotoAction.FetchVersion, Guid.NewGuid(), "IMG_0003.JPG", 10, "c"),
|
|
new("c", PhotoAction.TrashHere, Guid.NewGuid(), "IMG_0003.JPG", 10, "c2"),
|
|
};
|
|
Assert.Equal(1, CopyDialogViewModel.KeptVersions(steps, PhotoAction.SendVersion, PhotoAction.TrashThere));
|
|
Assert.Equal(0, CopyDialogViewModel.KeptVersions(steps, PhotoAction.FetchVersion, PhotoAction.TrashHere));
|
|
}
|
|
|
|
[Test]
|
|
public void TheMergesTypedConfirmationIsTheCountWithoutSeparatorsAndThePromptNamesIt()
|
|
{
|
|
// 1,204 photos: what to type has no group separator in any language ("1.204" in Italian), and the prompt says it.
|
|
foreach (var culture in new[] { "en", "it", "de", "hu" })
|
|
{
|
|
Loc.SetCulture(CultureInfo.GetCultureInfo(culture));
|
|
try
|
|
{
|
|
Assert.Equal("1204", CopyDialogViewModel.MergeTyped(1_204));
|
|
var prompt = CopyDialogViewModel.MergeTypedPrompt(1_204, "Alps 2026");
|
|
Assert.Contains("1204", prompt);
|
|
Assert.Contains("Alps 2026", prompt);
|
|
}
|
|
finally
|
|
{
|
|
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TheSessionKeysTooltipNamesTheKeysThatStayOnlyWhenThereAreAny()
|
|
{
|
|
Assert.Equal(Loc.L("Tooltips.Server.Copies.Plan.SessionKeys"), CopyDialogViewModel.SessionKeysToolTip([]));
|
|
var kept = CopyDialogViewModel.SessionKeysToolTip(["card:A1", "folder:B2"]);
|
|
Assert.False(kept.Contains("{0}", StringComparison.Ordinal), "no placeholder is left in the text");
|
|
Assert.Contains("card:A1", kept);
|
|
Assert.Contains("folder:B2", kept);
|
|
}
|
|
|
|
[Test]
|
|
public void AMatchRowTrimsALongArchiveNameInItsMiddleAndItsTooltipSaysItWhole()
|
|
{
|
|
Assert.Equal("Main archive", CopyText.MiddleTrim("Main archive", CopyText.RowNameLength));
|
|
var name = "ChronosArchive-Photos-2026-Studio NAS backup";
|
|
var trimmed = CopyText.MiddleTrim(name, CopyText.RowNameLength);
|
|
Assert.LessOrEqual(trimmed.Length, CopyText.RowNameLength);
|
|
Assert.True(trimmed.StartsWith("ChronosArch", StringComparison.Ordinal) && trimmed.EndsWith("NAS backup", StringComparison.Ordinal), trimmed);
|
|
Assert.Contains("…", trimmed);
|
|
|
|
var facts = Facts("Lighthouse", name, 1_204);
|
|
Assert.Contains(trimmed, CopyText.Where(facts, isServer: false, maxName: CopyText.RowNameLength));
|
|
Assert.Contains(name, CopyText.Where(facts, isServer: false));
|
|
}
|
|
|
|
private static (StatusKind, string) Head((StatusKind Kind, string Text, string ToolTip) state) => (state.Kind, state.Text);
|
|
|
|
private static FoundCopy Copy(CopyState state, CopyKind kind = CopyKind.LocalServer, int deletedThere = 0, bool gone = false) => new()
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
Kind = kind,
|
|
LocalId = Local.Id,
|
|
Server = kind == CopyKind.LocalServer ? Nas : null,
|
|
RemoteId = kind == CopyKind.LocalServer ? Link.RemoteId : null,
|
|
OtherId = kind == CopyKind.LocalLocal ? Guid.CreateVersion7() : null,
|
|
Evidence = CopyEvidence.Hashes,
|
|
State = state,
|
|
Score = Score(deletedThere: deletedThere),
|
|
Fingerprint = "f",
|
|
RemoteGoneHits = gone ? 2 : 0,
|
|
UpdatedAt = new DateTimeOffset(2026, 11, 16, 9, 0, 0, TimeSpan.Zero),
|
|
};
|
|
|
|
private static CopyScore Score(int deletedThere = 0, int hints = 500) =>
|
|
new(1_178, 0, 0, 24, 0, 2, 0, deletedThere, 0, 1_204, 1_180, 980, 960, hints);
|
|
|
|
private static FoundCopyView View(FoundCopy copy, string title) =>
|
|
new(copy, Facts(title, "Main archive", 1_204), Facts(title + " (nas)", "Studio NAS", 1_180));
|
|
|
|
private static CopyFacts Facts(string title, string where, int photos) =>
|
|
new(title, where, null, photos, photos * 15_000_000L, null, null, null, photos, null, [], false);
|
|
|
|
private static SyncEntry Entry(SyncStatus status, SyncLink? link = null) =>
|
|
new(Local, status == SyncStatus.LocalOnly ? link : link ?? Link, status, null);
|
|
}
|