CSHARP-5798: Implement test to track if any UnobservedTaskExceptions were raised while test run

Author: sanych-sun

src/MongoDB.Driver/Core/Clusters/Cluster.cs

@@ -445,6 +445,7 @@ private sealed class ServerSelectionWaitQueue : IDisposable
             private readonly InterlockedInt32 _rapidHeartbeatTimerCallbackState;
 
             private int _serverSelectionWaitQueueSize;
+            private bool _disposed;
 
             public ServerSelectionWaitQueue(Cluster cluster)
             {
@@ -455,6 +456,7 @@ public ServerSelectionWaitQueue(Cluster cluster)
 
             public void Dispose()
             {
+                _disposed = true;
                 _rapidHeartbeatTimer.Dispose();
             }
 
@@ -489,6 +491,11 @@ private void ExitServerSelectionWaitQueue()
                 {
                     if (--_serverSelectionWaitQueueSize == 0)
                     {
+                        if (_disposed)
+                        {
+                            return;
+                        }
+
                         _rapidHeartbeatTimer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
                     }
                 }

tests/MongoDB.Driver.Tests/Core/Jira/CSharp3302Tests.cs

@@ -96,10 +96,15 @@ public async Task RapidHeartbeatTimerCallback_should_ignore_reentrant_calls()
                 cluster.Initialize();
 
                 // Trigger Cluster._rapidHeartbeatTimer
-                _ = cluster.SelectServerAsync(OperationContext.NoTimeout, CreateWritableServerAndEndPointSelector(__endPoint1));
+                using var cancellationTokenSource = new CancellationTokenSource();
+                var operationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationTokenSource.Token);
+                cluster.SelectServerAsync(operationContext, CreateWritableServerAndEndPointSelector(__endPoint1))
+                    .IgnoreExceptions();
 
                 // Wait for all heartbeats to complete
                 await Task.WhenAny(allHeartbeatsReceived.Task, Task.Delay(1000));
+
+                cancellationTokenSource.Cancel();
             }
 
             allHeartbeatsReceived.Task.Status.Should().Be(TaskStatus.RanToCompletion);

tests/MongoDB.Driver.Tests/UnobservedTaskExceptionTracking.cs

@@ -0,0 +1,29 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using FluentAssertions;
+using MongoDB.TestHelpers.XunitExtensions.TimeoutEnforcing;
+
+namespace MongoDB.Driver.Tests;
+
+public class UnobservedTaskExceptionTracking
+{
+    [UnobservedExceptionTrackingFact]
+    public void EnsureNoUnobservedTaskException()
+    {
+        UnobservedExceptionTrackingTestCase.__unobservedExceptions.Should().BeEmpty();
+    }
+}
+

tests/MongoDB.TestHelpers/XunitExtensions/TimeoutEnforcing/TimeoutEnforcingXunitTestAssemblyRunner.cs

