203 lines
12 KiB
C#
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);
|
|
}
|
|
}
|