Skip to content

Commit 5546543

Browse files
CopilotCopilot
Copilot
and
Copilot
committed
Replace Mock<McpServer> with real McpServer instances in McpServerResourceTests
Remove Moq dependency and use McpServer.Create() with TestServerTransport to create real server instances instead of mocks. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
1 parent 9b23cd0 commit 5546543

1 file changed

Lines changed: 43 additions & 41 deletions

File tree

‎tests/ModelContextProtocol.Tests/Server/McpServerResourceTests.cs‎

Lines changed: 43 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
using Microsoft.Extensions.DependencyInjection;
33
using ModelContextProtocol.Protocol;
44
using ModelContextProtocol.Server;
5-
using Moq;
5+
using ModelContextProtocol.Tests.Utils;
66
using System.Reflection;
77
using System.Runtime.InteropServices;
88
using System.Text.Json.Serialization;
@@ -21,6 +21,9 @@ private static JsonRpcRequest CreateTestJsonRpcRequest()
2121
};
2222
}
2323

24+
private static McpServer CreateTestServer(IServiceProvider? services = null) =>
25+
McpServer.Create(new TestServerTransport(), new McpServerOptions(), serviceProvider: services);
26+
2427
public McpServerResourceTests()
2528
{
2629
#if !NET
@@ -143,7 +146,7 @@ public async Task UriTemplate_CreatedFromParameters_LotsOfTypesSupported()
143146

144147
McpServerResource t;
145148
ReadResourceResult result;
146-
McpServer server = new Mock<McpServer>().Object;
149+
McpServer server = CreateTestServer();
147150

148151
t = McpServerResource.Create(() => "42", new() { Name = Name });
149152
Assert.Equal("resource://mcp/Hello", t.ProtocolResourceTemplate.UriTemplate);
@@ -288,7 +291,7 @@ public async Task UriTemplate_NonMatchingUri_DoesNotMatch(string uri)
288291
Assert.Equal("resource://mcp/Hello{?arg1}", t.ProtocolResourceTemplate.UriTemplate);
289292
Assert.False(t.IsMatch(uri));
290293
await Assert.ThrowsAsync<InvalidOperationException>(async () => await t.ReadAsync(
291-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = uri } },
294+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = uri } },
292295
TestContext.Current.CancellationToken));
293296
}
294297

@@ -299,7 +302,7 @@ public async Task UriTemplate_IsHostCaseInsensitive(string actualUri, string que
299302
{
300303
McpServerResource t = McpServerResource.Create(() => "resource", new() { UriTemplate = actualUri });
301304
Assert.NotNull(await t.ReadAsync(
302-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = queriedUri } },
305+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = queriedUri } },
303306
TestContext.Current.CancellationToken));
304307
}
305308

@@ -328,7 +331,7 @@ public async Task UriTemplate_MissingParameter_Throws(string uri)
328331
McpServerResource t = McpServerResource.Create((string arg1, int arg2) => arg1, new() { Name = "Hello" });
329332
Assert.Equal("resource://mcp/Hello{?arg1,arg2}", t.ProtocolResourceTemplate.UriTemplate);
330333
await Assert.ThrowsAsync<ArgumentException>(async () => await t.ReadAsync(
331-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = uri } },
334+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = uri } },
332335
TestContext.Current.CancellationToken));
333336
}
334337

@@ -341,25 +344,25 @@ public async Task UriTemplate_MissingOptionalParameter_Succeeds()
341344
ReadResourceResult result;
342345

343346
result = await t.ReadAsync(
344-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello" } },
347+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello" } },
345348
TestContext.Current.CancellationToken);
346349
Assert.NotNull(result);
347350
Assert.Equal("", ((TextResourceContents)result.Contents[0]).Text);
348351

349352
result = await t.ReadAsync(
350-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg1=first" } },
353+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg1=first" } },
351354
TestContext.Current.CancellationToken);
352355
Assert.NotNull(result);
353356
Assert.Equal("first", ((TextResourceContents)result.Contents[0]).Text);
354357

355358
result = await t.ReadAsync(
356-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg2=42" } },
359+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg2=42" } },
357360
TestContext.Current.CancellationToken);
358361
Assert.NotNull(result);
359362
Assert.Equal("42", ((TextResourceContents)result.Contents[0]).Text);
360363