@@ -15,6 +15,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit.Abstractions;
@@ -25,20 +26,50 @@ namespace MongoDB.TestHelpers.XunitExtensions.TimeoutEnforcing
     [DebuggerStepThrough]
     internal sealed class TimeoutEnforcingXunitTestAssemblyRunner : XunitTestAssemblyRunner
     {
+        private readonly UnobservedExceptionTrackingTestCase _unobservedExceptionTrackingTestCase;
+
         public TimeoutEnforcingXunitTestAssemblyRunner(
             ITestAssembly testAssembly,
             IEnumerable<IXunitTestCase> testCases,
             IMessageSink diagnosticMessageSink,
             IMessageSink executionMessageSink,
             ITestFrameworkExecutionOptions executionOptions)
-                : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions)
-        { }
+            : base(testAssembly, testCases.Where(t => t is not UnobservedExceptionTrackingTestCase), diagnosticMessageSink, executionMessageSink, executionOptions)
+        {
+            _unobservedExceptionTrackingTestCase = (UnobservedExceptionTrackingTestCase)testCases.SingleOrDefault(t => t is UnobservedExceptionTrackingTestCase);
+        }
 
         protected override Task<RunSummary> RunTestCollectionAsync(
             IMessageBus messageBus,
             ITestCollection testCollection,
             IEnumerable<IXunitTestCase> testCases,
-            CancellationTokenSource cancellationTokenSource) =>
-            new TimeoutEnforcingXunitTestCollectionRunner(testCollection, testCases,DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync();
+            CancellationTokenSource cancellationTokenSource)
+        {
+            return new TimeoutEnforcingXunitTestCollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync();
+        }
+
+        protected override async Task<RunSummary> RunTestCollectionsAsync(IMessageBus messageBus, CancellationTokenSource cancellationTokenSource)
+        {
+            var baseSummary = await base.RunTestCollectionsAsync(messageBus, cancellationTokenSource);
+
+            if (_unobservedExceptionTrackingTestCase == null)
+            {
+                return baseSummary;
+            }
+
+            var unobservedExceptionTestCaseRunSummary = await RunTestCollectionAsync(
+                messageBus,
+                _unobservedExceptionTrackingTestCase.TestMethod.TestClass.TestCollection,
+                [_unobservedExceptionTrackingTestCase],
+                cancellationTokenSource);
+
+            return new RunSummary
+            {
+                Total = baseSummary.Total + unobservedExceptionTestCaseRunSummary.Total,
+                Failed = baseSummary.Failed + unobservedExceptionTestCaseRunSummary.Failed,
+                Skipped = baseSummary.Skipped + unobservedExceptionTestCaseRunSummary.Skipped,
+                Time = baseSummary.Time + unobservedExceptionTestCaseRunSummary.Time
+            };
+        }
     }
 }

tests/MongoDB.TestHelpers/XunitExtensions/TimeoutEnforcing/UnobservedExceptionTestDiscoverer.cs

@@ -0,0 +1,32 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using Xunit;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace MongoDB.TestHelpers.XunitExtensions.TimeoutEnforcing;
+
+[XunitTestCaseDiscoverer("MongoDB.TestHelpers.XunitExtensions.TimeoutEnforcing.UnobservedExceptionTestDiscoverer", "MongoDB.TestHelpers")]
+public class UnobservedExceptionTrackingFactAttribute: FactAttribute
+{}
+
+public class UnobservedExceptionTestDiscoverer(IMessageSink DiagnosticsMessageSink) : IXunitTestCaseDiscoverer
+{
+    public IEnumerable<IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) =>
+        [new UnobservedExceptionTrackingTestCase(DiagnosticsMessageSink, testMethod)];
+}
+

tests/MongoDB.TestHelpers/XunitExtensions/TimeoutEnforcing/UnobservedExceptionTrackingTestCase.cs

@@ -0,0 +1,48 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace MongoDB.TestHelpers.XunitExtensions.TimeoutEnforcing;
+
+public sealed class UnobservedExceptionTrackingTestCase : XunitTestCase
+{
+    public static readonly List<string> __unobservedExceptions = new();
+
+#pragma warning disable CS0618 // Type or member is obsolete
+    public UnobservedExceptionTrackingTestCase()
+    {
+    }
+#pragma warning restore CS0618 // Type or member is obsolete
+
+    public UnobservedExceptionTrackingTestCase(IMessageSink diagnosticMessageSink, ITestMethod testMethod)
+        : base(diagnosticMessageSink, TestMethodDisplay.Method, TestMethodDisplayOptions.All, testMethod)
+    {
+        TaskScheduler.UnobservedTaskException += UnobservedTaskExceptionEventHandler;
+    }
+
+    public override void Dispose()
+    {
+        base.Dispose();
+        TaskScheduler.UnobservedTaskException -= UnobservedTaskExceptionEventHandler;
+    }
+
+    void UnobservedTaskExceptionEventHandler(object sender, UnobservedTaskExceptionEventArgs unobservedException) =>
+        __unobservedExceptions.Add(unobservedException.Exception.ToString());
+}
+