initial fix try

Author: BRUNER Patrick

src/LogExpert.Core/Config/Preferences.cs

@@ -12,6 +12,15 @@ public class Preferences
 
     public bool PortableMode { get; set; }
 
+    /// <summary>
+    /// OBSOLETE: This setting is no longer used. It was originally intended to show an error dialog when "Allow Only One Instance" was enabled,
+    /// but this behavior was incorrect (showed dialog on success instead of failure). The feature now works silently on success and only shows
+    /// a warning on IPC failure. This property is kept for backward compatibility with old settings files but is no longer used or saved.
+    /// Will be removed in a future version.
+    /// </summary>
+    [Obsolete("This setting is no longer used and will be removed in a future version. The 'Allow Only One Instance' feature now works silently.")]
+    [System.Text.Json.Serialization.JsonIgnore]
+    [Newtonsoft.Json.JsonIgnore]
     public bool ShowErrorMessageAllowOnlyOneInstances { get; set; }
 
     /// <summary>

src/LogExpert.Tests/IPC/LockInstancePriorityTests.cs

@@ -0,0 +1,114 @@
+using LogExpert.Classes;
+using LogExpert.Core.Interface;
+using LogExpert.UI.Extensions.LogWindow;
+
+using Moq;
+
+using NUnit.Framework;
+
+namespace LogExpert.Tests.IPC;
+
+/// <summary>
+/// Unit tests for Lock Instance Priority feature
+/// Tests that lock instance behavior works correctly with "Allow Only One Instance"
+/// </summary>
+[TestFixture]
+public class LockInstancePriorityTests
+{
+    private Mock<ILogTabWindow> _mockWindow1;
+    private Mock<ILogTabWindow> _mockWindow2;
+    private Mock<ILogTabWindow> _mockLockedWindow;
+
+    [SetUp]
+    public void SetUp ()
+    {
+        _mockWindow1 = new Mock<ILogTabWindow>();
+        _mockWindow2 = new Mock<ILogTabWindow>();
+        _mockLockedWindow = new Mock<ILogTabWindow>();
+
+        // Reset the static locked window state
+        AbstractLogTabWindow.StaticData.CurrentLockedMainWindow = null;
+    }
+
+    [TearDown]
+    public void TearDown ()
+    {
+        // Clean up static state
+        AbstractLogTabWindow.StaticData.CurrentLockedMainWindow = null;
+    }
+
+    [Test]
+    [Ignore("Requires UI thread context - manual testing recommended")]
+    public void NewWindowOrLockedWindow_WithLockedWindow_LoadsInLockedWindow ()
+    {
+        // This test requires a proper UI context and cannot be run in unit test environment
+        // It should be tested manually or in integration tests
+
+        // Arrange - would set up a locked window scenario
+        // Act - would call NewWindowOrLockedWindow
+        // Assert - would verify files loaded in locked window
+
+        Assert.Pass("Test structure documented - requires UI context for execution");
+    }
+
+    [Test]
+    public void NewWindowOrLockedWindow_WithoutLockedWindow_ShouldUseLoadFiles ()
+    {
+        // This test documents the expected behavior
+        // Actual implementation testing requires UI thread
+
+        // Expected behavior:
+        // 1. Check all windows for locked window
+        // 2. If no locked window found, call LoadFiles() instead of NewWindow()
+        // 3. LoadFiles() loads in most recent window (last in window list)
+
+        Assert.Pass("Expected behavior documented - integration test required");
+    }
+
+    [Test]
+    public void LoadFiles_UsesLastWindowInList ()
+    {
+        // This test documents that LoadFiles should use the last window in the list
+        // In Phase 2, this will be enhanced to use the most recently activated window
+
+        // Expected behavior for Phase 1:
+        // - LoadFiles() gets last window from _windowList
+        // - Sets that window to foreground
+        // - Loads files in that window
+
+        Assert.Pass("Phase 1 behavior documented - uses last window in list");
+    }
+
+    #region Documentation Tests
+
+    [Test]
+    public void Priority_LockedWindowTakesPrecedenceOverAllowOnlyOne ()
+    {
+        // Documents stakeholder decision:
+        // When both "Lock Instance" and "Allow Only One Instance" are active,
+        // the locked window takes priority
+
+        // Priority order:
+        // 1. If locked window exists -> use it (highest priority)
+        // 2. Else if AllowOnlyOneInstance -> load in most recent window
+        // 3. Else -> create new window
+
+        Assert.Pass("Priority order documented");
+    }
+
+    [Test]
+    public void AllowOnlyOneInstance_NeverCreatesNewWindow ()
+    {
+        // Documents stakeholder decision:
+        // When AllowOnlyOneInstance is true and no locked window exists,
+        // files should load in most recent window, NOT create new window
+
+        // This is the key fix for Issue #448
+        // Before: NewWindowOrLockedWindow() would call NewWindow() when no locked window
+        // After: NewWindowOrLockedWindow() calls LoadFiles() when no locked window
+
+        Assert.Pass("Behavior documented - NewWindow() should never be called");
+    }
+
+    #endregion
+}

