Use ExclusiveExecution collection fixture to ensure DiagnosticTests don't run concurrently with any other tests

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

tests/ModelContextProtocol.Tests/DiagnosticTests.cs

@@ -9,7 +9,7 @@
 
 namespace ModelContextProtocol.Tests;
 
-[Collection(nameof(DisableParallelization))]
+[Collection(nameof(ExclusiveExecution))]
 public class DiagnosticTests
 {
     [Fact]

tests/ModelContextProtocol.Tests/TestAttributes.cs

@@ -1,9 +1,32 @@
-// Uncomment to disable parallel test execution for the whole assembly
-//[assembly: CollectionBehavior(DisableTestParallelization = true)]
+/// <summary>
+/// Test collection for tests that require exclusive execution (no parallel execution with any other tests).
+/// This is needed for tests that interact with global static state like ActivitySource in OpenTelemetry.
+/// </summary>
+/// <remarks>
+/// The fixture ensures mutual exclusion across ALL tests by using a static semaphore.
+/// Tests in this collection will acquire the semaphore before running and release it after,
+/// preventing any other test from running concurrently.
+/// </remarks>
+[CollectionDefinition(nameof(ExclusiveExecution))]
+public sealed class ExclusiveExecution : ICollectionFixture<ExclusiveExecutionFixture>;
 
 /// <summary>
-/// Enables test classes to individually be attributed as [Collection(nameof(DisableParallelization))]
-/// to have those tests run non-concurrently with any other tests.
+/// Fixture that ensures only one test runs at a time across the entire test assembly.
 /// </summary>
-[CollectionDefinition(nameof(DisableParallelization), DisableParallelization = true)]
-public sealed class DisableParallelization;
+public sealed class ExclusiveExecutionFixture : IAsyncLifetime
+{
+    private static readonly SemaphoreSlim s_exclusiveLock = new(1, 1);
+
+    public async ValueTask InitializeAsync()
+    {
+        // Acquire the lock before any test in this collection starts
+        await s_exclusiveLock.WaitAsync();
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        // Release the lock after the test completes
+        s_exclusiveLock.Release();
+        return default;
+    }
+}