static void Main(string[] args)
{
var r = ResultFactory.CreateFailure <string>("tes", "a");
if (r.IsFailure(out var f))
{
}
}
public void GivenFailureOfString_ReturnsFailureOfUnit()
{
var resultOfString = ResultFactory.CreateFailure <string>("sup mate");
var resultOfUnit = resultOfString.ToUnit();
resultOfUnit.ShouldBeOfType(typeof(Failure <Unit>));
}
public async Task GivenFailureOfStringAsync_ReturnsFailureOfUnitAsync()
{
var resultOfString = Task.FromResult(ResultFactory.CreateFailure <string>("sup mate"));
var resultOfUnit = await resultOfString.ToUnitAsync();
resultOfUnit.ShouldBeOfType(typeof(Failure <Unit>));
}
public void GivenFailure_ReturnsOnFailureDelegateResult()
{
var failure = ResultFactory.CreateFailure("error");
var delegateResult = failure.Map(unit => 1, error => 0);
Assert.Equal(0, delegateResult);
}
public async Task GivenAsyncFailure_ReturnsOnFailureDelegateResult()
{
var failure = Task.FromResult(ResultFactory.CreateFailure("error"));
var delegateResult = await failure.MapAsync(unit => 1, error => 0);
Assert.Equal(0, delegateResult);
}
IEnumerable <IResult <int> > Produce10ResultsWithErrorsOnIndex5And9()
{
var resultCollection = ProduceSuccess(10).ToArray();
resultCollection[5] = ResultFactory.CreateFailure <int>("error");
resultCollection[9] = ResultFactory.CreateFailure <int>("another error");
return(resultCollection);
}
public void Bind_ReturnsFailure()
{
var failure = ResultFactory.CreateFailure("some serious message");
var next = ResultFactory.CreateFailure("next error");
var result = failure.Bind(a => next);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("some serious message");
}
public void Bind_ReturnsFailure()
{
var success = ResultFactory.CreateSuccess(1);
var next = ResultFactory.CreateFailure("some serious message");
var result = success.Bind(a => next);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("some serious message");
}
public async Task BindAnyAsync_OnFailure_GivenTask_WhenPayloadIsIgnored_ReturnsFailureAsync()
{
var failure = ResultFactory.CreateFailure <int>("serious error");
var result = await failure.BindAnyAsync(() => Task.FromResult(5));
result.ShouldBeFailure();
result.Error().Message.ShouldBe("serious error");
}
public void BindAny_OnFailure_GivenObject_WhenPayloadIgnored_ReturnsFailure()
{
var failure = ResultFactory.CreateFailure <int>("serious error");
var result = failure.BindAny(() => 4);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("serious error");
}
public void BindAny_OnFailure_GivenObject_ReturnsFailure()
{
var failure = ResultFactory.CreateFailure <int>("serious error");
var result = failure.BindAny(a => a + 3);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("serious error");
}
public void Is_GivenFailureOfTAndSuccess_ReturnsFalse()
{
var failure = ResultFactory.CreateFailure <int>("");
Assert.True(failure is IResult);
Assert.True(failure is IResult <int>);
Assert.False(failure is Success);
Assert.False(failure is Success <int>);
}
public void Is_GivenFailureOfTAndFailure_ReturnsTrue()
{
var failure = ResultFactory.CreateFailure <int>("");
Assert.True(failure is IResult);
Assert.True(failure is IResult <int>);
Assert.True(failure is Failure);
Assert.True(failure is Failure <int>);
}
public static IResult <IEnumerable <T> > Flatten <T>(this IEnumerable <IResult <T> > results)
{
var resultList = results.ToArray();
var errors = resultList.Where(x => x is Failure <T>).Select(failure => ((Failure <T>)failure).Error).ToList();
var payloads = resultList.Where(x => x is Success <T>).Select(failure => ((Success <T>)failure).Payload);
return(errors.Any()
? ResultFactory.CreateFailure <IEnumerable <T> >(new AggregateError(errors))
: ResultFactory.CreateSuccess(payloads));
}
public void Bind_WhenResultIgnored_ReturnsFailure()
{
var failure = ResultFactory.CreateFailure("some serious message");
var next = ResultFactory.CreateSuccess(1);
var result = failure.Bind(() => next);
result.ShouldBeFailure();
result.Error().Message.ShouldBe("some serious message");
}
public void Bind_GivenNextWithNoArg_ReturnsFailureWithNewType()
{
var failure = ResultFactory.CreateFailure <string>("error") as Failure <string>;
var result = failure.Bind(() => ResultFactory.CreateSuccess(1));
Assert.True(result is Failure);
Assert.True(result is Failure <int>);
Assert.True(result is Failure <int> f && f.Error == failure.Error);
}
public static IResult <IEnumerable <T> > Flatten <T>(this IEnumerable <IResult <T> > results)
{
var resultList = results.ToArray();
var errors = resultList.OfType <Failure <T> >().Select(failure => failure.Error).ToArray();
var payloads = resultList.OfType <Success <T> >().Select(success => success.Payload);
return(errors.Any()
? ResultFactory.CreateFailure <IEnumerable <T> >(new AggregateError(errors))
: ResultFactory.CreateSuccess(payloads));
}
public async Task BindAsync_WhenPrevIsAsync_WhenResultIgnored_ReturnsFailureAsync()
{
var success = ResultFactory.CreateSuccessAsync(1);
var next = ResultFactory.CreateFailure("some serious message");
var result = success.BindAsync(() => next);
await result.ShouldBeFailure();
(await result.Error()).Message.ShouldBe("some serious message");
}
public async Task BindAsync_WhenPrevIsAsync_ReturnsFailureAsync()
{
var failure = ResultFactory.CreateFailureAsync("some serious message");
var next = ResultFactory.CreateFailure("next error");
var result = failure.BindAsync(a => next);
await result.ShouldBeFailure();
(await result.Error()).Message.ShouldBe("some serious message");
}
public static RuleBuilder <TType> Build <TType>(Func <TType> func)
{
try
{
return(new RuleBuilder <TType>(func().ToSuccess()));
}
catch (Exception e)
{
return(new RuleBuilder <TType>(ResultFactory.CreateFailure <TType>(new BuildError($"Build of {typeof(TType).Name} failed with {e.Message}"))));
}
}
public static IResult <Unit> Apply(this IEnumerable <IRule> rules)
{
var notApplied = rules
.Select(x => x.Apply())
.Where(x => x is Failure <Unit>)
.Cast <Failure <Unit> >()
.ToList();
return(notApplied.Any()
? ResultFactory.CreateFailure(FormatMessages(notApplied))
: ResultFactory.CreateSuccess());
}
public static async Task <IResult <IEnumerable <T> > > FlattenAsync <T>(this IEnumerable <Task <IResult <T> > > results)
{
var resultList = results.ToList();
await Task.WhenAll(resultList);
var errors = resultList.Where(x => x.Result is Failure <T>).Select(failure => ((Failure <T>)failure.Result).Error).ToList();
var payloads = resultList.Where(x => x.Result is Success <T>).Select(failure => ((Success <T>)failure.Result).Payload);
return(errors.Any()
? ResultFactory.CreateFailure <IEnumerable <T> >(new AggregateError(errors))
: ResultFactory.CreateSuccess(payloads));
}
public async Task <Result <Unit> > SendAsync(TMessage msg, CancellationToken token = new CancellationToken())
{
try
{
var result = await _bufferBlock.SendAsync(msg, token);
return(result
? ResultFactory.CreateSuccess()
: ResultFactory.CreateFailure <Unit>("Message was refused by queue"));
}
catch (Exception e)
{
return(ResultFactory.CreateFailure <Unit>(e.Message));
}
}
public void Map_OnFailure_Return2() =>
ResultFactory.CreateFailure <Unit>("").Map(x => 1, y => 2).ShouldBe(2);
private static IResult <int> FailSync(int _) => ResultFactory.CreateFailure <int>("fail");
private static ValueTask <IResult <int> > Fail(int _) => new ValueTask <IResult <int> >(ResultFactory.CreateFailure <int>("fail"));
public IResult <Unit> Apply() =>
_predicate()
? ResultFactory.CreateSuccess()
: ResultFactory.CreateFailure(_message);
public void IsFailure_WhenResultIsFailure_ReturnTrue() =>
ResultFactory.CreateFailure("on nie wiedzial - exception").IsFailure().ShouldBeTrue();
public Task <IHandleResult> Handle(string evt)
{
return(Task.FromResult(ResultFactory.CreateFailure("Damnit")));
}
public static IResult <Unit> AsFailure(this string errorMessage,
[CallerMemberName] string memberName = "",
[CallerFilePath] string sourceFilePath = "",
[CallerLineNumber] int sourceLineNumber = 0) =>
ResultFactory.CreateFailure(errorMessage, memberName, sourceFilePath, sourceLineNumber);
