Merge pull request #335 from SamuelViesselman/master

MapError UnitResult Additions

Author: vkhorikov

CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorAsyncLeftTests.cs

@@ -39,6 +39,39 @@ public async Task MapError_returns_new_failure()
             invocations.Should().Be(1);
         }
 
+        [Fact]
+        public async Task MapError_returns_unit_result_succcess()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            var invocations = 0;
+
+            UnitResult<E> actual = await result.MapError(error =>
+            {
+                invocations++;
+                return E.Value;
+            });
+
+            actual.IsSuccess.Should().BeTrue();
+            invocations.Should().Be(0);
+        }
+
+        [Fact]
+        public async Task MapError_returns_new_unit_result_failure()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            var invocations = 0;
+
+            UnitResult<E> actual = await result.MapError(error =>
+            {
+                invocations++;
+                return E.Value;
+            });
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            invocations.Should().Be(1);
+        }
+
         [Fact]
         public async Task MapError_T_returns_success()
         {
@@ -73,6 +106,41 @@ public async Task MapError_T_returns_new_failure()
             invocations.Should().Be(1);
         }
 
+        [Fact]
+        public async Task MapError_unit_result_returns_success()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            var invocations = 0;
+
+            Result actual = await result.MapError(error =>
+            {
+                invocations++;
+                return $"{error} {error}";
+            });
+
+            actual.IsSuccess.Should().BeTrue();
+            invocations.Should().Be(0);
+        }
+
+        [Fact]
+        public async Task MapError_unit_result_returns_new_failure()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            var invocations = 0;
+
+            Result actual = await result.MapError(error =>
+            {
+                error.Should().Be(E.Value);
+
+                invocations++;
+                return "error";
+            });
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be("error");
+            invocations.Should().Be(1);
+        }
+
         [Fact]
         public async Task MapError_T_E_returns_success()
         {

CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.cs

@@ -38,6 +38,39 @@ public void MapError_returns_new_failure()
             invocations.Should().Be(1);
         }
 
+        [Fact]
+        public void MapError_returns_unit_result_succcess()
+        {
+            Result result = Result.Success();
+            var invocations = 0;
+
+            UnitResult<E> actual = result.MapError(error =>
+            {
+                invocations++;
+                return E.Value;
+            });
+
+            actual.IsSuccess.Should().BeTrue();
+            invocations.Should().Be(0);
+        }
+
+        [Fact]
+        public void MapError_returns_new_unit_result_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            var invocations = 0;
+
+            UnitResult<E> actual = result.MapError(error =>
+            {
+                invocations++;
+                return E.Value;
+            });
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            invocations.Should().Be(1);
+        }
+
         [Fact]
         public void MapError_T_returns_success()
         {
@@ -72,6 +105,41 @@ public void MapError_T_returns_new_failure()
             invocations.Should().Be(1);
         }
 
+        [Fact]
+        public void MapError_unit_result_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            var invocations = 0;
+
+            Result actual = result.MapError(error =>
+            {
+                invocations++;
+                return $"{error} {error}";
+            });
+
+            actual.IsSuccess.Should().BeTrue();
+            invocations.Should().Be(0);
+        }
+
+        [Fact]
+        public void MapError_unit_result_returns_new_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            var invocations = 0;
+
+            Result actual = result.MapError(error =>
+            {
+                error.Should().Be(E.Value);
+
+                invocations++;
+                return "error";
+            });
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be("error");
+            invocations.Should().Be(1);
+        }
+
         [Fact]
         public void MapError_T_E_returns_success()
         {

CSharpFunctionalExtensions/Result/Extensions/MapError.cs

@@ -18,7 +18,18 @@ public static Result MapError(this Result result, Func<string, string> errorFact
         /// <summary>
         ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
         /// </summary>
-        public static Result<T> MapError<T>(this Result<T> result, Func<string, string> errorFactory)
+        public static UnitResult<E> MapError<E>(this Result result, Func<string, E> errorFactory) 
+        {
+            if (result.IsFailure)
+                return UnitResult.Failure(errorFactory(result.Error));
+
+            return UnitResult.Success<E>();
+        }
+
+        /// <summary>
+        ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
+        /// </summary>
+        public static Result<T> MapError<T>(this Result<T> result, Func<string, string> errorFactory) 
         {
             if (result.IsFailure)
                 return Result.Failure<T>(errorFactory(result.Error));
@@ -40,14 +51,25 @@ public static Result<T, E> MapError<T, E>(this Result<T> result, Func<string, E>
         /// <summary>
         ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
         /// </summary>
-        public static Result<T> MapError<T, E>(this Result<T, E> result, Func<E, string> errorFactory)
+        public static Result MapError<E>(this UnitResult<E> result, Func<E, string> errorFactory) 
+        {
+            if (result.IsFailure)
+                return Result.Failure(errorFactory(result.Error));
+
+            return Result.Success();
+        }
+
+        /// <summary>
+        ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
+        /// </summary>
+        public static Result<T> MapError<T, E>(this Result<T, E> result, Func<E, string> errorFactory) 
         {
             if (result.IsFailure)
                 return Result.Failure<T>(errorFactory(result.Error));
 
             return Result.Success(result.Value);
         }
-        
+
         /// <summary>
         ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
         /// </summary>

CSharpFunctionalExtensions/Result/Extensions/MapErrorAsyncLeft.cs

@@ -15,6 +15,16 @@ public static async Task<Result> MapError(this Task<Result> resultTask, Func<str
             return result.MapError(errorFactory);
         }
 
+        /// <summary>
+        ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
+        /// </summary>
+        public static async Task<UnitResult<E>> MapError<E>(this Task<Result> resultTask, Func<string, E> errorFactory)
+        {
+            var result = await resultTask.DefaultAwait();
+
+            return result.MapError(errorFactory);
+        }
+
         /// <summary>
         ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
         /// </summary>
@@ -35,6 +45,16 @@ public static async Task<Result<T, E>> MapError<T, E>(this Task<Result<T>> resul
             return result.MapError(errorFactory);
         }
 
+        /// <summary>
+        ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
+        /// </summary>
+        public static async Task<Result> MapError<E>(this Task<UnitResult<E>> resultTask, Func<E, string> errorFactory) 
+        {
+            var result = await resultTask.DefaultAwait();
+
+            return result.MapError(errorFactory);
+        }
+
         /// <summary>
         ///     If the calling Result is a success, a new success result is returned. Otherwise, creates a new failure result from the return value of a given function.
         /// </summary>