using System.Globalization;
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;
/// Words, glyphs and actions of a match (owner review 6, #73, design ยง8.1), and the sync rows a match marks.
[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)));
Assert.SequenceEqual([CopyAction.Compare, CopyAction.Integrate, CopyAction.Unlink, CopyAction.Review],
CopyText.Actions(Copy(CopyState.Linked, deletedThere: 3)));
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();
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())
{
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())
{
Assert.False(string.IsNullOrWhiteSpace(CopyText.Class(c)), $"{culture}: {c}");
Assert.False(string.IsNullOrWhiteSpace(CopyText.ClassToolTip(c)), $"{culture}: {c} has a tooltip");
}
foreach (var block in Enum.GetValues())
Assert.False(string.IsNullOrWhiteSpace(CopyText.Block(block, "Lighthouse", "Studio NAS", "2 GB", 2)), $"{culture}: {block}");
foreach (var state in Enum.GetValues())
{
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())
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.
var skipped = SyncText.State(entry, new SyncMark(null, UploadSkip.KeptApart));
Assert.Equal((StatusKind.Offline, 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));
}
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);
}