Add serialization roundtrip tests for all Protocol namespace types (#1289)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

tests/ModelContextProtocol.Tests/Protocol/AnnotationsTests.cs

@@ -0,0 +1,43 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class AnnotationsTests
+{
+    [Fact]
+    public static void Annotations_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new Annotations
+        {
+            Audience = [Role.User, Role.Assistant],
+            Priority = 0.75f,
+            LastModified = new DateTimeOffset(2025, 6, 15, 10, 30, 0, TimeSpan.Zero)
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Annotations>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Audience);
+        Assert.Equal(2, deserialized.Audience.Count);
+        Assert.Equal(Role.User, deserialized.Audience[0]);
+        Assert.Equal(Role.Assistant, deserialized.Audience[1]);
+        Assert.Equal(original.Priority, deserialized.Priority);
+        Assert.Equal(original.LastModified, deserialized.LastModified);
+    }
+
+    [Fact]
+    public static void Annotations_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new Annotations();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Annotations>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Audience);
+        Assert.Null(deserialized.Priority);
+        Assert.Null(deserialized.LastModified);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ArgumentTests.cs

@@ -0,0 +1,24 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ArgumentTests
+{
+    [Fact]
+    public static void Argument_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new Argument
+        {
+            Name = "temperature",
+            Value = "72"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Argument>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.Equal(original.Value, deserialized.Value);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs

@@ -0,0 +1,56 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CallToolRequestParamsTests
+{
+    [Fact]
+    public static void CallToolRequestParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CallToolRequestParams
+        {
+            Name = "get_weather",
+            Arguments = new Dictionary<string, JsonElement>
+            {
+                ["city"] = JsonDocument.Parse("\"Seattle\"").RootElement.Clone(),
+                ["units"] = JsonDocument.Parse("\"metric\"").RootElement.Clone()
+            },
+            Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromHours(1) },
+            Meta = new JsonObject { ["progressToken"] = "token-123" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.NotNull(deserialized.Arguments);
+        Assert.Equal(2, deserialized.Arguments.Count);
+        Assert.Equal("Seattle", deserialized.Arguments["city"].GetString());
+        Assert.Equal("metric", deserialized.Arguments["units"].GetString());
+        Assert.NotNull(deserialized.Task);
+        Assert.Equal(original.Task.TimeToLive, deserialized.Task.TimeToLive);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("token-123", (string)deserialized.Meta["progressToken"]!);
+    }
+
+    [Fact]
+    public static void CallToolRequestParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CallToolRequestParams
+        {
+            Name = "simple_tool"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.Null(deserialized.Arguments);
+        Assert.Null(deserialized.Task);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs

@@ -0,0 +1,58 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CallToolResultTests
+{
+    [Fact]
+    public static void CallToolResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CallToolResult
+        {
+            Content = [new TextContentBlock { Text = "Result text" }],
+            StructuredContent = JsonNode.Parse("""{"temperature":72}"""),
+            IsError = false,
+            Task = new McpTask
+            {
+                TaskId = "task-1",
+                Status = McpTaskStatus.Completed,
+                CreatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero),
+                LastUpdatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero)
+            },
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Single(deserialized.Content);
+        var textBlock = Assert.IsType<TextContentBlock>(deserialized.Content[0]);
+        Assert.Equal("Result text", textBlock.Text);
+        Assert.NotNull(deserialized.StructuredContent);
+        Assert.Equal(72, deserialized.StructuredContent["temperature"]!.GetValue<int>());
+        Assert.False(deserialized.IsError);
+        Assert.NotNull(deserialized.Task);
+        Assert.Equal("task-1", deserialized.Task.TaskId);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void CallToolResult_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CallToolResult();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Empty(deserialized.Content);
+        Assert.Null(deserialized.StructuredContent);
+        Assert.Null(deserialized.IsError);
+        Assert.Null(deserialized.Task);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskRequestParamsTests.cs

@@ -0,0 +1,25 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelMcpTaskRequestParamsTests
+{
+    [Fact]
+    public static void CancelMcpTaskRequestParams_SerializationRoundTrip()
+    {
+        // Arrange
+        var original = new CancelMcpTaskRequestParams
+        {
+            TaskId = "cancel-task-456"
+        };
+
+        // Act
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelMcpTaskRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        // Assert
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.TaskId, deserialized.TaskId);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskResultTests.cs

@@ -0,0 +1,33 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelMcpTaskResultTests
+{
+    [Fact]
+    public static void CancelMcpTaskResult_SerializationRoundTrip()
+    {
+        // Arrange
+        var original = new CancelMcpTaskResult
+        {
+            TaskId = "cancelled-789",
+            Status = McpTaskStatus.Cancelled,
+            StatusMessage = "Cancelled by user",
+            CreatedAt = DateTimeOffset.UtcNow,
+            LastUpdatedAt = DateTimeOffset.UtcNow,
+            TimeToLive = null,
+            PollInterval = null
+        };
+
+        // Act
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelMcpTaskResult>(json, McpJsonUtilities.DefaultOptions);
+
+        // Assert
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.TaskId, deserialized.TaskId);
+        Assert.Equal(original.Status, deserialized.Status);
+        Assert.Equal(original.StatusMessage, deserialized.StatusMessage);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelledNotificationParamsTests.cs

@@ -0,0 +1,45 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelledNotificationParamsTests
+{
+    [Fact]
+    public static void CancelledNotificationParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CancelledNotificationParams
+        {
+            RequestId = new RequestId(42),
+            Reason = "User cancelled the operation",
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelledNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.RequestId, deserialized.RequestId);
+        Assert.Equal(original.Reason, deserialized.Reason);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void CancelledNotificationParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CancelledNotificationParams
+        {
+            RequestId = new RequestId("req-123")
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelledNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.RequestId, deserialized.RequestId);
+        Assert.Null(deserialized.Reason);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs

@@ -0,0 +1,57 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ClientCapabilitiesTests
+{
+    [Fact]
+    public static void ClientCapabilities_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ClientCapabilities
+        {
+            Roots = new RootsCapability { ListChanged = true },
+            Sampling = new SamplingCapability
+            {
+                Context = new SamplingContextCapability(),
+                Tools = new SamplingToolsCapability()
+            },
+            Elicitation = new ElicitationCapability
+            {
+                Form = new FormElicitationCapability(),
+                Url = new UrlElicitationCapability()
+            },
+            Tasks = new McpTasksCapability()
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ClientCapabilities>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Roots);
+        Assert.True(deserialized.Roots.ListChanged);
+        Assert.NotNull(deserialized.Sampling);
+        Assert.NotNull(deserialized.Sampling.Context);
+        Assert.NotNull(deserialized.Sampling.Tools);
+        Assert.NotNull(deserialized.Elicitation);
+        Assert.NotNull(deserialized.Elicitation.Form);
+        Assert.NotNull(deserialized.Elicitation.Url);
+        Assert.NotNull(deserialized.Tasks);
+    }
+
+    [Fact]
+    public static void ClientCapabilities_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new ClientCapabilities();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ClientCapabilities>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Experimental);
+        Assert.Null(deserialized.Roots);
+        Assert.Null(deserialized.Sampling);
+        Assert.Null(deserialized.Elicitation);
+        Assert.Null(deserialized.Tasks);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CompleteContextTests.cs

@@ -0,0 +1,41 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CompleteContextTests
+{
+    [Fact]
+    public static void CompleteContext_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CompleteContext
+        {
+            Arguments = new Dictionary<string, string>
+            {
+                ["language"] = "en",
+                ["region"] = "us"
+            }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteContext>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Arguments);
+        Assert.Equal(2, deserialized.Arguments.Count);
+        Assert.Equal("en", deserialized.Arguments["language"]);
+        Assert.Equal("us", deserialized.Arguments["region"]);
+    }
+
+    [Fact]
+    public static void CompleteContext_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CompleteContext();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteContext>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Arguments);
+    }
+}