Skip to content

Commit 2bd715b

Browse files
tarekghTarek Mahmoud Sayed
andauthored
Prevent discovery probe timeouts in controlled test connections (#1946)
Co-authored-by: Tarek Mahmoud Sayed <[email protected]>
1 parent 9a32782 commit 2bd715b

26 files changed

Lines changed: 268 additions & 136 deletions

‎CONTRIBUTING.md‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -97,6 +97,12 @@ The test projects include shared infrastructure in `tests/Common/Utils/` that mo
9797

9898
Use `TestConstants.DefaultTimeout` (60 seconds) rather than hardcoded values. CI machines are often slower than developer workstations, and short timeouts cause flaky failures.
9999

100+
For direct client connections to controlled test servers that respond to discovery, use `TestMcpClient.CreateAsync`.
101+
It disables the separate discovery probe timeout while retaining the overall `TestConstants.DefaultTimeout` initialization deadline.
102+
If configuring client options, start with `TestMcpClient.CreateOptions()` before applying test-specific settings; explicitly supplied options are otherwise preserved unchanged.
103+
Do not use these defaults in discovery-timeout tests or with servers that silently ignore discovery, since those rely on the probe timeout for fallback.
104+
For a mock that only implements the legacy initialize handshake, explicitly select its supported protocol version instead of waiting for discovery to time out.
105+
100106
```csharp
101107
// Good
102108
using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
using Microsoft.Extensions.Logging;
2+
using ModelContextProtocol.Client;
3+
4+
namespace ModelContextProtocol.Tests.Utils;
5+
6+
/// <summary>
7+
/// Creates clients for controlled test servers that respond to discovery, including with a fallback error.
8+
/// Do not use these defaults with servers that silently ignore discovery or in discovery-timeout tests.
9+
/// </summary>
10+
internal static class TestMcpClient
11+
{
12+
public static McpClientOptions CreateOptions() => new()
13+
{
14+
DiscoverProbeTimeout = Timeout.InfiniteTimeSpan,
15+
InitializationTimeout = TestConstants.DefaultTimeout,
16+
};
17+
18+
public static Task<McpClient> CreateAsync(
19+
IClientTransport clientTransport,
20+
McpClientOptions? clientOptions = null,
21+
ILoggerFactory? loggerFactory = null,
22+
CancellationToken cancellationToken = default) =>
23+
McpClient.CreateAsync(clientTransport, clientOptions ?? CreateOptions(), loggerFactory, cancellationToken);
24+
}

‎tests/ModelContextProtocol.AotCompatibility.TestApp/ModelContextProtocol.AotCompatibility.TestApp.csproj‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,9 @@
1212
</PropertyGroup>
1313

1414
<ItemGroup>
15+
<Compile Include="..\Common\Utils\TestConstants.cs" Link="TestConstants.cs" />
16+
<Compile Include="..\Common\Utils\TestMcpClient.cs" Link="TestMcpClient.cs" />
17+
1518
<ProjectReference Include="..\..\src\ModelContextProtocol.Core\ModelContextProtocol.Core.csproj" />
1619
<ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
1720
<ProjectReference Include="..\..\src\ModelContextProtocol.AspNetCore\ModelContextProtocol.AspNetCore.csproj" />

‎tests/ModelContextProtocol.AotCompatibility.TestApp/Program.cs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
using ModelContextProtocol.Extensions.Apps;
44
using ModelContextProtocol.Protocol;
55
using ModelContextProtocol.Server;
6+
using ModelContextProtocol.Tests.Utils;
67
using System.IO.Pipelines;
78

89
Pipe clientToServerPipe = new(), serverToClientPipe = new();
@@ -18,7 +19,7 @@
1819
_ = server.RunAsync();
1920

2021
// Connect a client using a stream-based transport over the same in-memory pipe.
21-
await using McpClient client = await McpClient.CreateAsync(
22+
await using McpClient client = await TestMcpClient.CreateAsync(
2223
new StreamClientTransport(clientToServerPipe.Writer.AsStream(), serverToClientPipe.Reader.AsStream()));
2324

2425
// List all tools.

‎tests/ModelContextProtocol.AspNetCore.Tests/AuthorizeAttributeTests.cs‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,12 +25,8 @@ private async Task<McpClient> ConnectAsync()
2525
Endpoint = new("http://localhost:5000"),
2626
}, HttpClient, LoggerFactory);
2727

28-
// This server supports discovery; slow startup must not trigger legacy fallback.
29-
return await McpClient.CreateAsync(transport, new()
30-
{
31-
DiscoverProbeTimeout = Timeout.InfiniteTimeSpan,
32-
InitializationTimeout = TestConstants.DefaultTimeout,
33-
}, cancellationToken: TestContext.Current.CancellationToken, loggerFactory: LoggerFactory);
28+
return await TestMcpClient.CreateAsync(transport,
29+
cancellationToken: TestContext.Current.CancellationToken, loggerFactory: LoggerFactory);
3430
}
3531

3632
[Fact]

‎tests/ModelContextProtocol.AspNetCore.Tests/HttpTaskIntegrationTests.cs‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
using ModelContextProtocol.Extensions.Tasks;
77
using ModelContextProtocol.Protocol;
88
using ModelContextProtocol.Server;
9+
using ModelContextProtocol.Tests.Utils;
910
using Moq;
1011
using System.Security.Claims;
1112

@@ -30,7 +31,7 @@ public async Task WithTasks_CanCallToolOverHttp()
3031
new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") },
3132
HttpClient,
3233
LoggerFactory);
33-
await using var client = await McpClient.CreateAsync(
34+
await using var client = await TestMcpClient.CreateAsync(
3435
transport,
3536
loggerFactory: LoggerFactory,
3637
cancellationToken: TestContext.Current.CancellationToken);
@@ -67,7 +68,7 @@ public async Task WithTasks_AfterOrdinaryFilter_RunsFilter()
6768
new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") },
6869
HttpClient,
6970
LoggerFactory);
70-
await using var client = await McpClient.CreateAsync(
71+
await using var client = await TestMcpClient.CreateAsync(
7172
transport,
7273
loggerFactory: LoggerFactory,
7374
cancellationToken: TestContext.Current.CancellationToken);
@@ -120,7 +121,7 @@ [new Claim(ClaimTypes.NameIdentifier, "test-user")],
120121
new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") },
121122
HttpClient,
122123
LoggerFactory);
123-
await using var client = await McpClient.CreateAsync(
124+
await using var client = await TestMcpClient.CreateAsync(
124125
transport,
125126
loggerFactory: LoggerFactory,
126127
cancellationToken: TestContext.Current.CancellationToken);
@@ -166,7 +167,7 @@ public async Task WithTasks_UnauthorizedTool_DoesNotCreateTask(bool registerTask
166167
new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") },
167168
HttpClient,
168169
LoggerFactory);
169-
await using var client = await McpClient.CreateAsync(
170+
await using var client = await TestMcpClient.CreateAsync(
170171
transport,
171172
loggerFactory: LoggerFactory,
172173
cancellationToken: TestContext.Current.CancellationToken);
@@ -217,7 +218,7 @@ public async Task WithTasks_ReauthorizesToolChangedByOrdinaryFilter()
217218
new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") },
218219
HttpClient,
219220
LoggerFactory);
220-
await using var client = await McpClient.CreateAsync(
221+
await using var client = await TestMcpClient.CreateAsync(
221222
transport,
222223
loggerFactory: LoggerFactory,
223224
cancellationToken: TestContext.Current.CancellationToken);

‎tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpFallbackTests.cs‎

Lines changed: 15 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -221,7 +221,7 @@ await StartServerAsync(async context =>
221221
}, HttpClient, LoggerFactory);
222222

223223
// Default options prefer 2026-07-28 but allow automatic fallback to an initialize-handshake server.
224-
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
224+
await using var client = await TestMcpClient.CreateAsync(transport,
225225
loggerFactory: LoggerFactory, cancellationToken: ct);
226226

227227
Assert.Equal(McpProtocolVersions.June2025ProtocolVersion, client.NegotiatedProtocolVersion);
@@ -308,7 +308,7 @@ await StartServerAsync(async context =>
308308
}, HttpClient, LoggerFactory);
309309

310310
// Default options prefer 2026-07-28 but allow automatic fallback to an initialize-handshake server.
311-
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
311+
await using var client = await TestMcpClient.CreateAsync(transport,
312312
loggerFactory: LoggerFactory, cancellationToken: ct);
313313

314314
Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion);
@@ -354,10 +354,10 @@ await WriteJsonRpcErrorAsync(context, HttpStatusCode.BadRequest,
354354

355355
var exception = await Assert.ThrowsAsync<McpProtocolException>(async () =>
356356
{
357-
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
358-
{
359-
ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion,
360-
}, loggerFactory: LoggerFactory, cancellationToken: ct);
357+
var clientOptions = TestMcpClient.CreateOptions();
358+
clientOptions.ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion;
359+
await using var client = await McpClient.CreateAsync(transport, clientOptions,
360+
loggerFactory: LoggerFactory, cancellationToken: ct);
361361
});
362362

363363
Assert.Equal(McpErrorCode.HeaderMismatch, exception.ErrorCode);
@@ -408,9 +408,8 @@ await WriteJsonRpcErrorAsync(
408408

409409
var exception = await Assert.ThrowsAsync<HttpRequestException>(async () =>
410410
{
411-
await using var client = await McpClient.CreateAsync(
411+
await using var client = await TestMcpClient.CreateAsync(
412412
transport,
413-
new McpClientOptions(),
414413
loggerFactory: LoggerFactory,
415414
cancellationToken: ct);
416415
});
@@ -481,10 +480,10 @@ await StartServerAsync(async context =>
481480
Endpoint = new("http://localhost:5000/mcp"),
482481
}, HttpClient, LoggerFactory);
483482

484-
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
485-
{
486-
ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion,
487-
}, loggerFactory: LoggerFactory, cancellationToken: ct);
483+
var clientOptions = TestMcpClient.CreateOptions();
484+
clientOptions.ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion;
485+
await using var client = await McpClient.CreateAsync(transport, clientOptions,
486+
loggerFactory: LoggerFactory, cancellationToken: ct);
488487

489488
await client.ListToolsAsync(cancellationToken: ct);
490489

@@ -541,10 +540,10 @@ await StartServerAsync(async context =>
541540
OwnsSession = false,
542541
}, HttpClient, LoggerFactory);
543542

544-
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
545-
{
546-
ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion,
547-
}, loggerFactory: LoggerFactory, cancellationToken: ct);
543+
var clientOptions = TestMcpClient.CreateOptions();
544+
clientOptions.ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion;
545+
await using var client = await McpClient.CreateAsync(transport, clientOptions,
546+
loggerFactory: LoggerFactory, cancellationToken: ct);
548547

549548
Assert.Equal("", discoverSessionId);
550549
}

‎tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHybridSessionModeTests.cs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
using ModelContextProtocol.Client;
55
using ModelContextProtocol.Protocol;
66
using ModelContextProtocol.Server;
7+
using ModelContextProtocol.Tests.Utils;
78
using System.Net;
89
using System.Net.Http.Headers;
910
using System.Text;
@@ -109,7 +110,8 @@ private Task<McpClient> ConnectClientAsync(string? protocolVersion = null, Actio
109110

110111
// A null ProtocolVersion prefers 2026-07-28 and probes with server/discover before considering a
111112
// fallback to the initialize handshake. Pinning an older version forces the initialize handshake.
112-
var clientOptions = new McpClientOptions { ProtocolVersion = protocolVersion };
113+
var clientOptions = TestMcpClient.CreateOptions();
114+
clientOptions.ProtocolVersion = protocolVersion;
113115
configureClient?.Invoke(clientOptions);
114116
return McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken);
115117
}

‎tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolStatefulFallbackTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ private async Task<McpClient> ConnectDefaultClientAsync(Action<McpClientOptions>
8383

8484
// Default options: ProtocolVersion is null, which now prefers the 2026-07-28 protocol revision and probes
8585
// with server/discover before falling back to an initialize handshake.
86-
var clientOptions = new McpClientOptions();
86+
var clientOptions = TestMcpClient.CreateOptions();
8787
configureClient?.Invoke(clientOptions);
8888
return await McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken);
8989
}

‎tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs‎

Lines changed: 78 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
using Microsoft.AspNetCore.Builder;
22
using Microsoft.AspNetCore.Http;
33
using Microsoft.Extensions.DependencyInjection;
4+
using Microsoft.Extensions.Time.Testing;
45
using ModelContextProtocol.AspNetCore.Tests.Utils;
56
using ModelContextProtocol.Client;
67
using ModelContextProtocol.Protocol;
@@ -37,11 +38,87 @@ protected async Task<McpClient> ConnectAsync(
3738
TransportMode = UseStreamableHttp ? HttpTransportMode.StreamableHttp : HttpTransportMode.Sse,
3839
}, HttpClient, LoggerFactory);
3940

40-
var clientOptions = new McpClientOptions();
41+
var clientOptions = TestMcpClient.CreateOptions();
4142
configureClient?.Invoke(clientOptions);
4243
return await McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken);
4344
}
4445

46+
[Fact]
47+
public async Task ConnectAsync_SlowDiscovery_PreservesModernProtocol()
48+
{
49+
Assert.SkipWhen(UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason);
50+
51+
var discovery = new AsyncGate();
52+
var timeProvider = new FakeTimeProvider();
53+
await using var app = await StartServerWithGatedDiscoveryAsync(discovery);
54+
55+
var connecting = ConnectAsync(configureClient: options =>
56+
{
57+
options.ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion;
58+
options.TimeProvider = timeProvider;
59+
});
60+
await discovery.WaitUntilEnteredAsync(connecting);
61+
timeProvider.Advance(new McpClientOptions().DiscoverProbeTimeout * 2);
62+
discovery.Release.SetResult();
63+
64+
await using var client = await connecting.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken);
65+
Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion);
66+
}
67+
68+
[Theory]
69+
[InlineData(false)]
70+
[InlineData(true)]
71+
public async Task ConnectAsync_Discovery_RespectsConfiguredDeadline(bool customProbeTimeout)
72+
{
73+
Assert.SkipWhen(UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason);
74+
75+
var discovery = new AsyncGate();
76+
var timeProvider = new FakeTimeProvider();
77+
var probeTimeout = new McpClientOptions().DiscoverProbeTimeout;
78+
await using var app = await StartServerWithGatedDiscoveryAsync(discovery);
79+
80+
var connecting = ConnectAsync(configureClient: options =>
81+
{
82+
options.ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion;
83+
options.TimeProvider = timeProvider;
84+
if (customProbeTimeout)
85+
{
86+
options.DiscoverProbeTimeout = probeTimeout;
87+
}
88+
});
89+
await discovery.WaitUntilEnteredAsync(connecting);
90+
timeProvider.Advance(customProbeTimeout ? probeTimeout : TestConstants.DefaultTimeout);
91+
92+
if (customProbeTimeout)
93+
{
94+
await Assert.ThrowsAsync<McpException>(() => connecting.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken));
95+
}
96+
else
97+
{
98+
var exception = await Assert.ThrowsAsync<TimeoutException>(() => connecting.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken));
99+
Assert.Equal("Initialization timed out", exception.Message);
100+
}
101+
}
102+
103+
private async Task<WebApplication> StartServerWithGatedDiscoveryAsync(AsyncGate discovery)
104+
{
105+
Builder.Services.AddMcpServer()
106+
.WithHttpTransport(ConfigureStateless)
107+
.WithMessageFilters(filters => filters.AddIncomingFilter(next => async (context, cancellationToken) =>
108+
{
109+
if (context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.ServerDiscover })
110+
{
111+
await discovery.WaitAsync(cancellationToken);
112+
}
113+
await next(context, cancellationToken);
114+
}));
115+
116+
var app = Builder.Build();
117+
app.MapMcp();
118+
await app.StartAsync(TestContext.Current.CancellationToken);
119+
return app;
120+
}
121+
45122
[Fact]
46123
public async Task MapMcp_ThrowsInvalidOperationException_IfWithHttpTransportIsNotCalled()
47124
{

0 commit comments

Comments
 (0)