diff --git a/src/Titano.App/DesignTime/SampleData.cs b/src/Titano.App/DesignTime/SampleData.cs index 105b4f1a..5bcf98c6 100644 --- a/src/Titano.App/DesignTime/SampleData.cs +++ b/src/Titano.App/DesignTime/SampleData.cs @@ -9,6 +9,7 @@ using Titano.Core.Imaging; using Titano.Core.Model; using Titano.Core.Video; using Titano.Data; +using Titano.Data.Sync; using Titano.Protocol; using Titano.Protocol.Client; @@ -17,14 +18,18 @@ namespace Titano.App.DesignTime; /// /// Synthetic content for --capture screenshots and the screen smoke tests ONLY: a temporary SQLite index /// with an archive of generated JPEGs (one sequence stores its thumbnail as an embedded preview inside a fake RAW -/// file), jobs in every state, a fake signed-in server and a fake encoder inventory. Everything lives in the +/// file), jobs in every state, a fake signed-in server with sequences to compare (one in conflict) and a fake +/// encoder inventory. Everything lives in the /// capture environment's temporary folder; nothing touches the network or the user's data. /// public sealed class SampleData { public const string ServerFingerprint = "9A:3C:71:E0:5B:12:C4:88:0F:6D:2A:91:E7:44:B3:5C:19:D2:6F:80:A1:3E:57:C9:0B:64:F8:2D:93:A6:71:CE"; + private const string ServerAddress = "https://nas.local:8443"; + private readonly AppServices _services; + private readonly SampleSyncRemote _remote = new(); private TitanoDatabase? _db; private SampleData(AppServices services) => _services = services; @@ -38,7 +43,9 @@ public sealed class SampleData services.Server = new ServerSession(settings, services.SaveSettings, new SampleServerApiFactory(), new PlainTokenProtector()); services.Encoders = new SampleEncoders(); services.CheckForUpdateAsync = _ => Task.FromResult(null); - return new SampleData(services); + var sample = new SampleData(services); + services.Sync.RemoteFactory = (_, _, _) => sample._remote; + return sample; } /// Opens the empty temporary index (first run: no archive, nothing indexed). @@ -68,6 +75,7 @@ public sealed class SampleData await db.Sequences.SetTagsAsync(sequences[9].Sequence.Id, ["holy grail"]); foreach (var job in Jobs(sequences.Select(s => s.Sequence).ToList(), archive.Id)) await db.Jobs.EnqueueAsync(job); + await FillServerAsync(db, sequences.Select(s => s.Sequence).ToList()); settings.LastArchivePath = @"D:\TitanoArchive"; settings.ServerUrl = "https://nas.local:8443"; @@ -79,6 +87,82 @@ public sealed class SampleData settings.FirstRunCompleted = true; } + /// An upload in progress for the sync table (Comet over the ridge, 46 %). + public async Task FillSyncAsync() + { + var db = _db ?? throw new InvalidOperationException("FillAsync first."); + var comet = (await db.Sequences.ListAsync(new Data.Repositories.SequenceQuery { Text = "Comet", Limit = 1 })).Items[0]; + var now = DateTimeOffset.UtcNow; + await db.Jobs.EnqueueAsync(new Job + { + Id = Guid.CreateVersion7(), + Kind = JobKind.UploadCommit, + TargetIds = [comet.Id], + TargetLabel = comet.DisplayTitle, + ParametersJson = $$"""{"server":"{{ServerAddress}}"}""", + State = JobState.Running, + Priority = JobPriority.User, + ProgressDone = 462, + ProgressTotal = 1_005, + ItemsPerSecond = 1.6, + Eta = TimeSpan.FromMinutes(4), + NodeId = _services.WorkerId, + Attempts = 1, + Created = now.AddMinutes(-5), + Started = now.AddMinutes(-5), + }); + } + + /// + /// The server's side: four sequences this PC also holds (two the same, one with settings changed on both sides, one + /// with more originals on the server) and two only on the server; the others are only here. + /// + private async Task FillServerAsync(TitanoDatabase db, IReadOnlyList local) + { + Guid Id(string title) => local.First(s => s.Title == title).Id; + await db.Sequences.EditAsync(Id("Holy grail · Monviso"), new Data.Repositories.SequenceEdit { SettingsJson = DeflickerWindow(41) }, null); + var linked = new (string Title, int Frames, string? Settings)[] + { + ("Harbour sunset", 3, null), + ("Aurora, Tromsø", 3, null), + ("Holy grail · Monviso", 3, DeflickerWindow(33)), + ("Construction cam · week 38", 8, null), + }; + foreach (var (title, frames, settings) in linked) + { + // The server's copy carries the same title, tags and rating as this PC's. + var sequence = (await db.Sequences.GetAsync(Id(title)))!; + var remote = _remote.Add(SampleSyncRemote.Dto(sequence), settings, frames); + await _services.Sync.Service!.LinkAsync(ServerAddress, remote, sequence.Id); + } + _remote.Add(SampleSyncRemote.Dto(new Sequence + { + Id = Guid.CreateVersion7(), + ArchiveId = Guid.Empty, + Title = "Sunrise over Superga", + Folder = "2026/2026-07-02 Sony ILCE-7M4", + FrameCount = 2_880, + TotalBytes = 2_880 * 21_000_000L, + Status = SequenceStatus.ProxiesBuilt | SequenceStatus.ThumbsBuilt, + RenderedCount = 1, + UpdatedAt = DateTimeOffset.UtcNow, + }), null, 3); + _remote.Add(SampleSyncRemote.Dto(new Sequence + { + Id = Guid.CreateVersion7(), + ArchiveId = Guid.Empty, + Title = "Lake Como storm", + Folder = "2026/2026-08-21 Canon EOS R5", + FrameCount = 1_450, + TotalBytes = 1_450 * 45_000_000L, + Status = SequenceStatus.ThumbsBuilt, + UpdatedAt = DateTimeOffset.UtcNow, + }), null, 3); + + static string DeflickerWindow(int frames) => + """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":""" + frames.ToString(System.Globalization.CultureInfo.InvariantCulture) + "}}}"; + } + private IEnumerable<(Sequence Sequence, string[] Colours, bool Raw)> Sequences(Guid archiveId) { var now = new DateTime(2026, 9, 28, 18, 2, 11); @@ -278,7 +362,8 @@ public sealed class SampleData private sealed class SampleServerApi(Uri baseAddress, IReadOnlyCollection trusted) : IServerApi { - private static readonly UserDto User = new(Guid.Empty, "alberto", "Alberto", "editor", 0, 5_000_000_000_000, 2_100_000_000_000, false, false, + private static readonly UserDto User = new(Guid.Empty, "alberto", "Alberto", "editor", (long)RolePermissions.Default(UserRole.Editor), 5_000_000_000_000, + 2_100_000_000_000, false, false, new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero), DateTimeOffset.UtcNow); public Uri BaseAddress { get; } = baseAddress; @@ -308,6 +393,67 @@ public sealed class SampleData } } + /// + /// The sample server's sequences for the sync table: listings, manifests (frames hashed from their index, so + /// unhashed sample frames match them by count) and settings edits; transfers are not part of the screenshots. + /// + private sealed class SampleSyncRemote : ISyncRemote + { + private readonly Dictionary _sequences = []; + + public string Server => ServerAddress; + + public static SequenceDto Dto(Sequence s) => new(Guid.CreateVersion7(), s.Title, s.DisplayTitle, s.Folder, s.CameraMake, s.CameraModel, s.Lens, + s.FirstCapture, s.LastCapture, s.FrameCount, s.MedianInterval, s.TotalBytes, (long)s.Status, s.RenderedCount, null, s.Tags, s.Rating, s.Notes, 2, 1, + 0, null, s.UpdatedAt); + + public Guid Add(SequenceDto dto, string? settings, int frames) + { + _sequences[dto.Id] = (dto, settings, frames); + return dto.Id; + } + + public Task> ListSequencesAsync(CancellationToken cancellationToken) => + Task.FromResult>([.. _sequences.Values.Select(s => s.Dto)]); + + public Task GetSequenceAsync(Guid id, CancellationToken cancellationToken) => Task.FromResult(_sequences[id].Dto); + + public Task GetManifestAsync(Guid id, CancellationToken cancellationToken) + { + var (dto, settings, frames) = _sequences[id]; + var hasProxy = (dto.Status & (long)SequenceStatus.ProxiesBuilt) != 0; + return Task.FromResult(new SequenceManifest(id, dto.FramesVersion, dto.SettingsVersion, settings, dto.Tags, + [.. Enumerable.Range(0, frames).Select(i => new ManifestFrame(Guid.CreateVersion7(), i, $"IMG_{i + 1:0000}.JPG", 24_000_000, + Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData(BitConverter.GetBytes(i))), hasProxy, true))], [])); + } + + public Task> ListFramesAsync(Guid sequenceId, CancellationToken cancellationToken) => Task.FromResult>([]); + + public Task UpdateSequenceAsync(Guid id, UpdateSequenceRequest request, CancellationToken cancellationToken) + { + var (dto, _, frames) = _sequences[id]; + var updated = dto with { SettingsVersion = dto.SettingsVersion + 1, UpdatedAt = DateTimeOffset.UtcNow }; + _sequences[id] = (updated, request.SettingsJson, frames); + return Task.FromResult(updated); + } + + public Task UploadFileAsync(string path, Guid? sequenceId, string? sessionKey, string sha256, DateTime? capturedAt, + CancellationToken cancellationToken) => throw new NotSupportedException("The sample server takes no uploads."); + + public Task DownloadFrameAsync(Guid frameId, string kind, Stream destination, CancellationToken cancellationToken) => + throw new NotSupportedException("The sample server serves no files."); + + public async IAsyncEnumerable EventsAsync([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken) + { + await Task.Delay(Timeout.Infinite, cancellationToken); + yield break; + } + + public void Dispose() + { + } + } + /// No encryption: the capture environment is thrown away. private sealed class PlainTokenProtector : ITokenProtector { diff --git a/src/Titano.App/Server/SyncHost.cs b/src/Titano.App/Server/SyncHost.cs index 29051bc0..69bb216e 100644 --- a/src/Titano.App/Server/SyncHost.cs +++ b/src/Titano.App/Server/SyncHost.cs @@ -70,6 +70,13 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo _switch = SwitchAsync(_switch, wanted); } + /// Compares now, once the session switch in progress settled; null while signed out. + public async Task RefreshAsync(CancellationToken ct = default) + { + await _switch; + return Agent is { } agent ? await agent.RefreshAsync(ct) : null; + } + /// Compares again soon (an option changed, an edit on this PC). public void RequestRefresh() => Agent?.RequestRefresh(); diff --git a/src/Titano.App/Server/SyncTableViewModel.cs b/src/Titano.App/Server/SyncTableViewModel.cs index 179f1167..7b659ee1 100644 --- a/src/Titano.App/Server/SyncTableViewModel.cs +++ b/src/Titano.App/Server/SyncTableViewModel.cs @@ -142,11 +142,11 @@ public sealed class SyncTableViewModel : ObservableObject, IDisposable _ = ReloadAsync(); } - /// Reads the table again; concurrent requests collapse into one more pass. + /// Reads the table again; requests made while a pass runs share the next one, which they wait for. public async Task ReloadAsync() { Interlocked.Exchange(ref _reloadQueued, 1); - if (!await _reloading.WaitAsync(0)) return; + await _reloading.WaitAsync(); try { while (Interlocked.Exchange(ref _reloadQueued, 0) == 1) @@ -293,18 +293,7 @@ public sealed class SyncTableViewModel : ObservableObject, IDisposable SyncAction.TakeServer => SyncResolution.TakeServer, _ => SyncResolution.SaveBoth, }; - if (resolution != SyncResolution.SaveBoth && !_shell.Services.Dialogs.Confirm(new ConfirmRequest - { - Heading = Loc.L("Server.Conflict." + action + ".Title"), - Message = Loc.L("Server.Conflict." + action + ".Message", entry.Title), - Detail = SyncText.Conflict(entry), - DetailToolTip = Loc.L("Tooltips.Server.Conflict.Detail"), - SafeText = Loc.L("Server.Conflict.Cancel"), - SafeToolTip = Loc.L("Tooltips.Server.Conflict.Cancel"), - ActionText = Loc.L("Server.Sync.Action." + action), - ActionToolTip = Loc.L("Tooltips.Server.Sync." + action), - IsDestructive = true, - })) return; + if (resolution != SyncResolution.SaveBoth && !_shell.Services.Dialogs.Confirm(OverwriteRequest(entry, action))) return; try { await service.ResolveAsync(remote, entry.Id, resolution, CancellationToken.None); @@ -317,6 +306,20 @@ public sealed class SyncTableViewModel : ObservableObject, IDisposable } } + /// "Keep this PC's settings?" with the settings that differ: one side's edits are about to be overwritten. + private static ConfirmRequest OverwriteRequest(SyncEntry entry, SyncAction action) => new() + { + Heading = Loc.L("Server.Conflict." + action + ".Title"), + Message = Loc.L("Server.Conflict." + action + ".Message", entry.Title), + Detail = SyncText.Conflict(entry), + DetailToolTip = Loc.L("Tooltips.Server.Conflict.Detail"), + SafeText = Loc.L("Server.Conflict.Cancel"), + SafeToolTip = Loc.L("Tooltips.Server.Conflict.Cancel"), + ActionText = Loc.L("Server.Sync.Action." + action), + ActionToolTip = Loc.L("Tooltips.Server.Sync." + action), + IsDestructive = true, + }; + private async Task UploadAllAsync() { if (Host is not { Service: { } service, Server: { } server } || _shell.Services.Engine is not { } engine) return; diff --git a/src/Titano.App/Shell/ScreenCapture.cs b/src/Titano.App/Shell/ScreenCapture.cs index 6a406d5a..22291041 100644 --- a/src/Titano.App/Shell/ScreenCapture.cs +++ b/src/Titano.App/Shell/ScreenCapture.cs @@ -4,6 +4,7 @@ using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Threading; using Titano.App.DesignTime; +using Titano.App.Server; using Titano.App.Settings; using Titano.Core.Diagnostics; using Titano.Ui.Theming; @@ -13,7 +14,7 @@ namespace Titano.App.Shell; /// /// Titano.exe --capture <dir>: renders every client screen at 1440×900 in the dark and light themes to /// <screen>-<theme>.png from (first run on an empty index, then a populated -/// one), for visual review and phase reports (BRIEF §20.2), then exits. +/// one, then the sync table with an upload and a settings conflict), for visual review and phase reports (BRIEF §20.2), then exits. /// public static class ScreenCapture { @@ -55,6 +56,8 @@ public static class ScreenCapture await shell.Library.RefreshAsync(); await shell.Jobs.ReloadAsync(); await shell.Services.Server.RestoreAsync(); + await shell.Services.Sync.RefreshAsync(); + await shell.Server.Sync.ReloadAsync(); shell.About.SetResult(null); await shell.Settings.DetectEncodersAsync(); await shell.Settings.SelfTestAsync(); @@ -97,6 +100,19 @@ public static class ScreenCapture written += await SaveAsync(window, directory, key.ToString().ToLowerInvariant(), theme); } } + // The sync table with an upload in progress, then filtered to the settings conflict. + await sample.FillSyncAsync(); + await shell.Server.Sync.ReloadAsync(); + foreach (var theme in Themes) + { + ThemeManager.Apply(theme); + shell.Navigate(SectionKey.Server); + SelectSyncFilter(shell, SyncFilter.All); + written += await SaveAsync(window, directory, "server-sync", theme); + SelectSyncFilter(shell, SyncFilter.Conflicts); + written += await SaveAsync(window, directory, "server-conflict", theme); + SelectSyncFilter(shell, SyncFilter.All); + } Log.Info("capture", $"{written} screenshot(s) written to {Path.GetFullPath(directory)}"); if (written == 0) Environment.ExitCode = 1; } @@ -111,6 +127,9 @@ public static class ScreenCapture } } + private static void SelectSyncFilter(ShellViewModel shell, SyncFilter filter) => + shell.Server.Sync.Chips.First(c => c.Filter == filter).SelectCommand.Execute(null); + private static async Task SaveAsync(Window window, string directory, string screen, AppTheme theme, ShellViewModel? waitForThumbnails = null) { await Settle(window); diff --git a/tests/Titano.App.Tests/Server/ServerScreenSmokeTests.cs b/tests/Titano.App.Tests/Server/ServerScreenSmokeTests.cs new file mode 100644 index 00000000..5b8b3f97 --- /dev/null +++ b/tests/Titano.App.Tests/Server/ServerScreenSmokeTests.cs @@ -0,0 +1,100 @@ +using Titano.App.Sections; +using Titano.App.Server; +using Titano.App.Shell; +using Titano.App.Tests.Windows; +using Titano.Core.Model; +using Titano.Data.Sync; +using Titano.Testing; +using Titano.Ui.Controls; + +namespace Titano.App.Tests.Server; + +/// The Server screen's sync table on the capture sample data: comparison, transfer, conflict and the Library's glyphs. +[WindowsOnly] +[Serial] +[Timeout(300_000)] +public sealed class ServerScreenSmokeTests +{ + [Test] + public Task TheSyncTableShowsEveryStateOfTheSample() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var shell = app.Shell; + await app.Sample.FillAsync(); + await shell.Library.RefreshAsync(); + await shell.Services.Server.RestoreAsync(); + Assert.NotNull(await shell.Services.Sync.RefreshAsync()); + var table = shell.Server.Sync; + await table.ReloadAsync(); + + // 36 sequences here (4 also on the server) and 2 only on the server. + Assert.True(table.IsActive); + Assert.Equal(38, table.Rows.Count); + Assert.Equal(1, Chip(table, SyncFilter.Conflicts).Count); + Assert.Equal(2, Chip(table, SyncFilter.Remote).Count); + Assert.Equal(32, Chip(table, SyncFilter.LocalOnly).Count); + Assert.Equal(SyncStatus.InSync, Row(table, "Harbour sunset").Entry.Status); + Assert.Equal(SyncStatus.ServerAhead, Row(table, "Construction cam · week 38").Entry.Status); + Assert.SequenceEqual([SyncAction.DownloadOriginals], Row(table, "Construction cam · week 38").Actions.Select(a => a.Action)); + Assert.SequenceEqual([SyncAction.OpenWithProxies, SyncAction.DownloadOriginals], Row(table, "Sunrise over Superga").Actions.Select(a => a.Action)); + Assert.SequenceEqual([SyncAction.Upload], Row(table, "Clouds over the Langhe").Actions.Select(a => a.Action)); + var conflict = Row(table, "Holy grail · Monviso"); + Assert.Equal(StatusKind.Warning, conflict.StateKind); + Assert.SequenceEqual([SyncAction.KeepMine, SyncAction.TakeServer, SyncAction.SaveBoth], conflict.Actions.Select(a => a.Action)); + Assert.Contains("41", conflict.StateToolTip); + Assert.NotNull(table.LastSyncText); + Assert.NotNull(table.ArchiveText); + + // The Library shows the real sync state of each local copy. + var holyGrail = shell.Library.Items.Single(i => i.Title == "Holy grail · Monviso"); + Assert.Equal(SyncState.Conflict, holyGrail.Sequence.SyncState); + Assert.Contains(holyGrail.Statuses, s => s.Kind == StatusKind.Warning); + Assert.Contains(shell.Library.Items.Single(i => i.Title == "Harbour sunset").Statuses, s => s.Kind == StatusKind.Synced); + + shell.Navigate(SectionKey.Server); + await app.ExpectAsync("server"); + + // An upload in progress: the row shows what the server received and offers Pause. + await app.Sample.FillSyncAsync(); + await table.ReloadAsync(); + var comet = Row(table, "Comet over the ridge"); + Assert.Equal(SyncStatus.Transferring, comet.Entry.Status); + Assert.SequenceEqual([SyncAction.Pause], comet.Actions.Select(a => a.Action)); + Assert.Contains("46", comet.ServerText); + await app.ExpectAsync("server-sync"); + + // The conflict filter leaves the one row waiting for a choice. + Chip(table, SyncFilter.Conflicts).SelectCommand.Execute(null); + Assert.Equal("Holy grail · Monviso", Assert.Contains(table.Rows, _ => true).Title); + Assert.Count(1, table.Rows); + await app.ExpectAsync("server-conflict"); + table.SearchText = "nothing like this"; + Assert.False(table.HasRows); + Assert.NotNull(table.EmptyText); + }); + + [Test] + public Task SigningOutEmptiesTheTable() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var shell = app.Shell; + await app.Sample.FillAsync(); + await shell.Services.Server.RestoreAsync(); + await shell.Services.Sync.RefreshAsync(); + await shell.Server.Sync.ReloadAsync(); + Assert.True(shell.Server.Sync.HasRows); + + await shell.Services.Server.SignOutAsync(); + Assert.Null(await shell.Services.Sync.RefreshAsync()); + await shell.Server.Sync.ReloadAsync(); + + Assert.False(shell.Server.Sync.IsActive); + Assert.False(shell.Server.Sync.HasRows); + shell.Navigate(SectionKey.Server); + await app.ExpectAsync("server-signedout-table"); + }); + + private static SyncFilterChip Chip(SyncTableViewModel table, SyncFilter filter) => table.Chips.Single(c => c.Filter == filter); + + private static SyncRow Row(SyncTableViewModel table, string title) => table.Rows.Single(r => r.Title == title); +} diff --git a/tests/Titano.App.Tests/Server/SyncTextTests.cs b/tests/Titano.App.Tests/Server/SyncTextTests.cs new file mode 100644 index 00000000..22018451 --- /dev/null +++ b/tests/Titano.App.Tests/Server/SyncTextTests.cs @@ -0,0 +1,136 @@ +using Titano.App.Server; +using Titano.Core.Localization; +using Titano.Core.Model; +using Titano.Data.Sync; +using Titano.Testing; +using Titano.Ui.Controls; + +namespace Titano.App.Tests.Server; + +/// Words, glyphs and actions of the sync table rows (Server.html). +public sealed class SyncTextTests +{ + private static readonly SyncRights Editor = SyncRights.Of((long)RolePermissions.Default(UserRole.Editor)); + private static readonly SyncRights Viewer = SyncRights.Of((long)RolePermissions.Default(UserRole.Viewer)); + + private static readonly Sequence Local = new() + { + Id = Guid.CreateVersion7(), + ArchiveId = Guid.CreateVersion7(), + Title = "Harbour sunset", + Folder = "2026/harbour", + FrameCount = 3_600, + TotalBytes = 86_000_000_000, + Status = SequenceStatus.ProxiesBuilt, + SettingsJson = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":41}}}""", + }; + + private static readonly SyncLink Link = new() + { + Server = "https://nas.local:8443", + RemoteId = Guid.CreateVersion7(), + Title = "Harbour sunset", + TotalBytes = 61_000_000_000, + RemoteStatus = SequenceStatus.ProxiesBuilt | SequenceStatus.ThumbsBuilt, + RenderCount = 2, + }; + + [Test] + public void RightsFollowTheServerPermissions() + { + Assert.Equal(new SyncRights(true, true), Editor); + Assert.Equal(new SyncRights(false, false), Viewer); + Assert.Equal(new SyncRights(false, true), SyncRights.Of((long)Permissions.RenderNode)); + } + + [Test] + public void EachStateOffersItsActions() + { + Assert.SequenceEqual([SyncAction.Upload], SyncText.Actions(Entry(SyncStatus.LocalOnly, link: null), Editor)); + Assert.Empty(SyncText.Actions(Entry(SyncStatus.LocalOnly, link: null), Viewer)); + Assert.SequenceEqual([SyncAction.OpenWithProxies, SyncAction.DownloadOriginals], SyncText.Actions(Entry(SyncStatus.RemoteOnly, local: null), Editor)); + Assert.SequenceEqual([SyncAction.OpenWithProxies], SyncText.Actions(Entry(SyncStatus.ProxiesOnly, local: null), Viewer)); + Assert.SequenceEqual([SyncAction.Upload], SyncText.Actions(Entry(SyncStatus.LocalAhead, Link with { MissingRemote = 4 }), Editor)); + Assert.SequenceEqual([SyncAction.DownloadOriginals], SyncText.Actions(Entry(SyncStatus.ServerAhead, Link with { MissingLocal = 2 }), Editor)); + Assert.SequenceEqual([SyncAction.SyncSettings], SyncText.Actions(Entry(SyncStatus.ServerAhead), Editor)); + Assert.SequenceEqual([SyncAction.KeepMine, SyncAction.TakeServer, SyncAction.SaveBoth], SyncText.Actions(Entry(SyncStatus.Conflict), Editor)); + Assert.Empty(SyncText.Actions(Entry(SyncStatus.InSync), Editor)); + + Assert.SequenceEqual([SyncAction.Pause], SyncText.Actions(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Running)), Editor)); + Assert.SequenceEqual([SyncAction.Pause], SyncText.Actions(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Queued)), Editor)); + Assert.SequenceEqual([SyncAction.Resume], SyncText.Actions(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Paused)), Editor)); + } + + [Test] + public void ColumnsSayWhatEachSideHolds() + { + var originals = Loc.L("Server.Sync.Originals"); + var proxies = Loc.L("Server.Sync.Proxies"); + Assert.Equal($"{originals} · {proxies}", SyncText.Local(Entry(SyncStatus.InSync))); + Assert.Equal(originals, SyncText.Local(Entry(SyncStatus.InSync, local: Local with { Status = SequenceStatus.None }))); + Assert.Equal(proxies, SyncText.Local(Entry(SyncStatus.ProxiesOnly, Link with { ProxiesCached = 10 }, local: null))); + Assert.Equal(Loc.L("Server.Sync.None"), SyncText.Local(Entry(SyncStatus.RemoteOnly, local: null))); + + Assert.Equal($"{originals} · {proxies} · {Loc.Plural("Server.Sync.Exports", 2)}", SyncText.Server(Entry(SyncStatus.InSync))); + Assert.Equal(Loc.L("Server.Sync.None"), SyncText.Server(Entry(SyncStatus.LocalOnly, link: null))); + var uploading = Entry(SyncStatus.Transferring, link: null, transfer: Upload(JobState.Running) with { ProgressDone = 462, ProgressTotal = 1_005 }); + Assert.Equal(Loc.L("Server.Sync.Received", Loc.L("Common.Percent", "46")), SyncText.Server(uploading)); + Assert.Equal(86_000_000_000, SyncText.Size(Entry(SyncStatus.LocalOnly, link: null), SyncAction.Upload)); + Assert.Equal(61_000_000_000, SyncText.Size(Entry(SyncStatus.RemoteOnly, local: null), SyncAction.DownloadOriginals)); + } + + [Test] + public void StatesPairAGlyphWithAWord() + { + Assert.Equal((StatusKind.Done, Loc.L("Server.Sync.State.InSync")), Kind(Entry(SyncStatus.InSync))); + Assert.Equal((StatusKind.Offline, Loc.L("Server.Sync.State.LocalOnly")), Kind(Entry(SyncStatus.LocalOnly, link: null))); + Assert.Equal((StatusKind.Remote, Loc.L("Server.Sync.State.RemoteOnly")), Kind(Entry(SyncStatus.RemoteOnly, local: null))); + Assert.Equal((StatusKind.Warning, Loc.L("Server.Sync.State.Conflict")), Kind(Entry(SyncStatus.Conflict))); + Assert.Equal((StatusKind.Running, Loc.L("Server.Sync.State.Uploading")), Kind(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Running)))); + Assert.Equal((StatusKind.Paused, Loc.L("Server.Sync.State.Paused")), Kind(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Paused)))); + Assert.Equal((StatusKind.Running, Loc.L("Server.Sync.State.Downloading")), + Kind(Entry(SyncStatus.Transferring, transfer: Upload(JobState.Running) with { Kind = JobKind.Download }))); + } + + [Test] + public void AConflictNamesTheSettingsThatDiffer() + { + var conflict = Entry(SyncStatus.Conflict, Link with { ConflictSettingsJson = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":33}}}""" }); + + var text = SyncText.State(conflict).ToolTip; + + Assert.Equal(Loc.L("Server.Conflict.Difference", "exposure.deflickerWindow.manual", "41", "33"), text); + Assert.Equal(Loc.L("Tooltips.Server.Sync.State.Conflict"), SyncText.Conflict(Entry(SyncStatus.Conflict))); + } + + [Test] + public void FiltersAndSearchSelectRows() + { + var rows = new[] + { + Entry(SyncStatus.LocalOnly, link: null), + Entry(SyncStatus.RemoteOnly, local: null), + Entry(SyncStatus.ProxiesOnly, local: null), + Entry(SyncStatus.Conflict), + Entry(SyncStatus.InSync, local: Local with { Title = "Comet over the ridge" }), + }; + Assert.Equal(5, rows.Count(r => SyncText.Matches(r, SyncFilter.All, string.Empty))); + Assert.Equal(1, rows.Count(r => SyncText.Matches(r, SyncFilter.LocalOnly, string.Empty))); + Assert.Equal(2, rows.Count(r => SyncText.Matches(r, SyncFilter.Remote, string.Empty))); + Assert.Equal(1, rows.Count(r => SyncText.Matches(r, SyncFilter.Conflicts, string.Empty))); + Assert.Equal(1, rows.Count(r => SyncText.Matches(r, SyncFilter.All, "COMET"))); + Assert.Equal(0, rows.Count(r => SyncText.Matches(r, SyncFilter.Conflicts, "comet"))); + } + + private static (StatusKind, string) Kind(SyncEntry entry) + { + var (kind, text, _) = SyncText.State(entry); + return (kind, text); + } + + private static SyncEntry Entry(SyncStatus status, SyncLink? link = null, Sequence? local = null, Job? transfer = null) => + new(local ?? (status is SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly ? null : Local), link ?? (status == SyncStatus.LocalOnly ? null : Link), status, + transfer); + + private static Job Upload(JobState state) => new() { Id = Guid.CreateVersion7(), Kind = JobKind.UploadCommit, State = state }; +} diff --git a/tests/Titano.App.Tests/Windows/ScreenSmokeTests.cs b/tests/Titano.App.Tests/Windows/ScreenSmokeTests.cs index fd589fa2..bc8647fc 100644 --- a/tests/Titano.App.Tests/Windows/ScreenSmokeTests.cs +++ b/tests/Titano.App.Tests/Windows/ScreenSmokeTests.cs @@ -122,7 +122,7 @@ public sealed class ScreenSmokeTests }); /// A on capture services and sample data, shown off screen like --capture. - private sealed class SampleApp : IAsyncDisposable + internal sealed class SampleApp : IAsyncDisposable { private const double Width = 1440; private const double Height = 900;