public async Task AsyncValueTask_Sync_HasErrors_ErrorMatch_CallIfError( IErrorPredicate errorPredicate, Error validError, Error _ ) { const int ifErrorData = 3; var mock = new Mock <ISyncResponseProvider <Error, int> >(); mock.Setup(v => v.Execute(It.IsAny <Error>())) .Returns(ApiResponse.Ok(ifErrorData)); var response = await ApiResponse .Error <int>(validError) .AsValueTask() .IfError( errorPredicate, e => mock.Object.Execute(e)); Assert.True(response.IsOk); Assert.Equal(ifErrorData, response.Data); mock.Verify(v => v.Execute(validError), Times.Once()); }
public async Task AsyncValueTask_Sync_HasErrors_ErrorDoesNotMatch_DoNotCallIfError( IErrorPredicate errorPredicate, Error _, Error invalidError ) { const int ifErrorData = 3; var mock = new Mock <ISyncResponseProvider <Error, int> >(); mock.Setup(v => v.Execute(It.IsAny <Error>())) .Returns(ApiResponse.Ok(ifErrorData)); var response = await ApiResponse .Error <int>(invalidError) .AsValueTask() .IfError( errorPredicate, e => mock.Object.Execute(e)); Assert.True(response.HasErrors); Assert.Equal(invalidError, response.Error, ErrorComparer.Default); mock.Verify(v => v.Execute(invalidError), Times.Never()); }
public async Task AsyncValueTask_Sync_IsOk_DoNotCallIfError( IErrorPredicate errorPredicate, Error _, Error __ ) { const int data = 2; const int ifErrorData = 3; var mock = new Mock <ISyncResponseProvider <Error, int> >(); mock.Setup(v => v.Execute(It.IsAny <Error>())) .Returns(ApiResponse.Ok(ifErrorData)); var response = await ApiResponse .Ok(data) .AsValueTask() .IfError( errorPredicate, e => mock.Object.Execute(e)); Assert.True(response.IsOk); Assert.Equal(data, response.Data); mock.Verify(v => v.Execute(It.IsAny <Error>()), Times.Never()); }
public static Task <ApiResponse <T> > OnError <T, TOnError>( this Task <ApiResponse <T> > source, IErrorPredicate errorPredicate, Func <Error, Task <ApiResponse <TOnError> > > onError ) { throw new NotImplementedException(); }
/// <summary> /// Return ok response and suppress errors that match <paramref name="errorPredicate"/> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Predicate for errors</param> /// <returns></returns> public static async ValueTask <ApiResponse <Unit> > SuppressErrors <T>( this ValueTask <ApiResponse <T> > source, IErrorPredicate errorPredicate) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } var response = await source.ConfigureAwait(false); return(response.SuppressErrors(errorPredicate)); }
/// <summary> /// Switch to <paramref name="ifError"/> flow if response returns error /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Predicate for error to execute <paramref name="ifError"/></param> /// <param name="ifError">Flow to execute in case of error</param> /// <returns></returns> public static async ValueTask <ApiResponse <T> > IfError <T>( this ValueTask <ApiResponse <T> > source, IErrorPredicate errorPredicate, Func <Error, ApiResponse <T> > ifError) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } var response = await source.ConfigureAwait(false); return(response.IfError(errorPredicate, ifError)); }
public void Sync_HasErrors_ValidError_ReturnsOk( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int expectedStatusCode = 203; var response = ApiResponse .Error <int>(validError) .WithStatusCode(expectedStatusCode) .SuppressErrors(errorPredicate); Assert.True(response.IsOk); Assert.Null(response.StatusCode); }
/// <summary> /// Execute <paramref name="onError"/> if response has errors /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Error predicate</param> /// <param name="onError"></param> /// <returns></returns> public static async Task <ApiResponse <T> > OnError <T>( this Task <ApiResponse <T> > source, IErrorPredicate errorPredicate, Action <Error> onError ) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } var response = await source.ConfigureAwait(false); return(response.OnError(errorPredicate, onError)); }
/// <summary> /// Return ok response and suppress errors that match <paramref name="errorPredicate"/> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Predicate for errors</param> /// <returns></returns> public static ApiResponse <Unit> SuppressErrors <T>( this ApiResponse <T> source, IErrorPredicate errorPredicate) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } if (source.Error is not null && errorPredicate.IsMatch(source.Error)) { return(ApiResponse.Ok()); } return(source.AsUnit()); }
public void Sync_HasErrors_InvalidError_ReturnsError( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int expectedStatusCode = 203; var response = ApiResponse .Error <int>(invalidError) .WithStatusCode(expectedStatusCode) .SuppressErrors(errorPredicate); Assert.True(response.HasErrors); Assert.Equal(expectedStatusCode, response.StatusCode); Assert.Equal(invalidError, response.Error, ErrorComparer.Default); }
public void Sync_IsOk_ReturnsResponse( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int data = 3; const int expectedStatusCode = 203; var response = ApiResponse .Ok(data) .WithStatusCode(expectedStatusCode) .SuppressErrors(errorPredicate); Assert.True(response.IsOk); Assert.Equal(expectedStatusCode, response.StatusCode); }
public async Task AsyncValueTask_HasErrors_ValidError_ReturnsOk( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int expectedStatusCode = 203; var response = await ApiResponse .Error <int>(validError) .WithStatusCode(expectedStatusCode) .AsValueTask() .SuppressErrors(errorPredicate); Assert.True(response.IsOk); Assert.Null(response.StatusCode); }
/// <summary> /// Switch to <paramref name="ifError"/> flow if response returns error /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Predicate for error to execute <paramref name="ifError"/></param> /// <param name="ifError">Flow to execute in case of error</param> /// <returns></returns> public static ApiResponse <T> IfError <T>( this ApiResponse <T> source, IErrorPredicate errorPredicate, Func <Error, ApiResponse <T> > ifError) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } if (source.Error is not null && errorPredicate.IsMatch(source.Error)) { return(ifError(source.Error)); } return(source); }
public async Task AsyncValueTask_IsOk_ReturnsResponse( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int data = 3; const int expectedStatusCode = 203; var response = await ApiResponse .Ok(data) .WithStatusCode(expectedStatusCode) .AsValueTask() .SuppressErrors(errorPredicate); Assert.True(response.IsOk); Assert.Equal(expectedStatusCode, response.StatusCode); }
/// <summary> /// Switch to <paramref name="ifError"/> flow if response returns error /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="errorPredicate">Predicate for error to execute <paramref name="ifError"/></param> /// <param name="ifError">Flow to execute in case of error</param> /// <returns></returns> public static async Task <ApiResponse <T> > IfError <T>( this ApiResponse <T> source, IErrorPredicate errorPredicate, Func <Error, Task <ApiResponse <T> > > ifError) { if (errorPredicate == null) { throw new ArgumentNullException(nameof(errorPredicate)); } if (source.Error is not null && errorPredicate.IsMatch(source.Error)) { return(await ifError(source.Error).ConfigureAwait(false)); } return(source); }
public void Sync_Sync_HasErrors_ValidError_ExecuteOnError( IErrorPredicate errorPredicate, Error validError, Error invalidError) { var onErrorMock = new Mock <ISyncExecutionProvider <Error> >(); var response = ApiResponse .Error(validError) .OnError( errorPredicate, e => onErrorMock.Object.Execute(e)); Assert.True(response.HasErrors); Assert.Equal(validError, response.Error, ErrorComparer.Default); onErrorMock.Verify(v => v.Execute(validError), Times.Once()); }
public async Task Sync_Async_HasErrors_InvalidError_DoesNotExecuteOnError( IErrorPredicate errorPredicate, Error validError, Error invalidError) { var onErrorMock = new Mock <IAsyncExecutionProvider <Error> >(); var response = await ApiResponse .Error(invalidError) .OnError( errorPredicate, e => onErrorMock.Object.Execute(e)); Assert.True(response.HasErrors); Assert.Equal(invalidError, response.Error, ErrorComparer.Default); onErrorMock.Verify(v => v.Execute(validError), Times.Never()); }
public async Task AsyncValueTask_AsyncValueTask_HasErrors_ValidError_ExecuteOnError( IErrorPredicate errorPredicate, Error validError, Error invalidError) { var onErrorMock = new Mock <IAsyncValueTaskExecutionProvider <Error> >(); var response = await ApiResponse .Error(validError) .AsValueTask() .OnError( errorPredicate, e => onErrorMock.Object.Execute(e)); Assert.True(response.HasErrors); Assert.Equal(validError, response.Error, ErrorComparer.Default); onErrorMock.Verify(v => v.Execute(validError), Times.Once()); }
public async Task Sync_Async_IsOk_DoesNotExecuteOnError( IErrorPredicate errorPredicate, Error validError, Error invalidError) { const int expectedData = 3; var onErrorMock = new Mock <IAsyncExecutionProvider <Error> >(); var response = await ApiResponse .Ok(expectedData) .OnError( errorPredicate, e => onErrorMock.Object.Execute(e)); Assert.True(response.IsOk); Assert.Equal(expectedData, response.Data); onErrorMock.Verify(v => v.Execute(It.IsAny <Error>()), Times.Never()); }