361364
result = await t.ReadAsync(
362-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg1=first&arg2=42" } },
365+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Hello?arg1=first&arg2=42" } },
363366
TestContext.Current.CancellationToken);
364367
Assert.NotNull(result);
365368
Assert.Equal("first42", ((TextResourceContents)result.Contents[0]).Text);
@@ -368,16 +371,16 @@ public async Task UriTemplate_MissingOptionalParameter_Succeeds()
368371
[Fact]
369372
public async Task SupportsMcpServer()
370373
{
371-
Mock<McpServer> mockServer = new();
374+
McpServer testServer = CreateTestServer();
372375

373376
McpServerResource resource = McpServerResource.Create((McpServer server) =>
374377
{
375-
Assert.Same(mockServer.Object, server);
378+
Assert.Same(testServer, server);
376379
return "42";
377380
}, new() { Name = "Test" });
378381

379382
var result = await resource.ReadAsync(
380-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
383+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
381384
TestContext.Current.CancellationToken);
382385
Assert.NotNull(result);
383386
Assert.Equal("42", ((TextResourceContents)result.Contents[0]).Text);
@@ -392,8 +395,7 @@ public async Task SupportsCtorInjection()
392395
sc.AddSingleton(expectedMyService);
393396
IServiceProvider services = sc.BuildServiceProvider();
394397

395-
Mock<McpServer> mockServer = new();
396-
mockServer.SetupGet(s => s.Services).Returns(services);
398+
McpServer testServer = CreateTestServer(services);
397399

398400
MethodInfo? testMethod = typeof(HasCtorWithSpecialParameters).GetMethod(nameof(HasCtorWithSpecialParameters.TestResource));
399401
Assert.NotNull(testMethod);
@@ -404,7 +406,7 @@ public async Task SupportsCtorInjection()
404406
}, new() { Services = services });
405407

406408
var result = await tool.ReadAsync(
407-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "https://something" } },
409+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "https://something" } },
408410
TestContext.Current.CancellationToken);
409411
Assert.NotNull(result);
410412
Assert.NotNull(result.Contents);
@@ -478,14 +480,14 @@ public async Task SupportsServiceFromDI(ServiceLifetime injectedArgumentLifetime
478480

479481
McpServerResource resource = services.GetRequiredService<McpServerResource>();
480482

481-
Mock<McpServer> mockServer = new();
483+
McpServer testServer = CreateTestServer();
482484

483485
await Assert.ThrowsAnyAsync<ArgumentException>(async () => await resource.ReadAsync(
484-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
486+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
485487
TestContext.Current.CancellationToken));
486488

487489
var result = await resource.ReadAsync(
488-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Services = services, Params = new() { Uri = "resource://mcp/Test" } },
490+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Services = services, Params = new() { Uri = "resource://mcp/Test" } },
489491
TestContext.Current.CancellationToken);
490492
Assert.NotNull(result);
491493
Assert.Equal("42", ((TextResourceContents)result.Contents[0]).Text);
@@ -507,7 +509,7 @@ public async Task SupportsOptionalServiceFromDI()
507509
}, new() { Services = services, Name = "Test" });
508510

509511
var result = await resource.ReadAsync(
510-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
512+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
511513
TestContext.Current.CancellationToken);
512514
Assert.NotNull(result);
513515
Assert.Equal("42", ((TextResourceContents)result.Contents[0]).Text);
@@ -523,7 +525,7 @@ public async Task SupportsDisposingInstantiatedDisposableTargets()
523525
_ => new DisposableResourceType());
524526

