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

203 lines
12 KiB
C#

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 McpSessionTests
{
internal sealed record EchoInput(string Text);
internal sealed record EchoOutput(string Text, string Status);
internal static McpToolDefinition<EchoInput, EchoOutput> EchoTool() =>
new("test.echo", "Synthetic test-only echo.", (input, _) =>
Task.FromResult(new McpToolOutcome<EchoOutput>(
new(input.Text, input.Text == "expected failure" ? "failed" : "complete"),
IsError: input.Text == "expected failure")),
input =>
{
if (string.IsNullOrWhiteSpace(input.Text))
{
throw new McpToolInputException("text must be nonempty");
}
});
internal static async Task<McpSession> ReadySessionAsync(McpToolRegistry? registry = null)
{
var session = new McpSession(registry ?? new());
await session.HandleRequestAsync("initialize", ProtocolTestConnection.Json(ProtocolTestConnection.Initialization), default);
session.HandleNotification("notifications/initialized", null);
return session;
}
private static async Task<JsonElement> RequestAsync(McpSession session, string method, string? parameters = null) =>
JsonSerializer.SerializeToElement(await session.HandleRequestAsync(
method, parameters is null ? null : ProtocolTestConnection.Json(parameters), default));
[Theory]
[InlineData("2025-11-25")]
[InlineData("2024-11-05")]
[InlineData("future-unknown")]
public async Task InitializesAndNegotiatesOnlyTheImplementedVersion(string requested)
{
var session = new McpSession(new());
var result = await RequestAsync(session, "initialize",
ProtocolTestConnection.Initialization.Replace("2025-11-25", requested, StringComparison.Ordinal));
Assert.Equal("2025-11-25", result.GetProperty("protocolVersion").GetString());
Assert.Equal("GAJ3T.MusicGen.RiffGrooveBuilder", result.GetProperty("serverInfo").GetProperty("name").GetString());
Assert.False(string.IsNullOrEmpty(result.GetProperty("serverInfo").GetProperty("version").GetString()));
var capability = Assert.Single(result.GetProperty("capabilities").EnumerateObject());
Assert.Equal("tools", capability.Name);
Assert.False(capability.Value.GetProperty("listChanged").GetBoolean());
session.HandleNotification("notifications/initialized", null);
Assert.Empty((await RequestAsync(session, "tools/list")).GetProperty("tools").EnumerateArray());
}
[Theory]
[InlineData(null)]
[InlineData("{}")]
[InlineData("[]")]
[InlineData("""{"protocolVersion":42,"capabilities":{},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":[],"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":"x"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":1,"version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":"x","version":"1","title":false}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{"roots":{"listChanged":"yes"}},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{"sampling":{"tools":false}},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{"elicitation":{"url":null}},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{"tasks":{"requests":{"sampling":{"createMessage":false}}}},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":"x","version":"1","icons":[{"src":"x","sizes":[42]}]}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":"x","version":"1","icons":[{"src":"x","theme":"invalid"}]}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{"experimental":{"extension":false}},"clientInfo":{"name":"x","version":"1"}}""")]
[InlineData("""{"protocolVersion":"x","capabilities":{},"clientInfo":{"name":"x","version":"1"},"_meta":{"progressToken":true}}""")]
public async Task InvalidInitializationDoesNotAdvanceTheSession(string? parameters)
{
var session = new McpSession(new());
var error = await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "initialize", parameters));
Assert.Equal(-32602, error.Code);
Assert.True((await RequestAsync(session, "initialize", ProtocolTestConnection.Initialization)).TryGetProperty("serverInfo", out _));
}
[Fact]
public async Task AcceptsOptionalClientMetadataAndCapabilitiesWithoutAdvertisingTheirFeatures()
{
var session = new McpSession(new());
var result = await RequestAsync(session, "initialize", """
{"protocolVersion":"2025-11-25","capabilities":{"roots":{"listChanged":true},
"sampling":{"tools":{},"context":{}},"elicitation":{"form":{},"url":{}},
"tasks":{"list":{},"cancel":{},"requests":{"sampling":{"createMessage":{}},"elicitation":{"create":{}}}},
"custom.extension":{},"experimental":{"extension":{}}},
"clientInfo":{"name":"client","version":"1","description":"desc","title":"Client",
"websiteUrl":"https://example.test","icons":[{"src":"data:image/png;base64,","sizes":["any"],"theme":"dark"}]},
"_meta":{"custom/key":"value"}}
""");
Assert.Single(result.GetProperty("capabilities").EnumerateObject());
}
[Fact]
public async Task RequiresTheWholeHandshakeRejectsRepeatsAndAllowsPingAtEveryStage()
{
var session = new McpSession(new());
Assert.Equal("{}", (await RequestAsync(session, "ping")).GetRawText());
Assert.Throws<JsonRpcError>(() => session.HandleNotification("notifications/initialized", null));
Assert.Equal(-32002, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "tools/list"))).Code);
await RequestAsync(session, "initialize", ProtocolTestConnection.Initialization);
Assert.Equal("{}", (await RequestAsync(session, "ping", """{"_meta":{}}""")).GetRawText());
Assert.Equal(-32002, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "tools/list"))).Code);
Assert.Equal(-32002, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "initialize", ProtocolTestConnection.Initialization))).Code);
Assert.Throws<JsonRpcError>(() => session.HandleNotification("notifications/initialized", ProtocolTestConnection.Json("""{"bad":true}""")));
session.HandleNotification("notifications/initialized", ProtocolTestConnection.Json("""{"_meta":{}}"""));
Assert.Empty((await RequestAsync(session, "tools/list")).GetProperty("tools").EnumerateArray());
Assert.Equal("{}", (await RequestAsync(session, "ping", "{}")).GetRawText());
Assert.Throws<JsonRpcError>(() => session.HandleNotification("notifications/initialized", null));
Assert.Equal(-32002, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "initialize", ProtocolTestConnection.Initialization))).Code);
}
[Theory]
[InlineData("ping", "null")]
[InlineData("ping", "[]")]
[InlineData("ping", """{"extra":1}""")]
[InlineData("ping", """{"_meta":42}""")]
[InlineData("ping", """{"_meta":{"progressToken":null}}""")]
[InlineData("tools/list", """{"cursor":"not-issued"}""")]
[InlineData("tools/list", """{"cursor":null}""")]
[InlineData("tools/call", null)]
[InlineData("tools/call", "{}")]
[InlineData("tools/call", """{"name":12}""")]
[InlineData("tools/call", """{"name":"unknown"}""")]
[InlineData("tools/call", """{"name":"unknown","arguments":[]}""")]
[InlineData("tools/call", """{"name":"unknown","arguments":{},"task":{"ttl":1000}}""")]
[InlineData("tools/call", """{"name":"a","name":"b"}""")]
public async Task InvalidMethodAndToolSelectionParametersAreProtocolErrors(string method, string? parameters)
{
var session = await ReadySessionAsync();
Assert.Equal(-32602, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, method, parameters))).Code);
}
[Fact]
public async Task RegistryIsEmptyInProductionAndIsFrozenPerSession()
{
var registry = new McpToolRegistry();
Assert.Empty(registry.List());
Assert.Null(registry.Find("generate_project"));
registry.Register(EchoTool());
Assert.Throws<ArgumentException>(() => registry.Register(EchoTool()));
var session = await ReadySessionAsync(registry);
Assert.Throws<InvalidOperationException>(() => registry.Register(EchoTool()));
Assert.Null(registry.Find("TEST.ECHO"));
Assert.Equal(-32601, (await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "shutdown"))).Code);
}
[Theory]
[InlineData("écho\n🎸", false)]
[InlineData("expected failure", true)]
public async Task ToolSchemasComeFromTypedContractsAndContentMatchesStructuredResult(string text, bool isError)
{
var registry = new McpToolRegistry();
registry.Register(EchoTool());
var session = await ReadySessionAsync(registry);
var tool = Assert.Single((await RequestAsync(session, "tools/list")).GetProperty("tools").EnumerateArray());
Assert.Equal("test.echo", tool.GetProperty("name").GetString());
foreach (var schemaName in new[] { "inputSchema", "outputSchema" })
{
var schema = tool.GetProperty(schemaName);
Assert.Equal("object", schema.GetProperty("type").GetString());
Assert.False(schema.GetProperty("additionalProperties").GetBoolean());
Assert.Contains(schema.GetProperty("required").EnumerateArray(), field => field.GetString() == "text");
Assert.Equal("string", schema.GetProperty("properties").GetProperty("text").GetProperty("type").GetString());
}
var result = await RequestAsync(session, "tools/call", JsonSerializer.Serialize(new
{
name = "test.echo", arguments = new { text }
}));
Assert.Equal(isError, result.GetProperty("isError").GetBoolean());
var structured = result.GetProperty("structuredContent");
Assert.Equal(text, structured.GetProperty("text").GetString());
Assert.Equal(isError ? "failed" : "complete", structured.GetProperty("status").GetString());
var content = Assert.Single(result.GetProperty("content").EnumerateArray());
Assert.Equal("text", content.GetProperty("type").GetString());
Assert.Equal(structured.GetRawText(), content.GetProperty("text").GetString());
var schemaProperties = tool.GetProperty("outputSchema").GetProperty("properties");
Assert.Equal(schemaProperties.EnumerateObject().Select(p => p.Name).Order(),
structured.EnumerateObject().Select(p => p.Name).Order());
}
[Theory]
[InlineData("{}")]
[InlineData("""{"text":null}""")]
[InlineData("""{"text":123}""")]
[InlineData("""{"text":"valid","extra":true}""")]
[InlineData("""{"text":" "}""")]
[InlineData("""{"text":"one","text":"two"}""")]
public async Task TypedAndSemanticValidationFailBeforeTheHandler(string arguments)
{
var registry = new McpToolRegistry();
registry.Register(EchoTool());
var session = await ReadySessionAsync(registry);
var error = await Assert.ThrowsAsync<JsonRpcError>(() => RequestAsync(session, "tools/call",
$$"""{"name":"test.echo","arguments":{{arguments}}}"""));
Assert.Equal(-32602, error.Code);
}
}