diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Left.cs index 2144b700..a30305a6 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Left.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Left.cs @@ -6,6 +6,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapErrorTests_Task_Left : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_Task_Left_returns_success() { @@ -22,6 +24,26 @@ public async Task MapError_Task_Left_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_returns_success_with_context() + { + Task result = Result.Success().AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_returns_new_failure() { @@ -39,6 +61,27 @@ public async Task MapError_Task_Left_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_returns_new_failure_with_context() + { + Task result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_returns_UnitResult_success() { @@ -55,6 +98,26 @@ public async Task MapError_Task_Left_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_returns_UnitResult_success_with_context() + { + Task result = Result.Success().AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_returns_new_UnitResult_failure() { @@ -72,6 +135,27 @@ public async Task MapError_Task_Left_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_returns_new_UnitResult_failure_with_context() + { + Task result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_T_returns_success() { @@ -89,6 +173,27 @@ public async Task MapError_Task_Left_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_T_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_T_returns_new_failure() { @@ -106,6 +211,27 @@ public async Task MapError_Task_Left_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_T_returns_new_failure_with_context() + { + Task> result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_UnitResult_returns_success() { @@ -122,6 +248,26 @@ public async Task MapError_Task_Left_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_UnitResult_returns_success_with_context() + { + Task> result = UnitResult.Success().AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_UnitResult_returns_new_failure() { @@ -131,7 +277,6 @@ public async Task MapError_Task_Left_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "error"; }); @@ -141,6 +286,28 @@ public async Task MapError_Task_Left_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_UnitResult_returns_new_failure_with_context() + { + Task> result = UnitResult.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_E_UnitResult_returns_success() { @@ -157,6 +324,26 @@ public async Task MapError_Task_Left_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_E_UnitResult_returns_success_with_context() + { + Task> result = UnitResult.Success().AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_E_UnitResult_returns_new_failure() { @@ -166,7 +353,6 @@ public async Task MapError_Task_Left_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -176,6 +362,28 @@ public async Task MapError_Task_Left_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_E_UnitResult_returns_new_failure_with_context() + { + Task> result = UnitResult.Failure(E.Value).AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_T_E_returns_success() { @@ -193,6 +401,27 @@ public async Task MapError_Task_Left_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_T_E_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_T_E_returns_new_failure() { @@ -202,7 +431,6 @@ public async Task MapError_Task_Left_T_E_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return E.Value; }); @@ -212,6 +440,28 @@ public async Task MapError_Task_Left_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_T_E_returns_new_failure_with_context() + { + Task> result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_T_E_string_returns_success() { @@ -229,6 +479,27 @@ public async Task MapError_Task_Left_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_T_E_string_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_T_E_E2_returns_success() { @@ -246,6 +517,27 @@ public async Task MapError_Task_Left_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Left_T_E_E2_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Left_T_E_string_returns_new_failure() { @@ -255,7 +547,6 @@ public async Task MapError_Task_Left_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "string"; }); @@ -265,6 +556,28 @@ public async Task MapError_Task_Left_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Left_T_E_string_returns_new_failure_with_context() + { + Task> result = Result.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "string"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("string"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Left_T_E_E2_returns_new_failure() { @@ -274,7 +587,6 @@ public async Task MapError_Task_Left_T_E_E2_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -283,5 +595,27 @@ public async Task MapError_Task_Left_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_Task_Left_T_E_E2_returns_new_failure_with_context() + { + Task> result = Result.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Right.cs index 63464742..73a1657b 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Right.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.Right.cs @@ -6,6 +6,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapErrorTests_Task_Right : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_Task_Right_returns_success() { @@ -22,6 +24,26 @@ public async Task MapError_Task_Right_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_returns_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_returns_new_failure() { @@ -39,6 +61,27 @@ public async Task MapError_Task_Right_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_returns_UnitResult_success() { @@ -55,6 +98,26 @@ public async Task MapError_Task_Right_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_returns_UnitResult_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_returns_new_UnitResult_failure() { @@ -72,6 +135,27 @@ public async Task MapError_Task_Right_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_returns_new_UnitResult_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_T_returns_success() { @@ -89,6 +173,27 @@ public async Task MapError_Task_Right_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_T_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_T_returns_new_failure() { @@ -106,6 +211,27 @@ public async Task MapError_Task_Right_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_T_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_UnitResult_returns_success() { @@ -122,6 +248,26 @@ public async Task MapError_Task_Right_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_UnitResult_returns_new_failure() { @@ -131,7 +277,6 @@ public async Task MapError_Task_Right_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("error"); }); @@ -141,6 +286,28 @@ public async Task MapError_Task_Right_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_E_UnitResult_returns_success() { @@ -157,6 +324,26 @@ public async Task MapError_Task_Right_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_E_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_E_UnitResult_returns_new_failure() { @@ -166,7 +353,6 @@ public async Task MapError_Task_Right_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -176,6 +362,28 @@ public async Task MapError_Task_Right_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_E_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_T_E_returns_success() { @@ -193,16 +401,36 @@ public async Task MapError_Task_Right_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_T_E_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_T_E_returns_new_failure() { Result result = Result.Failure(ErrorMessage); var invocations = 0; - + Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return Task.FromResult(E.Value); }); @@ -212,6 +440,28 @@ public async Task MapError_Task_Right_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_T_E_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_T_E_string_returns_success() { @@ -229,6 +479,27 @@ public async Task MapError_Task_Right_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_T_E_string_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_T_E_E2_returns_success() { @@ -246,6 +517,27 @@ public async Task MapError_Task_Right_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_Right_T_E_E2_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_Right_T_E_string_returns_new_failure() { @@ -255,7 +547,6 @@ public async Task MapError_Task_Right_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("error"); }); @@ -265,6 +556,28 @@ public async Task MapError_Task_Right_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_Right_T_E_string_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_Right_T_E_E2_returns_new_failure() { @@ -274,7 +587,6 @@ public async Task MapError_Task_Right_T_E_E2_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -283,5 +595,27 @@ public async Task MapError_Task_Right_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_Task_Right_T_E_E2_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.cs index 9f376136..555d8397 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.Task.cs @@ -6,6 +6,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapError_Task_Tests : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_Task_returns_success() { @@ -22,6 +24,26 @@ public async Task MapError_Task_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_returns_success_with_context() + { + Task result = Result.Success().AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_returns_new_failure() { @@ -39,6 +61,27 @@ public async Task MapError_Task_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_returns_new_failure_with_context() + { + Task result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_returns_UnitResult_success() { @@ -55,6 +98,26 @@ public async Task MapError_Task_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_returns_UnitResult_success_with_context() + { + Task result = Result.Success().AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_returns_new_UnitResult_failure() { @@ -72,6 +135,27 @@ public async Task MapError_Task_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_returns_new_UnitResult_failure_with_context() + { + Task result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_T_returns_success() { @@ -89,6 +173,27 @@ public async Task MapError_Task_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_T_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_T_returns_new_failure() { @@ -106,6 +211,27 @@ public async Task MapError_Task_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_T_returns_new_failure_with_context() + { + Task> result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_UnitResult_returns_success() { @@ -122,6 +248,26 @@ public async Task MapError_Task_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_UnitResult_returns_success_with_context() + { + Task> result = UnitResult.Success().AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_UnitResult_returns_new_failure() { @@ -131,7 +277,6 @@ public async Task MapError_Task_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("error"); }); @@ -141,6 +286,28 @@ public async Task MapError_Task_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_UnitResult_returns_new_failure_with_context() + { + Task> result = UnitResult.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_E_UnitResult_returns_success() { @@ -157,6 +324,26 @@ public async Task MapError_Task_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_E_UnitResult_returns_success_with_context() + { + Task> result = UnitResult.Success().AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_E_UnitResult_returns_new_failure() { @@ -166,7 +353,6 @@ public async Task MapError_Task_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -176,6 +362,28 @@ public async Task MapError_Task_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_E_UnitResult_returns_new_failure_with_context() + { + Task> result = UnitResult.Failure(E.Value).AsTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_T_E_returns_success() { @@ -193,6 +401,27 @@ public async Task MapError_Task_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_T_E_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_T_E_returns_new_failure() { @@ -202,7 +431,6 @@ public async Task MapError_Task_T_E_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return Task.FromResult(E.Value); }); @@ -212,6 +440,28 @@ public async Task MapError_Task_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_T_E_returns_new_failure_with_context() + { + Task> result = Result.Failure(ErrorMessage).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_T_E_string_returns_success() { @@ -229,6 +479,27 @@ public async Task MapError_Task_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_T_E_string_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_T_E_E2_returns_success() { @@ -246,6 +517,27 @@ public async Task MapError_Task_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_Task_T_E_E2_returns_success_with_context() + { + Task> result = Result.Success(T.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_Task_T_E_string_returns_new_failure() { @@ -255,7 +547,6 @@ public async Task MapError_Task_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("string"); }); @@ -265,6 +556,28 @@ public async Task MapError_Task_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_Task_T_E_string_returns_new_failure_with_context() + { + Task> result = Result.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("string"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("string"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_Task_T_E_E2_returns_new_failure() { @@ -274,7 +587,6 @@ public async Task MapError_Task_T_E_E2_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -283,5 +595,27 @@ public async Task MapError_Task_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_Task_T_E_E2_returns_new_failure_with_context() + { + Task> result = Result.Failure(E.Value).AsTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Left.cs index 14ff2a00..ced86099 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Left.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Left.cs @@ -7,6 +7,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapErrorTests_ValueTask_Left : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_ValueTask_Left_returns_success() { @@ -23,6 +25,26 @@ public async Task MapError_ValueTask_Left_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_returns_success_with_context() + { + ValueTask result = Result.Success().AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_returns_new_failure() { @@ -40,6 +62,27 @@ public async Task MapError_ValueTask_Left_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_returns_new_failure_with_context() + { + ValueTask result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_returns_UnitResult_success() { @@ -56,6 +99,26 @@ public async Task MapError_ValueTask_Left_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_returns_UnitResult_success_with_context() + { + ValueTask result = Result.Success().AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_returns_new_UnitResult_failure() { @@ -73,6 +136,27 @@ public async Task MapError_ValueTask_Left_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_returns_new_UnitResult_failure_with_context() + { + ValueTask result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_T_returns_success() { @@ -90,6 +174,27 @@ public async Task MapError_ValueTask_Left_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_T_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_T_returns_new_failure() { @@ -107,6 +212,27 @@ public async Task MapError_ValueTask_Left_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_T_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_UnitResult_returns_success() { @@ -123,6 +249,26 @@ public async Task MapError_ValueTask_Left_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_UnitResult_returns_success_with_context() + { + ValueTask> result = UnitResult.Success().AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_UnitResult_returns_new_failure() { @@ -132,7 +278,6 @@ public async Task MapError_ValueTask_Left_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "error"; }); @@ -142,6 +287,28 @@ public async Task MapError_ValueTask_Left_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_UnitResult_returns_new_failure_with_context() + { + ValueTask> result = UnitResult.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_E_UnitResult_returns_success() { @@ -158,6 +325,26 @@ public async Task MapError_ValueTask_Left_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_E_UnitResult_returns_success_with_context() + { + ValueTask> result = UnitResult.Success().AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_E_UnitResult_returns_new_failure() { @@ -167,7 +354,6 @@ public async Task MapError_ValueTask_Left_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -177,6 +363,28 @@ public async Task MapError_ValueTask_Left_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_E_UnitResult_returns_new_failure_with_context() + { + ValueTask> result = UnitResult.Failure(E.Value).AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_returns_success() { @@ -194,6 +402,27 @@ public async Task MapError_ValueTask_Left_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_T_E_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_returns_new_failure() { @@ -203,7 +432,6 @@ public async Task MapError_ValueTask_Left_T_E_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return E.Value; }); @@ -213,6 +441,28 @@ public async Task MapError_ValueTask_Left_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_T_E_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_string_returns_success() { @@ -230,6 +480,27 @@ public async Task MapError_ValueTask_Left_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_T_E_string_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_E2_returns_success() { @@ -247,6 +518,27 @@ public async Task MapError_ValueTask_Left_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Left_T_E_E2_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_string_returns_new_failure() { @@ -256,7 +548,6 @@ public async Task MapError_ValueTask_Left_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "string"; }); @@ -266,6 +557,28 @@ public async Task MapError_ValueTask_Left_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Left_T_E_string_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "string"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("string"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Left_T_E_E2_returns_new_failure() { @@ -275,7 +588,6 @@ public async Task MapError_ValueTask_Left_T_E_E2_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -284,5 +596,27 @@ public async Task MapError_ValueTask_Left_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_ValueTask_Left_T_E_E2_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Right.cs index 84734697..81a635fa 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Right.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.Right.cs @@ -6,6 +6,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapErrorTests_ValueTask_Right : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_ValueTask_Right_returns_success() { @@ -22,6 +24,26 @@ public async Task MapError_ValueTask_Right_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_returns_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_returns_new_failure() { @@ -39,6 +61,27 @@ public async Task MapError_ValueTask_Right_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_returns_UnitResult_success() { @@ -55,6 +98,26 @@ public async Task MapError_ValueTask_Right_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_returns_UnitResult_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_returns_new_UnitResult_failure() { @@ -72,6 +135,27 @@ public async Task MapError_ValueTask_Right_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_returns_new_UnitResult_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_T_returns_success() { @@ -89,6 +173,27 @@ public async Task MapError_ValueTask_Right_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_T_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_T_returns_new_failure() { @@ -106,6 +211,27 @@ public async Task MapError_ValueTask_Right_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_T_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_UnitResult_returns_success() { @@ -122,6 +248,26 @@ public async Task MapError_ValueTask_Right_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult($"{error} {error}"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_UnitResult_returns_new_failure() { @@ -131,7 +277,6 @@ public async Task MapError_ValueTask_Right_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("error"); }); @@ -141,6 +286,28 @@ public async Task MapError_ValueTask_Right_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_E_UnitResult_returns_success() { @@ -157,6 +324,26 @@ public async Task MapError_ValueTask_Right_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_E_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_E_UnitResult_returns_new_failure() { @@ -166,7 +353,6 @@ public async Task MapError_ValueTask_Right_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -176,6 +362,28 @@ public async Task MapError_ValueTask_Right_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_E_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_returns_success() { @@ -193,16 +401,36 @@ public async Task MapError_ValueTask_Right_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_T_E_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_returns_new_failure() { Result result = Result.Failure(ErrorMessage); var invocations = 0; - + Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return Task.FromResult(E.Value); }); @@ -212,6 +440,28 @@ public async Task MapError_ValueTask_Right_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_T_E_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_string_returns_success() { @@ -229,6 +479,27 @@ public async Task MapError_ValueTask_Right_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_T_E_string_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_E2_returns_success() { @@ -246,6 +517,27 @@ public async Task MapError_ValueTask_Right_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_Right_T_E_E2_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_string_returns_new_failure() { @@ -255,7 +547,6 @@ public async Task MapError_ValueTask_Right_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult("error"); }); @@ -265,6 +556,28 @@ public async Task MapError_ValueTask_Right_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_Right_T_E_string_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult("error"); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_Right_T_E_E2_returns_new_failure() { @@ -274,7 +587,6 @@ public async Task MapError_ValueTask_Right_T_E_E2_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return Task.FromResult(E2.Value); }); @@ -283,5 +595,27 @@ public async Task MapError_ValueTask_Right_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_ValueTask_Right_T_E_E2_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return Task.FromResult(E2.Value); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.cs index 29d28338..488202e4 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.ValueTask.cs @@ -7,6 +7,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapError_ValueTask_Tests : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public async Task MapError_ValueTask_returns_success() { @@ -23,6 +25,26 @@ public async Task MapError_ValueTask_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_returns_success_with_context() + { + ValueTask result = Result.Success().AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_returns_new_failure() { @@ -40,6 +62,27 @@ public async Task MapError_ValueTask_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_returns_new_failure_with_context() + { + ValueTask result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_returns_UnitResult_success() { @@ -56,6 +99,26 @@ public async Task MapError_ValueTask_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_returns_UnitResult_success_with_context() + { + ValueTask result = Result.Success().AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_returns_new_UnitResult_failure() { @@ -73,6 +136,27 @@ public async Task MapError_ValueTask_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_returns_new_UnitResult_failure_with_context() + { + ValueTask result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_T_returns_success() { @@ -90,6 +174,27 @@ public async Task MapError_ValueTask_T_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_T_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_T_returns_new_failure() { @@ -107,6 +212,27 @@ public async Task MapError_ValueTask_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_T_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_UnitResult_returns_success() { @@ -123,6 +249,26 @@ public async Task MapError_ValueTask_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_UnitResult_returns_success_with_context() + { + ValueTask> result = UnitResult.Success().AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_UnitResult_returns_new_failure() { @@ -132,7 +278,6 @@ public async Task MapError_ValueTask_UnitResult_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "error".AsCompletedValueTask(); }); @@ -142,6 +287,28 @@ public async Task MapError_ValueTask_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_UnitResult_returns_new_failure_with_context() + { + ValueTask> result = UnitResult.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "error".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_E_UnitResult_returns_success() { @@ -158,6 +325,26 @@ public async Task MapError_ValueTask_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_E_UnitResult_returns_success_with_context() + { + ValueTask> result = UnitResult.Success().AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_E_UnitResult_returns_new_failure() { @@ -167,7 +354,6 @@ public async Task MapError_ValueTask_E_UnitResult_returns_new_failure() UnitResult actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value.AsCompletedValueTask(); }); @@ -177,6 +363,28 @@ public async Task MapError_ValueTask_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_E_UnitResult_returns_new_failure_with_context() + { + ValueTask> result = UnitResult.Failure(E.Value).AsValueTask(); + var invocations = 0; + + UnitResult actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_T_E_returns_success() { @@ -194,6 +402,27 @@ public async Task MapError_ValueTask_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_T_E_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_T_E_returns_new_failure() { @@ -203,7 +432,6 @@ public async Task MapError_ValueTask_T_E_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return E.Value.AsCompletedValueTask(); }); @@ -213,6 +441,28 @@ public async Task MapError_ValueTask_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public async Task MapError_ValueTask_T_E_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(ErrorMessage).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return E.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public async Task MapError_ValueTask_T_E_string_returns_success() { @@ -230,6 +480,27 @@ public async Task MapError_ValueTask_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_T_E_string_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return "error".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_T_E_E2_returns_success() { @@ -247,6 +518,27 @@ public async Task MapError_ValueTask_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public async Task MapError_ValueTask_T_E_E2_returns_success_with_context() + { + ValueTask> result = Result.Success(T.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public async Task MapError_ValueTask_T_E_string_returns_new_failure() { @@ -256,7 +548,6 @@ public async Task MapError_ValueTask_T_E_string_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "string".AsCompletedValueTask(); }); @@ -267,7 +558,29 @@ public async Task MapError_ValueTask_T_E_string_returns_new_failure() } [Fact] - public async Task MapError_T_E_E2_ValueTask_returns_new_failure() + public async Task MapError_ValueTask_T_E_string_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "string".AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("string"); + invocations.Should().Be(1); + } + + [Fact] + public async Task MapError_ValueTask_T_E_E2_returns_new_failure() { ValueTask> result = Result.Failure(E.Value).AsValueTask(); var invocations = 0; @@ -275,7 +588,6 @@ public async Task MapError_T_E_E2_ValueTask_returns_new_failure() Result actual = await result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value.AsCompletedValueTask(); }); @@ -284,5 +596,27 @@ public async Task MapError_T_E_E2_ValueTask_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public async Task MapError_ValueTask_T_E_E2_returns_new_failure_with_context() + { + ValueTask> result = Result.Failure(E.Value).AsValueTask(); + var invocations = 0; + + Result actual = await result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value.AsCompletedValueTask(); + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.cs index 458eb122..d1faf62d 100644 --- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.cs +++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapErrorTests.cs @@ -5,6 +5,8 @@ namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions { public class MapErrorTests : TestBase { + private const string ContextMessage = "Context-specific error"; + [Fact] public void MapError_returns_success() { @@ -21,6 +23,26 @@ public void MapError_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_returns_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public void MapError_returns_new_failure() { @@ -38,6 +60,27 @@ public void MapError_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public void MapError_returns_UnitResult_success() { @@ -54,6 +97,26 @@ public void MapError_returns_UnitResult_success() invocations.Should().Be(0); } + [Fact] + public void MapError_returns_UnitResult_success_with_context() + { + Result result = Result.Success(); + var invocations = 0; + + UnitResult actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public void MapError_returns_new_UnitResult_failure() { @@ -71,6 +134,27 @@ public void MapError_returns_new_UnitResult_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_returns_new_UnitResult_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + UnitResult actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public void MapError_T_returns_success() { @@ -88,6 +172,27 @@ public void MapError_T_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_T_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public void MapError_T_returns_new_failure() { @@ -105,6 +210,27 @@ public void MapError_T_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_T_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be($"{ErrorMessage} {ErrorMessage}"); + invocations.Should().Be(1); + } + [Fact] public void MapError_UnitResult_returns_success() { @@ -121,6 +247,26 @@ public void MapError_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return $"{error} {error}"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public void MapError_UnitResult_returns_new_failure() { @@ -130,7 +276,6 @@ public void MapError_UnitResult_returns_new_failure() Result actual = result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "error"; }); @@ -140,6 +285,28 @@ public void MapError_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public void MapError_E_UnitResult_returns_success() { @@ -156,6 +323,26 @@ public void MapError_E_UnitResult_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_E_UnitResult_returns_success_with_context() + { + UnitResult result = UnitResult.Success(); + var invocations = 0; + + UnitResult actual = result.MapError( + (error, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + invocations.Should().Be(0); + } + [Fact] public void MapError_E_UnitResult_returns_new_failure() { @@ -165,7 +352,6 @@ public void MapError_E_UnitResult_returns_new_failure() UnitResult actual = result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -175,6 +361,28 @@ public void MapError_E_UnitResult_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_E_UnitResult_returns_new_failure_with_context() + { + UnitResult result = UnitResult.Failure(E.Value); + var invocations = 0; + + UnitResult actual = result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } + [Fact] public void MapError_T_E_returns_success() { @@ -192,16 +400,36 @@ public void MapError_T_E_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_T_E_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public void MapError_T_E_returns_new_failure() { Result result = Result.Failure(ErrorMessage); var invocations = 0; - + Result actual = result.MapError(error => { error.Should().Be(ErrorMessage); - invocations++; return E.Value; }); @@ -211,6 +439,28 @@ public void MapError_T_E_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_T_E_returns_new_failure_with_context() + { + Result result = Result.Failure(ErrorMessage); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + error.Should().Be(ErrorMessage); + context.Should().Be(ContextMessage); + invocations++; + return E.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E.Value); + invocations.Should().Be(1); + } + [Fact] public void MapError_T_E_string_returns_success() { @@ -228,6 +478,27 @@ public void MapError_T_E_string_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_T_E_string_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public void MapError_T_E_E2_returns_success() { @@ -245,6 +516,27 @@ public void MapError_T_E_E2_returns_success() invocations.Should().Be(0); } + [Fact] + public void MapError_T_E_E2_returns_success_with_context() + { + Result result = Result.Success(T.Value); + var invocations = 0; + + Result actual = result.MapError( + (_, context) => + { + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeTrue(); + actual.Value.Should().Be(T.Value); + invocations.Should().Be(0); + } + [Fact] public void MapError_T_E_string_returns_new_failure() { @@ -254,7 +546,6 @@ public void MapError_T_E_string_returns_new_failure() Result actual = result.MapError(error => { error.Should().Be(E.Value); - invocations++; return "error"; }); @@ -264,6 +555,28 @@ public void MapError_T_E_string_returns_new_failure() invocations.Should().Be(1); } + [Fact] + public void MapError_T_E_string_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return "error"; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be("error"); + invocations.Should().Be(1); + } + [Fact] public void MapError_T_E_E2_returns_new_failure() { @@ -273,7 +586,6 @@ public void MapError_T_E_E2_returns_new_failure() Result actual = result.MapError(error => { error.Should().Be(E.Value); - invocations++; return E2.Value; }); @@ -282,5 +594,27 @@ public void MapError_T_E_E2_returns_new_failure() actual.Error.Should().Be(E2.Value); invocations.Should().Be(1); } + + [Fact] + public void MapError_T_E_E2_returns_new_failure_with_context() + { + Result result = Result.Failure(E.Value); + var invocations = 0; + + Result actual = result.MapError( + (error, context) => + { + error.Should().Be(E.Value); + context.Should().Be(ContextMessage); + invocations++; + return E2.Value; + }, + ContextMessage + ); + + actual.IsSuccess.Should().BeFalse(); + actual.Error.Should().Be(E2.Value); + invocations.Should().Be(1); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Left.cs index 259128b5..7aca0bd1 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Left.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Left.cs @@ -8,7 +8,10 @@ public static partial class ResultExtensions /// /// 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. /// - public static async Task MapError(this Task resultTask, Func errorFactory) + public static async Task MapError( + this Task resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -20,10 +23,29 @@ public static async Task MapError(this Task resultTask, Func MapError( + this Task resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task resultTask, Func errorFactory) + public static async Task> MapError( + this Task resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -35,10 +57,29 @@ public static async Task> MapError(this Task resultTask return UnitResult.Failure(error); } + public static async Task> MapError( + this Task resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -50,10 +91,29 @@ public static async Task> MapError(this Task> resultTask, return Result.Failure(error); } + public static async Task> MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -65,10 +125,29 @@ public static async Task> MapError(this Task> resul return Result.Failure(error); } + public static async Task> MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task MapError(this Task> resultTask, Func errorFactory) + public static async Task MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -80,10 +159,29 @@ public static async Task MapError(this Task> resultTask return Result.Failure(error); } + public static async Task MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -95,10 +193,29 @@ public static async Task> MapError(this Task return UnitResult.Failure(error); } + public static async Task> MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -110,10 +227,29 @@ public static async Task> MapError(this Task> resul return Result.Failure(error); } + public static async Task> MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func errorFactory + ) { var result = await resultTask.DefaultAwait(); if (result.IsSuccess) @@ -124,5 +260,21 @@ public static async Task> MapError(this Task(error); } + + public static async Task> MapError( + this Task> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Right.cs index e6cd050a..5be9cde5 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Right.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.Right.cs @@ -8,7 +8,10 @@ public static partial class ResultExtensions /// /// 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. /// - public static async Task MapError(this Result result, Func> errorFactory) + public static async Task MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -19,10 +22,28 @@ public static async Task MapError(this Result result, Func MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Result result, Func> errorFactory) + public static async Task> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -33,10 +54,28 @@ public static async Task> MapError(this Result result, Func> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return UnitResult.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Result result, Func> errorFactory) + public static async Task> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -47,10 +86,28 @@ public static async Task> MapError(this Result result, Func(error); } + public static async Task> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Result result, Func> errorFactory) + public static async Task> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -61,10 +118,28 @@ public static async Task> MapError(this Result result, Fun return Result.Failure(error); } + public static async Task> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task MapError(this UnitResult result, Func> errorFactory) + public static async Task MapError( + this UnitResult result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -75,10 +150,28 @@ public static async Task MapError(this UnitResult result, Func MapError( + this UnitResult result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this UnitResult result, Func> errorFactory) + public static async Task> MapError( + this UnitResult result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -89,10 +182,28 @@ public static async Task> MapError(this UnitResult resu return UnitResult.Failure(error); } + public static async Task> MapError( + this UnitResult result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return UnitResult.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Result result, Func> errorFactory) + public static async Task> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -103,10 +214,28 @@ public static async Task> MapError(this Result result, Fun return Result.Failure(error); } + public static async Task> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } + /// /// 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. /// - public static async Task> MapError(this Result result, Func> errorFactory) + public static async Task> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -116,5 +245,20 @@ public static async Task> MapError(this Result res var error = await errorFactory(result.Error).DefaultAwait(); return Result.Failure(error); } + + public static async Task> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context).DefaultAwait(); + return Result.Failure(error); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.cs index babe60b1..6d2b183a 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.Task.cs @@ -8,73 +8,177 @@ public static partial class ResultExtensions /// /// 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. /// - public static async Task MapError(this Task resultTask, Func> errorFactory) + public static async Task MapError( + this Task resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task MapError( + this Task resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task resultTask, Func> errorFactory) + public static async Task> MapError( + this Task resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task> MapError( + this Task resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func> errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func> errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task MapError(this Task> resultTask, Func> errorFactory) + public static async Task MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func> errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func> errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } + /// /// 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. /// - public static async Task> MapError(this Task> resultTask, Func> errorFactory) + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory + ) { var result = await resultTask.DefaultAwait(); return await result.MapError(errorFactory).DefaultAwait(); } + + public static async Task> MapError( + this Task> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask.DefaultAwait(); + return await result.MapError(errorFactory, context).DefaultAwait(); + } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Left.cs index 78bc53bf..65e24632 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Left.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Left.cs @@ -9,7 +9,10 @@ public static partial class ResultExtensions /// /// 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 valueTask action. /// - public static async ValueTask MapError(this ValueTask resultTask, Func errorFactory) + public static async ValueTask MapError( + this ValueTask resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -21,10 +24,29 @@ public static async ValueTask MapError(this ValueTask resultTask return Result.Failure(error); } + public static async ValueTask MapError( + this ValueTask resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -36,10 +58,29 @@ public static async ValueTask> MapError(this ValueTask return UnitResult.Failure(error); } + public static async ValueTask> MapError( + this ValueTask resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -51,10 +92,29 @@ public static async ValueTask> MapError(this ValueTask> r return Result.Failure(error); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -66,10 +126,29 @@ public static async ValueTask> MapError(this ValueTask(error); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -81,10 +160,29 @@ public static async ValueTask MapError(this ValueTask> return Result.Failure(error); } + public static async ValueTask MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -96,10 +194,29 @@ public static async ValueTask> MapError(this ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -111,10 +228,29 @@ public static async ValueTask> MapError(this ValueTask(error); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory + ) { var result = await resultTask; if (result.IsSuccess) @@ -125,6 +261,22 @@ public static async ValueTask> MapError(this ValueTask(error); } + + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func errorFactory, + TContext context + ) + { + var result = await resultTask; + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = errorFactory(result.Error, context); + return Result.Failure(error); + } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Right.cs index 9b5009d5..3bd18818 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Right.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.Right.cs @@ -9,7 +9,10 @@ public static partial class ResultExtensions /// /// 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 valueTask action. /// - public static async ValueTask MapError(this Result result, Func> errorFactory) + public static async ValueTask MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -23,7 +26,28 @@ public static async ValueTask MapError(this Result result, Func /// 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 valueTask action. /// - public static async ValueTask> MapError(this Result result, Func> errorFactory) + public static async ValueTask MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -37,7 +61,28 @@ public static async ValueTask> MapError(this Result result, Fun /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this Result result, Func> errorFactory) + public static async ValueTask> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = await errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -51,7 +96,28 @@ public static async ValueTask> MapError(this Result result, Func /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this Result result, Func> errorFactory) + public static async ValueTask> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -65,7 +131,28 @@ public static async ValueTask> MapError(this Result result /// /// 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 valueTask action. /// - public static async ValueTask MapError(this UnitResult result, Func> errorFactory) + public static async ValueTask> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask MapError( + this UnitResult result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -79,7 +166,28 @@ public static async ValueTask MapError(this UnitResult result, Fun /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this UnitResult result, Func> errorFactory) + public static async ValueTask MapError( + this UnitResult result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this UnitResult result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -93,7 +201,28 @@ public static async ValueTask> MapError(this UnitResult /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this Result result, Func> errorFactory) + public static async ValueTask> MapError( + this UnitResult result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return UnitResult.Success(); + } + + var error = await errorFactory(result.Error, context); + return UnitResult.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -107,7 +236,28 @@ public static async ValueTask> MapError(this Result result /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this Result result, Func> errorFactory) + public static async ValueTask> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory + ) { if (result.IsSuccess) { @@ -117,6 +267,24 @@ public static async ValueTask> MapError(this Result(error); } + + /// + /// 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 valueTask action. + /// + public static async ValueTask> MapError( + this Result result, + Func> errorFactory, + TContext context + ) + { + if (result.IsSuccess) + { + return Result.Success(result.Value); + } + + var error = await errorFactory(result.Error, context); + return Result.Failure(error); + } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.cs index aca0da90..81d0082e 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.ValueTask.cs @@ -9,74 +9,178 @@ public static partial class ResultExtensions /// /// 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 valueTask action. /// - public static async ValueTask MapError(this ValueTask resultTask, Func> errorFactory) + public static async ValueTask MapError( + this ValueTask resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask MapError( + this ValueTask resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask> MapError( + this ValueTask resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } + /// /// 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 valueTask action. /// - public static async ValueTask> MapError(this ValueTask> resultTask, Func> errorFactory) + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory + ) { var result = await resultTask; return await result.MapError(errorFactory); } + + public static async ValueTask> MapError( + this ValueTask> resultTask, + Func> errorFactory, + TContext context + ) + { + var result = await resultTask; + return await result.MapError(errorFactory, context); + } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.cs index 013e8485..ab319fab 100644 --- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.cs +++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapError.cs @@ -15,6 +15,18 @@ public static Result MapError(this Result result, Func errorFact return Result.Success(); } + public static Result MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(); + } + /// /// 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. /// @@ -26,10 +38,25 @@ public static UnitResult MapError(this Result result, Func erro return UnitResult.Success(); } + public static UnitResult MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return UnitResult.Failure(errorFactory(result.Error, context)); + + return UnitResult.Success(); + } + /// /// 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. /// - public static Result MapError(this Result result, Func errorFactory) + public static Result MapError( + this Result result, + Func errorFactory + ) { if (result.IsFailure) return Result.Failure(errorFactory(result.Error)); @@ -37,10 +64,25 @@ public static Result MapError(this Result result, Func return Result.Success(result.Value); } + public static Result MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(result.Value); + } + /// /// 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. /// - public static Result MapError(this Result result, Func errorFactory) + public static Result MapError( + this Result result, + Func errorFactory + ) { if (result.IsFailure) return Result.Failure(errorFactory(result.Error)); @@ -48,6 +90,18 @@ public static Result MapError(this Result result, Func return Result.Success(result.Value); } + public static Result MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(result.Value); + } + /// /// 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. /// @@ -59,10 +113,25 @@ public static Result MapError(this UnitResult result, Func erro return Result.Success(); } + public static Result MapError( + this UnitResult result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(); + } + /// /// 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. /// - public static UnitResult MapError(this UnitResult result, Func errorFactory) + public static UnitResult MapError( + this UnitResult result, + Func errorFactory + ) { if (result.IsFailure) return UnitResult.Failure(errorFactory(result.Error)); @@ -70,10 +139,25 @@ public static UnitResult MapError(this UnitResult result, Func(); } + public static UnitResult MapError( + this UnitResult result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return UnitResult.Failure(errorFactory(result.Error, context)); + + return UnitResult.Success(); + } + /// /// 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. /// - public static Result MapError(this Result result, Func errorFactory) + public static Result MapError( + this Result result, + Func errorFactory + ) { if (result.IsFailure) return Result.Failure(errorFactory(result.Error)); @@ -81,15 +165,42 @@ public static Result MapError(this Result result, Func return Result.Success(result.Value); } + public static Result MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(result.Value); + } + /// /// 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. /// - public static Result MapError(this Result result, Func errorFactory) + public static Result MapError( + this Result result, + Func errorFactory + ) { if (result.IsFailure) return Result.Failure(errorFactory(result.Error)); return Result.Success(result.Value); } + + public static Result MapError( + this Result result, + Func errorFactory, + TContext context + ) + { + if (result.IsFailure) + return Result.Failure(errorFactory(result.Error, context)); + + return Result.Success(result.Value); + } } -} \ No newline at end of file +}