Merge pull request #9 from NitroDevs/feat/unit-and-t-e-results

Add UnitResult<E> and Result<T, E> Assertions

Author: KyleMcMaster

src/CSharpFunctionalExtensions.FluentAssertions/ResultExtensions.cs

@@ -25,8 +25,8 @@ public AndConstraint<ResultAssertions> Succeed(string because = "", params objec
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
-            .Given(() => Subject.IsSuccess)
-            .ForCondition(isSuccess => isSuccess)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsSuccess)
             .FailWith("Expected Result to be successful but it failed");
 
         return new AndConstraint<ResultAssertions>(this);
@@ -42,8 +42,8 @@ public AndConstraint<ResultAssertions> Fail(string because = "", params object[]
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
-            .Given(() => Subject.IsFailure)
-            .ForCondition(isSuccess => isSuccess)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
             .FailWith("Expected Result to be failure but it succeeded");
 
         return new AndConstraint<ResultAssertions>(this);

src/CSharpFunctionalExtensions.FluentAssertions/ResultTEExtensions.cs

@@ -0,0 +1,94 @@
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using FluentAssertions;
+
+namespace CSharpFunctionalExtensions.FluentAssertions;
+public static class ResultTEExtensions
+{
+    public static ResultTEAssertions<T, E> Should<T, E>(this Result<T, E> instance) => new(instance);
+}
+
+public class ResultTEAssertions<T, E> : ReferenceTypeAssertions<Result<T, E>, ResultTEAssertions<T, E>>
+{
+    public ResultTEAssertions(Result<T, E> instance) : base(instance) { }
+
+    protected override string Identifier => "Result{T}";
+
+    /// <summary>
+    /// Asserts a result is a success.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTEAssertions<T, E>> Succeed(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsSuccess)
+            .FailWith("Expected Result to be successful but it failed");
+
+        return new AndConstraint<ResultTEAssertions<T, E>>(this);
+    }
+
+    /// <summary>
+    /// Asserts a result is a success with a specified value.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTEAssertions<T, E>> SucceedWith(T value, string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsSuccess)
+            .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<ResultTEAssertions<T, E>>(this);
+    }
+
+    /// <summary>
+    /// Asserts a result is a failure.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTEAssertions<T, E>> Fail(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
+            .FailWith("Expected Result to be failure but it succeeded");
+
+        return new AndConstraint<ResultTEAssertions<T, E>>(this);
+    }
+
+    /// <summary>
+    /// Asserts a result is a failure with a specified error.
+    /// </summary>
+    /// <param name="error"></param>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<ResultTEAssertions<T, E>> FailWith(E error, string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
+            .FailWith("Expected Result to be failure but it succeeded")
+            .Then
+            .Given(s => s.Error)
+            .ForCondition(e => e.Equals(error))
+            .FailWith("Excepted Result value to be {0} but found {1}", error, Subject.Error);
+
+        return new AndConstraint<ResultTEAssertions<T, E>>(this);
+    }
+}

src/CSharpFunctionalExtensions.FluentAssertions/ResultTExtensions.cs

@@ -25,15 +25,15 @@ public AndConstraint<ResultTAssertions<T>> Succeed(string because = "", params o
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
-            .Given(() => Subject.IsSuccess)
-            .ForCondition(isSuccess => isSuccess)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsSuccess)
             .FailWith("Expected Result to be successful but it failed");
 
         return new AndConstraint<ResultTAssertions<T>>(this);
     }
 
     /// <summary>
-    /// Asserts a result is a failure.
+    /// Asserts a result is a success with a specified value.
     /// </summary>
     /// <param name="value"></param>
     /// <param name="because"></param>
@@ -44,7 +44,7 @@ public AndConstraint<ResultTAssertions<T>> SucceedWith(T value, string because =
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject)
-            .ForCondition(isSuccess => Subject.IsSuccess)
+            .ForCondition(s => s.IsSuccess)
             .FailWith("Expected Result to be successful but it failed")
             .Then
             .Given(s => s.Value)
@@ -55,7 +55,7 @@ public AndConstraint<ResultTAssertions<T>> SucceedWith(T value, string because =
     }
 
     /// <summary>
-    /// 
+    /// Asserts a result is a failure
     /// </summary>
     /// <param name="because"></param>
     /// <param name="becauseArgs"></param>
@@ -64,8 +64,8 @@ public AndConstraint<ResultTAssertions<T>> Fail(string because = "", params obje
     {
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
-            .Given(() => Subject.IsFailure)
-            .ForCondition(isSuccess => isSuccess)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
             .FailWith("Expected Result to be failure but it succeeded");
 
         return new AndConstraint<ResultTAssertions<T>>(this);

src/CSharpFunctionalExtensions.FluentAssertions/UnitResultExtensions.cs

@@ -0,0 +1,72 @@
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using FluentAssertions;
+
+namespace CSharpFunctionalExtensions.FluentAssertions;
+public static class UnitResultExtensions
+{
+    public static UnitResultAssertions<E> Should<E>(this UnitResult<E> instance) => new(instance);
+}
+
+public class UnitResultAssertions<E> : ReferenceTypeAssertions<UnitResult<E>, UnitResultAssertions<E>>
+{
+    public UnitResultAssertions(UnitResult<E> instance) : base(instance) { }
+
+    protected override string Identifier => "Result";
+
+    /// <summary>
+    /// Asserts a unit result is a success.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<UnitResultAssertions<E>> Succeed(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsSuccess)
+            .FailWith("Expected UnitResult to be successful but it failed");
+
+        return new AndConstraint<UnitResultAssertions<E>>(this);
+    }
+
+    /// <summary>
+    /// Asserts a unit result is a failure.
+    /// </summary>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<UnitResultAssertions<E>> Fail(string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
+            .FailWith("Expected UnitResult to be failure but it succeeded");
+
+        return new AndConstraint<UnitResultAssertions<E>>(this);
+    }
+
+    /// <summary>
+    /// Asserts a unit result is a failure with a specfied error.
+    /// </summary>
+    /// <param name="error"></param>
+    /// <param name="because"></param>
+    /// <param name="becauseArgs"></param>
+    /// <returns></returns>
+    public AndConstraint<UnitResultAssertions<E>> FailWith(E error, string because = "", params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .Given(() => Subject)
+            .ForCondition(s => s.IsFailure)
+            .FailWith("Expected UnitResult to be failure but it succeeded")
+            .Then
+            .Given(s => s.Error)
+            .ForCondition(e => e.Equals(error))
+            .FailWith("Excepted UnitResult value to be {0} but found {1}", error, Subject.Error);
+
+        return new AndConstraint<UnitResultAssertions<E>>(this);
+    }
+}

