Remove IsModelVersion and replace with AtLeastModelVersion due to test instability.

Replace Await with thread sleep in EvaluateAfterDelay

Author: condron

src/ReactiveDomain.Foundation.Tests/when_using_read_model_base.cs

@@ -62,7 +62,7 @@ public void can_start_streams_by_aggregate()
             var s1 = Namer.GenerateForAggregate(typeof(TestAggregate), aggId);
             AppendEvents(1, _conn, s1, 7);
             Start<TestAggregate>(aggId);
-            AssertEx.IsModelVersion(this, 2, 1000, msg: $"Expected 2 got {Version}"); // 1 message + CatchupSubscriptionBecameLive
+            AssertEx.AtLeastModelVersion(this, 2, 1000, msg: $"Expected 2 got {Version}"); // 1 message + CatchupSubscriptionBecameLive
             AssertEx.IsOrBecomesTrue(() => Sum == 7);
         }
         [Fact]
@@ -75,14 +75,14 @@ public void can_start_streams_by_aggregate_category()
             AppendEvents(1, _conn, s2, 5);
             Start<ReadModelTestCategoryAggregate>(null, true);
 
-            AssertEx.IsModelVersion(this, 3, 1000, msg: $"Expected 3 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 3, 1000, msg: $"Expected 3 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 12);
         }
         [Fact]
         public void can_read_one_stream()
         {
             Start(_stream1);
-            AssertEx.IsModelVersion(this, 11, 1000, msg: $"Expected 11 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 11, 1000, msg: $"Expected 11 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 20);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -93,7 +93,7 @@ public void can_read_two_streams()
         {
             Start(_stream1);
             Start(_stream2);
-            AssertEx.IsModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 50);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -105,29 +105,29 @@ public void can_read_two_streams()
         public void can_wait_for_one_stream_to_go_live()
         {
             Start(_stream1, null, true);
-            AssertEx.IsModelVersion(this, 11, 100, msg: $"Expected 11 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 11, 100, msg: $"Expected 11 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 20, 100);
         }
         [Fact]
         public void can_wait_for_two_streams_to_go_live()
         {
             Start(_stream1, null, true);
-            AssertEx.IsModelVersion(this, 11, 100, msg: $"Expected 11 got {Version}");
-            AssertEx.IsOrBecomesTrue(() => Sum == 20, 100);
+            AssertEx.AtLeastModelVersion(this, 11, 100, msg: $"Expected 11 got {Version}");
+            AssertEx.IsOrBecomesTrue(() => Sum == 20, 150);
 
             Start(_stream2, null, true);
-            AssertEx.IsModelVersion(this, 21, 100, msg: $"Expected 21 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 21, 100, msg: $"Expected 21 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 50, 150);
         }
         [Fact]
         public void can_listen_to_one_stream()
         {
             Start(_stream1);
-            AssertEx.IsModelVersion(this, 11, 1000, msg: $"Expected 11 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 11, 1000, msg: $"Expected 11 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 20);
             //add more messages
             AppendEvents(10, _conn, _stream1, 5);
-            AssertEx.IsModelVersion(this, 21, 1000, msg: $"Expected 21 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 21, 1000, msg: $"Expected 21 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 70);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -139,12 +139,12 @@ public void can_listen_to_two_streams()
         {
             Start(_stream1);
             Start(_stream2);
-            AssertEx.IsModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 50);
             //add more messages
             AppendEvents(10, _conn, _stream1, 5);
             AppendEvents(10, _conn, _stream2, 7);
-            AssertEx.IsModelVersion(this, 42, 1000, msg: $"Expected 42 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 42, 1000, msg: $"Expected 42 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 170);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -161,11 +161,11 @@ public void can_use_checkpoint_on_one_stream()
             //start at the checkpoint
             Start(_stream1, checkPoint);
             //add the one recorded event
-            AssertEx.IsModelVersion(this, 2, 100, msg: $"Expected 2 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 2, 100, msg: $"Expected 2 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 20);
             //add more messages
             AppendEvents(10, _conn, _stream1, 5);
-            AssertEx.IsModelVersion(this, 12, 100, msg: $"Expected 12 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 12, 100, msg: $"Expected 12 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 70);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -181,12 +181,12 @@ public void can_use_checkpoint_on_two_streams()
             Start(_stream1, checkPoint1);
             Start(_stream2, checkPoint2);
             //add the recorded events 2 on stream 1 & 5 on stream 2
-            AssertEx.IsModelVersion(this, 7, 1000, msg: $"Expected 7 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 7, 1000, msg: $"Expected 7 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 50, msg: $"Expected 50 got {Sum}");
             //add more messages
             AppendEvents(10, _conn, _stream1, 5);
             AppendEvents(10, _conn, _stream2, 7);
-            AssertEx.IsModelVersion(this, 27, 1000, msg: $"Expected 27 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 27, 1000, msg: $"Expected 27 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 170);
             //confirm checkpoints
             Assert.Equal(_stream1, GetCheckpoint()[0].Item1);
@@ -203,11 +203,11 @@ public void can_listen_to_the_same_stream_twice()
             Start(_stream1);
             Start(_stream1);
             //double events
-            AssertEx.IsModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 22, 1000, msg: $"Expected 22 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 40);
             //even more doubled events
             AppendEvents(10, _conn, _stream1, 5);
-            AssertEx.IsModelVersion(this, 42, 2000, msg: $"Expected 42 got {Version}");
+            AssertEx.AtLeastModelVersion(this, 42, 2000, msg: $"Expected 42 got {Version}");
             AssertEx.IsOrBecomesTrue(() => Sum == 140);
         }
 

src/ReactiveDomain.Testing/AssertEx.cs

@@ -47,31 +47,31 @@ public static void ArraySegmentEqual<T>(
         /// Repeatedly evaluates the function until false is returned or the timeout expires.  
         /// Will return immediately when the condition is false.  
         /// Evaluates the condition on an exponential back off up to 250 ms until timeout.  
-        /// Will yield the thread after each evaluation, use the hint yieldThread if it is known the function should yield before evaluation.  
+        /// Will yield the thread after each evaluation.  
         /// </summary>
         /// <param name="func">The function to evaluate.</param>
         /// <param name="timeout">A timeout in milliseconds. If not specified, defaults to 1000.</param>
         /// <param name="msg">A message to display if the condition is not satisfied.</param>
-        /// <param name="yieldThread">Execution hint to yield thread before evaluation</param>
+        /// <param name="yieldThread">Ignored, will be removed in a future release</param>
         public static void IsOrBecomesFalse(Func<bool> func, int? timeout = null, string msg = null, bool yieldThread = false)
         {
-            IsOrBecomesTrue(() => !func(), timeout, msg, yieldThread);
+            IsOrBecomesTrue(() => !func(), timeout, msg);
         }
 
         /// <summary>
         /// Asserts the given function will return true before the timeout expires.  
         /// Repeatedly evaluates the function until true is returned or the timeout expires.  
         /// Will return immediately when the condition is true.  
         /// Evaluates the condition on an exponential back off up to 250 ms until timeout.  
-        /// Will yield the thread after each evaluation, use the hint yieldThread if it is known the function should yield before evaluation.  
+        /// Will yield the thread after each evaluation.  
         /// </summary>
         /// <param name="func">The function to evaluate.</param>
         /// <param name="timeout">A timeout in milliseconds. If not specified, defaults to 1000.</param>
         /// <param name="msg">A message to display if the condition is not satisfied.</param>
-        /// <param name="yieldThread">Execution hint to yield thread before evaluation</param>
+        /// <param name="yieldThread">Ignored, will be removed in a future release</param>
         public static void IsOrBecomesTrue(Func<bool> func, int? timeout = null, string msg = null, bool yieldThread = false)
         {
-            if (!yieldThread && func() == true)
+            if (func() == true)
             {
                 Assert.True(true, msg ?? "");
                 return;
@@ -85,67 +85,45 @@ public static void IsOrBecomesTrue(Func<bool> func, int? timeout = null, string
             var delay = 1;
             while (true)
             {
-                using (var task = EvaluateAfterDelay(func, TimeSpan.FromMilliseconds(delay)))
+                if (EvaluateAfterDelay(func, TimeSpan.FromMilliseconds(delay)))
                 {
-                    task.Wait();
-                    if (task.Result == true)
-                    {
-                        result = true;
-                        break;
-                    }
+                    result = true;
+                    break;
                 }
+
                 var now = Environment.TickCount;
                 if ((endTime - now) <= 0) { break; }
                 if (delay < 250)
                 {
                     delay = delay << 1;
-                }    
+                }
                 delay = Math.Min(delay, endTime - now);
             }
             Assert.True(result, msg ?? "");
         }
 
-        /// <summary>
-        /// Asserts that the given read model will have exactly the expected version before the timeout expires.
-        /// This can make tests fragile and should generally not be used unless the exact number of messages
-        /// handled is critical to your tests. In most cases you should use <see cref="AtLeastModelVersion"/>
-        /// instead.
-        /// </summary>
-        /// <param name="readModel">The read model.</param>
-        /// <param name="expectedVersion">The read model's expected version.</param>
-        /// <param name="timeout">A timeout in milliseconds. If not specified, defaults to 1000.</param>
-        /// <param name="msg">A message to display if the condition is not satisfied.</param>
-        /// <param name="yieldThread">If true, the thread relinquishes the remainder of its time
-        /// slice to any thread of equal priority that is ready to run.</param>
-        public static void IsModelVersion(ReadModelBase readModel, int expectedVersion, int? timeout = null, string msg = null, bool yieldThread = false)
-        {
-            IsOrBecomesTrue(() => readModel.Version == expectedVersion, timeout, msg, yieldThread);
-        }
-
         /// <summary>
         /// Asserts that the given read model will have at least the expected version before the
-        /// timeout expires. This is generally preferred to <see cref="IsModelVersion"/>.
+        /// timeout expires.  If a test needs to check an exact model version use 'IsOrBecomesTrue(()=> ReadModel.Version == [expectedVersion], [timeout])'. 
         /// </summary>
         /// <param name="readModel">The read model.</param>
         /// <param name="expectedVersion">The read model's expected minimum version.</param>
         /// <param name="timeout">A timeout in milliseconds. If not specified, defaults to 1000.</param>
         /// <param name="msg">A message to display if the condition is not satisfied.</param>
-        /// <param name="yieldThread">If true, the thread relinquishes the remainder of its time
-        /// slice to any thread of equal priority that is ready to run.</param>
-        public static void AtLeastModelVersion(ReadModelBase readModel, int expectedVersion, int? timeout = null, string msg = null, bool yieldThread = false)
+        public static void AtLeastModelVersion(ReadModelBase readModel, int expectedVersion, int? timeout = null, string msg = null)
         {
-            IsOrBecomesTrue(() => readModel.Version >= expectedVersion, timeout, msg, yieldThread);
+            IsOrBecomesTrue(() => readModel.Version >= expectedVersion, timeout, msg);
         }
+
         /// <summary>
         /// Evaluates the given function after the supplied delay.
         /// The current thread will yield at the start of the delay.  
         /// </summary>
         /// <param name="func">The function to evaluate.</param>
         /// <param name="delay">A delay timeSpan.</param>
-        /// <param name="cancellationToken">A token to cancel evaluation, TaskCanceledException will be thrown.</param>
-        public static async Task<bool> EvaluateAfterDelay(Func<bool> func, TimeSpan delay, CancellationToken cancellationToken = default)
+        public static bool EvaluateAfterDelay(Func<bool> func, TimeSpan delay)
         {
-            await Task.Delay(delay, cancellationToken);
+            Thread.Sleep(delay);
             return func();
         }
     }

src/ReactiveDomain.Testing/Specifications/TestQueue.cs

@@ -126,15 +126,11 @@ public void WaitForMultiple<T>(uint num, TimeSpan timeout) where T : IMessage
             var endTime = startTime + (int)timeout.TotalMilliseconds;
 
             var delay = 1;
-            while (true)
+            //Evaluating the entire queue is a bit heavy, but is required to support waiting on base types, interfaces, etc. 
+            while (!AssertEx.EvaluateAfterDelay(() => Messages.Count(x => x is T) >= num, TimeSpan.FromMilliseconds(delay)))
             {
                 if (_disposed) { throw new ObjectDisposedException(nameof(TestQueue)); }
-                //Evaluating the entire queue is a bit heavy, but is required to support waiting on base types, interfaces, etc. 
-                using (var task = AssertEx.EvaluateAfterDelay(() => Messages.Count(x => x is T) >= num, TimeSpan.FromMilliseconds(delay)))
-                {
-                    task.Wait();
-                    if (task.Result == true) { break; }
-                }
+
                 var now = Environment.TickCount;
                 if ((endTime - now) <= 0) { throw new TimeoutException(); }