csharp-sdk/tests/mcpdotnet.Tests/Transport/StdioServerTransportTests.cs

using System.Text.Json;
using McpDotNet.Protocol.Messages;
using McpDotNet.Protocol.Transport;
using McpDotNet.Protocol.Types;
using McpDotNet.Server;
using McpDotNet.Utils.Json;
using Microsoft.Extensions.Logging.Abstractions;

namespace McpDotNet.Tests.Transport;

public class StdioServerTransportTests
{
    private readonly McpServerOptions _serverOptions;

    public StdioServerTransportTests()
    {
        _serverOptions = new McpServerOptions
        {
            ServerInfo = new Implementation
            {
                Name = "Test Server",
                Version = "1.0"
            },
            ProtocolVersion = "2.0",
            InitializationTimeout = TimeSpan.FromSeconds(10),
            ServerInstructions = "Test Instructions"
        };
    }

    [Fact]
    public async Task Constructor_Should_Initialize_With_Valid_Parameters()
    {
        // Act
        await using var transport = new StdioServerTransport(_serverOptions);

        // Assert
        Assert.NotNull(transport);
    }

    [Fact]
    public void Constructor_Throws_For_Null_Options()
    {
        Assert.Throws<ArgumentNullException>("serverName", () => new StdioServerTransport((string)null!));

        Assert.Throws<ArgumentNullException>("serverOptions", () => new StdioServerTransport((McpServerOptions)null!));
        Assert.Throws<ArgumentNullException>("serverOptions.ServerInfo", () => new StdioServerTransport(new McpServerOptions() { ServerInfo = null! }));
        Assert.Throws<ArgumentNullException>("serverName", () => new StdioServerTransport(new McpServerOptions() { ServerInfo = new() { Name = null!, Version = "" } }));
    }

    [Fact]
    public void Constructor_Throws_For_Null_Streams()
    {
        Assert.Throws<ArgumentNullException>("input", () => new StdioServerTransport(_serverOptions, null!, Console.Out));
        Assert.Throws<ArgumentNullException>("input", () => new StdioServerTransport("name", null!, Console.Out));

        Assert.Throws<ArgumentNullException>("output", () => new StdioServerTransport("name", Console.In, null!));
        Assert.Throws<ArgumentNullException>("output", () => new StdioServerTransport(_serverOptions, Console.In, null!));
    }

    [Fact]
    public async Task StartListeningAsync_Should_Set_Connected_State()
    {
        await using var transport = new StdioServerTransport(_serverOptions);

        await transport.StartListeningAsync();

        Assert.True(transport.IsConnected);
    }

    [Fact]
    public async Task SendMessageAsync_Should_Send_Message()
    {
        var input = new StringReader("");
        var output = new StringWriter();

        await using var transport = new StdioServerTransport(_serverOptions, input, output, NullLoggerFactory.Instance);
        await transport.StartListeningAsync();

        var message = new JsonRpcRequest { Method = "test", Id = RequestId.FromNumber(44) };


        await transport.SendMessageAsync(message);

        var result = output.ToString()?.Trim();
        var expected = JsonSerializer.Serialize(message, JsonSerializerOptionsExtensions.DefaultOptions);

        Assert.Equal(expected, result);
    }

    [Fact]
    public async Task SendMessageAsync_Throws_Exception_If_Not_Connected()
    {
        await using var transport = new StdioServerTransport(_serverOptions);

        var message = new JsonRpcRequest { Method = "test" };

        await Assert.ThrowsAsync<McpTransportException>(() => transport.SendMessageAsync(message));
    }

    [Fact]
    public async Task DisposeAsync_Should_Dispose_Resources()
    {
        await using var transport = new StdioServerTransport(_serverOptions);

        await transport.DisposeAsync();

        Assert.False(transport.IsConnected);
    }

    [Fact]
    public async Task ReadMessagesAsync_Should_Read_Messages()
    {
        var message = new JsonRpcRequest { Method = "test", Id = RequestId.FromNumber(44) };
        var json = JsonSerializer.Serialize(message, JsonSerializerOptionsExtensions.DefaultOptions);

        var input = new StringReader(json);
        var output = new StringWriter();

        await using var transport = new StdioServerTransport(_serverOptions, input, output);
        await transport.StartListeningAsync();

        var canRead = await transport.MessageReader.WaitToReadAsync();

        Assert.True(canRead, "Nothing to read here from transport message reader");
        Assert.True(transport.MessageReader.TryPeek(out var readMessage));
        Assert.NotNull(readMessage);
        Assert.IsType<JsonRpcRequest>(readMessage);
        Assert.Equal(44, ((JsonRpcRequest)readMessage).Id.AsNumber);
    }

    [Fact]
    public async Task CleanupAsync_Should_Cleanup_Resources()
    {
        var transport = new StdioServerTransport(_serverOptions);
        await transport.StartListeningAsync();

        await transport.DisposeAsync();

        Assert.False(transport.IsConnected);
    }
}