wip

Author: MrKWatkins

src/MrKWatkins.Assertions.Tests/AsyncActionAssertionsTests.cs

@@ -5,15 +5,15 @@ public sealed class AsyncActionAssertionsTests
     [Test]
     public async Task ThrowAsync()
     {
-        Func<Task> doesNotThrow = () => Task.CompletedTask;
-        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+        var doesNotThrow = () => Task.CompletedTask;
+        var doesNotThrowAsync = async () => await Task.Yield();
 
         var exception = new InvalidOperationException("Test");
         Func<Task> throws = () => throw exception;
-        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+        var throwsAsync = async () => { await Task.Yield(); throw exception; };
 
         Func<Task> throwsWrongException = () => throw new NotSupportedException("Wrong");
-        Func<Task> throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
+        var throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
 
         await Assert.That(() => throws.Should().ThrowAsync<InvalidOperationException>()).ThrowsNothing();
         await Assert.That(() => throwsAsync.Should().ThrowAsync<InvalidOperationException>()).ThrowsNothing();
@@ -34,7 +34,7 @@ public async Task ThrowAsync_Chain()
     {
         var exception = new InvalidOperationException("Test");
         Func<Task> throws = () => throw exception;
-        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+        var throwsAsync = async () => { await Task.Yield(); throw exception; };
 
         var chain = await throws.Should().ThrowAsync<InvalidOperationException>().ConfigureAwait(false);
         await Assert.That(chain.Exception).IsSameReferenceAs(exception);
@@ -48,15 +48,15 @@ public async Task ThrowAsync_Chain()
     [Test]
     public async Task ThrowAsync_String()
     {
-        Func<Task> doesNotThrow = () => Task.CompletedTask;
-        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+        var doesNotThrow = () => Task.CompletedTask;
+        var doesNotThrowAsync = async () => await Task.Yield();
 
         var exception = new InvalidOperationException("Test");
         Func<Task> throws = () => throw exception;
-        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+        var throwsAsync = async () => { await Task.Yield(); throw exception; };
 
         Func<Task> throwsWrongException = () => throw new NotSupportedException("Wrong");
-        Func<Task> throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
+        var throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
 
         await Assert.That(() => throws.Should().ThrowAsync<InvalidOperationException>("Test")).ThrowsNothing();
         await Assert.That(() => throwsAsync.Should().ThrowAsync<InvalidOperationException>("Test")).ThrowsNothing();
@@ -82,7 +82,7 @@ public async Task ThrowAsync_String_Chain()
     {
         var exception = new InvalidOperationException("Test");
         Func<Task> throws = () => throw exception;
-        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+        var throwsAsync = async () => { await Task.Yield(); throw exception; };
 
         var chain = await throws.Should().ThrowAsync<InvalidOperationException>("Test").ConfigureAwait(false);
         await Assert.That(chain.Exception).IsSameReferenceAs(exception);
@@ -96,12 +96,12 @@ public async Task ThrowAsync_String_Chain()
     [Test]
     public async Task NotThrowAsync()
     {
-        Func<Task> doesNotThrow = () => Task.CompletedTask;
-        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+        var doesNotThrow = () => Task.CompletedTask;
+        var doesNotThrowAsync = async () => await Task.Yield();
 
         var exception = new InvalidOperationException("Test");
         Func<Task> throws = () => throw exception;
-        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+        var throwsAsync = async () => { await Task.Yield(); throw exception; };
 
         await Assert.That(() => doesNotThrow.Should().NotThrowAsync()).ThrowsNothing();
         await Assert.That(() => doesNotThrowAsync.Should().NotThrowAsync()).ThrowsNothing();

src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs

@@ -77,9 +77,9 @@ await Assert.That(() => nullEnumerable.Should().SequenceEqual(1)).Throws<Asserti
 
     [Test]
     [Arguments(new int[0], true, new[] { 1, 2, 3 }, true, "Value [] should sequence equal [1, 2, 3] but it has 0 elements rather than the expected 3.")]
-    [Arguments(new int[0], true, new[] { 1, 2, 3 }, false, "Value [] should sequence equal [1, 2, ...] but it has less elements (0) than expected.")]
+    [Arguments(new int[0], true, new[] { 1, 2, 3 }, false, "Value [] should sequence equal [1, 2, ...] but it has fewer elements (0) than expected.")]
     [Arguments(new int[0], false, new[] { 1, 2, 3 }, true, "Value [] should sequence equal [1, 2, 3] but it has 0 elements rather than the expected 3.")]
-    [Arguments(new int[0], false, new[] { 1, 2, 3 }, false, "Value [] should sequence equal [1, 2, ...] but it has less elements (0) than expected.")]
+    [Arguments(new int[0], false, new[] { 1, 2, 3 }, false, "Value [] should sequence equal [1, 2, ...] but it has fewer elements (0) than expected.")]
     [Arguments(new[] { 1 }, true, new int[0], true, "Value [1] should sequence equal [] but it has 1 element rather than the expected 0.")]
     [Arguments(new[] { 1, 2, 3 }, true, new int[0], false, "Value [1, 2, 3] should sequence equal [] but it has 3 elements rather than the expected 0.")]
     [Arguments(new[] { 1, 2, 3 }, false, new int[0], true, "Value [1, 2, ...] should sequence equal [] but it has more elements than the expected 0.")]

src/MrKWatkins.Assertions.Tests/ReadOnlySpanAssertionsTests.cs

@@ -172,7 +172,7 @@ await Assert.That(() =>
             ReadOnlySpan<byte> value = [];
             var differentLength = CreateEnumerable(1);
             value.Should().SequenceEqual(differentLength);
-        }).Throws<AssertionException>().WithMessage("Value [] should sequence equal [1, ...] but it has less elements (0) than expected.");
+        }).Throws<AssertionException>().WithMessage("Value [] should sequence equal [1, ...] but it has fewer elements (0) than expected.");
 
         await Assert.That(() =>
         {
@@ -186,7 +186,7 @@ await Assert.That(() =>
             ReadOnlySpan<byte> value = [1, 2, 3];
             var differentLength = CreateEnumerable(1, 2, 3, 4);
             value.Should().SequenceEqual(differentLength);
-        }).Throws<AssertionException>().WithMessage("Value [1, 2, 3] should sequence equal [1, 2, ...] but it has less elements (3) than expected.");
+        }).Throws<AssertionException>().WithMessage("Value [1, 2, 3] should sequence equal [1, 2, ...] but it has fewer elements (3) than expected.");
 
         await Assert.That(() =>
         {

src/MrKWatkins.Assertions/AsyncActionAssertions.cs

@@ -52,6 +52,78 @@ public async Task<ActionAssertionsChain<TException>> ThrowAsync<TException>(stri
         return chain;
     }
 
+    /// <summary>
+    /// Asserts that the async action throws an exception of the specified type with the specified message and inner exception.
+    /// </summary>
+    /// <typeparam name="TException">The expected exception type.</typeparam>
+    /// <param name="expectedMessage">The expected exception message.</param>
+    /// <param name="expectedInnerException">The expected inner exception, or <see langword="null" /> to assert no inner exception.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<TException>> ThrowAsync<TException>(string expectedMessage, Exception? expectedInnerException)
+        where TException : Exception
+    {
+        var chain = await ThrowAsync<TException>().ConfigureAwait(false);
+
+        chain.That.Should().HaveMessage(expectedMessage);
+        if (expectedInnerException != null)
+        {
+            chain.That.Should().HaveInnerException(expectedInnerException);
+        }
+        else
+        {
+            chain.That.Should().NotHaveInnerException();
+        }
+
+        return chain;
+    }
+
+    /// <summary>
+    /// Asserts that the async action throws the exact specified exception instance.
+    /// </summary>
+    /// <typeparam name="TException">The expected exception type.</typeparam>
+    /// <param name="expected">The expected exception instance.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<TException>> ThrowAsync<TException>(TException expected)
+        where TException : Exception
+    {
+        var chain = await ThrowAsync<TException>().ConfigureAwait(false);
+
+        chain.Exception.Should().BeTheSameInstanceAs(expected);
+
+        return chain;
+    }
+
+    /// <summary>
+    /// Asserts that the async action throws an <see cref="ArgumentException" /> with the specified message and parameter name.
+    /// </summary>
+    /// <param name="expectedMessage">The expected exception message.</param>
+    /// <param name="expectedParamName">The expected parameter name.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<ArgumentException>> ThrowArgumentExceptionAsync(string expectedMessage, string expectedParamName)
+    {
+        var chain = await ThrowAsync<ArgumentException>().ConfigureAwait(false);
+
+        chain.Exception.Should().HaveMessageStartingWith(expectedMessage).And.HaveParamName(expectedParamName);
+
+        return chain;
+    }
+
+    /// <summary>
+    /// Asserts that the async action throws an <see cref="ArgumentOutOfRangeException" /> with the specified message, parameter name and actual value.
+    /// </summary>
+    /// <param name="expectedMessage">The expected exception message.</param>
+    /// <param name="expectedParamName">The expected parameter name.</param>
+    /// <param name="expectedActualValue">The expected actual value.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<ArgumentOutOfRangeException>> ThrowArgumentOutOfRangeExceptionAsync(string expectedMessage, string expectedParamName, object expectedActualValue)
+    {
+        var chain = await ThrowAsync<ArgumentOutOfRangeException>().ConfigureAwait(false);
+
+        chain.Exception.Should().HaveMessageStartingWith(expectedMessage).And.HaveParamName(expectedParamName).And.HaveActualValue(expectedActualValue);
+
+        return chain;
+    }
+
     /// <summary>
     /// Asserts that the async action does not throw any exception.
     /// </summary>

src/MrKWatkins.Assertions/EnumerableAssertions.cs

@@ -32,6 +32,31 @@ public EnumerableAssertionsChain<TEnumerable, T> OnlyContain([InstantHandle] Fun
         return new EnumerableAssertionsChain<TEnumerable, T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the enumerable contains exactly one item.
+    /// </summary>
+    /// <returns>An <see cref="ObjectAssertionsChain{T}" /> for the single item.</returns>
+    public ObjectAssertionsChain<T> ContainSingle()
+    {
+        NotBeNull();
+
+        using var enumerator = Value.GetEnumerator();
+
+        if (!enumerator.MoveNext())
+        {
+            throw Verify.CreateException("Value should contain a single item but was empty.");
+        }
+
+        var item = enumerator.Current;
+
+        if (enumerator.MoveNext())
+        {
+            throw Verify.CreateException("Value should contain a single item but contains more than one item.");
+        }
+
+        return new ObjectAssertionsChain<T>(new ObjectAssertions<T>(item));
+    }
+
     /// <summary>
     /// Asserts that the enumerable contains exactly one item that satisfies the specified predicate.
     /// </summary>
@@ -128,7 +153,7 @@ private EnumerableAssertionsChain<TEnumerable, T> SequenceEqualCore(IEnumerable<
         if (expectedEnumerator.MoveNext())
         {
             throw Verify.CreateException(
-                $"Value {Format.Enumerable(Value)} should sequence equal {Format.Enumerable(expected)} but it has less elements ({actualList.Count}) than expected.");
+                $"Value {Format.Enumerable(Value)} should sequence equal {Format.Enumerable(expected)} but it has fewer elements ({actualList.Count}) than expected.");
         }
 
         return new EnumerableAssertionsChain<TEnumerable, T>(this);
@@ -222,4 +247,78 @@ public EnumerableAssertionsChain<TEnumerable, T> Contain(T expected)
 
         return new EnumerableAssertionsChain<TEnumerable, T>(this);
     }
+
+    /// <summary>
+    /// Asserts that the enumerable contains the specified item using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The item that should be present in the enumerable.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> Contain(T expected, IEqualityComparer<T> comparer)
+    {
+        NotBeNull();
+
+        Verify.That(Value.Contains(expected, comparer), $"Value should contain {expected} but did not.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the enumerable contains the specified item using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The item that should be present in the enumerable.</param>
+    /// <param name="predicate">The predicate to use for element comparison, taking the actual item and expected item as arguments.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> Contain(T expected, Func<T?, T?, bool> predicate)
+    {
+        NotBeNull();
+
+        Verify.That(Value.Any(item => predicate(item, expected)), $"Value should contain {expected} but did not.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the enumerable does not contain the specified item.
+    /// </summary>
+    /// <param name="expected">The item that should not be present in the enumerable.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> NotContain(T expected)
+    {
+        NotBeNull();
+
+        Verify.That(!Value.Contains(expected), $"Value should not contain {expected}.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the enumerable does not contain the specified item using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The item that should not be present in the enumerable.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> NotContain(T expected, IEqualityComparer<T> comparer)
+    {
+        NotBeNull();
+
+        Verify.That(!Value.Contains(expected, comparer), $"Value should not contain {expected}.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the enumerable does not contain the specified item using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The item that should not be present in the enumerable.</param>
+    /// <param name="predicate">The predicate to use for element comparison, taking the actual item and expected item as arguments.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> NotContain(T expected, Func<T?, T?, bool> predicate)
+    {
+        NotBeNull();
+
+        Verify.That(!Value.Any(item => predicate(item, expected)), $"Value should not contain {expected}.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
 }