Cubase-MCP-GAJ3T.MusicGen.R.../tests/GAJ3T.MusicGen.RiffGrooveBu.../Protocol/JsonRpcDispatcherTests.cs

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"));
}
}