- Integrate Microsoft.Extensions.Logging in TestHelper and SshSession for improved debugging.

- Add `AnsiConsoleLogger` for console-based logging in tests.
- Refactor `ThrowIfNotSuccessful` to include session-specific error context.
- Enhance method preference handling in `SshSession` with deferred application and validation tests.
- Improve testing coverage with additional scenarios and timeout validation.

Author: 0x25CBFC4F

NullOpsDevs.LibSsh.Test/AnsiConsoleLogger.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.Logging;
+using Spectre.Console;
+
+namespace NullOpsDevs.LibSsh.Test;
+
+public class AnsiConsoleLogger : ILogger
+{
+    /// <inheritdoc />
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <inheritdoc />
+    public bool IsEnabled(LogLevel logLevel) => true;
+
+    /// <inheritdoc />
+    public void Log<TState>(LogLevel logLevel, EventId _, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        var logLevelColor = logLevel switch
+        {
+            LogLevel.Trace => "dim",
+            LogLevel.Debug => "dim",
+            LogLevel.Information => "white",
+            LogLevel.Warning => "yellow",
+            LogLevel.Error => "red",
+            LogLevel.Critical => "red",
+            _ => "white"
+        };
+        
+        var formatted = formatter(state, exception);
+        AnsiConsole.MarkupLine($"[{logLevelColor}]{logLevel:G}[/] {Markup.Escape(formatted)}");
+    }
+}

NullOpsDevs.LibSsh.Test/Program.cs

@@ -2,6 +2,7 @@
 using System.Text;
 using NullOpsDevs.LibSsh.Core;
 using NullOpsDevs.LibSsh.Credentials;
+using NullOpsDevs.LibSsh.Exceptions;
 using NullOpsDevs.LibSsh.Terminal;
 using Spectre.Console;
 
@@ -28,8 +29,6 @@ public static async Task<int> Main()
             return 255;
         }
 
-        // LibSsh2.GlobalLogger = msg => AnsiConsole.MarkupLine($"[grey]{Markup.Escape(msg)}[/]");
-
         // Wait for Docker containers
         AnsiConsole.MarkupLine("[yellow]Waiting for Docker containers to be ready...[/]");
         try
@@ -548,16 +547,41 @@ private static async Task RunEdgeCaseTests()
         await RunTest("Command with large output", TestLargeOutput);
         await RunTest("Multiple sequential operations", TestMultipleOperations);
         await RunTest("Timeout test", TimeoutTest);
+        await RunTest("Won't connect with empty methods", WontConnectWithEmptyMethods);
+    }
+
+    private static Task<bool> WontConnectWithEmptyMethods()
+    {
+        var session = new SshSession();
+        session.SetMethodPreferences(SshMethod.Kex, "diffie-hellman-group1-sha1");
+
+        try
+        {
+            session.Connect(TestConfig.Host, TestConfig.Port);
+        }
+        catch (SshException)
+        {
+            return Task.FromResult(true);
+        }
+
+        return Task.FromResult(false);
     }
 
     private static Task<bool> TimeoutTest()
     {
         var session = TestHelper.CreateConnectAndAuthenticate();
         session.SetSessionTimeout(TimeSpan.FromMilliseconds(1));
+
+        try
+        {
+            _ = session.ExecuteCommand("sleep 10");
+        }
+        catch (SshException e) when (e.Error == SshError.Timeout)
+        {
+            return Task.FromResult(true);
+        }
 
-        var result = session.ExecuteCommand("sleep 10");
-        
-        return Task.FromResult(result is { Successful: false });
+        return Task.FromResult(false);
     }
 
     private static Task<bool> TestEmptyFileTransfer()

NullOpsDevs.LibSsh.Test/TestHelper.cs

@@ -1,4 +1,5 @@
 using System.Security.Cryptography;
+using Microsoft.Extensions.Logging;
 using NullOpsDevs.LibSsh.Credentials;
 
 namespace NullOpsDevs.LibSsh.Test;
@@ -13,7 +14,12 @@ public static class TestHelper
     /// </summary>
     public static SshSession CreateAndConnect()
     {
-        var session = new SshSession();
+        ILogger? logger = null;
+
+        if (Environment.GetEnvironmentVariable("DEBUG_LOGGING") != null)
+            logger = new AnsiConsoleLogger();
+        
+        var session = new SshSession(logger);
         session.Connect(TestConfig.Host, TestConfig.Port);
         return session;
     }

NullOpsDevs.LibSsh/Exceptions/SshException.cs

@@ -21,17 +21,18 @@ public class SshException(string message, SshError error, Exception? innerExcept
     /// Creates an <see cref="SshException"/> from the last error that occurred in the specified libssh2 session.
     /// </summary>
     /// <param name="session">Pointer to the libssh2 session.</param>
+    /// <param name="additionalMessage">Additional message.</param>
     /// <returns>An <see cref="SshException"/> containing the error code and message from the session.</returns>
-    internal static unsafe SshException FromLastSessionError(_LIBSSH2_SESSION* session)
+    internal static unsafe SshException FromLastSessionError(_LIBSSH2_SESSION* session, string? additionalMessage = null)
     {
         sbyte* errorMsg = null;
         var errorMsgLen = 0;
         var errorCode = LibSshNative.libssh2_session_last_error(session, &errorMsg, &errorMsgLen, 0);
 
-        var errorText = errorMsg != null 
-            ? Marshal.PtrToStringAnsi((IntPtr)errorMsg, errorMsgLen) 
-            : "Unknown error";
+        var errorText = errorMsg != null ?
+            Marshal.PtrToStringAnsi((IntPtr)errorMsg, errorMsgLen) : 
+            "Unknown error";
 
-        return new SshException($"[{(SshError)errorCode:G}] {errorText}", (SshError) errorCode);
+        return new SshException($"{(additionalMessage != null ? $"{additionalMessage}: " : "")} [{(SshError)errorCode:G}] {errorText}", (SshError) errorCode);
     }
 }

