Increase the test coverage

Author: CapulusCodeNinja

unittests/nexus_engine/nexus_engine_extensions_unittests/Core/ManagerTests.cs

@@ -306,4 +306,228 @@ public void Operations_AfterDispose_DoNotThrow()
         _ = m_Manager.ExtensionExists("test");
         _ = m_Manager.GetExtensionsVersion();
     }
+
+    /// <summary>
+    /// Verifies that constructor handles directory creation failure gracefully.
+    /// </summary>
+    [Fact]
+    public void Constructor_WhenDirectoryCreationFails_HandlesGracefully()
+    {
+        // Arrange
+        _ = m_FileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(false);
+        _ = m_FileSystemMock.Setup(fs => fs.CreateDirectory(It.IsAny<string>()));
+        _ = m_FileSystemMock.SetupSequence(fs => fs.DirectoryExists(It.IsAny<string>()))
+            .Returns(false) // First check - doesn't exist
+            .Returns(false); // After creation - still doesn't exist (creation failed)
+
+        // Act - should not throw
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+
+        // Assert
+        _ = m_Manager.Should().NotBeNull();
+    }
+
+    /// <summary>
+    /// Verifies that ValidateExtension returns invalid when script file does not exist.
+    /// </summary>
+    [Fact]
+    public void ValidateExtension_WhenScriptFileDoesNotExist_ReturnsInvalid()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+        var extensionName = "TestExtension";
+        var metadata = new Nexus.Engine.Extensions.Models.ExtensionMetadata
+        {
+            Name = extensionName,
+            ScriptFile = "script.ps1",
+            ScriptType = "powershell",
+            FullScriptPath = "C:\\extensions\\TestExtension\\script.ps1",
+        };
+
+        // Manually add extension to manager's internal dictionary via reflection
+        var extensionsField = typeof(Manager).GetField("m_Extensions", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        if (extensionsField?.GetValue(m_Manager) is System.Collections.Generic.Dictionary<string, Nexus.Engine.Extensions.Models.ExtensionMetadata> extensions)
+        {
+            extensions[extensionName] = metadata;
+        }
+
+        // Setup file system to return false for file exists check
+        _ = m_FileSystemMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(false);
+
+        // Act
+        var (isValid, errorMessage) = m_Manager.ValidateExtension(extensionName);
+
+        // Assert
+        _ = isValid.Should().BeFalse();
+        _ = errorMessage.Should().Contain("not found");
+    }
+
+    /// <summary>
+    /// Verifies that ValidateExtension returns invalid when script file is null or empty.
+    /// </summary>
+    [Fact]
+    public void ValidateExtension_WhenScriptFileIsEmpty_ReturnsInvalid()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+        var extensionName = "TestExtension";
+        var metadata = new Nexus.Engine.Extensions.Models.ExtensionMetadata
+        {
+            Name = extensionName,
+            ScriptFile = string.Empty,
+            ScriptType = "powershell",
+        };
+
+        // Manually add extension to manager's internal dictionary via reflection
+        var extensionsField = typeof(Manager).GetField("m_Extensions", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        if (extensionsField?.GetValue(m_Manager) is System.Collections.Generic.Dictionary<string, Nexus.Engine.Extensions.Models.ExtensionMetadata> extensions)
+        {
+            extensions[extensionName] = metadata;
+        }
+
+        // Act
+        var (isValid, errorMessage) = m_Manager.ValidateExtension(extensionName);
+
+        // Assert
+        _ = isValid.Should().BeFalse();
+        _ = errorMessage.Should().Contain("no script file");
+    }
+
+    /// <summary>
+    /// Verifies that ValidateExtension returns invalid when script type is unsupported.
+    /// </summary>
+    [Fact]
+    public void ValidateExtension_WhenScriptTypeIsUnsupported_ReturnsInvalid()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+        var extensionName = "TestExtension";
+        var metadata = new Nexus.Engine.Extensions.Models.ExtensionMetadata
+        {
+            Name = extensionName,
+            ScriptFile = "script.sh",
+            ScriptType = "bash",
+            FullScriptPath = "C:\\extensions\\TestExtension\\script.sh",
+        };
+
+        // Manually add extension to manager's internal dictionary via reflection
+        var extensionsField = typeof(Manager).GetField("m_Extensions", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        if (extensionsField?.GetValue(m_Manager) is System.Collections.Generic.Dictionary<string, Nexus.Engine.Extensions.Models.ExtensionMetadata> extensions)
+        {
+            extensions[extensionName] = metadata;
+        }
+
+        // Setup file system to return true for file exists check
+        _ = m_FileSystemMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+
+        // Act
+        var (isValid, errorMessage) = m_Manager.ValidateExtension(extensionName);
+
+        // Assert
+        _ = isValid.Should().BeFalse();
+        _ = errorMessage.Should().Contain("unsupported script type");
+    }
+
+    /// <summary>
+    /// Verifies that ValidateExtension returns invalid when script type is null or empty.
+    /// </summary>
+    [Fact]
+    public void ValidateExtension_WhenScriptTypeIsEmpty_ReturnsInvalid()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+        var extensionName = "TestExtension";
+        var metadata = new Nexus.Engine.Extensions.Models.ExtensionMetadata
+        {
+            Name = extensionName,
+            ScriptFile = "script.ps1",
+            ScriptType = string.Empty,
+            FullScriptPath = "C:\\extensions\\TestExtension\\script.ps1",
+        };
+
+        // Manually add extension to manager's internal dictionary via reflection
+        var extensionsField = typeof(Manager).GetField("m_Extensions", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        if (extensionsField?.GetValue(m_Manager) is System.Collections.Generic.Dictionary<string, Nexus.Engine.Extensions.Models.ExtensionMetadata> extensions)
+        {
+            extensions[extensionName] = metadata;
+        }
+
+        // Setup file system to return true for file exists check
+        _ = m_FileSystemMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+
+        // Act
+        var (isValid, errorMessage) = m_Manager.ValidateExtension(extensionName);
+
+        // Assert
+        _ = isValid.Should().BeFalse();
+        _ = errorMessage.Should().Contain("no script type");
+    }
+
+    /// <summary>
+    /// Verifies that constructor handles absolute path configuration correctly.
+    /// </summary>
+    [Fact]
+    public void Constructor_WithAbsolutePathConfiguration_UsesPathAsIs()
+    {
+        // Arrange
+        var absolutePath = "C:\\Absolute\\Extensions\\Path";
+        var sharedConfig = new SharedConfiguration
+        {
+            McpNexus = new McpNexusSettings
+            {
+                Extensions = new ExtensionsSettings
+                {
+                    ExtensionsPath = absolutePath,
+                    CallbackPort = 0,
+                },
+            },
+        };
+        _ = m_Settings.Setup(s => s.Get()).Returns(sharedConfig);
+        _ = m_FileSystemMock.Setup(fs => fs.DirectoryExists(It.Is<string>(p => p == absolutePath))).Returns(true);
+
+        // Act
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+
+        // Assert
+        _ = m_Manager.Should().NotBeNull();
+        m_FileSystemMock.Verify(fs => fs.DirectoryExists(It.Is<string>(p => p == absolutePath)), Times.AtLeastOnce);
+    }
+
+    /// <summary>
+    /// Verifies that LoadExtensionsAsync handles directory that doesn't exist.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+    [Fact]
+    public async Task LoadExtensionsAsync_WhenDirectoryDoesNotExist_CreatesDirectory()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+        _ = m_FileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(false);
+
+        // Act
+        await m_Manager.LoadExtensionsAsync();
+
+        // Assert
+        m_FileSystemMock.Verify(fs => fs.CreateDirectory(It.IsAny<string>()), Times.AtLeastOnce);
+    }
+
+    /// <summary>
+    /// Verifies that LoadExtensionsAsync propagates file system errors from GetFiles.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+    [Fact]
+    public async Task LoadExtensionsAsync_WhenGetFilesThrowsException_PropagatesException()
+    {
+        // Arrange
+        m_Manager = new Manager(m_FileSystemMock.Object, m_Settings.Object);
+
+        // Reset mock after constructor setup
+        m_FileSystemMock.Reset();
+        _ = m_FileSystemMock.Setup(fs => fs.DirectoryExists(It.IsAny<string>())).Returns(true);
+        _ = m_FileSystemMock.Setup(fs => fs.GetFiles(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<SearchOption>()))
+            .Throws(new UnauthorizedAccessException("Access denied"));
+
+        // Act & Assert - exception should propagate since GetFiles is not wrapped in try-catch
+        _ = await Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await m_Manager.LoadExtensionsAsync());
+    }
 }

