Removed assert helpers that conflict with Shoudly

Author: egil

sample/tests/Tests/Components/TodoListTest.cs

@@ -119,8 +119,8 @@ public void Test005()
             cut.Find("input").Change(taskValue);
             cut.Find("form").Submit();
 
-            createdTask.ShouldNotBeNull();
-            createdTask?.Text.ShouldBe(taskValue);
+            createdTask = createdTask.ShouldBeOfType<Todo>();
+            createdTask.Text.ShouldBe(taskValue);
         }
 
         [Fact(DisplayName = "When add task form is submitted with no text OnAddingTodo is not called")]

src/Asserting/CollectionAssertExtensions.cs

@@ -7,62 +7,11 @@
 
 namespace Egil.RazorComponents.Testing.Asserting
 {
-    /// <summary>
-    /// Collection test assertions
-    /// </summary>
-    public static class GenericAssertExtensions
-    {
-        /// <summary>
-        /// Verifies that <paramref name="actual"/> is not null
-        /// and returns <paramref name="actual"/> again.
-        /// </summary>
-        /// <returns>Returns <paramref name="actual"/> if it is not null.</returns>
-        public static T ShouldNotBeNull<T>([NotNullIfNotNull("actual")]this T? actual) where T : class
-        {
-            if (actual is null)
-                throw new XunitException($"{nameof(ShouldNotBeNull)}() Failure");
-            return actual;
-        }
-
-        /// <summary>
-        /// Verifies that <paramref name="actual"/> is not null
-        /// and returns <paramref name="actual"/> again.
-        /// </summary>
-        /// <returns>Returns <paramref name="actual"/> if it is not null.</returns>
-        public static T ShouldNotBeNull<T>([NotNullIfNotNull("actual")]this T? actual) where T : struct
-        {
-            if (actual is null)
-                throw new XunitException($"{nameof(ShouldNotBeNull)}() Failure");
-            return actual.Value;
-        }
-
-        /// <summary>
-        /// Verifies that a nullable <paramref name="actual"/> is not null
-        /// and of type <typeparamref name="T"/>.
-        /// </summary>
-        /// <returns>Returns <paramref name="actual"/> as <typeparamref name="T"/>.</returns>
-        public static T ShouldBeOfType<T>([NotNullIfNotNull("actual")]this object? actual)
-        {
-            return Assert.IsType<T>(actual);
-        }
-
-        /// <summary>
-        /// Verifies that a non nullable struct is the same as its nullable counter part.
-        /// </summary>
-        public static void ShouldBe<T>(this T actual, T? expected)
-             where T : struct
-        {
-            Assert.Equal(expected, actual);
-        }
-    }
-
     /// <summary>
     /// Collection test assertions
     /// </summary>
     public static class CollectionAssertExtensions
     {
-
-
         /// <summary>
         /// Verifies that a collection contains exactly a given number of elements, which
         /// meet the criteria provided by the element inspectors.

src/Asserting/DiffAssertExtensions.cs

@@ -37,7 +37,7 @@ public static IDiff ShouldHaveSingleChange(this IReadOnlyList<IDiff> diffs)
         /// The total number of <see cref="IDiff"/> inspectors must exactly match the number of <see cref="IDiff"/>s in the collection</param>
         public static void ShouldHaveChanges(this IReadOnlyList<IDiff> diffs, params Action<IDiff>[] diffInspectors)
         {
-            Assert.Collection(diffs, diffInspectors);
+            CollectionAssertExtensions.ShouldAllBe(diffs, diffInspectors);
         }
 
     }

tests/Asserting/DiffAssertExtensionsTest.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AngleSharp.Diffing.Core;
+using Egil.RazorComponents.Testing.Diffing;
+using Moq;
+using Shouldly;
+using Xunit;
+using Xunit.Sdk;
+
+namespace Egil.RazorComponents.Testing.Asserting
+{
+    public class DiffAssertExtensionsTest
+    {
+        [Fact(DisplayName = "ShouldHaveSingleChange throws when input is null")]
+        public void Test001()
+        {
+            IReadOnlyList<IDiff>? diffs = null;
+            Exception? exception = null;
+
+            try
+            {
+                DiffAssertExtensions.ShouldHaveSingleChange(diffs!);
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            };
+
+            exception.ShouldBeOfType<ArgumentNullException>();
+        }
+
+        [Theory(DisplayName = "ShouldHaveSingleChange throws when input length not exactly 1")]
+        [MemberData(nameof(GetDiffLists))]
+        public void Test002(IReadOnlyList<IDiff> diffs)
+        {
+            Exception? exception = null;
+
+            try
+            {
+                diffs.ShouldHaveSingleChange();
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            };
+
+            exception.ShouldBeOfType<EqualException>();
+        }
+
+        [Fact(DisplayName = "ShouldHaveSingleChange returns the single diff in input when there is only one")]
+        public void Test003()
+        {
+            var input = new IDiff[] { Mock.Of<IDiff>() };
+
+            var output = input.ShouldHaveSingleChange();
+
+            output.ShouldBe(input[0]);
+        }
+
+        internal static IEnumerable<object[]> GetDiffLists()
+        {
+            yield return new object[] { Array.Empty<IDiff>() };
+            yield return new object[]
+            {
+                new IDiff[]
+                {
+                    Mock.Of<IDiff>(),
+                    Mock.Of<IDiff>(),
+                }
+            };
+        }
+    }
+}

tests/Asserting/GenericAssertExtensions.cs

@@ -28,7 +28,7 @@ public void Test001()
                 exception = ex;
             };
 
-            var actual = exception.ShouldNotBeNull().ShouldBeOfType<CollectionException>();
+            var actual = exception.ShouldBeOfType<CollectionException>();
             actual.ActualCount.ShouldBe(collection.Length);
             actual.ExpectedCount.ShouldBe(1);
         }
@@ -49,7 +49,7 @@ public void Test002()
                 exception = ex;
             };
 
-            var actual = exception.ShouldNotBeNull().ShouldBeOfType<CollectionException>();
+            var actual = exception.ShouldBeOfType<CollectionException>();
             actual.IndexFailurePoint.ShouldBe(1);
         }
 
@@ -70,7 +70,7 @@ public void Test003()
                 exception = ex;
             };
 
-            var actual = exception.ShouldNotBeNull().ShouldBeOfType<CollectionException>();
+            var actual = exception.ShouldBeOfType<CollectionException>();
             actual.ActualCount.ShouldBe(collection.Length);
             actual.ExpectedCount.ShouldBe(1);
         }
@@ -91,7 +91,7 @@ public void Test004()
                 exception = ex;
             };
 
-            var actual = exception.ShouldNotBeNull().ShouldBeOfType<CollectionException>();
+            var actual = exception.ShouldBeOfType<CollectionException>();
             actual.IndexFailurePoint.ShouldBe(1);
         }