test new assertions

Author: rose-a

Src/FluentAssertions.Reactive/ReactiveAssertions.cs

@@ -275,9 +275,6 @@ public AndConstraint<ReactiveAssertions<TPayload>> PushMatch(
             if (predicate == null) throw new ArgumentNullException(nameof(predicate));
 
             IList<TPayload> notifications = new List<TPayload>();
-            AssertionScope assertion = Execute.Assertion
-                .WithExpectation("Expected {context:observable} {0} to push an item matching {1}{reason}", Subject, predicate.Body)
-                .BecauseOf(because, becauseArgs);
 
             try
             {
@@ -297,12 +294,15 @@ public AndConstraint<ReactiveAssertions<TPayload>> PushMatch(
             {
                 if (e is AggregateException aggregateException)
                     e = aggregateException.InnerException;
-                assertion.FailWith(", but it failed with a {0}.", e);
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected {context:observable} to push an item matching {0}{reason}, but it failed with a {1}.", predicate.Body, e);
             }
-            
-            assertion
+
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
                 .ForCondition(notifications.Any())
-                .FailWith(" within {0}.", timeout);
+                .FailWith("Expected {context:observable} to push an item matching {0}{reason} within {1}.", predicate.Body, timeout);
 
             return new AndConstraint<ReactiveAssertions<TPayload>>(this);
         }
@@ -339,9 +339,6 @@ public async Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync(
                 throw new ArgumentNullException(nameof(predicate));
 
             IList<TPayload> notifications = new List<TPayload>();
-            AssertionScope assertion = Execute.Assertion
-                .WithExpectation("Expected {context:observable} {0} to push an item matching {1}{reason}", Subject, predicate.Body)
-                .BecauseOf(because, becauseArgs);
 
             try
             {
@@ -360,12 +357,15 @@ public async Task<AndConstraint<ReactiveAssertions<TPayload>>> PushMatchAsync(
             {
                 if (e is AggregateException aggregateException)
                     e = aggregateException.InnerException;
-                assertion.FailWith(", but it failed with a {0}.", e);
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected {context:observable} to push an item matching {0}{reason}, but it failed with a {1}.", predicate.Body, e);
             }
 
-            assertion
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
                 .ForCondition(notifications.Any())
-                .FailWith(" within {0}.", timeout);
+                .FailWith("Expected {context:observable} to push an item matching {0}{reason} within {1}.", predicate.Body, timeout);
 
             return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }

Tests/FluentAssertions.Reactive.Specs/ReactiveAssertionSpecs.cs

@@ -164,13 +164,12 @@ 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));
+                OnNext(200, 2));
 
             // observe the sequence
             using var observer = observable.Observe(scheduler);
             // push subscriptions
-            scheduler.AdvanceTo(400);
+            scheduler.AdvanceTo(250);
 
             // Act
             Action act = () => observer.Should().PushMatch(i => i > 1);
@@ -180,5 +179,47 @@ public void When_the_observable_pushes_an_expected_match_it_should_not_throw()
 
             observer.RecordedNotifications.Should().BeEquivalentTo(observable.Messages);
         }
+
+        [Fact]
+        public void When_the_observable_does_not_push_a_match_it_should_throw()
+        {
+            var scheduler = new TestScheduler();
+            var observable = scheduler.CreateColdObservable(
+                OnNext(100, 1),
+                OnNext(200, 2));
+
+            // observe the sequence
+            using var observer = observable.Observe(scheduler);
+            // push subscriptions
+            scheduler.AdvanceTo(250);
+
+            // Act
+            Action act = () => observer.Should().PushMatch(i => i > 3, TimeSpan.FromMilliseconds(1));
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage(
+                $"Expected observable to push an item matching (i > 3) within {Formatter.ToString(TimeSpan.FromMilliseconds(1))}.");
+
+            observer.RecordedNotifications.Should().BeEquivalentTo(observable.Messages);
+        }
+
+        [Fact]
+        public void When_the_observable_fails_instead_of_pushing_a_match_it_should_throw()
+        {
+            var exception = new ArgumentException("That was wrong.");
+            var scheduler = new TestScheduler();
+            var observable = scheduler.CreateColdObservable(
+                OnError<int>(1, exception));
+
+            // observe the sequence
+            using var observer = observable.Observe(scheduler);
+            scheduler.AdvanceTo(10);
+            // Act
+            Action act = () => observer.Should().PushMatch(i => i > 1);
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage(
+                $"Expected observable to push an item matching (i > 1), but it failed with a {Formatter.ToString(exception)}.");
+            observer.Error.Should().BeEquivalentTo(exception);
+        }
     }
 }