fixed settings import bug...

Author: Hirogen

src/LogExpert.Configuration/ConfigManager.cs

@@ -196,7 +196,7 @@ public ImportResult Import (FileInfo fileInfo, ExportImportFlags importFlags)
             // Handle any critical errors from loading
             if (loadResult.CriticalFailure)
             {
-                return ImportResult.Failed("Import Failed", $"Import file is invalid or corrupted:\n\n{loadResult.CriticalMessage}\n\nImport cancelled.");
+                return ImportResult.Failed("Import Failed", $"Import file is invalid or corrupted:\n\n{loadResult.CriticalMessage}\n\nImport canceled.");
             }
 
             importedSettings = loadResult.Settings;
@@ -205,7 +205,7 @@ public ImportResult Import (FileInfo fileInfo, ExportImportFlags importFlags)
                                          JsonSerializationException)
         {
             _logger.Error($"Import file is invalid or corrupted: {ex}");
-            return ImportResult.Failed("Import Failed", $"Import file is invalid or corrupted:\n\n{ex.Message}\n\nImport cancelled.");
+            return ImportResult.Failed("Import Failed", $"Import file is invalid or corrupted:\n\n{ex.Message}\n\nImport canceled.");
         }
 
         if (SettingsAreEmptyOrDefault(importedSettings))
@@ -228,8 +228,8 @@ public ImportResult Import (FileInfo fileInfo, ExportImportFlags importFlags)
             $"History={importedSettings.FileHistoryList?.Count ?? 0}, " +
             $"Highlights={importedSettings.Preferences?.HighlightGroupList?.Count ?? 0}");
 
-        // Proceed with import
-        Instance._settings = Instance.Import(Instance._settings, fileInfo, importFlags);
+        // Proceed with import - Use Settings property to ensure _settings is initialized
+        _settings = Instance.Import(Instance.Settings, fileInfo, importFlags);
         Save(SettingsFlags.All);
 
         _logger.Info("Import completed successfully");

src/LogExpert.Core/Classes/ObjectClone.cs

@@ -1,4 +1,3 @@
-using System.IO;
 using System.Text.Json;
 
 namespace LogExpert.Core.Classes;
