public async Task BindAnyAsync_OnFailureAsync_GivenValue_WhenPayloadIsIgnored_ReturnsFailureAsync()
{
var failure = ResultFactory.CreateFailureAsync <int>("serious error");
var result = await failure.BindAnyAsync(() => 3);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("serious error");
}
public async Task BindAnyAsync_OnFailureAsync_GivenTask_ReturnsFailureAsync()
{
var failure = ResultFactory.CreateFailureAsync <int>("serious error");
var result = await failure.BindAnyAsync(a => Task.FromResult(a + 3));
result.ShouldBeFailure();
result.Error().Message.ShouldBe("serious error");
}
public async Task BindAsync_WhenBothAreAsync_WhenResultIgnored_ReturnsFailureAsync()
{
var success = ResultFactory.CreateSuccessAsync(1);
var next = ResultFactory.CreateFailureAsync("some serious message");
var result = success.BindAsync(() => next);
await result.ShouldBeFailure();
(await result.Error()).Message.ShouldBe("some serious message");
}
public async Task BindAsync_WhenBothAreAsync_ReturnsFailureAsync()
{
var failure = ResultFactory.CreateFailureAsync("some serious message");
var next = ResultFactory.CreateFailureAsync("next error");
var result = failure.BindAsync(a => next);
await result.ShouldBeFailure();
(await result.Error()).Message.ShouldBe("some serious message");
}
public Task <IResult <Unit> > DeleteAsync(TKey id, CancellationToken token = default)
{
try
{
Cache.Remove(GetKey(id));
return(ResultFactory.CreateSuccessAsync());
}
catch (Exception e)
{
return(ResultFactory.CreateFailureAsync <Unit>(e.Message));
}
}
public Task <IResult <Unit> > DeleteAllAsync(CancellationToken token = default)
{
try
{
_tokenSource.Cancel();
_tokenSource.Dispose();
_tokenSource = new CancellationTokenSource();
return(ResultFactory.CreateSuccessAsync());
}
catch (Exception e)
{
return(ResultFactory.CreateFailureAsync <Unit>(e.Message));
}
}
public async Task OnResultExecutionAsync_WhenBodyShouldNotBeIncluded_NotCallSetBody()
{
var httpAccessor = new Mock <IRequestDataAccessor>();
httpAccessor.Setup(x => x.SetBody(It.IsAny <HttpContext>(), It.IsAny <IActionResult>()))
.Returns(await ResultFactory.CreateFailureAsync("dd"));
var logger = new Mock <ILogger <RewindFilter> >();
var telemetryEnricher = new Mock <ITelemetryEnricher>();
telemetryEnricher.Setup(x => x.AttachResponse(It.IsAny <HttpContext>())).Returns(false);
var filter = new RewindFilter(httpAccessor.Object, logger.Object, telemetryEnricher.Object);
await filter.OnResultExecutionAsync(new ResultExecutingContext(new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()), new List <IFilterMetadata>(), new OkObjectResult("dd"), new object()), () => Task.FromResult(new ResultExecutedContext(new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()), new List <IFilterMetadata>(), new OkObjectResult("dd"), new object())));
httpAccessor.Verify(x => x.SetBody(It.IsAny <HttpContext>(), It.IsAny <ActionDescriptor>(),
It.IsAny <IDictionary <string, object> >()), Times.Never);
}
public Task <IResult <Unit> > UpsertAsync(TKey id, TItem item, CancellationToken token = default)
{
try
{
var key = GetKey(id);
var opt = new MemoryCacheEntryOptions
{
SlidingExpiration = _cacheEntryExpiration,
Size = 1
};
opt.AddExpirationToken(new CancellationChangeToken(_tokenSource.Token));
Cache.Set(key, item, opt);
var successSave = Cache.TryGetValue(key, out _);
return(successSave
? ResultFactory.CreateSuccessAsync()
: ResultFactory.CreateFailureAsync <Unit>($"entry under key {key} was not saved in a cache"));
}
catch (Exception e)
{
return(ResultFactory.CreateFailureAsync(e.Message));
}
}
private static Task <IResult <int> > FailAsync(int _) => ResultFactory.CreateFailureAsync <int>("fail");
public async Task MapAsync_OnFailure_ReturnTaskWith2Inside() =>
(await ResultFactory.CreateFailureAsync <Unit>("").MapAsync(x => Task.FromResult(1), y => Task.FromResult(2))).ShouldBe(2);
public async Task MapAsync_OnFailure_Return2() =>
(await ResultFactory.CreateFailureAsync <Unit>("").MapAsync(x => 1, y => 2)).ShouldBe(2);
public static async Task <IResult <TType> > ToFailureAsync <TType>(this Task <Exception> obj, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
{
var ex = await obj;
return(await ResultFactory.CreateFailureAsync <TType>(new Error(ex.Message, memberName, sourceFilePath, sourceLineNumber)));
}
public static async Task <IResult <TType> > ToFailureAsync <TType>(this Task <Exception> obj, string msg, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0) => await ResultFactory.CreateFailureAsync <TType>(new Error(msg, memberName, sourceFilePath, sourceLineNumber));
public static Task <IResult <TType> > ToFailureWithMsgAsync <TType>(this Exception obj, string msg, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0) => ResultFactory.CreateFailureAsync <TType>(new ErrorWithException(msg, obj, memberName, sourceFilePath, sourceLineNumber));
