377 lines
17 KiB
C#
377 lines
17 KiB
C#
using System.Text;
|
|
using System.Text.Json;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Server.Protocol;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Server.Tools;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Protocol;
|
|
|
|
public sealed class JsonRpcDispatcherTests
|
|
{
|
|
[Theory]
|
|
[InlineData("0")]
|
|
[InlineData("-9223372036854775808")]
|
|
[InlineData("9223372036854775807")]
|
|
[InlineData("\"1\"")]
|
|
[InlineData("\"\"")]
|
|
[InlineData("\"音楽\\n🎸\"")]
|
|
public async Task PreservesStringAndSignedIntegerIds(string id)
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
await connection.SendAsync($$"""{"jsonrpc":"2.0","id":{{id}},"method":"ping"}""");
|
|
var response = await connection.ReadAsync();
|
|
var expectedId = ProtocolTestConnection.Json(id);
|
|
var actualId = response.GetProperty("id");
|
|
Assert.Equal(expectedId.ValueKind, actualId.ValueKind);
|
|
if (expectedId.ValueKind == JsonValueKind.String)
|
|
{
|
|
Assert.Equal(expectedId.GetString(), actualId.GetString());
|
|
}
|
|
else
|
|
{
|
|
Assert.Equal(expectedId.GetInt64(), actualId.GetInt64());
|
|
}
|
|
Assert.Equal("{}", response.GetProperty("result").GetRawText());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("{")]
|
|
[InlineData("not-json")]
|
|
[InlineData("")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":1,"method":"ping",}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":1,"method":"ping" /* comment */}""")]
|
|
public async Task MalformedJsonReturnsParseErrorAndRecovers(string invalid)
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
await connection.SendAsync(invalid);
|
|
var error = await connection.ReadAsync();
|
|
Assert.Equal(-32700, ErrorCode(error));
|
|
Assert.Equal(JsonValueKind.Null, error.GetProperty("id").ValueKind);
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":2,"method":"ping"}""");
|
|
Assert.Equal(2, (await connection.ReadAsync()).GetProperty("id").GetInt32());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("[]")]
|
|
[InlineData("""[{"jsonrpc":"2.0","id":1,"method":"ping"}]""")]
|
|
[InlineData("{}")]
|
|
[InlineData("null")]
|
|
[InlineData("123")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":null,"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":true,"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":{},"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":1.5,"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":1.0,"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":9223372036854775808,"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":[],"method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":1,"id":2,"method":"ping"}""")]
|
|
public async Task InvalidEnvelopeOrUnsupportedIdReturnsNullId(string invalid)
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
await connection.SendAsync(invalid);
|
|
var response = await connection.ReadAsync();
|
|
Assert.Equal(-32600, ErrorCode(response));
|
|
Assert.Equal(JsonValueKind.Null, response.GetProperty("id").ValueKind);
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("""{"id":"valid","method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"1.0","id":"valid","method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":2,"id":"valid","method":"ping"}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":"valid","method":42}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":"valid","method":"ping","result":{}}""")]
|
|
[InlineData("""{"jsonrpc":"2.0","id":"valid","method":"ping","method":"initialize"}""")]
|
|
public async Task IdentifiableValidIdIsPreservedOnInvalidEnvelope(string invalid)
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
await connection.SendAsync(invalid);
|
|
var response = await connection.ReadAsync();
|
|
Assert.Equal(-32600, ErrorCode(response));
|
|
Assert.Equal("valid", response.GetProperty("id").GetString());
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("unknown", null, -32601)]
|
|
[InlineData("shutdown", null, -32601)]
|
|
[InlineData("notifications/initialized", null, -32601)]
|
|
[InlineData("ping", "[]", -32602)]
|
|
[InlineData("ping", "true", -32602)]
|
|
[InlineData("ping", "null", -32602)]
|
|
[InlineData("tools/list", null, -32002)]
|
|
public async Task DispatchesExplicitRequestErrors(string method, string? parameters, int code)
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
var suffix = parameters is null ? "" : ",\"params\":" + parameters;
|
|
await connection.SendAsync($$"""{"jsonrpc":"2.0","id":1,"method":"{{method}}"{{suffix}}}""");
|
|
Assert.Equal(code, ErrorCode(await connection.ReadAsync()));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NotificationsAreSilentAndInitializeWithoutIdDoesNotChangeLifecycle()
|
|
{
|
|
await using var connection = new ProtocolTestConnection();
|
|
foreach (var message in new[]
|
|
{
|
|
"""{"jsonrpc":"2.0","method":"ping"}""",
|
|
"""{"jsonrpc":"2.0","method":"unknown","params":{}}""",
|
|
"""{"jsonrpc":"2.0","method":"notifications/initialized"}""",
|
|
"""{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":[]}}""",
|
|
"""{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":"missing"}}""",
|
|
$$"""{"jsonrpc":"2.0","method":"initialize","params":{{ProtocolTestConnection.Initialization}}}"""
|
|
})
|
|
{
|
|
await connection.SendAsync(message);
|
|
}
|
|
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":12,"method":"tools/list"}""");
|
|
var response = await connection.ReadAsync();
|
|
Assert.Equal(12, response.GetProperty("id").GetInt32());
|
|
Assert.Equal(-32002, ErrorCode(response));
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
Assert.Contains("Ignored", connection.Diagnostics.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task HandlerFailureReturnsInternalErrorOnlyAndTheConnectionSurvives()
|
|
{
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new McpToolDefinition<McpSessionTests.EchoInput, McpSessionTests.EchoOutput>(
|
|
"test.failure", "Synthetic failing tool.", (_, _) =>
|
|
throw new InvalidOperationException("test-only diagnostic detail")));
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
await connection.SendAsync("""
|
|
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"test.failure","arguments":{"text":"go"}}}
|
|
""");
|
|
var response = await connection.ReadAsync();
|
|
Assert.Equal(-32603, ErrorCode(response));
|
|
Assert.DoesNotContain("test-only diagnostic detail", response.GetRawText());
|
|
Assert.Contains("test-only diagnostic detail", connection.Diagnostics.ToString());
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":2,"method":"ping"}""");
|
|
Assert.Equal(2, (await connection.ReadAsync()).GetProperty("id").GetInt32());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CancellationTargetsTypedIdDuplicateDoesNotReplaceWorkAndOtherRequestSurvives()
|
|
{
|
|
var stringStarted = Signal();
|
|
var numericStarted = Signal();
|
|
var stringCancelled = Signal();
|
|
var numericRelease = Signal();
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new McpToolDefinition<McpSessionTests.EchoInput, McpSessionTests.EchoOutput>(
|
|
"test.wait", "Synthetic cancellable tool.", async (input, token) =>
|
|
{
|
|
if (input.Text == "string")
|
|
{
|
|
stringStarted.SetResult();
|
|
try
|
|
{
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, token);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
stringCancelled.SetResult();
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
numericStarted.SetResult();
|
|
await numericRelease.Task.WaitAsync(token);
|
|
}
|
|
|
|
return new(new(input.Text, "complete"));
|
|
}));
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
await connection.SendAsync("""
|
|
{"jsonrpc":"2.0","id":"7","method":"tools/call","params":{"name":"test.wait","arguments":{"text":"string"}}}
|
|
""");
|
|
await connection.SendAsync("""
|
|
{"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"name":"test.wait","arguments":{"text":"integer"}}}
|
|
""");
|
|
await Task.WhenAll(stringStarted.Task, numericStarted.Task).WaitAsync(TimeSpan.FromSeconds(5));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":"7","method":"ping"}""");
|
|
Assert.Equal(-32600, ErrorCode(await connection.ReadAsync()));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":7,"reason":false}}""");
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":"7","reason":"unit test"}}""");
|
|
await stringCancelled.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":"still-alive","method":"ping"}""");
|
|
Assert.Equal("still-alive", (await connection.ReadAsync()).GetProperty("id").GetString());
|
|
numericRelease.SetResult();
|
|
var survivor = await connection.ReadAsync();
|
|
Assert.Equal(7, survivor.GetProperty("id").GetInt32());
|
|
Assert.Equal("integer", survivor.GetProperty("result").GetProperty("structuredContent").GetProperty("text").GetString());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public async Task EofOrLifetimeCancellationStopsOutstandingWorkWithoutAResponse(bool eof)
|
|
{
|
|
var started = Signal();
|
|
var cancelled = Signal();
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new McpToolDefinition<McpSessionTests.EchoInput, McpSessionTests.EchoOutput>(
|
|
"test.wait", "Synthetic EOF cancellation.", async (_, token) =>
|
|
{
|
|
started.SetResult();
|
|
try
|
|
{
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, token);
|
|
}
|
|
finally
|
|
{
|
|
cancelled.SetResult();
|
|
}
|
|
|
|
throw new InvalidOperationException("Unreachable");
|
|
}));
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
await connection.SendAsync("""
|
|
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"test.wait","arguments":{"text":"go"}}}
|
|
""");
|
|
await started.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
if (!eof)
|
|
{
|
|
await connection.CancelAsync();
|
|
}
|
|
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
Assert.True(cancelled.Task.IsCompletedSuccessfully);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ActiveRequestBoundRejectsNewWorkButStillReadsCancellation()
|
|
{
|
|
var started = 0;
|
|
var allStarted = Signal();
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new McpToolDefinition<McpSessionTests.EchoInput, McpSessionTests.EchoOutput>(
|
|
"test.wait", "Synthetic admission bound.", async (_, token) =>
|
|
{
|
|
if (Interlocked.Increment(ref started) == JsonRpcDispatcher.MaxActiveRequests)
|
|
{
|
|
allStarted.SetResult();
|
|
}
|
|
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, token);
|
|
throw new InvalidOperationException("Unreachable");
|
|
}));
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
for (var id = 0; id < JsonRpcDispatcher.MaxActiveRequests; id++)
|
|
{
|
|
await connection.SendAsync($$$$"""
|
|
{"jsonrpc":"2.0","id":{{{{id}}}},"method":"tools/call","params":{"name":"test.wait","arguments":{"text":"go"}}}
|
|
""");
|
|
}
|
|
|
|
await allStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":"overflow","method":"ping"}""");
|
|
Assert.Equal(-32000, ErrorCode(await connection.ReadAsync()));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":0}}""");
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
Assert.Equal(JsonRpcDispatcher.MaxActiveRequests, started);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task OverlappingHandlersProduceSeparateValidResponses()
|
|
{
|
|
const int count = 25;
|
|
var release = Signal();
|
|
var allStarted = Signal();
|
|
var started = 0;
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new McpToolDefinition<McpSessionTests.EchoInput, McpSessionTests.EchoOutput>(
|
|
"test.overlap", "Synthetic overlapping handler.", async (input, token) =>
|
|
{
|
|
if (Interlocked.Increment(ref started) == count)
|
|
{
|
|
allStarted.SetResult();
|
|
}
|
|
|
|
await release.Task.WaitAsync(token);
|
|
return new(new(input.Text, "complete"));
|
|
}));
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
for (var id = 0; id < count; id++)
|
|
{
|
|
await connection.SendAsync($$$$"""
|
|
{"jsonrpc":"2.0","id":{{{{id}}}},"method":"tools/call","params":{"name":"test.overlap","arguments":{"text":"音楽\nline"}}}
|
|
""");
|
|
}
|
|
|
|
await allStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
release.SetResult();
|
|
var ids = new List<int>();
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var response = await connection.ReadAsync();
|
|
ids.Add(response.GetProperty("id").GetInt32());
|
|
Assert.Equal("音楽\nline", response.GetProperty("result").GetProperty("structuredContent").GetProperty("text").GetString());
|
|
}
|
|
|
|
Assert.Equal(Enumerable.Range(0, count), ids.Order());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
public async Task ActualIoFailureIsNotHiddenAsSuccessfulShutdown(bool writing)
|
|
{
|
|
using var failing = new FailingStream();
|
|
using var input = new MemoryStream(Encoding.UTF8.GetBytes("""{"jsonrpc":"2.0","id":1,"method":"ping"}""" + "\n"));
|
|
using var transport = new StdioTransport(writing ? input : failing, writing ? failing : Stream.Null);
|
|
var dispatcher = new JsonRpcDispatcher(transport, new McpSession(new()), TextWriter.Null);
|
|
await Assert.ThrowsAsync<IOException>(() => dispatcher.RunAsync().WaitAsync(TimeSpan.FromSeconds(5)));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ResponseSerializationFailureIsAnInternalRequestErrorNotATransportFailure()
|
|
{
|
|
var registry = new McpToolRegistry();
|
|
registry.Register(new UnserializableTool());
|
|
await using var connection = new ProtocolTestConnection(registry);
|
|
await connection.ReadyAsync();
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"test.bad-result"}}""");
|
|
Assert.Equal(-32603, ErrorCode(await connection.ReadAsync()));
|
|
await connection.SendAsync("""{"jsonrpc":"2.0","id":2,"method":"ping"}""");
|
|
Assert.Equal(2, (await connection.ReadAsync()).GetProperty("id").GetInt32());
|
|
Assert.Contains("Request handler failed:", connection.Diagnostics.ToString());
|
|
await connection.AssertNoMoreResponsesAsync();
|
|
}
|
|
|
|
private static int ErrorCode(JsonElement response)
|
|
{
|
|
Assert.False(response.TryGetProperty("result", out _));
|
|
return response.GetProperty("error").GetProperty("code").GetInt32();
|
|
}
|
|
|
|
private static TaskCompletionSource Signal() => new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
private sealed class UnserializableTool : McpToolDefinition
|
|
{
|
|
public override object Descriptor => new { name = Name };
|
|
public override string Name => "test.bad-result";
|
|
public override Task<object> InvokeAsync(JsonElement arguments, CancellationToken cancellationToken) =>
|
|
Task.FromResult<object>(new { unsupported = typeof(string) });
|
|
}
|
|
|
|
private sealed class FailingStream : MemoryStream
|
|
{
|
|
public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) =>
|
|
ValueTask.FromException<int>(new IOException("Synthetic read failure"));
|
|
public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) =>
|
|
ValueTask.FromException(new IOException("Synthetic write failure"));
|
|
}
|
|
}
|