Feature: Add UnitResult{E} assertions/test

src/FluentAssertions.CSharpFunctionalExtensions.Spec/UnitResultEAssertionsSpec.cs

@@ -0,0 +1,73 @@
+using CSharpFunctionalExtensions;
+using System;
+using System.Text;
+using Xunit;
+using Xunit.Sdk;
+
+namespace FluentAssertions.CSharpFunctionalExtensions.Spec
+{
+    public class UnitUnitResultEAssertionsSpec
+    {
+        private readonly DummyError _dummyError = new DummyError
+        {
+            TheError = "This is the error"
+        };
+
+        [Fact]
+        public void When_result_is_expected_to_be_success_and_it_is_should_not_throw()
+        {
+            // Arrange
+            var subject = UnitResult.Success<DummyError>();
+
+            // Act / Assert
+            subject.Should().BeSuccess();
+        }
+
+        [Fact]
+        public void When_result_is_expected_to_be_success_and_it_is_not_should_throw()
+        {
+            // Arrange
+            var subject = UnitResult.Failure(_dummyError);
+
+            // Act
+            Action act = () => subject.Should().BeSuccess("Success means {0}", "it works");
+
+            // Assert
+            var expectedErrorMessageBuilder = new StringBuilder();
+            expectedErrorMessageBuilder.AppendLine(
+                "Expected subject to be Success because Success means it works, but it is failure with error ");
+            expectedErrorMessageBuilder.AppendLine();
+            expectedErrorMessageBuilder.AppendLine(typeof(DummyError).FullName);
+            expectedErrorMessageBuilder.AppendLine("{");
+            expectedErrorMessageBuilder.AppendLine("   TheError = \"This is the error\"");
+            expectedErrorMessageBuilder.Append("}");
+
+            var expectedErrorMessage = expectedErrorMessageBuilder.ToString();
+            act.Should().Throw<XunitException>().WithMessage(expectedErrorMessage);
+        }
+
+        [Fact]
+        public void When_result_is_expected_to_be_failure_and_it_is_should_not_throw()
+        {
+            // Arrange
+            var subject = UnitResult.Failure(_dummyError);
+
+            // Act / Assert
+            subject.Should().BeFailure();
+        }
+
+        [Fact]
+        public void When_result_is_expected_to_be_failure_and_it_is_not_should_throw()
+        {
+            // Arrange
+            var subject = UnitResult.Success<DummyError>();
+
+            // Act
+            Action act = () => subject.Should().BeFailure("this operation {0}", "should not work");
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage(
+                $"Expected subject to be Failure because this operation should not work, but it is Success");
+        }
+    }
+}

src/FluentAssertions.CSharpFunctionalExtensions/Extensions.cs

@@ -18,5 +18,10 @@ public static ResultTEAssertions<T, E> Should<T, E>(this Result<T, E> subject)
         {
             return new ResultTEAssertions<T, E>(subject);
         }
+
+        public static UnitResultEAssertions<E> Should<E>(this UnitResult<E> subject)
+        {
+            return new UnitResultEAssertions<E>(subject);
+        }
     }
 }

src/FluentAssertions.CSharpFunctionalExtensions/FluentAssertions.CSharpFunctionalExtensions.csproj

@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="CSharpFunctionalExtensions" Version="2.3.0" />
+    <PackageReference Include="CSharpFunctionalExtensions" Version="2.19.0" />
     <PackageReference Include="FluentAssertions" Version="5.10.2" />
   </ItemGroup>
 

src/FluentAssertions.CSharpFunctionalExtensions/UnitResultEAssertions.cs

@@ -0,0 +1,18 @@
+using CSharpFunctionalExtensions;
+using FluentAssertions.Execution;
+using System;
+
+namespace FluentAssertions.CSharpFunctionalExtensions
+{
+    public class UnitResultEAssertions<E> : BaseResultAssertions<UnitResult<E>>
+    {
+        public UnitResultEAssertions(UnitResult<E> subject) : base(subject)
+        {
+        }
+
+        protected override Func<FailReason> GetErrorMessageFromSubject()
+        {
+            return () => new FailReason($"Expected {{context:result}} to be Success{{reason}}, but it is failure with error {{0}}", Subject.Error);
+        }
+    }
+}