unittests/nexus_protocol_unittests/Middleware/ResponseFormattingMiddlewareTests.cs

@@ -149,4 +149,85 @@ public async Task InvokeAsync_WithFileNotFoundException_Returns500()
         var responseBody = await reader.ReadToEndAsync();
         _ = responseBody.Should().Contain("File not found");
     }
+
+    /// <summary>
+    /// Verifies that InvokeAsync handles OperationCanceledException gracefully without sending error response.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+    [Fact]
+    public async Task InvokeAsync_WithOperationCanceledException_DoesNotSendErrorResponse()
+    {
+        RequestDelegate next = (HttpContext context) => throw new OperationCanceledException();
+        var middleware = new ResponseFormattingMiddleware(next);
+        var context = new DefaultHttpContext();
+        context.Response.Body = new MemoryStream();
+
+        await middleware.InvokeAsync(context);
+
+        // Should not have written to response body
+        _ = context.Response.StatusCode.Should().Be(200); // Default status code
+        context.Response.Body.Position = 0;
+        var reader = new StreamReader(context.Response.Body);
+        var responseBody = await reader.ReadToEndAsync();
+        _ = responseBody.Should().BeEmpty();
+    }
+
+    /// <summary>
+    /// Verifies that InvokeAsync handles exception when writing to response fails.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+    [Fact]
+    public async Task InvokeAsync_WhenWritingResponseFails_HandlesGracefully()
+    {
+        RequestDelegate next = (HttpContext context) => throw new InvalidOperationException("Test error");
+        var middleware = new ResponseFormattingMiddleware(next);
+        var context = new DefaultHttpContext();
+        var throwingStream = new ThrowingMemoryStream();
+        context.Response.Body = throwingStream;
+
+        // Should not throw even if writing fails
+        await middleware.InvokeAsync(context);
+    }
+
+    /// <summary>
+    /// Memory stream that throws exception on write.
+    /// </summary>
+    private class ThrowingMemoryStream : MemoryStream
+    {
+        /// <summary>
+        /// Writes to the stream, throwing exception after first write.
+        /// </summary>
+        /// <param name="buffer">The buffer to write.</param>
+        /// <param name="offset">The offset.</param>
+        /// <param name="count">The count.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (Position > 0)
+            {
+                throw new IOException("Write failed");
+            }
+
+            base.Write(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Writes to the stream asynchronously, throwing exception after first write.
+        /// </summary>
+        /// <param name="buffer">The buffer to write.</param>
+        /// <param name="offset">The offset.</param>
+        /// <param name="count">The count.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The write task.</returns>
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+#pragma warning disable IDE0046 // Convert to conditional expression - keeping explicit throw for clarity
+            if (Position > 0)
+            {
+                throw new IOException("Write failed");
+            }
+#pragma warning restore IDE0046
+
+            return base.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+    }
 }