Skip to content

Commit 0748f44

Browse files
halter73Copilot
andcommitted
Use TimeProvider for deterministic client timeout tests
Expose a per-client clock for initialization and discovery deadlines, defaulting to TimeProvider.System and supporting .NET Standard through Microsoft.Bcl.TimeProvider. Keep caller cancellation and transport connection deadlines unchanged. Drive timeout regressions with FakeTimeProvider and phase gates, surface connection failures while waiting for a phase, and observe initialized notifications without assuming server handler ordering. Co-authored-by: Copilot App <[email protected]>
1 parent 8b14805 commit 0748f44

12 files changed

Lines changed: 264 additions & 77 deletions

File tree

‎Directory.Packages.props‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
<!-- Product dependencies .NET Standard -->
2626
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
2727
<PackageVersion Include="Microsoft.Bcl.Memory" Version="$(System10Version)" />
28+
<PackageVersion Include="Microsoft.Bcl.TimeProvider" Version="8.0.1" />
2829
<PackageVersion Include="System.Collections.Immutable" Version="$(System10Version)" />
2930
<PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="$(System10Version)" />
3031
<PackageVersion Include="System.IO.Pipelines" Version="$(System10Version)" />

‎docs/concepts/transports/transports.md‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -145,6 +145,21 @@ var transport = new HttpClientTransport(new HttpClientTransportOptions
145145
});
146146
```
147147

148+
#### Controlling client timeout timers in tests
149+
150+
<xref:ModelContextProtocol.Client.McpClientOptions.TimeProvider> controls
151+
<xref:ModelContextProtocol.Client.McpClientOptions.InitializationTimeout> and
152+
<xref:ModelContextProtocol.Client.McpClientOptions.DiscoverProbeTimeout>. It defaults to
153+
`TimeProvider.System`. Tests can set it to a `FakeTimeProvider` from the
154+
`Microsoft.Extensions.TimeProvider.Testing` package and advance time explicitly instead
155+
of waiting for real deadlines.
156+
157+
Use synchronization signals to wait until the request or authorization phase being tested
158+
has started before advancing the clock. Fake time does not control HTTP processing or
159+
task scheduling, so keep a real-time outer test deadline as a safety bound. The client
160+
time provider does not change `HttpClient.Timeout`, OAuth token expiration, or
161+
<xref:ModelContextProtocol.Client.HttpClientTransportOptions.ConnectionTimeout>.
162+
148163
#### Resuming sessions
149164

150165
Streamable HTTP supports session resumption. Save the session ID, server capabilities, and server info from the original session, then use <xref:ModelContextProtocol.Client.McpClient.ResumeSessionAsync*> to reconnect:

‎src/ModelContextProtocol.Core/Client/McpClientImpl.cs‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -286,8 +286,9 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
286286
_ = _sessionHandler.ProcessMessagesAsync(CancellationToken.None);
287287

288288
// Perform initialization sequence
289-
using var initializationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
290-
initializationCts.CancelAfter(_options.InitializationTimeout);
289+
var timeProvider = _options.TimeProvider;
290+
using var initializationTimeout = new RequestTimeout(_options.InitializationTimeout, timeProvider, cancellationToken);
291+
var initializationToken = initializationTimeout.Token;
291292

292293
try
293294
{
@@ -315,9 +316,9 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
315316
var probeTimeout = _options.DiscoverProbeTimeout;
316317
using var probeTimeoutController = !fallbackToInitialize && probeTimeout != Timeout.InfiniteTimeSpan &&
317318
(_options.InitializationTimeout == Timeout.InfiniteTimeSpan || probeTimeout < _options.InitializationTimeout)
318-
? new RequestTimeout(probeTimeout, initializationCts.Token)
319+
? new RequestTimeout(probeTimeout, timeProvider, initializationToken)
319320
: null;
320-
var probeToken = probeTimeoutController?.Token ?? initializationCts.Token;
321+
var probeToken = probeTimeoutController?.Token ?? initializationToken;
321322

322323
try
323324
{
@@ -399,7 +400,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
399400
// server, so fall back. Other statuses stay uncaught and surface to the caller.
400401
fallbackToInitialize = true;
401402
}
402-
catch (OperationCanceledException) when (probeToken.IsCancellationRequested && !initializationCts.IsCancellationRequested)
403+
catch (OperationCanceledException) when (probeToken.IsCancellationRequested && !initializationToken.IsCancellationRequested)
403404
{
404405
// Probe timeout elapsed without a response. Per stdio.mdx fallback rules, no
405406
// response within a reasonable timeout means the server requires initialize. Fall back.
@@ -441,7 +442,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
441442
: $"Server-supported versions: {string.Join(", ", serverSupportedVersions)}."));
442443
}
443444

444-
await PerformInitializeHandshakeAsync(fallbackVersion, initializationCts.Token).ConfigureAwait(false);
445+
await PerformInitializeHandshakeAsync(fallbackVersion, initializationToken).ConfigureAwait(false);
445446
}
446447
else
447448
{
@@ -483,10 +484,10 @@ async Task<DiscoverResult> SendDiscoverAsync(string protocolVersion, Cancellatio
483484
// ProtocolVersion that still supports Streamable HTTP sessions (opting out of the default), so
484485
// _options.ProtocolVersion is non-null here.
485486
string requestProtocol = _options.ProtocolVersion ?? McpProtocolVersions.November2025ProtocolVersion;
486-
await PerformInitializeHandshakeAsync(requestProtocol, initializationCts.Token).ConfigureAwait(false);
487+
await PerformInitializeHandshakeAsync(requestProtocol, initializationToken).ConfigureAwait(false);
487488
}
488489
}
489-
catch (OperationCanceledException oce) when (initializationCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
490+
catch (OperationCanceledException oce) when (initializationToken.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
490491
{
491492
LogClientInitializationTimeout(_endpointName);
492493
throw new TimeoutException("Initialization timed out", oce);

‎src/ModelContextProtocol.Core/Client/McpClientOptions.cs‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,25 @@ public sealed class McpClientOptions
101101
/// </remarks>
102102
public TimeSpan InitializationTimeout { get; set; } = TimeSpan.FromSeconds(60);
103103

104+
/// <summary>
105+
/// Gets or sets the time provider used for <see cref="InitializationTimeout"/> and <see cref="DiscoverProbeTimeout"/>.
106+
/// </summary>
107+
/// <value>The time provider. The default is <see cref="TimeProvider.System"/>.</value>
108+
/// <remarks>
109+
/// This provider does not control HTTP client timeouts, OAuth token expiration, or transport-specific
110+
/// deadlines such as <see cref="HttpClientTransportOptions.ConnectionTimeout"/>.
111+
/// </remarks>
112+
/// <exception cref="ArgumentNullException">The value is <see langword="null"/>.</exception>
113+
public TimeProvider TimeProvider
114+
{
115+
get;
116+
set
117+
{
118+
Throw.IfNull(value);
119+
field = value;
120+
}
121+
} = TimeProvider.System;
122+
104123
/// <summary>
105124
/// Gets or sets the timeout applied to the <c>server/discover</c> probe that the client issues
106125
/// before falling back to the <c>initialize</c> handshake.

‎src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@
4242
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
4343
<Compile Include="..\Common\CancellableStreamReader\**\*.cs" />
4444
<PackageReference Include="Microsoft.Bcl.Memory" />
45+
<PackageReference Include="Microsoft.Bcl.TimeProvider" />
4546
<PackageReference Include="System.Collections.Immutable" />
4647
<PackageReference Include="System.Diagnostics.DiagnosticSource" />
4748
<PackageReference Include="System.Text.Json" />

‎src/ModelContextProtocol.Core/RequestTimeout.cs‎

Lines changed: 29 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,42 +2,65 @@ namespace ModelContextProtocol;
22

33
/// <summary>A request-local timer that can be suspended without suspending linked cancellation.</summary>
44
/// <remarks>
5-
/// Owned by one awaited discovery request, linked to the enclosing initialization scope.
5+
/// Owned by one awaited initialization or discovery operation, linked to its caller's cancellation.
66
/// Suspension scopes must be sequential and disposed before their owner.
77
/// Cancellation may race with suspension, but an expired timer cannot be restarted.
88
/// </remarks>
99
internal sealed class RequestTimeout : IDisposable
1010
{
1111
private readonly CancellationTokenSource _source;
12+
private readonly ITimer _timer;
1213
private readonly TimeSpan _timeout;
1314

14-
public RequestTimeout(TimeSpan timeout, CancellationToken cancellationToken)
15+
public RequestTimeout(TimeSpan timeout, TimeProvider timeProvider, CancellationToken cancellationToken)
1516
{
1617
_timeout = timeout;
1718
_source = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
1819
Token = _source.Token;
19-
_source.CancelAfter(timeout);
20+
try
21+
{
22+
_timer = timeProvider.CreateTimer(static state =>
23+
{
24+
try
25+
{
26+
((CancellationTokenSource)state!).Cancel();
27+
}
28+
catch (ObjectDisposedException)
29+
{
30+
// A timer callback already queued when Dispose ran can outlive the source.
31+
}
32+
}, _source, timeout, Timeout.InfiniteTimeSpan);
33+
}
34+
catch
35+
{
36+
_source.Dispose();
37+
throw;
38+
}
2039
}
2140

2241
public CancellationToken Token { get; }
2342

24-
public void Stop() => _source.CancelAfter(Timeout.InfiniteTimeSpan);
43+
public void Stop() => _timer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
2544

2645
public Suspension Suspend()
2746
{
2847
Stop();
2948
return new Suspension(this);
3049
}
3150

32-
public void Dispose() => _source.Dispose();
51+
public void Dispose()
52+
{
53+
_timer.Dispose();
54+
_source.Dispose();
55+
}
3356

3457
public readonly struct Suspension(RequestTimeout owner) : IDisposable
3558
{
3659
public void Dispose()
3760
{
3861
if (!owner.Token.IsCancellationRequested)
3962
{
40-
owner._source.CancelAfter(owner._timeout);
63+
owner._timer.Change(owner._timeout, Timeout.InfiniteTimeSpan);
4164
}
4265
}
4366
}

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

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
using Microsoft.AspNetCore.Http;
33
using Microsoft.AspNetCore.Http.Json;
44
using Microsoft.Extensions.DependencyInjection;
5+
using Microsoft.Extensions.Time.Testing;
56
using ModelContextProtocol.AspNetCore.Tests.Utils;
67
using ModelContextProtocol.Client;
78
using ModelContextProtocol.Protocol;
@@ -85,7 +86,8 @@ private async Task StartServerAsync(RequestDelegate handler, bool acceptGet = fa
8586
[InlineData("application/json", 400)]
8687
public async Task SilentDiscoverHeadersOrBody_UseProbeBudget(string? contentType, int statusCode)
8788
{
88-
var probeBudget = TimeSpan.FromMilliseconds(500);
89+
var timeProvider = new FakeTimeProvider();
90+
var probeBudget = TimeSpan.FromSeconds(5);
8991
var stalled = new AsyncGate();
9092
var methods = new List<string>();
9193
await StartServerAsync(async context =>
@@ -123,9 +125,10 @@ await StartServerAsync(async context =>
123125
await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo<JsonRpcMessage>(), context.RequestAborted);
124126
});
125127
await using var transport = new HttpClientTransport(new() { Endpoint = new("http://localhost:5000/mcp") }, HttpClient, LoggerFactory);
126-
var connecting = McpClient.CreateAsync(transport, new() { DiscoverProbeTimeout = probeBudget }, LoggerFactory, TestContext.Current.CancellationToken);
127-
await stalled.Entered.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken);
128-
await using var client = await connecting.WaitAsync(probeBudget * 8, TestContext.Current.CancellationToken);
128+
var connecting = McpClient.CreateAsync(transport, new() { TimeProvider = timeProvider, DiscoverProbeTimeout = probeBudget }, LoggerFactory, TestContext.Current.CancellationToken);
129+
await stalled.WaitUntilEnteredAsync(connecting);
130+
timeProvider.Advance(probeBudget);
131+
await using var client = await connecting.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken);
129132
Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion);
130133
Assert.Equal([RequestMethods.ServerDiscover, RequestMethods.Initialize], methods);
131134
}

‎tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthTests.cs‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
using Microsoft.AspNetCore.Http;
66
using Microsoft.AspNetCore.WebUtilities;
77
using Microsoft.Extensions.DependencyInjection;
8+
using Microsoft.Extensions.Time.Testing;
89
using ModelContextProtocol;
910
using ModelContextProtocol.AspNetCore.Authentication;
1011
using ModelContextProtocol.AspNetCore.Tests.Utils;
@@ -1508,7 +1509,8 @@ public async Task CanAuthenticate_WithResourceMetadataPathFallbacks()
15081509
const string resourcePath = "/mcp";
15091510
List<string> wellKnownRequests = [];
15101511
var metadataGate = new AsyncGate();
1511-
var probeBudget = TimeSpan.FromMilliseconds(500);
1512+
var timeProvider = new FakeTimeProvider();
1513+
var probeBudget = TimeSpan.FromSeconds(5);
15121514

15131515
Builder.Services.Configure<AuthenticationOptions>(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme);
15141516
Builder.Services.Configure<HttpServerTransportOptions>(options => options.Stateless = true);
@@ -1558,8 +1560,10 @@ public async Task CanAuthenticate_WithResourceMetadataPathFallbacks()
15581560
}, HttpClient, LoggerFactory);
15591561

15601562
var connecting = McpClient.CreateAsync(
1561-
transport, new() { DiscoverProbeTimeout = probeBudget }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken);
1562-
await metadataGate.AssertStillWaitingAsync(probeBudget * 2);
1563+
transport, new() { TimeProvider = timeProvider, DiscoverProbeTimeout = probeBudget }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken);
1564+
await metadataGate.WaitUntilEnteredAsync(connecting);
1565+
timeProvider.Advance(probeBudget * 2);
1566+
Assert.False(metadataGate.Token.IsCancellationRequested);
15631567
metadataGate.Release.SetResult();
15641568
await using var client = await connecting.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken);
15651569

0 commit comments

Comments
 (0)