Add call Then after ThenAsync extension method

amantinband · Jan 5, 2024 · da73db4 · da73db4
1 parent efc42dc
commit da73db4
Show file tree

Hide file tree

Showing 7 changed files with 317 additions and 282 deletions.
diff --git a/src/ErrorOrExtensions.cs b/src/ErrorOrExtensions.cs
@@ -17,6 +17,21 @@ public static class ErrorOrExtensions
         return result.Then(onValue);
     }
 
+    /// <summary>
+    /// If the state of <paramref name="errorOr"/> is a value, the provided function <paramref name="onValue"/> is executed and its result is returned.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TNextResult">The type of the next result.</typeparam>
+    /// <param name="errorOr">The error.</param>
+    /// <param name="onValue">The function to execute if the state is a value.</param>
+    /// <returns>The result from calling <paramref name="onValue"/> if state is value; otherwise the original errors.</returns>
+    public static async Task<ErrorOr<TNextResult>> Then<TResult, TNextResult>(this Task<ErrorOr<TResult>> errorOr, Func<TResult, TNextResult> onValue)
+    {
+        var result = await errorOr.ConfigureAwait(false);
+
+        return result.Then(onValue);
+    }
+
     /// <summary>
     /// If the state of <paramref name="errorOr"/> is a value, the provided function <paramref name="onValue"/> is executed asynchronously and its result is returned.
     /// </summary>

