Akka.TestKit: ensure that EventFilter respects WithinAsync timeout blocks

src/core/Akka.Cluster.Tests/Serialization/BugFix3724Spec.cs

@@ -6,6 +6,7 @@
 //-----------------------------------------------------------------------
 
 using System;
+using System.Threading.Tasks;
 using Akka.Actor;
 using Akka.TestKit;
 using Akka.Util.Internal;
@@ -23,8 +24,10 @@ namespace Akka.Cluster.Tests.Serialization
     public class BugFix3724Spec : AkkaSpec
     {
         public BugFix3724Spec(ITestOutputHelper helper)
-            : base(@"akka.actor.provider = cluster
-                     akka.actor.serialize-messages = on", helper)
+            : base("""
+                   akka.actor.provider = cluster
+                    akka.actor.serialize-messages = on
+                   """, helper)
         {
             _cluster = Cluster.Get(Sys);
             _selfAddress = Sys.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
@@ -34,17 +37,18 @@ public BugFix3724Spec(ITestOutputHelper helper)
         private readonly Cluster _cluster;
 
         [Fact(DisplayName = "Should be able to use 'akka.actor.serialize-messages' while running Akka.Cluster")]
-        public void Should_serialize_all_AkkaCluster_messages()
+        public async Task Should_serialize_all_AkkaCluster_messages()
         {
             _cluster.Subscribe(TestActor, ClusterEvent.SubscriptionInitialStateMode.InitialStateAsEvents,
                 typeof(ClusterEvent.MemberUp));
-            Within(TimeSpan.FromSeconds(10), () =>
+            await WithinAsync(TimeSpan.FromSeconds(10), async () =>
             {
-                EventFilter.Exception<Exception>().Expect(0, () =>
+                // Expect 0 means we have to wait for the full duration
+                await EventFilter.Exception<Exception>().ExpectAsync(0, async () =>
                 {
                     // wait for a singleton cluster to fully form and publish a member up event
-                    _cluster.Join(_selfAddress);
-                    var up = ExpectMsg<ClusterEvent.MemberUp>();
+                    await _cluster.JoinAsync(_selfAddress);
+                    var up = await ExpectMsgAsync<ClusterEvent.MemberUp>();
                     up.Member.Address.Should().Be(_selfAddress);
                 });
             });

src/core/Akka.Cluster/Cluster.cs

@@ -78,7 +78,7 @@ bool GetAssertInvariants()
         }
 
         /// <summary>
-        /// TBD
+        /// Debug setting for internal purposes.
         /// </summary>
         internal static bool IsAssertInvariantsEnabled
         {

src/core/Akka.Streams.Tests/Dsl/HubSpec.cs

@@ -266,13 +266,14 @@ await this.AssertAllStagesStoppedAsync(async () =>
 
                 await WithinAsync(10.Seconds(), async () =>
                 {
-                    await EventFilter.Error(contains: "Upstream producer failed with exception").ExpectOneAsync(async () =>
-                    {
-                        Source.Failed<int>(new TestException("failing")).RunWith(sink, Materializer);
-                        Source.From(Enumerable.Range(1, 10)).RunWith(sink, Materializer);
-                        var result = await task.ShouldCompleteWithin(3.Seconds());
-                        result.Should().BeEquivalentTo(Enumerable.Range(1, 10));
-                    });
+                    await EventFilter.Error(contains: "Upstream producer failed with exception")
+                        .ExpectOneAsync(async () =>
+                        {
+                            Source.Failed<int>(new TestException("failing")).RunWith(sink, Materializer);
+                            Source.From(Enumerable.Range(1, 10)).RunWith(sink, Materializer);
+                            var result = await task.ShouldCompleteWithin(3.Seconds());
+                            result.Should().BeEquivalentTo(Enumerable.Range(1, 10));
+                        });
                 });
             }, Materializer);
         }

src/core/Akka.TestKit.Tests/TestKitBaseTests/WithinTests.cs

@@ -21,7 +21,7 @@ public class WithinTests : AkkaSpec
         [Fact]
         public void Within_should_increase_max_timeout_by_the_provided_epsilon_value()
         {
-            Within(TimeSpan.FromSeconds(1), () => ExpectNoMsg(), TimeSpan.FromMilliseconds(50));
+            Within(TimeSpan.FromSeconds(1), () => ExpectNoMsg(), TimeSpan.FromMilliseconds(500));
         }
 
         [Fact]
@@ -63,5 +63,67 @@ await WithinAsync(
                     0.1.Seconds());
             }).Should().ThrowAsync<XunitException>();
         }
+
+        [Fact]
+        public async Task WithinAsync_timeout_should_propagate_to_EventFilter()
+        {
+            // This test passes if:
+            // 1. The test fails quickly due to the short WithinAsync timeout (expected)
+            // 2. The timeoutOccurred flag remains false - meaning our short timeout was respected
+            //
+            // This test will fail if:
+            // 1. The EventFilter ignores the WithinAsync timeout and uses its own longer default timeout
+            // 2. The timeoutOccurred flag will be set to true in that case
+
+            var testEvent = "test-event-" + Guid.NewGuid().ToString("N");
+            var filter = EventFilter.Info(contains: testEvent);
+
+            // Use a very short timeout for WithinAsync - something that would definitely
+            // fail if the EventFilter is using its own longer default timeout
+            var shortTimeout = 200.Milliseconds();
+
+            // Create a custom timeout tracker for precise measurement
+            var timeoutOccurred = false;
+            var timerCts = new System.Threading.CancellationTokenSource();
+            var timerTask = Task.Run(async () => {
+                try 
+                {
+                    // Wait slightly longer than the short timeout
+                    await Task.Delay(shortTimeout.Add(300.Milliseconds()), timerCts.Token);
+                    // If we get here, the test is taking too long
+                    timeoutOccurred = true;
+                }
+                catch (System.Threading.Tasks.TaskCanceledException)
+                {
+                    // This is expected if the test completes in time
+                }
+            });
+
+            try
+            {
+                // This should fail quickly with the short timeout
+                // The timeout error is wrapped in an AggregateException when using our fix
+                await Assert.ThrowsAsync<AggregateException>(async () =>
+                {
+                    await WithinAsync(shortTimeout, async () =>
+                    {
+                        // This won't receive any messages and should inherit the short timeout
+                        await filter.ExpectOneAsync(() => Task.CompletedTask);
+                    });
+                });
+
+                // Cancel the timeout tracker since we've already completed
+                timerCts.Cancel();
+                await Task.WhenAny(timerTask);
+
+                // Verify the test completed before our manual timeout
+                Assert.False(timeoutOccurred, 
+                    "The test took longer than expected. EventFilter likely did not inherit WithinAsync timeout.");
+            }
+            finally
+            {
+                timerCts.Cancel();
+            }
+        }
     }
 }