src/LogExpert.Tests/IPC/OneInstanceIpcTests.cs

@@ -0,0 +1,204 @@
+using LogExpert.Classes;
+using LogExpert.Core.Classes.IPC;
+using LogExpert.Core.Interface;
+
+using Moq;
+
+using Newtonsoft.Json;
+
+using NUnit.Framework;
+
+namespace LogExpert.Tests.IPC;
+
+/// <summary>
+/// Unit tests for One Instance Only feature - IPC logic tests
+/// Tests the IPC message serialization and handling logic
+/// </summary>
+[TestFixture]
+public class OneInstanceIpcTests
+{
+    #region IPC Message Type Tests
+
+    [Test]
+    public void SerializeCommand_WhenAllowOnlyOneInstance_UsesNewWindowOrLockedWindowType ()
+    {
+        // Arrange
+        string[] files = ["test.log"];
+        bool allowOnlyOne = true;
+
+        // Act
+        // Note: We can't call the private method directly, so we test the integration
+        // through the public API. This test verifies the expected behavior.
+        // For unit testing, we'd need to make SerializeCommandIntoNonFormattedJSON internal
+        // or use InternalsVisibleTo attribute.
+        
+        // For now, we test the IpcMessage structure directly
+        var message = new IpcMessage
+        {
+            Type = allowOnlyOne ? IpcMessageType.NewWindowOrLockedWindow : IpcMessageType.NewWindow,
+            Payload = Newtonsoft.Json.Linq.JObject.FromObject(new LoadPayload { Files = [.. files] })
+        };
+        
+        var json = JsonConvert.SerializeObject(message, Formatting.None);
+        var deserialized = JsonConvert.DeserializeObject<IpcMessage>(json);
+
+        // Assert
+        Assert.That(deserialized.Type, Is.EqualTo(IpcMessageType.NewWindowOrLockedWindow));
+        var payload = deserialized.Payload.ToObject<LoadPayload>();
+        Assert.That(payload, Is.Not.Null);
+        Assert.That(payload.Files.Count, Is.EqualTo(1));
+        Assert.That(payload.Files[0], Is.EqualTo("test.log"));
+    }
+
+    [Test]
+    public void SerializeCommand_WhenMultipleInstancesAllowed_UsesNewWindowType ()
+    {
+        // Arrange
+        string[] files = ["test.log"];
+        bool allowOnlyOne = false;
+
+        // Act
+        var message = new IpcMessage
+        {
+            Type = allowOnlyOne ? IpcMessageType.NewWindowOrLockedWindow : IpcMessageType.NewWindow,
+            Payload = Newtonsoft.Json.Linq.JObject.FromObject(new LoadPayload { Files = [.. files] })
+        };
+        
+        var json = JsonConvert.SerializeObject(message, Formatting.None);
+        var deserialized = JsonConvert.DeserializeObject<IpcMessage>(json);
+
+        // Assert
+        Assert.That(deserialized.Type, Is.EqualTo(IpcMessageType.NewWindow));
+    }
+
+    [Test]
+    public void IpcMessage_SerializesAndDeserializesCorrectly ()
+    {
+        // Arrange
+        var originalMessage = new IpcMessage
+        {
+            Type = IpcMessageType.Load,
+            Payload = Newtonsoft.Json.Linq.JObject.FromObject(new LoadPayload 
+            { 
+                Files = ["file1.log", "file2.log", "file3.log"] 
+            })
+        };
+
+        // Act
+        var json = JsonConvert.SerializeObject(originalMessage, Formatting.None);
+        var deserializedMessage = JsonConvert.DeserializeObject<IpcMessage>(json);
+
+        // Assert
+        Assert.That(deserializedMessage, Is.Not.Null);
+        Assert.That(deserializedMessage.Type, Is.EqualTo(originalMessage.Type));
+        
+        var originalPayload = originalMessage.Payload.ToObject<LoadPayload>();
+        var deserializedPayload = deserializedMessage.Payload.ToObject<LoadPayload>();
+        
+        Assert.That(deserializedPayload.Files.Count, Is.EqualTo(originalPayload.Files.Count));
+        for (int i = 0; i < originalPayload.Files.Count; i++)
+        {
+            Assert.That(deserializedPayload.Files[i], Is.EqualTo(originalPayload.Files[i]));
+        }
+    }
+
+    [Test]
+    public void IpcMessage_MultipleFiles_SerializesCorrectly ()
+    {
+        // Arrange
+        string[] multipleFiles = ["log1.txt", "log2.txt", "log3.txt", "log4.txt"];
+        var message = new IpcMessage
+        {
+            Type = IpcMessageType.NewWindowOrLockedWindow,
+            Payload = Newtonsoft.Json.Linq.JObject.FromObject(new LoadPayload { Files = [.. multipleFiles] })
+        };
+
+        // Act
+        var json = JsonConvert.SerializeObject(message, Formatting.None);
+        var deserialized = JsonConvert.DeserializeObject<IpcMessage>(json);
+
+        // Assert
+        var payload = deserialized.Payload.ToObject<LoadPayload>();
+        Assert.That(payload.Files.Count, Is.EqualTo(4));
+        Assert.That(payload.Files, Is.EquivalentTo(multipleFiles));
+    }
+
+    [Test]
+    public void IpcMessage_EmptyFileList_SerializesCorrectly ()
+    {
+        // Arrange
+        var message = new IpcMessage
+        {
+            Type = IpcMessageType.NewWindow,
+            Payload = Newtonsoft.Json.Linq.JObject.FromObject(new LoadPayload { Files = [] })
+        };
+
+        // Act
+        var json = JsonConvert.SerializeObject(message, Formatting.None);
+        var deserialized = JsonConvert.DeserializeObject<IpcMessage>(json);
+
+        // Assert
+        var payload = deserialized.Payload.ToObject<LoadPayload>();
+        Assert.That(payload.Files, Is.Empty);
+    }
+
+    #endregion
+
+    #region IPC Message Type Enum Tests
+
+    [Test]
+    public void IpcMessageType_HasCorrectValues ()
+    {
+        // Assert - verify the enum values exist
+        Assert.That(IpcMessageType.Load, Is.Not.Null);
+        Assert.That(IpcMessageType.NewWindow, Is.Not.Null);
+        Assert.That(IpcMessageType.NewWindowOrLockedWindow, Is.Not.Null);
+    }
+
+    [Test]
+    public void IpcMessageType_Load_IsDistinctFromNewWindow ()
+    {
+        // Assert
+        Assert.That(IpcMessageType.Load, Is.Not.EqualTo(IpcMessageType.NewWindow));
+    }
+
+    [Test]
+    public void IpcMessageType_NewWindowOrLockedWindow_IsDistinctFromOthers ()
+    {
+        // Assert
+        Assert.That(IpcMessageType.NewWindowOrLockedWindow, Is.Not.EqualTo(IpcMessageType.Load));
+        Assert.That(IpcMessageType.NewWindowOrLockedWindow, Is.Not.EqualTo(IpcMessageType.NewWindow));
+    }
+
+    #endregion
+
+    #region LoadPayload Tests
+
+    [Test]
+    public void LoadPayload_CanBeCreatedEmpty ()
+    {
+        // Arrange & Act
+        var payload = new LoadPayload();
+
+        // Assert
+        Assert.That(payload, Is.Not.Null);
+        Assert.That(payload.Files, Is.Not.Null);
+    }
+
+    [Test]
+    public void LoadPayload_CanBeCreatedWithFiles ()
+    {
+        // Arrange & Act
+        var payload = new LoadPayload
+        {
+            Files = ["test1.log", "test2.log"]
+        };
+
+        // Assert
+        Assert.That(payload.Files, Has.Count.EqualTo(2));
+        Assert.That(payload.Files[0], Is.EqualTo("test1.log"));
+        Assert.That(payload.Files[1], Is.EqualTo("test2.log"));
+    }
+
+    #endregion
+}

src/LogExpert/Classes/LogExpertProxy.cs

@@ -93,17 +93,23 @@ public void NewWindow (string[] fileNames)
     [SupportedOSPlatform("windows")]
     public void NewWindowOrLockedWindow (string[] fileNames)
     {
+        // Lock Instance has priority
+        // Check for locked window first
         foreach (var logWin in _windowList)
         {
             if (AbstractLogTabWindow.StaticData.CurrentLockedMainWindow == logWin)
             {
+                _logger.Info("Loading files in locked window");
                 _ = logWin.Invoke(new MethodInvoker(logWin.SetForeground));
                 logWin.LoadFiles(fileNames);
                 return;
             }
         }
-        // No locked window was found --> create a new one
-        NewWindow(fileNames);
+
+        // No locked window found
+        // Load in most recent window (not new window)
+        _logger.Info("No locked window, loading files in most recent window");
+        LoadFiles(fileNames); // Uses most recent window
     }
 
     [SupportedOSPlatform("windows")]