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