public async Task OnSuccessAsync_ShouldBeCalled_WhenReturnsSuccessResult()
{
var isAlwaysExecuted = false;
var isSuccessExecuted = false;
var isFailureExecuted = false;
var result = await Task.FromResult(ServiceResult <string> .AsSuccess("ok"))
.OnSuccessAsync((r) =>
{
isSuccessExecuted = true;
return(Task.FromResult(ServiceResult <string> .AsSuccess("ok")));
})
.OnFailureAsync(r =>
{
isFailureExecuted = true;
return(Task.Delay(0));
})
.AlwaysAsync(r =>
{
isAlwaysExecuted = true;
return(Task.Delay(0));
});
Assert.True(isSuccessExecuted);
Assert.False(isFailureExecuted);
Assert.True(isAlwaysExecuted);
Assert.True(result.IsSuccessful);
Assert.Equal("ok", result.Result);
}
public void OnCancelled_ShouldCallOnCancelled_WhenResultIsCancelled()
{
var isAlwaysExecuted = false;
var isSuccessExecuted = false;
var isFailureExecuted = false;
var isCancellExecuted = false;
var result = ServiceResult <string> .AsCancel()
.OnSuccess((r) =>
{
isSuccessExecuted = true;
return(ServiceResult <string> .AsSuccess("ok"));
})
.OnFailure(r =>
{
isFailureExecuted = true;
})
.OnCancelled(r =>
{
isCancellExecuted = true;
})
.Always(r => isAlwaysExecuted = true);
Assert.False(isSuccessExecuted);
Assert.False(isFailureExecuted);
Assert.True(isAlwaysExecuted);
Assert.True(isCancellExecuted);
Assert.True(result.IsCancelled);
}
public void Combine_ShouldSucceed_WhenResultConsistsAllSuccess()
{
var res1 = ServiceResult.AsSuccess();
var res2 = ServiceResult.AsSuccess();
var res3 = ServiceResult.AsSuccess();
var r = ServiceResult.Combine(res1, res2, res3);
Assert.True(r.IsSuccessful);
Assert.False(r.Message.Contains("failed"));
}
public void Combine_ShouldFail_WhenResultConsistsAtLeastOneErrorResult()
{
var res1 = ServiceResult.AsFailure("failed");
var res2 = ServiceResult.AsSuccess();
var res3 = ServiceResult.AsFailure("test");
var r = ServiceResult.Combine(res1, res2, res3);
Assert.False(r.IsSuccessful);
Assert.True(r.Message.Contains("failed"));
}
public void AsSuccess_ShouldSetFieldsCorrectly()
{
var result = ServiceResult.AsSuccess("test message");
Assert.True(result.IsSuccessful);
Assert.False(result.IsCancelled);
Assert.Null(result.Exception);
Assert.Equal("test message", result.Message);
var genericResult = ServiceResult <Dummy> .AsSuccess(new Dummy());
Assert.True(genericResult.IsSuccessful);
Assert.False(genericResult.IsCancelled);
Assert.Null(genericResult.Exception);
Assert.Null(genericResult.Message);
Assert.Equal(typeof(Dummy), genericResult.Result.GetType());
}
/// <summary>
/// Waits for an API request to complete and return a response
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="task">A <see cref="Task"/> representing the API request to be awaited</param>
/// <param name="config">A <see cref="ApiExceptionHandlerConfig"/> specifying any error handlers and logger to use</param>
/// <param name="continueOnCapturedContext">Specifies whether the resonse should return on the same thread as the request.
/// Setting this value to <c>false</c> can improve performance by avoiding thread context switches.</param>
/// <returns>A <see cref="ServiceResult"/> instance representing the status of the completed request</returns>
public static async Task <ServiceResult <T> > WaitForResponse <T>(this Task <T> task, ApiExceptionHandlerConfig config, bool continueOnCapturedContext = true)
{
try
{
var result = await task.ConfigureAwait(continueOnCapturedContext);
return(ServiceResult <T> .AsSuccess(result));
}
catch (ApiException ex)
{
HandleException(ex, config);
return(ServiceResult <T> .AsFailure(new ApiHandledException(ex), statusCode : (int)ex.StatusCode));
}
catch (Exception ex)
{
return(ServiceResult <T> .AsFailure(new ApiHandledException(ex)));
}
}
public void OnSuccess_ShouldBeCalled_WhenResultIsSuccessful()
{
var isAlwaysExecuted = false;
var isSuccessExecuted = false;
var isFailureExecuted = false;
var result = ServiceResult <string> .AsSuccess("test")
.OnSuccess((r) =>
{
isSuccessExecuted = true;
return(ServiceResult <string> .AsSuccess("ok"));
})
.OnFailure(r =>
{
isFailureExecuted = true;
})
.Always(r => isAlwaysExecuted = true);
Assert.True(isSuccessExecuted);
Assert.False(isFailureExecuted);
Assert.True(isAlwaysExecuted);
Assert.Equal("ok", result.Result);
}
public void OnSuccess_ShouldCallOnFailure_WhenFirstOnSuccessReturnsFailureResult()
{
var isAlwaysExecuted = false;
var isSuccessExecuted = false;
var isFailureExecuted = false;
var result = ServiceResult <string> .AsSuccess("ok")
.OnSuccess((r) =>
{
isSuccessExecuted = true;
return(ServiceResult <string> .AsFailure("failed"));
})
.OnFailure(r =>
{
isFailureExecuted = true;
})
.Always(r => isAlwaysExecuted = true);
Assert.True(isSuccessExecuted);
Assert.True(isFailureExecuted);
Assert.True(isAlwaysExecuted);
Assert.False(result.IsSuccessful);
Assert.Equal("failed", result.Message);
}
