lightweight variant (#1)

Reviewed-on: #1 Co-authored-by: Aleksandr Neychev <alexnejchev73@gmail.com>
2026-08-12 13:37:30 +00:00
parent a0d3098fe4
commit 55ac8e6556
147 changed files with 4055 additions and 2349 deletions
@@ -0,0 +1,391 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Media;
+using CursorLang.Core.Models;
+using CursorLang.Core.Services;
+using CursorLang.Settings.Services;
+using CursorLang.Settings.Tests.Infrastructure;
+using CursorLang.Settings.ViewModels;
+using CursorLang.Settings.Views;
+using CursorLang.Tests.Shared;
+
+namespace CursorLang.Settings.Tests.Views;
+
+/// <summary>
+/// The settings window as a whole: the markup, the bindings and the hook-up
+/// to the theme.
+/// </summary>
+/// <remarks>
+/// The window has to be shown for real: before the show WPF builds no element
+/// tree and computes no bindings. Full transparency keeps it out of sight.
+/// </remarks>
+public sealed class MainWindowTests
+{
+    [Fact]
+    public void The_window_is_built_and_takes_its_data_from_the_view_model()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+            var theme = new FakeThemeService();
+
+            Open(viewModel, theme, window =>
+            {
+                Assert.Same(viewModel, window.DataContext);
+                Assert.Equal([window], theme.Registered);
+            });
+        });
+    }
+
+    [Fact]
+    public void The_window_title_comes_from_the_interface_strings()
+    {
+        Sta.Run(() =>
+        {
+            var localization = new FakeLocalizationService();
+            using SettingsViewModel viewModel = CreateViewModel(localization: localization);
+
+            Open(viewModel, window =>
+            {
+                Assert.Equal("en:SettingsTitle", window.Title);
+
+                // A language change goes over every binding to a string
+                localization.CurrentLanguage = "ru";
+                Assert.Equal("ru:SettingsTitle", window.Title);
+            });
+        });
+    }
+
+    [Fact]
+    public void The_window_fits_its_height_to_its_content()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+
+            Open(viewModel, window =>
+            {
+                Assert.Equal(SizeToContent.Height, window.SizeToContent);
+                Assert.Equal(ResizeMode.CanMinimize, window.ResizeMode);
+                Assert.True(window.ActualHeight > 0);
+                Assert.True(window.ActualWidth > 0);
+            });
+        });
+    }
+
+    // The markup asks the view model for lists and palettes: if a name drifts
+    // apart from the model, the binding silently shows an empty list
+    [Fact]
+    public void The_lists_in_the_window_are_filled()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+
+            Open(viewModel, window =>
+            {
+                List<ComboBox> boxes = [.. FindAll<ComboBox>(window)];
+
+                Assert.NotEmpty(boxes);
+                Assert.All(boxes, box => Assert.NotEmpty(box.Items));
+            });
+        });
+    }
+
+    [Fact]
+    public void The_lists_show_captions_in_the_chosen_language()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+
+            Open(viewModel, window =>
+            {
+                // Languages are named in themselves, while the enum options are
+                // named by strings from the resources: the latter are checked
+                List<string> displays =
+                [
+                    .. FindAll<ComboBox>(window)
+                        .SelectMany(box => box.Items.OfType<object>())
+                        .Where(item => item.GetType().Name.StartsWith("EnumOption", StringComparison.Ordinal))
+                        .Select(item => item.ToString() ?? string.Empty),
+                ];
+
+                Assert.NotEmpty(displays);
+                Assert.All(displays, display => Assert.StartsWith("en:", display, StringComparison.Ordinal));
+            });
+        });
+    }
+
+    [Fact]
+    public void The_window_shows_a_preview_of_the_tooltip()
+    {
+        Sta.Run(() =>
+        {
+            var settings = new AppSettings { FontSize = 33 };
+            using SettingsViewModel viewModel = CreateViewModel(settings);
+
+            Open(viewModel, window =>
+                // The font size from the settings is visible right in the window
+                Assert.Contains(FindAll<TextBlock>(window), text => Math.Abs(text.FontSize - 33) < 0.001));
+        });
+    }
+
+    [Fact]
+    public void The_tooltip_colours_are_shown_as_swatches()
+    {
+        Sta.Run(() =>
+        {
+            var settings = new AppSettings();
+            using SettingsViewModel viewModel = CreateViewModel(settings);
+
+            // The chosen colour is shown as a swatch with a caption — in the
+            // same notation the settings file uses
+            System.Drawing.Color chosen = viewModel.BackgroundPalette[2];
+            settings.BackgroundColor = chosen;
+
+            string expected = $"#{chosen.R:X2}{chosen.G:X2}{chosen.B:X2}";
+
+            Open(viewModel, window => Assert.Contains(
+                FindAll<TextBlock>(window),
+                text => text.Text.Equals(expected, StringComparison.OrdinalIgnoreCase)));
+        });
+    }
+
+    [Fact]
+    public void The_startup_setting_hides_until_Windows_answers()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+
+            Open(viewModel, window =>
+            {
+                Assert.False(viewModel.IsStartupAvailable);
+                Assert.All(FindStartupCheckBoxes(window), box => Assert.False(box.IsVisible));
+            });
+        });
+    }
+
+    [Fact]
+    public void An_allowed_startup_shows_up_in_the_window()
+    {
+        Sta.Run(() =>
+        {
+            var startup = new FakeStartupService { State = StartupState.Disabled };
+            using SettingsViewModel viewModel = CreateViewModel(startup: startup);
+
+            Open(viewModel, window =>
+            {
+                viewModel.InitializeAsync().GetAwaiter().GetResult();
+                window.UpdateLayout();
+
+                CheckBox box = Assert.Single(FindStartupCheckBoxes(window));
+                Assert.True(box.IsVisible);
+                Assert.True(box.IsEnabled);
+                Assert.False(box.IsChecked);
+            });
+        });
+    }
+
+    // A ban by the user is not for the app to argue with: the tick is shown,
+    // but it cannot be moved
+    [Fact]
+    public void A_startup_banned_by_Windows_is_shown_as_unavailable()
+    {
+        Sta.Run(() =>
+        {
+            var startup = new FakeStartupService { State = StartupState.DisabledByUser };
+            using SettingsViewModel viewModel = CreateViewModel(startup: startup);
+
+            Open(viewModel, window =>
+            {
+                viewModel.InitializeAsync().GetAwaiter().GetResult();
+                window.UpdateLayout();
+
+                CheckBox box = Assert.Single(FindStartupCheckBoxes(window));
+                Assert.True(box.IsVisible);
+                Assert.False(box.IsEnabled);
+            });
+        });
+    }
+
+    [Fact]
+    public void The_Caps_Lock_interception_is_toggled_by_a_tick()
+    {
+        Sta.Run(() =>
+        {
+            var settings = new AppSettings { UseCapsLockHotkey = false };
+            using SettingsViewModel viewModel = CreateViewModel(settings);
+
+            Open(viewModel, window =>
+            {
+                CheckBox box = Assert.Single(FindCheckBoxesBoundTo(window, "Settings.UseCapsLockHotkey"));
+
+                box.IsChecked = true;
+
+                Assert.True(settings.UseCapsLockHotkey);
+            });
+        });
+    }
+
+    [Fact]
+    public void The_updates_are_checked_by_the_button_in_the_window()
+    {
+        Sta.Run(() =>
+        {
+            var updates = new FakeUpdateService();
+            using UpdateViewModel section = CreateUpdates(updates);
+            using SettingsViewModel viewModel = CreateViewModel(updates: section);
+
+            Open(viewModel, window =>
+            {
+                Button check = Assert.Single(FindButtonsBoundTo(window, "Updates.CheckCommand"));
+
+                Assert.True(check.IsVisible);
+                check.Command.Execute(null);
+
+                Assert.Equal(1, updates.CheckCalls);
+            });
+        });
+    }
+
+    // An app installed from the Store is updated by the Store
+    [Fact]
+    public void An_app_that_updates_itself_elsewhere_shows_no_updates_section()
+    {
+        Sta.Run(() =>
+        {
+            using UpdateViewModel section = CreateUpdates(new FakeUpdateService { IsSupported = false });
+            using SettingsViewModel viewModel = CreateViewModel(updates: section);
+
+            Open(viewModel, window =>
+                Assert.All(FindButtonsBoundTo(window, "Updates.CheckCommand"), button =>
+                    Assert.False(button.IsVisible)));
+        });
+    }
+
+    // The application lives in the tray, and the settings window is a guest on the
+    // screen: its close button puts it away rather than ends anything
+    /// <summary>
+    /// Closing the window closes it. The tray it used to hide into belongs to another
+    /// process now, and there is nothing shared left to keep alive.
+    /// </summary>
+    [Fact]
+    public void Closing_the_window_really_closes_it()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+
+            Open(viewModel, window =>
+            {
+                window.Close();
+
+                Assert.False(window.IsVisible);
+
+                Assert.Throws<InvalidOperationException>(window.Show);
+            });
+        });
+    }
+
+    [Fact]
+    public void The_window_hooks_up_to_the_placement()
+    {
+        Sta.Run(() =>
+        {
+            using SettingsViewModel viewModel = CreateViewModel();
+            var placement = new MainWindowPlacement();
+
+            Open(viewModel, new FakeThemeService(), placement, window =>
+            {
+                // The placement works off the window creation event: the window
+                // has to end up on a monitor rather than beyond its edges
+                Assert.True(window.Left > -10_000);
+                Assert.True(window.Top > -10_000);
+            });
+        });
+    }
+
+    private static SettingsViewModel CreateViewModel(
+        AppSettings? settings = null,
+        ILocalizationService? localization = null,
+        IStartupService? startup = null,
+        UpdateViewModel? updates = null) =>
+        new(settings ?? new AppSettings(),
+            localization ?? new FakeLocalizationService(),
+            startup ?? new FakeStartupService(),
+            updates ?? Fake.Updates());
+
+    private static void Open(SettingsViewModel viewModel, Action<MainWindow> check) =>
+        Open(viewModel, new FakeThemeService(), new MainWindowPlacement(), check);
+
+    private static void Open(SettingsViewModel viewModel, IThemeService theme, Action<MainWindow> check) =>
+        Open(viewModel, theme, new MainWindowPlacement(), check);
+
+    private static void Open(
+        SettingsViewModel viewModel,
+        IThemeService theme,
+        MainWindowPlacement placement,
+        Action<MainWindow> check)
+    {
+        var window = new MainWindow(viewModel, theme, placement)
+        {
+            // The window is needed alive, but not in sight
+            Opacity = 0,
+            ShowInTaskbar = false,
+            ShowActivated = false,
+        };
+
+        try
+        {
+            window.Show();
+            window.UpdateLayout();
+
+            check(window);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static UpdateViewModel CreateUpdates(IUpdateService updates) =>
+        new(updates, new FakeLocalizationService(), new AppSettings(), new UpdateOptions());
+
+    private static IEnumerable<Button> FindButtonsBoundTo(DependencyObject root, string path) =>
+        FindAll<Button>(root).Where(button =>
+            BindingOperations.GetBinding(button, ButtonBase.CommandProperty)?.Path.Path == path);
+
+    private static IEnumerable<CheckBox> FindStartupCheckBoxes(DependencyObject root) =>
+        FindCheckBoxesBoundTo(root, nameof(SettingsViewModel.RunAtStartup));
+
+    // An element is found by what it is bound to: the markup gives them no names
+    private static IEnumerable<CheckBox> FindCheckBoxesBoundTo(DependencyObject root, string path) =>
+        FindAll<CheckBox>(root).Where(box =>
+            BindingOperations.GetBinding(box, ToggleButton.IsCheckedProperty)?.Path.Path == path);
+
+    // Walking the element tree: the window markup is large, and things have to be searched for
+    private static IEnumerable<TElement> FindAll<TElement>(DependencyObject root)
+        where TElement : DependencyObject
+    {
+        int count = VisualTreeHelper.GetChildrenCount(root);
+
+        for (int i = 0; i < count; i++)
+        {
+            DependencyObject child = VisualTreeHelper.GetChild(root, i);
+
+            if (child is TElement found)
+            {
+                yield return found;
+            }
+
+            foreach (TElement nested in FindAll<TElement>(child))
+            {
+                yield return nested;
+            }
+        }
+    }
+}