NullOpsDevs.LibSsh/Extensions/LibSshExtensions.cs

@@ -12,16 +12,27 @@ internal static class LibSshExtensions
     /// Throws an <see cref="SshException"/> if the libssh2 return code indicates failure (negative value).
     /// </summary>
     /// <param name="return">The libssh2 function return code.</param>
+    /// <param name="session">Libssh2 session.</param>
     /// <param name="message">Optional custom error message.</param>
     /// <param name="also">Optional action to execute before throwing the exception (e.g., cleanup).</param>
     /// <exception cref="SshException">Thrown when the return code is negative (indicates error).</exception>
-    public static void ThrowIfNotSuccessful(this int @return, string? message = null, Action? also = null)
+    public static unsafe void ThrowIfNotSuccessful(this int @return, SshSession session,
+        string? message = null, Action? also = null)
     {
         if (@return >= 0)
             return;
 
         also?.Invoke();
-        throw new SshException(message ?? "Unhandled exception", (SshError)@return);
+
+        if (session.SessionPtr != null)
+        {
+            if (message != null)
+                throw SshException.FromLastSessionError(session.SessionPtr, message);
+            
+            throw SshException.FromLastSessionError(session.SessionPtr);
+        }
+
+        throw new SshException(message ?? "Unknown error", (SshError)@return);
     }
 
     /// <summary>

NullOpsDevs.LibSsh/SshSession.cs

@@ -36,6 +36,8 @@ public sealed class SshSession(ILogger? logger = null) : IDisposable
     public SshConnectionStatus ConnectionStatus { get; private set; }
 
     internal unsafe _LIBSSH2_SESSION* SessionPtr { get; private set; }
+    
+    private readonly Dictionary<SshMethod, string> methodPreferences = new();
 
     private void EnsureInitialized()
     {
@@ -49,7 +51,7 @@ private void EnsureInitialized()
             var initResult = libssh2_init(0);
             logger?.LogDebug("libssh2_init returned: {InitResult}", initResult);
 
-            initResult.ThrowIfNotSuccessful("LibSSH2 initialization failed");
+            initResult.ThrowIfNotSuccessful(this, "LibSSH2 initialization failed");
             libraryInitialized = true;
         }
     }
@@ -107,11 +109,29 @@ public unsafe void Connect(string host, int port)
             }
 
             logger?.LogDebug("Connected to server: '{Host}:{Port}'", host, port);
+            
+            logger?.LogDebug("Setting method preferences...");
+
+            foreach (var (method, pref) in methodPreferences)
+            {
+                logger?.LogDebug("Setting method preference for '{Method:G}' to '{Pref}'", method, pref);
+                
+                using var prefBuffer = NativeBuffer.Allocate(pref);
+                
+                var prefResult = libssh2_session_method_pref(newSession, (int) method, prefBuffer.AsPointer<sbyte>());
+                
+                prefResult.ThrowIfNotSuccessful(this, $"Failed to set preference to '{method:G}' to '{pref}'", also: () =>
+                {
+                    _ = libssh2_session_free(newSession);
+                    socket.Dispose();
+                });
+            }
+            
             logger?.LogDebug("Handshaking...");
 
             var result = libssh2_session_handshake(newSession, (ulong)socket.Handle);
 
-            result.ThrowIfNotSuccessful("Failed to handshake with server", also: () =>
+            result.ThrowIfNotSuccessful(this, "Failed to handshake with server", also: () =>
             {
                 _ = libssh2_session_free(newSession);
                 socket.Dispose();
@@ -191,15 +211,15 @@ public unsafe SshHostKey GetHostKey()
     /// This method must be called before connecting to the server. The session must be in <see cref="SshConnectionStatus.Disconnected"/> status.
     /// Use <see cref="SetSecureMethodPreferences"/> to apply a predefined set of secure defaults.
     /// </remarks>
-    public unsafe void SetMethodPreferences(SshMethod method, string preferences)
+    public void SetMethodPreferences(SshMethod method, string preferences)
     {
+        if(string.IsNullOrWhiteSpace(preferences))
+            throw new ArgumentException("Preferences cannot be empty", nameof(preferences));
+        
         EnsureInitialized();
         EnsureInStatus(SshConnectionStatus.Disconnected);
 
-        using var preferencesBuffer = NativeBuffer.Allocate(preferences);
-        
-        var result = libssh2_session_method_pref(SessionPtr, (int) method, preferencesBuffer.AsPointer<sbyte>());
-        result.ThrowIfNotSuccessful("Failed to set preferences");
+        methodPreferences[method] = preferences;
     }
 
     /// <summary>
@@ -368,7 +388,7 @@ public unsafe SshCommandResult ExecuteCommand(string command, CommandExecutionOp
                 options.TerminalHeightPixels
             );
 
-            ptyResult.ThrowIfNotSuccessful("Failed to request PTY", also: () =>
+            ptyResult.ThrowIfNotSuccessful(this, "Failed to request PTY", also: () =>
             {
                 libssh2_channel_close(channel);
                 libssh2_channel_wait_closed(channel);
@@ -389,7 +409,7 @@ public unsafe SshCommandResult ExecuteCommand(string command, CommandExecutionOp
             (uint)commandBytes.Length
         );
 
-        processStartupResult.ThrowIfNotSuccessful("Unable to execute command", also: () =>
+        processStartupResult.ThrowIfNotSuccessful(this, "Unable to execute command", also: () =>
         {
             libssh2_channel_close(channel);
             libssh2_channel_wait_closed(channel);