modelcontextprotocol/csharp-sdk
Watch
1
0
Fork
You've already forked csharp-sdk
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Remove obsolete APIs from codebase and standardize MCP diagnostic IDs (#985)

Browse source 
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: MackinnonBuck <10456961+MackinnonBuck@users.noreply.github.com>
Co-authored-by: eiriktsarpalis <2813363+eiriktsarpalis@users.noreply.github.com>
Co-authored-by: Mackinnon Buck <mackinnon.buck@gmail.com>
Co-authored-by: jeffhandley <1031940+jeffhandley@users.noreply.github.com>
Co-authored-by: Jeff Handley <jeffhandley@users.noreply.github.com>
This commit is contained in:
Copilot 2025-12-02 10:28:46 -08:00 • committed by GitHub
commit 136755f2be
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 663 additions and 2674 deletions
Download patch file Download diff file Expand all files Collapse all files

394
tests/ModelContextProtocol.Tests/Client/McpClientExtensionsTests.cs
View file

@ -1,394 +0,0 @@
using ModelContextProtocol.Client;
using ModelContextProtocol.Protocol;
using Moq;
using System.Text.Json;
namespace ModelContextProtocol.Tests;
#pragma warning disable CS0618 // Type or member is obsolete
public class McpClientExtensionsTests
{
[Fact]
public async Task PingAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.PingAsync(TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.PingAsync' instead", ex.Message);
}
[Fact]
public async Task GetPromptAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.GetPromptAsync(
"name", cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.GetPromptAsync' instead", ex.Message);
}
[Fact]
public async Task CallToolAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.CallToolAsync(
"tool", cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.CallToolAsync' instead", ex.Message);
}
[Fact]
public async Task ListResourcesAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ListResourcesAsync(
cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ListResourcesAsync' instead", ex.Message);
}
[Fact]
public void EnumerateResourcesAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = Assert.Throws<InvalidOperationException>(() => client.EnumerateResourcesAsync(cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.EnumerateResourcesAsync' instead", ex.Message);
}
[Fact]
public async Task SubscribeToResourceAsync_String_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SubscribeToResourceAsync(
"mcp://resource/1", TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.SubscribeToResourceAsync' instead", ex.Message);
}
[Fact]
public async Task SubscribeToResourceAsync_Uri_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SubscribeToResourceAsync(
new Uri("mcp://resource/1"), TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.SubscribeToResourceAsync' instead", ex.Message);
}
[Fact]
public async Task UnsubscribeFromResourceAsync_String_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.UnsubscribeFromResourceAsync(
"mcp://resource/1", TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.UnsubscribeFromResourceAsync' instead", ex.Message);
}
[Fact]
public async Task UnsubscribeFromResourceAsync_Uri_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.UnsubscribeFromResourceAsync(
new Uri("mcp://resource/1"), TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.UnsubscribeFromResourceAsync' instead", ex.Message);
}
[Fact]
public async Task ReadResourceAsync_String_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ReadResourceAsync(
"mcp://resource/1", TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ReadResourceAsync' instead", ex.Message);
}
[Fact]
public async Task ReadResourceAsync_Uri_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ReadResourceAsync(
new Uri("mcp://resource/1"), TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ReadResourceAsync' instead", ex.Message);
}
[Fact]
public async Task ReadResourceAsync_Template_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ReadResourceAsync(
"mcp://resource/{id}", new Dictionary<string, object?> { ["id"] = 1 }, TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ReadResourceAsync' instead", ex.Message);
}
[Fact]
public async Task CompleteAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var reference = new PromptReference { Name = "prompt" };
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.CompleteAsync(
reference, "arg", "val", TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.CompleteAsync' instead", ex.Message);
}
[Fact]
public async Task ListToolsAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ListToolsAsync(
cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ListToolsAsync' instead", ex.Message);
}
[Fact]
public void EnumerateToolsAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = Assert.Throws<InvalidOperationException>(() => client.EnumerateToolsAsync(cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.EnumerateToolsAsync' instead", ex.Message);
}
[Fact]
public async Task ListPromptsAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ListPromptsAsync(
cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ListPromptsAsync' instead", ex.Message);
}
[Fact]
public void EnumeratePromptsAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = Assert.Throws<InvalidOperationException>(() => client.EnumeratePromptsAsync(cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.EnumeratePromptsAsync' instead", ex.Message);
}
[Fact]
public async Task ListResourceTemplatesAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.ListResourceTemplatesAsync(
cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.ListResourceTemplatesAsync' instead", ex.Message);
}
[Fact]
public void EnumerateResourceTemplatesAsync_Throws_When_Not_McpClient()
{
var client = new Mock<IMcpClient>(MockBehavior.Strict).Object;
var ex = Assert.Throws<InvalidOperationException>(() => client.EnumerateResourceTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken));
Assert.Contains("Prefer using 'McpClient.EnumerateResourceTemplatesAsync' instead", ex.Message);
}
[Fact]
public async Task PingAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(new object(), McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
await client.PingAsync(TestContext.Current.CancellationToken);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task GetPromptAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var resultPayload = new GetPromptResult
{
Messages = [new()
{
Role = Role.User,
Content = new TextContentBlock { Text = "hi" }
}]
};
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(resultPayload, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.GetPromptAsync("name", cancellationToken: TestContext.Current.CancellationToken);
Assert.Equal("hi", Assert.IsType<TextContentBlock>(result.Messages[0].Content).Text);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task CallToolAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var callResult = new CallToolResult { Content = [new TextContentBlock { Text = "ok" }] };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(callResult, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.CallToolAsync("tool", cancellationToken: TestContext.Current.CancellationToken);
Assert.Equal("ok", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task SubscribeToResourceAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(new EmptyResult(), McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
await client.SubscribeToResourceAsync("mcp://resource/1", TestContext.Current.CancellationToken);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task UnsubscribeFromResourceAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(new EmptyResult(), McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
await client.UnsubscribeFromResourceAsync("mcp://resource/1", TestContext.Current.CancellationToken);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task CompleteAsync_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var completion = new Completion { Values = ["one", "two"] };
var resultPayload = new CompleteResult { Completion = completion };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(resultPayload, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.CompleteAsync(new PromptReference { Name = "p" }, "arg", "val", TestContext.Current.CancellationToken);
Assert.Contains("one", result.Completion.Values);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task ReadResourceAsync_String_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var resultPayload = new ReadResourceResult { Contents = [] };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(resultPayload, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.ReadResourceAsync("mcp://resource/1", TestContext.Current.CancellationToken);
Assert.NotNull(result);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task ReadResourceAsync_Uri_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var resultPayload = new ReadResourceResult { Contents = [] };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(resultPayload, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.ReadResourceAsync(new Uri("mcp://resource/1"), TestContext.Current.CancellationToken);
Assert.NotNull(result);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task ReadResourceAsync_Template_Forwards_To_McpClient_SendRequestAsync()
{
var mockClient = new Mock<McpClient> { CallBase = true };
var resultPayload = new ReadResourceResult { Contents = [] };
mockClient
.Setup(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new JsonRpcResponse
{
Result = JsonSerializer.SerializeToNode(resultPayload, McpJsonUtilities.DefaultOptions),
});
IMcpClient client = mockClient.Object;
var result = await client.ReadResourceAsync("mcp://resource/{id}", new Dictionary<string, object?> { ["id"] = 1 }, TestContext.Current.CancellationToken);
Assert.NotNull(result);
mockClient.Verify(c => c.SendRequestAsync(It.IsAny<JsonRpcRequest>(), It.IsAny<CancellationToken>()), Times.Once);
}
}