diff --git a/OpenNest.Desktop.Tests/DesktopStartupTests.cs b/OpenNest.Desktop.Tests/DesktopStartupTests.cs new file mode 100644 index 00000000..703a6996 --- /dev/null +++ b/OpenNest.Desktop.Tests/DesktopStartupTests.cs @@ -0,0 +1,144 @@ +using OpenNest.Data; +using OpenNest.Engine.BestFit; +using OpenNest.IO; + +namespace OpenNest.Desktop.Tests; + +public sealed class DesktopStartupTests : IDisposable +{ + private readonly string directory = + Directory.CreateTempSubdirectory("opennest-desktop-startup-").FullName; + + public void Dispose() => Directory.Delete(directory, recursive: true); + + private string SettingsPath => Path.Combine(directory, "user-settings.json"); + + private string DefaultsPath => Path.Combine(directory, "defaults.json"); + + // BestFitCacheStore has no public constructor: Shared wraps the process-wide cache. + private DesktopStartupResult Run() => + DesktopStartup.Run(SettingsPath, DefaultsPath, BestFitCacheStore.Shared); + + private void WriteSettings(Dictionary values) => + Assert.True(UserSettingsFile.Write(SettingsPath, values)); + + private string WriteTemplate() + { + var path = Path.Combine(directory, "template.nstdot"); + var nest = TestNests.OneSquare(); + nest.Units = Units.Millimeters; + Assert.True(new NestWriter(nest).Write(path)); + return path; + } + + [Fact] + public void NoSettings_OpensANewNest_AsTheOptionDefaultsToOn() + { + var result = Run(); + + Assert.True(result.CreateNewNest); + Assert.False(result.ClearTemplateSetting); + Assert.Null(result.TemplateWarning); + } + + [Fact] + public void NoSettings_LeavesTheSettingsFileUnwritten() + { + Run(); + + Assert.False(File.Exists(SettingsPath)); + } + + [Fact] + public void Run_NeverWritesTheSettingsFile_EvenWhenATemplateConverts() + { + WriteSettings(new() + { + [NestTemplateMigration.SettingName] = WriteTemplate(), + ["SomethingElse"] = "kept", + }); + var before = File.ReadAllBytes(SettingsPath); + + Run(); + + Assert.Equal(before, File.ReadAllBytes(SettingsPath)); + } + + [Fact] + public void OptionOff_OpensNoNewNest() + { + WriteSettings(new() { [DesktopOptions.CreateNewNestOnOpenName] = "False" }); + + Assert.False(Run().CreateNewNest); + } + + [Fact] + public void OptionOn_OpensANewNest() + { + WriteSettings(new() { [DesktopOptions.CreateNewNestOnOpenName] = "True" }); + + Assert.True(Run().CreateNewNest); + } + + [Fact] + public void ATemplate_IsConverted_AndItsSettingIsToBeCleared() + { + WriteSettings(new() { [NestTemplateMigration.SettingName] = WriteTemplate() }); + + var result = Run(); + + Assert.True(result.ClearTemplateSetting); + Assert.Null(result.TemplateWarning); + Assert.Equal(Units.Millimeters, NestDefaults.Load(DefaultsPath).Units); + } + + [Fact] + public void ExistingDefaults_AreKept_AndTheTemplateSettingIsToBeCleared() + { + File.WriteAllText(DefaultsPath, "{ \"kept\": true }"); + WriteSettings(new() { [NestTemplateMigration.SettingName] = WriteTemplate() }); + + var result = Run(); + + Assert.True(result.ClearTemplateSetting); + Assert.Equal("{ \"kept\": true }", File.ReadAllText(DefaultsPath)); + } + + [Fact] + public void AnAlreadyClearedSetting_IsNotClearedAgain() + { + WriteSettings(new() { [NestTemplateMigration.SettingName] = "" }); + + Assert.False(Run().ClearTemplateSetting); + } + + [Fact] + public void AnUnreadableTemplate_Warns_KeepsTheSetting_AndStillOpensANewNest() + { + var path = Path.Combine(directory, "broken.nstdot"); + File.WriteAllText(path, "not a nest"); + WriteSettings(new() { [NestTemplateMigration.SettingName] = path }); + + var result = Run(); + + Assert.Contains(path, result.TemplateWarning); + Assert.False(result.ClearTemplateSetting); + Assert.True(result.CreateNewNest); + } + + [Fact] + public void ClearTemplateSetting_EmptiesOnlyThatSetting() + { + WriteSettings(new() + { + [NestTemplateMigration.SettingName] = "old.nstdot", + ["SomethingElse"] = "kept", + }); + + Assert.True(DesktopStartup.ClearTemplateSetting(SettingsPath)); + + var saved = UserSettingsFile.Read(SettingsPath); + Assert.Equal("", saved[NestTemplateMigration.SettingName]); + Assert.Equal("kept", saved["SomethingElse"]); + } +} diff --git a/OpenNest.Desktop/DesktopStartup.cs b/OpenNest.Desktop/DesktopStartup.cs new file mode 100644 index 00000000..5da97d73 --- /dev/null +++ b/OpenNest.Desktop/DesktopStartup.cs @@ -0,0 +1,48 @@ +using OpenNest.BestFit; +using OpenNest.Data; + +namespace OpenNest.Desktop; + +/// What the desktop app's start-up steps found. +/// Why the legacy nest template could not be converted, to show +/// the user; null when there was nothing to report. +/// The template was converted or is gone: clear its setting +/// () so it is never consulted again. +/// Open a new nest, as Tools > Options > Create a new nest on +/// startup asks; the window adds none beside nests already open. +public sealed record DesktopStartupResult( + string TemplateWarning, bool ClearTemplateSetting, bool CreateNewNest); + +/// +/// The desktop app's start-up steps, in the WinForms main window's order: first the one-time +/// conversion of the legacy nest template into the nest defaults file (a new nest reads that +/// file), then whether to open a new nest. +/// +public static class DesktopStartup +{ + /// + /// Converts the legacy nest template and decides on the new nest. Reads the user settings + /// but never writes them, so it can run off the UI thread while the window's own settings + /// writers run on it; the caller clears the setting on the UI thread when asked to. + /// + /// The shared user settings file. + /// The nest defaults file the template converts into. + /// Best-fit cache the template's drawings read from. + public static DesktopStartupResult Run( + string settingsPath, string defaultsPath, IBestFitStore bestFitStore) + { + var settings = UserSettingsFile.Read(settingsPath); + settings.TryGetValue(NestTemplateMigration.SettingName, out var templatePath); + var migration = NestTemplateMigration.Run(templatePath, defaultsPath, bestFitStore); + return new DesktopStartupResult(migration.Warning, migration.ClearSetting, + DesktopOptions.Read(settings).CreateNewNestOnOpen); + } + + /// + /// Clears the template setting to the empty text WinForms stores, keeping every other + /// setting. Returns false when the file could not be written; the next start then finds + /// the defaults file already there and clears it again. + /// + public static bool ClearTemplateSetting(string settingsPath) => + UserSettingsFile.Update(settingsPath, s => s[NestTemplateMigration.SettingName] = ""); +}