tests/CSharpFunctionalExtensions.FluentAssertions.Tests/MaybeAssertionsTests.cs

@@ -7,15 +7,15 @@ namespace CSharpFunctionalExtensions.FluentAssertions.Tests;
 public class MaybeAssertionsTests
 {
     [Fact]
-    public void When_Maybe_Is_Expected_To_Have_Value_And_It_Does_Should_Not_Throw()
+    public void WhenMaybeIsExpectedToHaveValueAndItDoesShouldNotThrow()
     {
         var x = Maybe.From("test");
 
         x.Should().HaveValue("test");
     }
 
     [Fact]
-    public void When_Maybe_Is_Expected_To_Have_Value_And_It_Has_Wrong_Value_Should_Throw()
+    public void WhenMaybeIsExpectedToHaveValueAndItHasWrongValueShouldThrow()
     {
         var x = Maybe.From("oops");
 
@@ -25,7 +25,7 @@ public void When_Maybe_Is_Expected_To_Have_Value_And_It_Has_Wrong_Value_Should_T
     }
 
     [Fact]
-    public void When_Maybe_Is_Expected_To_Have_Value_And_It_Does_Not_Should_Throw()
+    public void WhenMaybeIsExpectedToHaveValueAndItDoesNotShouldThrow()
     {
         Maybe<string> x = null;
 
@@ -35,15 +35,15 @@ public void When_Maybe_Is_Expected_To_Have_Value_And_It_Does_Not_Should_Throw()
     }
 
     [Fact]
-    public void When_Maybe_Is_Expected_To_Have_No_Value_And_It_Has_None_Should_Not_Throw()
+    public void WhenMaybeIsExpectedToHaveNoValueAndItHasNoneShouldNotThrow()
     {
         Maybe<string> x = null;
 
         x.Should().HaveNoValue();
     }
 
     [Fact]
-    public void When_Maybe_Is_Expected_To_Have_No_Value_And_It_Has_One_Should_Throw()
+    public void WhenMaybeIsExpectedToHaveNoValueAndItHasOneShouldThrow()
     {
         var x = Maybe.From("test");
 

tests/CSharpFunctionalExtensions.FluentAssertions.Tests/ResultAssertionTests.cs

@@ -7,15 +7,15 @@ namespace CSharpFunctionalExtensions.FluentAssertions.Tests;
 public class ResultAssertionTests
 {
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful()
+    public void WhenResultIsExpectedToHaveValueItShouldBeSuccessful()
     {
         var x = Result.Success();
 
         x.Should().Succeed();
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
+    public void WhenResultIsExpectedToHaveValueItShouldNotBeFailure()
     {
         var x = Result.Success();
 
@@ -25,15 +25,15 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Error_It_Should_Not_Be_Failure()
+    public void WhenResultIsExpectedToHaveErrorItShouldNotBeFailure()
     {
         var x = Result.Failure("error");
 
         x.Should().Fail();
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Error_It_Should_Be_Failure()
+    public void WhenResultIsExpectedToHaveErrorItShouldBeFailure()
     {
         var x = Result.Failure("error");
 

tests/CSharpFunctionalExtensions.FluentAssertions.Tests/ResultTAssertionsTests.cs

@@ -7,15 +7,15 @@ namespace CSharpFunctionalExtensions.FluentAssertions.Tests;
 public class ResultAssertionsTests
 {
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful()
+    public void WhenResultIsExpectedToHaveValueItShouldBeSuccessful()
     {
         var x = Result.Success("test");
 
         x.Should().Succeed();
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
+    public void WhenResultIsExpectedToHaveValueItShouldNotBeFailure()
     {
         var x = Result.Success("test");
 
@@ -25,7 +25,7 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Failure()
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful_With_Value()
+    public void WhenResultIsExpectedToHaveValueItShouldBeSuccessfulWithValue()
     {
         string expected = "test";
         var x = Result.Success(expected);
@@ -34,7 +34,7 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Be_Successful_With_V
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Successful_With_Different_Value()
+    public void WhenResultIsExpectedToHaveValueItShouldNotBeSuccessfulWithDifferentValue()
     {
         var x = Result.Success("foo");
 
@@ -44,15 +44,15 @@ public void When_Result_Is_Expected_To_Have_Value_It_Should_Not_Be_Successful_Wi
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Error_It_Should_Not_Be_Failure()
+    public void WhenResultIsExpectedToHaveErrorItShouldNotBeFailure()
     {
         var x = Result.Failure<string>("error");
 
         x.Should().Fail();
     }
 
     [Fact]
-    public void When_Result_Is_Expected_To_Have_Error_It_Should_Be_Failure()
+    public void WhenResultIsExpectedToHaveErrorItShouldBeFailure()
     {
         var x = Result.Failure<string>("error");