525527
var result = await resource1.ReadAsync(
526-
new RequestContext<ReadResourceRequestParams>(new Mock<McpServer>().Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "test://static/resource/instanceMethod" } },
528+
new RequestContext<ReadResourceRequestParams>(CreateTestServer(), CreateTestJsonRpcRequest()) { Params = new() { Uri = "test://static/resource/instanceMethod" } },
527529
TestContext.Current.CancellationToken);
528530
Assert.NotNull(result);
529531
Assert.Equal("0", ((TextResourceContents)result.Contents[0]).Text);
@@ -534,14 +536,14 @@ public async Task SupportsDisposingInstantiatedDisposableTargets()
534536
[Fact]
535537
public async Task CanReturnReadResult()
536538
{
537-
Mock<McpServer> mockServer = new();
539+
McpServer testServer = CreateTestServer();
538540
McpServerResource resource = McpServerResource.Create((McpServer server) =>
539541
{
540-
Assert.Same(mockServer.Object, server);
542+
Assert.Same(testServer, server);
541543
return new ReadResourceResult { Contents = [new TextResourceContents { Text = "hello", Uri = "" }] };
542544
}, new() { Name = "Test" });
543545
var result = await resource.ReadAsync(
544-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
546+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
545547
TestContext.Current.CancellationToken);
546548
Assert.NotNull(result);
547549
Assert.Single(result.Contents);
@@ -551,14 +553,14 @@ public async Task CanReturnReadResult()
551553
[Fact]
552554
public async Task CanReturnResourceContents()
553555
{
554-
Mock<McpServer> mockServer = new();
556+
McpServer testServer = CreateTestServer();
555557
McpServerResource resource = McpServerResource.Create((McpServer server) =>
556558
{
557-
Assert.Same(mockServer.Object, server);
559+
Assert.Same(testServer, server);
558560
return new TextResourceContents { Text = "hello", Uri = "" };
559561
}, new() { Name = "Test", SerializerOptions = JsonContext6.Default.Options });
560562
var result = await resource.ReadAsync(
561-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
563+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
562564
TestContext.Current.CancellationToken);
563565
Assert.NotNull(result);
564566
Assert.Single(result.Contents);
@@ -568,18 +570,18 @@ public async Task CanReturnResourceContents()
568570
[Fact]
569571
public async Task CanReturnCollectionOfResourceContents()
570572
{
571-
Mock<McpServer> mockServer = new();
573+
McpServer testServer = CreateTestServer();
572574
McpServerResource resource = McpServerResource.Create((McpServer server) =>
573575
{
574-
Assert.Same(mockServer.Object, server);
576+
Assert.Same(testServer, server);
575577
return (IList<ResourceContents>)
576578
[
577579
new TextResourceContents { Text = "hello", Uri = "" },
578580
BlobResourceContents.FromBytes((byte[])[1, 2, 3], ""),
579581
];
580582
}, new() { Name = "Test" });
581583
var result = await resource.ReadAsync(
582-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
584+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
583585
TestContext.Current.CancellationToken);
584586
Assert.NotNull(result);
585587
Assert.Equal(2, result.Contents.Count);
@@ -590,14 +592,14 @@ public async Task CanReturnCollectionOfResourceContents()
590592
[Fact]
591593
public async Task CanReturnString()
592594
{
593-
Mock<McpServer> mockServer = new();
595+
McpServer testServer = CreateTestServer();
594596
McpServerResource resource = McpServerResource.Create((McpServer server) =>
595597
{
596-
Assert.Same(mockServer.Object, server);
598+
Assert.Same(testServer, server);
597599
return "42";
598600
}, new() { Name = "Test" });
599601
var result = await resource.ReadAsync(
600-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
602+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
601603
TestContext.Current.CancellationToken);
602604
Assert.NotNull(result);
603605
Assert.Single(result.Contents);
@@ -607,14 +609,14 @@ public async Task CanReturnString()
607609
[Fact]
608610
public async Task CanReturnCollectionOfStrings()
609611
{
610-
Mock<McpServer> mockServer = new();
612+
McpServer testServer = CreateTestServer();
611613
McpServerResource resource = McpServerResource.Create((McpServer server) =>
612614
{
613-
Assert.Same(mockServer.Object, server);
615+
Assert.Same(testServer, server);
614616
return new List<string> { "42", "43" };
615617
}, new() { Name = "Test", SerializerOptions = JsonContext6.Default.Options });
616618
var result = await resource.ReadAsync(
617-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
619+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
618620
TestContext.Current.CancellationToken);
619621
Assert.NotNull(result);
620622
Assert.Equal(2, result.Contents.Count);
@@ -625,14 +627,14 @@ public async Task CanReturnCollectionOfStrings()
625627
[Fact]
626628
public async Task CanReturnDataContent()
627629
{
628-
Mock<McpServer> mockServer = new();
630+
McpServer testServer = CreateTestServer();
629631
McpServerResource resource = McpServerResource.Create((McpServer server) =>
630632
{
631-
Assert.Same(mockServer.Object, server);
633+
Assert.Same(testServer, server);
632634
return new DataContent(new byte[] { 0, 1, 2 }, "application/octet-stream");
633635
}, new() { Name = "Test" });
634636
var result = await resource.ReadAsync(
635-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
637+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
636638
TestContext.Current.CancellationToken);
637639
Assert.NotNull(result);
638640
Assert.Single(result.Contents);
@@ -643,18 +645,18 @@ public async Task CanReturnDataContent()
643645
[Fact]
644646
public async Task CanReturnCollectionOfAIContent()
645647
{
646-
Mock<McpServer> mockServer = new();
648+
McpServer testServer = CreateTestServer();
647649
McpServerResource resource = McpServerResource.Create((McpServer server) =>
648650
{
649-
Assert.Same(mockServer.Object, server);
651+
Assert.Same(testServer, server);
650652
return new List<AIContent>
651653
{
652654
new TextContent("hello!"),
653655
new DataContent(new byte[] { 4, 5, 6 }, "application/json"),
654656
};
655657
}, new() { Name = "Test", SerializerOptions = JsonContext6.Default.Options });
656658
var result = await resource.ReadAsync(
657-
new RequestContext<ReadResourceRequestParams>(mockServer.Object, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
659+
new RequestContext<ReadResourceRequestParams>(testServer, CreateTestJsonRpcRequest()) { Params = new() { Uri = "resource://mcp/Test" } },
658660
TestContext.Current.CancellationToken);
659661
Assert.NotNull(result);
660662
Assert.Equal(2, result.Contents.Count);

0 commit comments

Comments
 (0)