create overloads with default timeout

Author: rose-a

Src/FluentAssertions.Reactive/ReactiveAssertions.cs

@@ -108,18 +108,18 @@ public async Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<T
         }
 
         /// <summary>
-        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
+        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 seconds.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
         /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
         /// <param name="because"></param>
         /// <param name="becauseArgs"></param>
         public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
+            => Push(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <inheritdoc cref="Push(int,string,object[])"/>
         public Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
+            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <summary>
         /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
@@ -266,7 +266,11 @@ public AndConstraint<ReactiveAssertions<TPayload>> NotComplete(string because =
         /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
         /// </param>
         /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <c>null</c>.</exception>
-        public AndConstraint<ReactiveAssertions<TPayload>> PushMatch([NotNull] Expression<Func<TPayload, bool>> predicate, TimeSpan timeout, string because = "", params object[] becauseArgs)
+        public AndConstraint<ReactiveAssertions<TPayload>> PushMatch(
+            [NotNull] Expression<Func<TPayload, bool>> predicate,
+            TimeSpan timeout,
+            string because = "",
+            params object[] becauseArgs)
         {
             if (predicate == null) throw new ArgumentNullException(nameof(predicate));
 
@@ -303,9 +307,33 @@ public AndConstraint<ReactiveAssertions<TPayload>> PushMatch([NotNull] Expressio
             return new AndConstraint<ReactiveAssertions<TPayload>>(this);
         }
 
-        /// <inheritdoc cref="PushMatch"/>
-        public async Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync([NotNull] Expression<Func<TPayload, bool>> predicate, TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
+        /// <summary>
+        /// Asserts that at least one notification matching <paramref name="predicate"/> was pushed to the <see cref="FluentTestObserver{TPayload}"/>
+        /// within the next 1 second.<br />
+        /// This includes any previously recorded notifications since it has been created or cleared.
+        /// </summary>
+        /// <param name="predicate">A predicate to match the items in the collection against.</param>
+        /// <param name="timeout">the maximum time to wait for the notification to arrive</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 <paramref name="because"/>.
+        /// </param>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <c>null</c>.</exception>
+        public AndConstraint<ReactiveAssertions<TPayload>> PushMatch(
+            [NotNull] Expression<Func<TPayload, bool>> predicate,
+            string because = "",
+            params object[] becauseArgs)
+            => PushMatch(predicate, TimeSpan.FromSeconds(1), because, becauseArgs);
+
+        /// <inheritdoc cref="PushMatch(Expression{Func{TPayload, bool}},TimeSpan,string,object[])"/>
+        public async Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync(
+            [NotNull] Expression<Func<TPayload, bool>> predicate,
+            TimeSpan timeout,
+            string because = "",
+            params object[] becauseArgs)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
@@ -342,6 +370,13 @@ public async Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync([N
             return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
 
+        /// <inheritdoc cref="PushMatch(Expression{Func{TPayload, bool}},string,object[])"/>
+        public Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync(
+            [NotNull] Expression<Func<TPayload, bool>> predicate,
+            string because = "",
+            params object[] becauseArgs)
+            => PushMatchAsync(predicate, TimeSpan.FromSeconds(1), because, becauseArgs);
+
         protected Task<IList<Recorded<Notification<TPayload>>>> GetRecordedNotifications(TimeSpan timeout) =>
             Observer.RecordedNotificationStream
                 .TakeUntil(recorded => recorded.Value.Kind == NotificationKind.OnError)

Tests/FluentAssertions.Reactive.Specs/ReactiveAssertionSpecs.cs

@@ -126,8 +126,7 @@ public void When_the_observable_is_expected_to_fail_but_does_not_it_should_throw
 
             observer.Error.Should().BeNull();
         }
-
-
+        
         [Fact]
         public void When_the_observable_completes_as_expected_it_should_not_throw()
         {
@@ -159,5 +158,27 @@ public void When_the_observable_is_expected_to_complete_but_does_not_it_should_t
             observer.Error.Should().BeNull();
         }
 
+        [Fact]
+        public void When_the_observable_pushes_an_expected_match_it_should_not_throw()
+        {
+            var scheduler = new TestScheduler();
+            var observable = scheduler.CreateColdObservable(
+                OnNext(100, 1),
+                OnNext(200, 2),
+                OnNext(300, 3));
+
+            // observe the sequence
+            using var observer = observable.Observe(scheduler);
+            // push subscriptions
+            scheduler.AdvanceTo(400);
+
+            // Act
+            Action act = () => observer.Should().PushMatch(i => i > 1);
+
+            // Assert
+            act.Should().NotThrow();
+
+            observer.RecordedNotifications.Should().BeEquivalentTo(observable.Messages);
+        }
     }
 }