Files
Chronos/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs
T
Claude 6417e2b3c2 fix(app): notification clicks run only what the toast names, batches speak once, warnings get badges
- Toast.RunsFromNotification: a click on a Windows notification restores the window and runs the toast's
  action only when the toast opts in (card detected: Import; interrupted import: Resume; job finished: Open;
  navigation to Import or Jobs) and it is the only notification shown since the icon appeared. Cancel, Undo
  and Retry stay in the window, and the notification text no longer offers them.
- Job endings are coalesced: finished jobs of one kind wait until no job of that kind the user waits for is
  queued or running, then one toast says how many finished ("12 jobs finished", action Jobs); failures of one
  update share one toast. Server > Upload all no longer raises one toast and one notification per sequence.
- Every failure that is not upkeep (scan, thumbnails, proxies, light analysis) is announced, including move,
  adopt and user downloads; finished moves and adoptions are announced too.
- Rail badges: Library counts the sequences with warnings (the Warnings filter), refreshed after analyses;
  Archive counts the index health lines that need attention.
- Tests: the balloon click path, the --minimized restore to a saved maximised window, batch and failure
  coalescing, and the new badges.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 10:35:19 +00:00

409 lines
21 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Shell;
using Titano.App.Infrastructure;
using Titano.App.Sections;
using Titano.App.Settings;
using Titano.App.Shell;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Data.Repositories;
using Titano.Testing;
using Titano.Ui.Controls;
using Titano.Ui.Mvvm;
using Titano.Ui.Visuals;
namespace Titano.App.Tests.Windows;
/// <summary>
/// The shell's ways of telling what happens outside the screen in front: the taskbar button (UI-05), Windows
/// notifications (UI-06), section shortcuts (UI-07), job toasts (UI-08), rail badges (UI-10), and the General settings
/// that drive them; the usage counts consent stays hidden in builds without monetization (RF-3).
/// </summary>
[WindowsOnly]
[Serial]
[Timeout(300_000)]
public sealed class ShellNotificationTests
{
[Test]
public Task TheTaskbarButtonMirrorsTheJobBar() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
var shell = app.Shell;
await JobsLoadedAsync(shell);
var taskbar = Assert.NotNull(app.Window.TaskbarItemInfo);
shell.SetJob("Render · Harbour sunset", 0.25, name: "Render: Harbour sunset");
Assert.Equal(TaskbarItemProgressState.Normal, taskbar.ProgressState);
Assert.Approximately(0.25, taskbar.ProgressValue, 1e-9);
shell.SetJob("Scan · Archive", 0, indeterminate: true);
Assert.Equal(TaskbarItemProgressState.Indeterminate, taskbar.ProgressState);
shell.SetJob(null, 0);
Assert.Equal(TaskbarItemProgressState.None, taskbar.ProgressState);
// A failure nobody has seen on the Jobs screen turns the idle button red.
shell.SetUnseenFailures(1);
Assert.Equal(TaskbarItemProgressState.Error, taskbar.ProgressState);
Assert.Approximately(1, taskbar.ProgressValue, 1e-9);
shell.SetJob("Render · Harbour sunset", 0.5);
Assert.Equal(TaskbarItemProgressState.Normal, taskbar.ProgressState, "a running job comes first");
shell.SetUnseenFailures(0);
shell.SetJob(null, 0);
Assert.Equal(TaskbarItemProgressState.None, taskbar.ProgressState);
});
[Test]
public Task TheRailShortcutsOfTheTooltipsNavigate() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync(firstRun: true);
var shell = app.Shell;
var bindings = app.Window.InputBindings.OfType<KeyBinding>().ToList();
var expected = new (Key Key, SectionKey Section)[]
{
(Key.D1, SectionKey.Library), (Key.D2, SectionKey.Import), (Key.D3, SectionKey.Sequence), (Key.D4, SectionKey.Archive),
(Key.D5, SectionKey.Jobs), (Key.D6, SectionKey.Server), (Key.OemComma, SectionKey.Settings),
};
// The first-run dialog keeps the shell behind it: no shortcut moves it.
var library = bindings.Single(b => b.Key == Key.D1 && b.Modifiers == ModifierKeys.Control);
Assert.False(library.Command.CanExecute(library.CommandParameter), "no navigation behind the first-run dialog");
shell.CompleteWelcome();
foreach (var (key, section) in expected)
{
var binding = bindings.Single(b => b.Key == key && b.Modifiers == ModifierKeys.Control);
Assert.True(binding.Command.CanExecute(binding.CommandParameter), $"Ctrl+{key}");
binding.Command.Execute(binding.CommandParameter);
Assert.Equal(section, shell.Current.Key, $"Ctrl+{key}");
// The rail tooltip lists the shortcut it answers to.
var shortcut = key == Key.OemComma ? "Ctrl+," : "Ctrl+" + (char)('1' + (key - Key.D1));
Assert.True(shell.Current.ToolTip.EndsWith(shortcut, StringComparison.Ordinal), $"{section} tooltip ends with {shortcut}");
}
// The editor's 1:1 view no longer takes Ctrl+1 from the Library.
var gestures = PreviewViewport.ActualSizeCommand.InputGestures.OfType<KeyGesture>().ToList();
Assert.True(gestures.All(g => g is not { Key: Key.D1, Modifiers: ModifierKeys.Control }), "the preview keeps away from Ctrl+1");
Assert.Contains(gestures, g => g is { Key: Key.D1, Modifiers: ModifierKeys.Control | ModifierKeys.Shift });
Assert.Contains("Ctrl+Shift+1", Loc.L("Tooltips.Editor.Preview.OneToOne"));
});
[Test]
public Task JobsThatEndRaiseOneToastAndFailuresCountUntilSeen() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
var shell = app.Shell;
shell.CompleteWelcome();
await JobsLoadedAsync(shell);
var jobs = shell.Jobs;
var raised = new List<Toast>();
shell.PendingToasts.CollectionChanged += (_, e) => raised.AddRange(e.NewItems?.Cast<Toast>() ?? []);
var badge = jobs.Badge;
// A deep analysis started from the Library ends: one toast whose action opens what it worked on.
var analysis = Job(JobKind.DeepAnalyse, JobState.Running, Guid.CreateVersion7());
jobs.OnJobChanged(analysis);
jobs.Flush();
jobs.OnJobChanged(analysis with { State = JobState.Done });
jobs.Flush();
var done = raised.Single(t => t.Title == Loc.L("Shell.Job.Done"));
Assert.Equal(Loc.L("Jobs.Action.Open"), done.ActionText);
Assert.False(done.IsError);
Assert.True(done.RunsFromNotification, "a click on the Windows notification opens what the job worked on");
// The same ending reported again says nothing more.
jobs.OnJobChanged(analysis with { State = JobState.Done });
jobs.Flush();
Assert.Equal(1, raised.Count(t => t.Title == Loc.L("Shell.Job.Done")));
// A failed verify: an error toast with Retry, a badge on the rail and a red taskbar button until Jobs is opened.
var verify = Job(JobKind.Verify, JobState.Running, Guid.CreateVersion7());
jobs.OnJobChanged(verify);
jobs.Flush();
jobs.OnJobChanged(verify with { State = JobState.Failed, Error = "Disk read error" });
jobs.Flush();
var failed = raised.Single(t => t.Title == Loc.L("Shell.Job.Failed"));
Assert.True(failed.IsError);
Assert.Equal(Loc.L("Jobs.Action.Retry"), failed.ActionText);
Assert.False(failed.RunsFromNotification, "a click on the Windows notification does not retry before the user sees why");
Assert.Equal(badge + 1, jobs.Badge);
Assert.Equal(TaskbarItemProgressState.Error, shell.TaskbarState);
shell.Navigate(SectionKey.Jobs);
Assert.Equal(badge, jobs.Badge);
Assert.NotEqual(TaskbarItemProgressState.Error, shell.TaskbarState);
// The editor announces the renders of its own sequence, with their output: the shell says nothing then.
var id = await app.Sample.FillEditorAsync();
shell.OpenSequence(id);
await shell.Sequence.OpenAsync(id);
Assert.NotNull(shell.Sequence.Editor);
raised.Clear();
var render = Job(JobKind.Render, JobState.Running, id);
jobs.OnJobChanged(render);
jobs.Flush();
jobs.OnJobChanged(render with { State = JobState.Done });
jobs.Flush();
Assert.False(raised.Any(t => t.Title == Loc.L("Shell.Job.Done")), "the editor's own render toast is not doubled");
// A render of another sequence is the shell's to announce.
var other = Job(JobKind.Render, JobState.Running, Guid.CreateVersion7());
jobs.OnJobChanged(other);
jobs.Flush();
jobs.OnJobChanged(other with { State = JobState.Done });
jobs.Flush();
Assert.Equal(1, raised.Count(t => t.Title == Loc.L("Shell.Job.Done")));
await shell.Sequence.CloseAsync();
// Server › Upload all: the batch speaks once, when its last upload ends.
raised.Clear();
var uploads = Enumerable.Range(0, 3).Select(_ => Job(JobKind.UploadCommit, JobState.Queued, Guid.CreateVersion7())).ToList();
foreach (var upload in uploads) jobs.OnJobChanged(upload);
jobs.Flush();
foreach (var upload in uploads)
{
Assert.Empty(raised);
jobs.OnJobChanged(upload with { State = JobState.Done });
jobs.Flush();
}
var batch = raised.Single();
Assert.Equal(Loc.Plural("Shell.Job.DonePlural", 3), batch.Title);
Assert.Equal(Loc.L("Jobs.Kind.UploadCommit"), batch.Message);
Assert.Equal(Loc.L("Shell.Nav.Jobs"), batch.ActionText);
shell.Navigate(SectionKey.Library);
batch.ActionCommand!.Execute(null);
Assert.Equal(SectionKey.Jobs, shell.Current.Key);
// Two failures of one update: one error toast that leads to the Jobs screen.
raised.Clear();
var broken = new[] { Job(JobKind.Move, JobState.Running, Guid.CreateVersion7()), Job(JobKind.Adopt, JobState.Running, Guid.CreateVersion7()) };
foreach (var job in broken) jobs.OnJobChanged(job);
jobs.Flush();
foreach (var job in broken) jobs.OnJobChanged(job with { State = JobState.Failed });
jobs.Flush();
var failures = raised.Single();
Assert.True(failures.IsError);
Assert.Equal(Loc.Plural("Shell.Job.FailedPlural", 2), failures.Title);
Assert.Null(failures.Message);
});
[Test]
public Task ToastsBecomeWindowsNotificationsOnlyWhileNobodySeesTheWindow() => ScreenHost.RunAsync(async () =>
{
Assert.True(OsNotifications.IsUnseen(WindowState.Minimized, isVisible: true, anyWindowActive: true));
Assert.True(OsNotifications.IsUnseen(WindowState.Normal, isVisible: true, anyWindowActive: false));
Assert.True(OsNotifications.IsUnseen(WindowState.Maximized, isVisible: false, anyWindowActive: true));
Assert.False(OsNotifications.IsUnseen(WindowState.Maximized, isVisible: true, anyWindowActive: true));
// The card prompt of BRIEF §12.4 reads "Card X detected", then its action, which a click runs.
var card = new Toast { Title = "EOS R5 card A inserted", Message = "SD 128 GB", ActionText = "Import", RunsFromNotification = true };
Assert.Equal("SD 128 GB" + Environment.NewLine + "Import", OsNotifications.BalloonText(card));
Assert.Equal("Job finished", OsNotifications.BalloonText(new Toast { Title = "Job finished" }));
// An action a click does not run (the auto-import's Cancel) waits in the window.
var auto = new Toast { Title = "EOS R5 card A inserted", Message = "Importing into the archive", ActionText = "Cancel" };
Assert.Equal("Importing into the archive", OsNotifications.BalloonText(auto));
Assert.True(MainWindow.StartsMinimized(["Titano.exe", "--minimized"]));
Assert.False(MainWindow.StartsMinimized(["Titano.exe"]));
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
app.Shell.CompleteWelcome();
// Minimised: nobody sees the window.
app.Window.WindowState = WindowState.Minimized;
var enabled = false;
using var notifications = new OsNotifications(app.Window, () => enabled, _ => { });
Assert.False(notifications.Show(card), "Settings › General › Notifications is off");
Assert.False(notifications.HasTrayIcon);
enabled = true;
Assert.True(notifications.Show(new Toast { Title = "Job finished", Message = "Render · Harbour sunset", ActionCommand = new RelayCommand(() => { }) }));
Assert.True(notifications.HasTrayIcon, "the notification area holds the icon while a notification can be clicked");
notifications.Dispose();
Assert.False(notifications.HasTrayIcon);
app.Window.WindowState = WindowState.Normal;
});
[Test]
public Task AClickOnANotificationBringsTheWindowBackAndRunsOnlyWhatItNames() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
app.Shell.CompleteWelcome();
var window = app.Window;
var imported = 0;
var cancelled = 0;
var dismissed = new List<Toast>();
Toast Import() => new() { Title = "EOS R5 card A inserted", ActionText = "Import", ActionCommand = new RelayCommand(() => imported++), RunsFromNotification = true };
// "Card X detected — Import": the click restores the window, opens the card and closes the in-window toast.
using (var notifications = new OsNotifications(window, () => true, dismissed.Add))
{
window.WindowState = WindowState.Minimized;
var card = Import();
Assert.True(notifications.Show(card));
notifications.OnBalloonClicked();
await StateAsync(window, WindowState.Normal);
Assert.Equal(1, imported);
Assert.SequenceEqual([card], dismissed);
}
// The auto-import's toast offers Cancel: the click only brings the window back.
using (var notifications = new OsNotifications(window, () => true, dismissed.Add))
{
window.WindowState = WindowState.Minimized;
Assert.True(notifications.Show(new Toast { Title = "EOS R5 card A inserted", ActionText = "Cancel", ActionCommand = new RelayCommand(() => cancelled++) }));
notifications.OnBalloonClicked();
await StateAsync(window, WindowState.Normal);
Assert.Equal(0, cancelled);
Assert.Count(1, dismissed);
}
// Two notifications: Windows does not say which one was clicked, so neither action runs.
using (var notifications = new OsNotifications(window, () => true, dismissed.Add))
{
window.WindowState = WindowState.Minimized;
Assert.True(notifications.Show(Import()));
Assert.True(notifications.Show(Import()));
notifications.OnBalloonClicked();
await StateAsync(window, WindowState.Normal);
Assert.Equal(1, imported);
Assert.Count(1, dismissed);
}
});
[Test]
public Task AWindowStartedMinimisedComesBackAsItWasSaved() => ScreenHost.RunAsync(async () =>
{
// Closed while still minimised from the start: the saved state stays the one it would have come back to.
Assert.True(MainWindow.SavesMaximized(WindowState.Maximized, restoreTo: null));
Assert.True(MainWindow.SavesMaximized(WindowState.Minimized, WindowState.Maximized));
Assert.False(MainWindow.SavesMaximized(WindowState.Minimized, WindowState.Normal));
Assert.False(MainWindow.SavesMaximized(WindowState.Normal, restoreTo: null));
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
app.Shell.CompleteWelcome();
var window = app.Window;
// Started at sign-in with the window saved maximised: it waits on the taskbar.
window.WaitMinimized(maximized: true);
Assert.Equal(WindowState.Minimized, window.WindowState);
// The user opens it from the taskbar: it comes back maximised.
window.WindowState = WindowState.Normal;
await StateAsync(window, WindowState.Maximized);
// Only that first restore: later ones are the user's.
window.WindowState = WindowState.Normal;
window.WindowState = WindowState.Minimized;
window.WindowState = WindowState.Normal;
await StateAsync(window, WindowState.Normal);
await Task.Delay(100);
Assert.Equal(WindowState.Normal, window.WindowState);
});
[Test]
public Task GeneralSettingsHoldStartupAndNotificationsButNoConsent() => ScreenHost.RunAsync(async () =>
{
// Monetization (BRIEF §21) ships disabled: the default build offers no usage counts consent.
Assert.False(ProductFeatures.AdsEnabled);
await using var app = await ScreenSmokeTests.SampleApp.StartAsync(firstRun: true);
var shell = app.Shell;
await app.ExpectAsync<WelcomeView>("welcome");
Assert.False(app.FindAll<CheckBox>().Any(c => c.IsVisible && Equals(c.Content, Loc.L("Settings.General.UsageCounts"))), "no consent on the first-run dialog");
shell.CompleteWelcome();
var settings = shell.Settings;
var startup = new MemoryStartWithWindows();
settings.Startup = startup;
shell.Navigate(SectionKey.Settings);
settings.Page = SettingsPage.General;
await app.ExpectAsync<SettingsView>("settings-general");
var boxes = app.FindAll<CheckBox>().Where(c => c.IsVisible).ToList();
Assert.False(boxes.Any(c => Equals(c.Content, Loc.L("Settings.General.UsageCounts"))), "no consent in Settings");
var start = boxes.Single(c => Equals(c.Content, Loc.L("Settings.General.StartWithWindows")));
Assert.Equal(Loc.L("Tooltips.Settings.StartWithWindows"), start.ToolTip);
var notify = boxes.Single(c => Equals(c.Content, Loc.L("Settings.General.OsNotifications")));
Assert.Equal(Loc.L("Tooltips.Settings.OsNotifications"), notify.ToolTip);
Assert.True(notify.IsChecked == true, "Windows notifications are on by default");
settings.StartWithWindows = true;
Assert.True(startup.IsEnabled);
settings.OsNotifications = false;
Assert.False(shell.Services.Settings.OsNotifications);
settings.ResetSectionCommand.Execute(null);
Assert.False(startup.IsEnabled, "Reset section turns Start with Windows off");
Assert.True(shell.Services.Settings.OsNotifications, "Reset section turns notifications back on");
// Reset section also returned the language to the system's.
UiLanguage.Apply("en");
// The search finds General by its new rows, not by the hidden consent.
settings.SearchText = Loc.L("Settings.General.Startup");
Assert.Contains(settings.VisiblePages, p => p.Page == SettingsPage.General);
settings.SearchText = Loc.L("Settings.General.Usage");
Assert.False(settings.VisiblePages.Any(p => p.Page == SettingsPage.General), "the hidden consent does not match");
settings.SearchText = string.Empty;
});
[Test]
public Task TheServerBadgeCountsConflicts() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
var shell = app.Shell;
shell.CompleteWelcome();
Assert.Equal(0, shell.Server.Badge);
await app.Sample.FillAsync();
await shell.Services.Server.RestoreAsync();
Assert.NotNull(await shell.Services.Sync.RefreshAsync());
await shell.Server.Sync.ReloadAsync();
// The sample server holds one sequence whose settings changed on both sides.
Assert.Equal(1, shell.Server.Sync.Chips.Single(c => c.Filter == Titano.App.Server.SyncFilter.Conflicts).Count);
Assert.Equal(1, shell.Server.Badge);
});
[Test]
public Task TheLibraryAndArchiveBadgesCountWarnings() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
var shell = app.Shell;
shell.CompleteWelcome();
await app.Sample.FillAsync();
var db = Assert.NotNull(shell.Services.Database);
// Library: the sequences the Warnings filter shows; an analysis that finds warnings adds one.
await shell.Library.RefreshAsync();
var warned = await db.Sequences.CountAsync(new SequenceQuery { WithStatus = SequenceStatus.HasWarnings });
Assert.Equal(warned, shell.Library.Badge);
var clean = (await db.Sequences.ListAsync(new SequenceQuery { WithoutStatus = SequenceStatus.HasWarnings, Limit = 1 })).Items[0];
await db.Sequences.RecordAnalysisAsync(clean.Id, SequenceStatus.AnalyzedLight | SequenceStatus.HasWarnings, SequenceStatus.None, 2, null);
await shell.Library.RefreshAsync();
Assert.Equal(warned + 1, shell.Library.Badge);
// Archive: the index health lines that need attention (the sample has unverified sequences).
shell.Navigate(SectionKey.Archive);
await shell.Archive.LoadAsync();
Assert.Greater(shell.Archive.Badge, 0);
Assert.Equal(shell.Archive.Health.Count(h => !h.IsOk), shell.Archive.Badge);
});
/// <summary>The Jobs screen read its first page (it would set the job bar and the badge again).</summary>
private static async Task JobsLoadedAsync(ShellViewModel shell)
{
for (var i = 0; i < 200 && !shell.Jobs.IsEmpty && !shell.Jobs.HasRows; i++) await Task.Delay(20);
Assert.True(shell.Jobs.IsEmpty || shell.Jobs.HasRows, "the job list loaded");
}
/// <summary>The window reached <paramref name="state"/> (a restore from a notification is a posted system command).</summary>
private static async Task StateAsync(Window window, WindowState state)
{
for (var i = 0; i < 250 && window.WindowState != state; i++) await Task.Delay(20);
Assert.Equal(state, window.WindowState);
}
private static Job Job(JobKind kind, JobState state, Guid target) => new()
{
Id = Guid.CreateVersion7(),
Kind = kind,
State = state,
Priority = JobPriority.User,
TargetIds = [target],
TargetLabel = "Harbour sunset",
Created = DateTimeOffset.UtcNow,
Started = DateTimeOffset.UtcNow,
};
}