Add UnitResult and ResultTE extensions

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>> Fail(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);
+    }
+}