Merge pull request #8 from NitroDevs/feat/result-assertions

Add ResultExtensions, tests, and update messaging

Author: KyleMcMaster

src/CSharpFunctionalExtensions.FluentAssertions/MaybeExtensions.cs

@@ -15,6 +15,13 @@ public MaybeAssertions(Maybe<T> instance) : base(instance) { }
 
     protected override string Identifier => "Maybe{T}";
 
+    /// <summary>
+    /// Asserts that the current <see cref="Maybe{T}"/> has a value.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
     public AndConstraint<MaybeAssertions<T>> HaveValue(T value, string because = "", params object[] becauseArgs)
     {
         Execute.Assertion
@@ -35,6 +42,12 @@ public AndConstraint<MaybeAssertions<T>> HaveValue(T value, string because = "",
         return new AndConstraint<MaybeAssertions<T>>(this);
     }
 
+    /// <summary>
+    /// Asserts that the current <see cref="Maybe{T}"/> has no value.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
     public AndConstraint<MaybeAssertions<T>> HaveNoValue(string because = "", params object[] becauseArgs)
     {
         Execute.Assertion

src/CSharpFunctionalExtensions.FluentAssertions/ResultExtensions.cs

@@ -0,0 +1,51 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+
+namespace CSharpFunctionalExtensions.FluentAssertions;
+
+public static class ResultExtensions
+{
+    public static ResultAssertions Should(this Result instance) => new(instance);
+}
+
+public class ResultAssertions : ReferenceTypeAssertions<Result, ResultAssertions>
+{
+    public ResultAssertions(Result instance) : base(instance) { }
+
+    protected override string Identifier => "Result";
+
+    /// <summary>
+    /// Asserts a result is a success.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultAssertions> Succeed(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject.IsSuccess)
+            .ForCondition(isSuccess => isSuccess)
+            .FailWith("Expected Result to be successful but it failed");
+
+        return new AndConstraint<ResultAssertions>(this);
+    }
+
+    /// <summary>
+    /// Asserts a result is a failure.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultAssertions> Fail(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject.IsFailure)
+            .ForCondition(isSuccess => isSuccess)
+            .FailWith("Expected Result to be failure but it succeeded");
+
+        return new AndConstraint<ResultAssertions>(this);
+    }
+}

src/CSharpFunctionalExtensions.FluentAssertions/ResultTExtensions.cs

@@ -6,49 +6,68 @@ namespace CSharpFunctionalExtensions.FluentAssertions;
 
 public static class ResultTExtensions
 {
-    public static ResultAssertions<T> Should<T>(this Result<T> instance) => new(instance);
+    public static ResultTAssertions<T> Should<T>(this Result<T> instance) => new(instance);
 }
 
-public class ResultAssertions<T> : ReferenceTypeAssertions<Result<T>, ResultAssertions<T>>
+public class ResultTAssertions<T> : ReferenceTypeAssertions<Result<T>, ResultTAssertions<T>>
 {
-    public ResultAssertions(Result<T> instance) : base(instance) { }
+    public ResultTAssertions(Result<T> instance) : base(instance) { }
 
     protected override string Identifier => "Result{T}";
 
-    public AndConstraint<ResultAssertions<T>> BeSuccessful(string because = "", params object[] becauseArgs)
+    /// <summary>
+    /// Asserts a result is a success.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTAssertions<T>> Succeed(string because = "", params object[] becauseArgs)
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject.IsSuccess)
             .ForCondition(isSuccess => isSuccess)
-            .FailWith("Expected Result to be successful but found error");
+            .FailWith("Expected Result to be successful but it failed");
 
-        return new AndConstraint<ResultAssertions<T>>(this);
+        return new AndConstraint<ResultTAssertions<T>>(this);
     }
 
-    public AndConstraint<ResultAssertions<T>> BeSuccessfulWith(T value, string because = "", params object[] becauseArgs)
+    /// <summary>
+    /// Asserts a result is a failure.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTAssertions<T>> SucceedWith(T value, string because = "", params object[] becauseArgs)
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject)
             .ForCondition(isSuccess => Subject.IsSuccess)