diff --git a/tests/ErrorOr.MatchAsyncTests.cs b/tests/ErrorOr.MatchAsyncTests.cs
@@ -1,98 +1,98 @@
-using ErrorOr;
-using FluentAssertions;
-
-namespace Tests;
-
-public class MatchAsyncTests
-{
-    private record Person(string Name);
-
-    [Fact]
-    public async Task MatchAsyncErrorOr_WhenHasValue_ShouldExecuteOnValueAction()
-    {
-        // Arrange
-        ErrorOr<Person> errorOrPerson = new Person("Amichai");
-        Task<string> OnValueAction(Person person)
-        {
-            person.Should().BeEquivalentTo(errorOrPerson.Value);
-            return Task.FromResult("Nice");
-        }
-
-        Task<string> OnErrorsAction(IReadOnlyList<Error> _) => throw new Exception("Should not be called");
-
-        // Act
-        var action = async () => await errorOrPerson.MatchAsync(
-            OnValueAction,
-            OnErrorsAction);
-
-        // Assert
-        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
-    }
-
-    [Fact]
-    public async Task MatchAsyncErrorOr_WhenHasError_ShouldExecuteOnErrorAction()
-    {
-        // Arrange
-        ErrorOr<Person> errorOrPerson = new List<Error> { Error.Validation(), Error.Conflict() };
-        Task<string> OnValueAction(Person _) => throw new Exception("Should not be called");
-
-        Task<string> OnErrorsAction(IReadOnlyList<Error> errors)
-        {
-            errors.Should().BeEquivalentTo(errorOrPerson.Errors);
-            return Task.FromResult("Nice");
-        }
-
-        // Act
-        var action = async () => await errorOrPerson.MatchAsync(
-            OnValueAction,
-            OnErrorsAction);
-
-        // Assert
-        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
-    }
-
-    [Fact]
-    public async Task MatchFirstAsyncErrorOr_WhenHasValue_ShouldExecuteOnValueAction()
-    {
-        // Arrange
-        ErrorOr<Person> errorOrPerson = new Person("Amichai");
-        Task<string> OnValueAction(Person person)
-        {
-            person.Should().BeEquivalentTo(errorOrPerson.Value);
-            return Task.FromResult("Nice");
-        }
-
-        Task<string> OnFirstErrorAction(Error _) => throw new Exception("Should not be called");
-
-        // Act
-        var action = async () => await errorOrPerson.MatchFirstAsync(
-            OnValueAction,
-            OnFirstErrorAction);
-
-        // Assert
-        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
-    }
-
-    [Fact]
-    public async Task MatchFirstAsyncErrorOr_WhenHasError_ShouldExecuteOnFirstErrorAction()
-    {
-        // Arrange
-        ErrorOr<Person> errorOrPerson = new List<Error> { Error.Validation(), Error.Conflict() };
-        Task<string> OnValueAction(Person _) => throw new Exception("Should not be called");
-        Task<string> OnFirstErrorAction(Error errors)
-        {
-            errors.Should().BeEquivalentTo(errorOrPerson.Errors[0])
-                .And.BeEquivalentTo(errorOrPerson.FirstError);
-
-            return Task.FromResult("Nice");
-        }
-
-        // Act
-        var action = async () => await errorOrPerson.MatchFirstAsync(
-            OnValueAction,
-            OnFirstErrorAction);
-
-        // Assert
-        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
-    }
-}
+using ErrorOr;
+using FluentAssertions;
+
+namespace Tests;
+
+public class MatchAsyncTests
+{
+    private record Person(string Name);
+
+    [Fact]
+    public async Task MatchAsyncErrorOr_WhenIsSuccess_ShouldExecuteOnValueAction()
+    {
+        // Arrange
+        ErrorOr<Person> errorOrPerson = new Person("Amichai");
+        Task<string> OnValueAction(Person person)
+        {
+            person.Should().BeEquivalentTo(errorOrPerson.Value);
+            return Task.FromResult("Nice");
+        }
+
+        Task<string> OnErrorsAction(IReadOnlyList<Error> _) => throw new Exception("Should not be called");
+
+        // Act
+        var action = async () => await errorOrPerson.MatchAsync(
+            OnValueAction,
+            OnErrorsAction);
+
+        // Assert
+        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
+    }
+
+    [Fact]
+    public async Task MatchAsyncErrorOr_WhenIsError_ShouldExecuteOnErrorAction()
+    {
+        // Arrange
+        ErrorOr<Person> errorOrPerson = new List<Error> { Error.Validation(), Error.Conflict() };
+        Task<string> OnValueAction(Person _) => throw new Exception("Should not be called");
+
+        Task<string> OnErrorsAction(IReadOnlyList<Error> errors)
+        {
+            errors.Should().BeEquivalentTo(errorOrPerson.Errors);
+            return Task.FromResult("Nice");
+        }
+
+        // Act
+        var action = async () => await errorOrPerson.MatchAsync(
+            OnValueAction,
+            OnErrorsAction);
+
+        // Assert
+        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
+    }
+
+    [Fact]
+    public async Task MatchFirstAsyncErrorOr_WhenIsSuccess_ShouldExecuteOnValueAction()
+    {
+        // Arrange
+        ErrorOr<Person> errorOrPerson = new Person("Amichai");
+        Task<string> OnValueAction(Person person)
+        {
+            person.Should().BeEquivalentTo(errorOrPerson.Value);
+            return Task.FromResult("Nice");
+        }
+
+        Task<string> OnFirstErrorAction(Error _) => throw new Exception("Should not be called");
+
+        // Act
+        var action = async () => await errorOrPerson.MatchFirstAsync(
+            OnValueAction,
+            OnFirstErrorAction);
+
+        // Assert
+        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
+    }
+
+    [Fact]
+    public async Task MatchFirstAsyncErrorOr_WhenIsError_ShouldExecuteOnFirstErrorAction()
+    {
+        // Arrange
+        ErrorOr<Person> errorOrPerson = new List<Error> { Error.Validation(), Error.Conflict() };
+        Task<string> OnValueAction(Person _) => throw new Exception("Should not be called");
+        Task<string> OnFirstErrorAction(Error errors)
+        {
+            errors.Should().BeEquivalentTo(errorOrPerson.Errors[0])
+                .And.BeEquivalentTo(errorOrPerson.FirstError);
+
+            return Task.FromResult("Nice");
+        }
+
+        // Act
+        var action = async () => await errorOrPerson.MatchFirstAsync(
+            OnValueAction,
+            OnFirstErrorAction);
+
+        // Assert
+        (await action.Should().NotThrowAsync()).Subject.Should().Be("Nice");
+    }
+}