Add Should().NotThrowAfter assertion for actions

Src/FluentAssertions/Specialized/ActionAssertions.cs

@@ -4,7 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-
+using System.Threading;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
@@ -114,6 +114,60 @@ public void NotThrow(string because = "", params object[] becauseArgs)
             }
         }
 
+#if NET45 || NET47 || NETSTANDARD2_0 || NETCOREAPP2_0
+        /// <summary>
+        /// Asserts that the current <see cref="Action"/> stops throwing any exception
+        /// after a specified amount of time.
+        /// </summary>
+        /// <remarks>
+        /// The <see cref="Action"/> is invoked. If it raises an exception,
+        /// the invocation is repeated until it either stops raising any exceptions
+        /// or the specified wait time is exceeded.
+        /// </remarks>
+        /// <param name="waitTime">
+        /// The time after which the <see cref="Action"/> should have stopped throwing any exception.
+        /// </param>
+        /// <param name="pollInterval">
+        /// The time between subsequent invocations of the <see cref="Action"/>.
+        /// </param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <see cref="because" />.
+        /// </param>
+        /// <exception cref="ArgumentOutOfRangeException">Throws if waitTime or pollInterval are negative.</exception>
+        public void NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval, string because = "", params object[] becauseArgs)
+        {
+            FailIfSubjectIsAsyncVoid();
+
+            if(waitTime < TimeSpan.Zero)
+                throw new ArgumentOutOfRangeException(nameof(waitTime), $"The value of {nameof(waitTime)} must be non-negative.");
+
+            if(pollInterval < TimeSpan.Zero)
+                throw new ArgumentOutOfRangeException(nameof(pollInterval), $"The value of {nameof(pollInterval)} must be non-negative.");
+
+
+            TimeSpan? invocationEndTime = null;
+            Exception exception = null;
+            var watch = Stopwatch.StartNew();
+
+            while (invocationEndTime is null || invocationEndTime < waitTime)
+            {
+                exception = InvokeSubjectWithInterception();
+                if (exception is null)
+                    return;
+
+                Thread.Sleep(pollInterval);
+                invocationEndTime = watch.Elapsed;
+            }
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
+	}
+#endif
+
         private Exception InvokeSubjectWithInterception()
         {
             Exception actualException = null;

Tests/Shared.Specs/ExceptionAssertionSpecs.cs

@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using Xunit;
 using Xunit.Sdk;
 
+using static FluentAssertions.Extensions.FluentTimeSpanExtensions;
+
 namespace FluentAssertions.Specs
 {
     public class ExceptionAssertionSpecs
@@ -863,6 +866,136 @@ public void When_no_exception_should_be_thrown_and_none_was_it_should_not_throw(
             //-----------------------------------------------------------------------------------------------------------
             foo.Invoking(f => f.Do()).Should().NotThrow();
         }
+
+#if NET45 || NET47 || NETSTANDARD2_0 || NETCOREAPP2_0
+        #pragma warning disable CS1998
+        [Fact]
+        public void NotThrowAfter_when_subject_is_async_it_should_throw()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            Action someAsyncAction = async () => { };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action action = () =>
+                someAsyncAction.Should().NotThrowAfter(1.Milliseconds(), 1.Milliseconds());
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            action.Should().Throw<InvalidOperationException>()
+                .WithMessage("Cannot use action assertions on an async void method.*");
+        }
+        #pragma warning restore CS1998
+
+        [Fact]
+        public void NotThrowAfter_when_waitTime_is_negative_it_should_throw()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var waitTime = -1.Milliseconds();
+            var pollInterval = 10.Milliseconds();
+            Action someAction = () => { };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action action = () =>
+                someAction.Should().NotThrowAfter(waitTime, pollInterval);
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            action.Should().Throw<ArgumentOutOfRangeException>()
+                .WithMessage("* value of waitTime must be non-negative*");
+        }
+
+        [Fact]
+        public void NotThrowAfter_when_pollInterval_is_negative_it_should_throw()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var waitTime = 10.Milliseconds();
+            var pollInterval = -1.Milliseconds();
+            Action someAction = () => { };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action action = () =>
+                someAction.Should().NotThrowAfter(waitTime, pollInterval);
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            action.Should().Throw<ArgumentOutOfRangeException>()
+                .WithMessage("* value of pollInterval must be non-negative*");
+        }
+
+        [Fact]
+        public void NotThrowAfter_when_no_exception_should_be_thrown_after_wait_time_but_it_was_it_should_throw()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var watch = Stopwatch.StartNew();
+            var waitTime = 100.Milliseconds();
+            var pollInterval = 10.Milliseconds();
+
+            Action throwLongerThanWaitTime = () =>
+                {
+                    if (watch.Elapsed <= waitTime + (waitTime.Milliseconds / 2).Milliseconds())
+                        throw new ArgumentException("An exception was forced");
+                };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action action = () =>
+                throwLongerThanWaitTime.Should().NotThrowAfter(waitTime, pollInterval, "we passed valid arguments");
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            action.Should().Throw<XunitException>()
+                         .WithMessage("Did not expect any exceptions after 0.100s because we passed valid arguments*");
+        }
+
+        [Fact]
+        public void NotThrowAfter_when_no_exception_should_be_thrown_after_wait_time_and_none_was_it_should_not_throw()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var watch = Stopwatch.StartNew();
+            var waitTime = 100.Milliseconds();
+            var pollInterval = 10.Milliseconds();
+
+            Action throwShorterThanWaitTime = () =>
+                {
+                    if (watch.Elapsed <= (waitTime.Milliseconds / 2).Milliseconds())
+                        throw new ArgumentException("An exception was forced");
+                };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+
+            Action act = () => throwShorterThanWaitTime.Should().NotThrowAfter(waitTime, pollInterval);
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+
+            act.Should().NotThrow();
+        }
+#endif // NotThrowAfter tests
+
     }
 
     #endregion