-            .FailWith("Expected Result to be successful but found error")
+            .FailWith("Expected Result to be successful but it failed")
             .Then
             .Given(s => s.Value)
             .ForCondition(v => v.Equals(value))
             .FailWith("Excepted Result value to be {0} but found {1}", value, Subject.Value);
 
-        return new AndConstraint<ResultAssertions<T>>(this);
+        return new AndConstraint<ResultTAssertions<T>>(this);
     }
 
-    public AndConstraint<ResultAssertions<T>> BeFailure(string because = "", params object[] becauseArgs)
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTAssertions<T>> Fail(string because = "", params object[] becauseArgs)
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject.IsFailure)
             .ForCondition(isSuccess => isSuccess)
-            .FailWith("Expected Result to be failure");
+            .FailWith("Expected Result to be failure but it succeeded");
 
-        return new AndConstraint<ResultAssertions<T>>(this);
+        return new AndConstraint<ResultTAssertions<T>>(this);
     }
 }

tests/CSharpFunctionalExtensions.FluentAssertions.Tests/ResultAssertionTests.cs

@@ -0,0 +1,44 @@
+using Xunit;
+using Xunit.Sdk;
+using FluentAssertions;
+
+namespace CSharpFunctionalExtensions.FluentAssertions.Tests;
+
+public class ResultAssertionTests
+{
+    [Fact]
+    public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful()
+    {
+        var x = Result.Success();
+
+        x.Should().Succeed();
+    }
+
+    [Fact]
+    public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
+    {
+        var x = Result.Success();
+
+        var action = () => x.Should().Fail();
+
+        action.Should().Throw<XunitException>().WithMessage("Expected Result to be failure but it succeeded");
+    }
+
+    [Fact]
+    public void When_Result_Is_Expected_To_Have_Error_It_Should_Not_Be_Failure()
+    {
+        var x = Result.Failure("error");
+
+        x.Should().Fail();
+    }
+
+    [Fact]
+    public void When_Result_Is_Expected_To_Have_Error_It_Should_Be_Failure()
+    {
+        var x = Result.Failure("error");
+
+        var action = () => x.Should().Succeed();
+
+        action.Should().Throw<XunitException>().WithMessage("Expected Result to be successful but it failed");
+    }
+}

tests/CSharpFunctionalExtensions.FluentAssertions.Tests/ResultTAssertionsTests.cs

@@ -11,17 +11,17 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful()
     {
         var x = Result.Success("test");
 
-        x.Should().BeSuccessful();
+        x.Should().Succeed();
     }
 
     [Fact]
     public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
     {
         var x = Result.Success("test");
 
-        var action = () => x.Should().BeFailure();
+        var action = () => x.Should().Fail();
 
-        action.Should().Throw<XunitException>().WithMessage("Expected Result to be failure");
+        action.Should().Throw<XunitException>().WithMessage("Expected Result to be failure but it succeeded");
     }
 
     [Fact]
@@ -30,15 +30,15 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful_With_V
         string expected = "test";
         var x = Result.Success(expected);
 
-        x.Should().BeSuccessfulWith(expected);
+        x.Should().SucceedWith(expected);
     }
 
     [Fact]
     public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Successful_With_Different_Value()
     {
         var x = Result.Success("foo");
 
-        var action = () => x.Should().BeSuccessfulWith("bar");
+        var action = () => x.Should().SucceedWith("bar");
 
         action.Should().Throw<XunitException>().WithMessage(@"Excepted Result value to be ""bar"" but found ""foo""");
     }
@@ -48,16 +48,16 @@ public void When_Result_Is_Expected_To_Have_Error_It_Should_Not_Be_Failure()
     {
         var x = Result.Failure<string>("error");
 
-        x.Should().BeFailure();
+        x.Should().Fail();
     }
 
     [Fact]
     public void When_Result_Is_Expected_To_Have_Error_It_Should_Be_Failure()
     {
         var x = Result.Failure<string>("error");
 
-        var action = () => x.Should().BeSuccessful();
+        var action = () => x.Should().Succeed();
 
-        action.Should().Throw<XunitException>().WithMessage("Expected Result to be successful but found error");
+        action.Should().Throw<XunitException>().WithMessage("Expected Result to be successful but it failed");
     }
 }