@@ -7,12 +6,12 @@ public static class ObjectClone
 {
     #region Public methods
 
-    public static T Clone<T>(T RealObject)
+    public static T Clone<T> (T realObject)
     {
         using MemoryStream objectStream = new();
 
-        JsonSerializer.Serialize(objectStream, RealObject);
-        objectStream.Seek(0, SeekOrigin.Begin);
+        JsonSerializer.Serialize(objectStream, realObject);
+        _ = objectStream.Seek(0, SeekOrigin.Begin);
         return JsonSerializer.Deserialize<T>(objectStream);
     }
 

src/LogExpert.Tests/ConfigManagerTest.cs

@@ -23,6 +23,7 @@ public class ConfigManagerTest
     private ConfigManager _configManager;
 
     [SetUp]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
     public void SetUp ()
     {
         // Create isolated test directory for each test
@@ -547,6 +548,313 @@ public void LoadOrCreateNew_InvalidJSON_HandlesGracefully ()
 
     #endregion
 
+    #region Import Method Tests
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should handle null _settings field by using Settings property")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Unit Test")]
+    public void Import_WithUninitializedSettings_ShouldNotThrowNullReference ()
+    {
+        // Arrange
+        // Create a valid import file
+        Settings importSettings = CreatePopulatedSettings();
+        importSettings.FilterList.Clear();
+        importSettings.FilterList.Add(new FilterParams { SearchText = "IMPORTED_FILTER" });
+
+        string importFilePath = Path.Join(_testDir, "import_test.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act & Assert - This should not throw NullReferenceException
+        ImportResult result = null;
+        Assert.DoesNotThrow(() => result = _configManager.Import(importFile, ExportImportFlags.All), "Import should not throw NullReferenceException when _settings is uninitialized");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.True, "Import should succeed");
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should validate that import file exists")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithNonExistentFile_ShouldReturnFailure ()
+    {
+        // Arrange
+        FileInfo nonExistentFile = new(Path.Join(_testDir, "does_not_exist.json"));
+
+        // Act
+        ImportResult result = _configManager.Import(nonExistentFile, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.False, "Import should fail for non-existent file");
+        Assert.That(result.ErrorMessage, Does.Contain("not found").IgnoreCase);
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should validate that import file is not null")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithNullFileInfo_ShouldReturnFailure ()
+    {
+        // Act
+        ImportResult result = _configManager.Import(null, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.False, "Import should fail for null file");
+        Assert.That(result.ErrorMessage, Does.Contain("not found").IgnoreCase);
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should detect corrupted import files")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithCorruptedFile_ShouldReturnFailure ()
+    {
+        // Arrange
+        string importFilePath = Path.Join(_testDir, "corrupt_import.json");
+        File.WriteAllText(importFilePath, "{invalid json}");
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.False, "Import should fail for corrupted file");
+        Assert.That(result.ErrorMessage, Does.Contain("invalid").Or.Contain("corrupted").IgnoreCase);
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should detect empty/default settings and require confirmation")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithEmptySettings_ShouldRequireConfirmation ()
+    {
+        // Arrange
+        Settings emptySettings = CreateTestSettings();
+        string importFilePath = Path.Join(_testDir, "empty_import.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(emptySettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.RequiresUserConfirmation, Is.True, "Empty settings should require confirmation");
+        Assert.That(result.ConfirmationMessage, Does.Contain("empty").Or.Contain("default").IgnoreCase);
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should successfully import valid populated settings")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithValidPopulatedSettings_ShouldSucceed ()
+    {
+        // Arrange
+        Settings importSettings = CreatePopulatedSettings();
+        importSettings.FilterList.Clear();
+        importSettings.FilterList.Add(new FilterParams { SearchText = "IMPORT_TEST_FILTER" });
+        importSettings.SearchHistoryList.Clear();
+        importSettings.SearchHistoryList.Add("IMPORT_TEST_SEARCH");
+
+        string importFilePath = Path.Join(_testDir, "valid_import.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.True, "Import should succeed with valid settings");
+
+        // Verify settings were actually imported
+        Settings currentSettings = _configManager.Settings;
+        Assert.That(currentSettings.FilterList.Any(f => f.SearchText == "IMPORT_TEST_FILTER"), Is.True,
+            "Imported filter should be present");
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import with Other flag should merge preferences correctly")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithOtherFlag_ShouldMergePreferences ()
+    {
+        // Arrange
+        // Set up current settings
+        Settings currentSettings = _configManager.Settings;
+        currentSettings.Preferences.FontSize = 10;
+        currentSettings.Preferences.ColumnizerMaskList.Clear();
+
+        // Create import settings with different preferences
+        Settings importSettings = CreateTestSettings();
+        importSettings.Preferences.FontSize = 12;
+        importSettings.Preferences.ShowBubbles = true;
+
+        string importFilePath = Path.Join(_testDir, "import_other.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.Other);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.True);
+
+        Settings updatedSettings = _configManager.Settings;
+        Assert.That(updatedSettings.Preferences.FontSize, Is.EqualTo(12),
+            "Preferences should be merged from import file");
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import with ColumnizerMasks flag should import columnizer masks")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithColumnizerMasksFlag_ShouldImportMasks ()
+    {
+        // Arrange
+        Settings importSettings = CreateTestSettings();
+        importSettings.Preferences.ColumnizerMaskList.Add(new ColumnizerMaskEntry { Mask = "*.log", ColumnizerName = "TestColumnizer" });
+
+        string importFilePath = Path.Join(_testDir, "import_columnizer.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.ColumnizerMasks);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.True);
+
+        Settings updatedSettings = _configManager.Settings;
+        Assert.That(updatedSettings.Preferences.ColumnizerMaskList.Count, Is.GreaterThan(0),
+            "Columnizer masks should be imported");
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import with KeepExisting flag should merge rather than replace")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_WithKeepExistingFlag_ShouldMergeSettings ()
+    {
+        // Arrange
+        // Set up current settings with existing data
+        Settings currentSettings = _configManager.Settings;
+        currentSettings.FilterList.Clear();
+        currentSettings.FilterList.Add(new FilterParams { SearchText = "EXISTING_FILTER" });
+
+        // Create import settings with different data
+        Settings importSettings = CreateTestSettings();
+        importSettings.FilterList.Clear();
+        importSettings.FilterList.Add(new FilterParams { SearchText = "NEW_FILTER" });
+
+        string importFilePath = Path.Join(_testDir, "import_keep_existing.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.ColumnizerMasks | ExportImportFlags.KeepExisting);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Success, Is.True);
+
+        // Both should be present when using KeepExisting
+        // Note: This test may need adjustment based on actual merge behavior
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should handle null Preferences in import file gracefully")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Unit Test")]
+    public void Import_WithNullPreferences_ShouldHandleGracefully ()
+    {
+        // Arrange
+        var importSettings = new Settings
+        {
+            Preferences = null, // Deliberately null
+            FilterList = [new() { SearchText = "TEST" }]
+        };
+
+        string importFilePath = Path.Join(_testDir, "import_null_prefs.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act & Assert
+        ImportResult result = null;
+        Assert.DoesNotThrow(() => result = _configManager.Import(importFile, ExportImportFlags.All), "Import should handle null Preferences gracefully");
+
+        Assert.That(result, Is.Not.Null);
+        // May fail validation or require confirmation due to null Preferences
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Multiple imports should maintain consistency")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_MultipleImports_ShouldMaintainConsistency ()
+    {
+        // Arrange & Act - Multiple imports
+        for (int i = 0; i < 3; i++)
+        {
+            Settings importSettings = CreateTestSettings();
+            importSettings.FilterList.Add(new FilterParams { SearchText = $"IMPORT_{i}" });
+
+            string importFilePath = Path.Join(_testDir, $"import_{i}.json");
+            File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+            FileInfo importFile = new(importFilePath);
+
+            ImportResult result = _configManager.Import(importFile, ExportImportFlags.All);
+            Assert.That(result.Success, Is.True, $"Import {i} should succeed");
+        }
+
+        // Assert - Final state should be consistent
+        Settings finalSettings = _configManager.Settings;
+        Assert.That(finalSettings, Is.Not.Null);
+        Assert.That(finalSettings.Preferences, Is.Not.Null);
+    }
+
+    [Test]
+    [Category("Import")]
+    [Description("Import should save settings after successful import")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Unit Test")]
+    public void Import_SuccessfulImport_ShouldSaveSettings ()
+    {
+        // Arrange
+        Settings importSettings = CreatePopulatedSettings();
+        importSettings.FilterList.Clear();
+        importSettings.FilterList.Add(new FilterParams { SearchText = "SAVE_TEST_FILTER" });
+
+        string importFilePath = Path.Join(_testDir, "import_save_test.json");
+        File.WriteAllText(importFilePath, JsonConvert.SerializeObject(importSettings));
+        FileInfo importFile = new(importFilePath);
+
+        // Act
+        ImportResult result = _configManager.Import(importFile, ExportImportFlags.All);
+
+        // Assert
+        Assert.That(result.Success, Is.True);
+
+        // Verify settings were saved by loading them
+        string settingsFile = Path.Join(_testDir, "settings.json");
+        if (File.Exists(settingsFile))
+        {
+            string content = File.ReadAllText(settingsFile);
+            Assert.That(content, Does.Contain("SAVE_TEST_FILTER"),
+                "Imported settings should be saved to disk");
+        }
+    }
+
+    #endregion
+
     #region Integration Tests
 
     [Test]