refactor: prevent exceptions in monads

Vonage · Nov 21, 2023 · c26cdbb · c26cdbb
1 parent 55a09bc
commit c26cdbb
Show file tree

Hide file tree

Showing 2 changed files with 75 additions and 25 deletions.
diff --git a/Vonage.Common.Test/Monads/ResultTest.cs b/Vonage.Common.Test/Monads/ResultTest.cs
@@ -7,6 +7,20 @@ namespace Vonage.Common.Test.Monads
 {
     public class ResultTest
     {
+        [Fact]
+        public void Bind_ShouldReturnFailure_GivenOperationThrowsException()
+        {
+            var expectedException = new Exception("Error");
+            CreateSuccess(5)
+                .Bind(value =>
+                {
+                    throw expectedException;
+                    return Result<int>.FromSuccess(value);
+                })
+                .Should()
+                .BeFailure(SystemFailure.FromException(expectedException));
+        }
+
         [Fact]
         public void Bind_ShouldReturnFailure_GivenValueIsFailure() =>
             CreateFailure()
@@ -21,6 +35,20 @@ public void Bind_ShouldReturnSuccess_GivenValueIsSuccess() =>
                 .Should()
                 .BeSuccess(6);
 
+        [Fact]
+        public async Task BindAsync_ShouldReturnFailure_GivenOperationThrowsException()
+        {
+            var expectedException = new Exception("Error");
+            (await CreateSuccess(5)
+                    .BindAsync(value =>
+                    {
+                        throw expectedException;
+                        return Task.FromResult(Result<int>.FromSuccess(value));
+                    }))
+                .Should()
+                .BeFailure(SystemFailure.FromException(expectedException));
+        }
+
         [Fact]
         public async Task BindAsync_ShouldReturnFailure_GivenValueBecomesFailure() =>
             (await CreateSuccess(5)
@@ -315,13 +343,6 @@ public void ImplicitOperator_ShouldConvertToSuccess_GivenValueIsSuccess()
             result.Should().BeSuccess(value);
         }
 
-        [Fact]
-        public void Map_ShouldReturnFailure_GivenValueIsFailure() =>
-            CreateFailure()
-                .Map(Increment)
-                .Should()
-                .BeFailure(CreateResultFailure());
-
         [Fact]
         public void Map_ShouldReturnFailure_GivenOperationThrowsException()
         {
@@ -336,13 +357,34 @@ public void Map_ShouldReturnFailure_GivenOperationThrowsException()
                 .BeFailure(SystemFailure.FromException(expectedException));
         }
 
+        [Fact]
+        public void Map_ShouldReturnFailure_GivenValueIsFailure() =>
+            CreateFailure()
+                .Map(Increment)
+                .Should()
+                .BeFailure(CreateResultFailure());
+
         [Fact]
         public void Map_ShouldReturnSuccess_GivenValueIsSuccess() =>
             CreateSuccess(5)
                 .Map(Increment)
                 .Should()
                 .BeSuccess(6);
 
+        [Fact]
+        public async Task MapAsync_ShouldReturnFailure_GivenOperationThrowsException()
+        {
+            var expectedException = new Exception("Error");
+            (await CreateSuccess(5)
+                    .MapAsync(value =>
+                    {
+                        throw expectedException;
+                        return Task.FromResult(value);
+                    }))
+                .Should()
+                .BeFailure(SystemFailure.FromException(expectedException));
+        }
+
         [Fact]
         public async Task MapAsync_ShouldReturnFailure_GivenValueIsChainedFailure() =>
             (await CreateFailure()
@@ -360,20 +402,6 @@ public async Task MapAsync_ShouldReturnFailure_GivenValueIsFailure() =>
                 .MapAsync(IncrementAsync))
             .Should()
             .BeFailure(CreateResultFailure());
-
-        [Fact]
-        public async Task MapAsync_ShouldReturnFailure_GivenOperationThrowsException()
-        {
-            var expectedException = new Exception("Error");
-            (await CreateSuccess(5)
-                .MapAsync(value =>
-                {
-                    throw expectedException;
-                    return Task.FromResult(value);
-                }))
-                .Should()
-                .BeFailure(SystemFailure.FromException(expectedException));
-        }
 
         [Fact]
         public async Task MapAsync_ShouldReturnSuccess_GivenValueIsChainedSuccess() =>

diff --git a/Vonage.Common/Monads/Result.cs b/Vonage.Common/Monads/Result.cs
@@ -52,17 +52,39 @@ private Result(IResultFailure failure)
     /// <param name="bind">Bind operation.</param>
     /// <typeparam name="TB">Return type.</typeparam>
     /// <returns>Bound functor.</returns>
-    public Result<TB> Bind<TB>(Func<T, Result<TB>> bind) =>
-        this.IsFailure ? Result<TB>.FromFailure(this.failure) : bind(this.success);
+    public Result<TB> Bind<TB>(Func<T, Result<TB>> bind)
+    {
+        try
+        {
+            return this.IsFailure
+                ? Result<TB>.FromFailure(this.failure)
+                : bind(this.success);
+        }
+        catch (Exception exception)
+        {
+            return SystemFailure.FromException(exception).ToResult<TB>();
+        }
+    }
 
     /// <summary>
     ///     Monadic bind operation.
     /// </summary>
     /// <param name="bind">Asynchronous bind operation.</param>
     /// <typeparam name="TB">Return type.</typeparam>
     /// <returns>Asynchronous bound functor.</returns>
-    public async Task<Result<TB>> BindAsync<TB>(Func<T, Task<Result<TB>>> bind) =>
-        this.IsFailure ? Result<TB>.FromFailure(this.failure) : await bind(this.success);
+    public async Task<Result<TB>> BindAsync<TB>(Func<T, Task<Result<TB>>> bind) 
+    {
+        try
+        {
+            return this.IsFailure
+                ? Result<TB>.FromFailure(this.failure)
+                : await bind(this.success);
+        }
+        catch (Exception exception)
+        {
+            return SystemFailure.FromException(exception).ToResult<TB>();
+        }
+    }
 
     /// <inheritdoc />
     public override bool Equals(object obj) => obj is Result<T> result && this.Equals(result);