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());
}
