public async Task CreateTaskResultValueAsync_Errors() { var initialError = CreateErrorListTwoTest(); var resultValue = await ResultValueFactory.CreateTaskResultValueErrorAsync <int>(initialError); Assert.True(resultValue.HasErrors); Assert.True(initialError.SequenceEqual(resultValue.Errors)); }
public async Task CreateTaskResultValueAsync_Ok() { int initialValue = Numbers.Number; var resultValue = await ResultValueFactory.CreateTaskResultValueAsync(initialValue); Assert.True(resultValue.OkStatus); Assert.Equal(initialValue, resultValue.Value); }
public async Task CreateTaskResultValueAsync_Error() { var initialError = CreateErrorTest(); var resultValue = await ResultValueFactory.CreateTaskResultValueErrorAsync <int>(initialError); Assert.True(resultValue.HasErrors); Assert.True(initialError.Equals(resultValue.Errors.First())); }
public async Task ToActionResultValueAsync_OkRequest() { var initialTransfer = TransferData.GetTestTransfer(); var testTransfer = ResultValueFactory.CreateTaskResultValue(initialTransfer); var actionResult = await testTransfer.ToActionResultValueTaskAsync <TestEnum, ITestTransfer>(); Assert.Equal(initialTransfer, actionResult.Value); }
public async Task ResultValueBindTryAsync_Ok() { int initialValue = Numbers.Number; var resultValue = await ResultValueBindTryAsync(() => ResultValueFactory.CreateTaskResultValue(Division(initialValue)), Exceptions.ExceptionError()); Assert.True(resultValue.OkStatus); Assert.Equal(resultValue.Value, await AsyncFunctions.DivisionAsync(initialValue)); }
public async Task ResultValueOkBindAsync_Bad_ReturnInitial() { var errorInitial = CreateErrorTest(); var resultValueTask = ResultValueFactory.CreateTaskResultValueError <int>(errorInitial); var resultAfterWhere = await resultValueTask.ResultValueOkBindAsync(AsyncFunctions.IntToStringAsync); Assert.True(resultAfterWhere.HasErrors); Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last())); }
public async Task ResultValueOkBindAsync_Ok_ReturnNewValue() { int initialValue = Numbers.Number; var resultValueTask = ResultValueFactory.CreateTaskResultValue(initialValue); var resultAfterWhere = await resultValueTask.ResultValueOkBindAsync(AsyncFunctions.IntToStringAsync); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(initialValue.ToString(), resultAfterWhere.Value); }
public async Task ResultValueBindTryAsync_Exception() { const int initialValue = 0; var resultValue = await ResultValueBindTryAsync(() => ResultValueFactory.CreateTaskResultValue(Division(initialValue)), Exceptions.ExceptionError()); Assert.True(resultValue.HasErrors); Assert.Equal(ErrorResultType.DivideByZero, resultValue.Errors.First().ErrorResultType); }
public async Task ResultValueTryOkTaskAsync_OkResult_ExceptionTry() { const int initialValue = 0; var numberResult = ResultValueFactory.CreateTaskResultValue(initialValue); var numberAfterTry = await numberResult.ResultValueTryOkTaskAsync(Division, Exceptions.ExceptionError()); Assert.True(numberAfterTry.HasErrors); Assert.Equal(ErrorResultType.DivideByZero, numberAfterTry.Errors.First().ErrorResultType); }
public async Task ResultValueOkToCollectionTaskAsync_Ok_ReturnNewValue() { int initialValue = Numbers.Number; var resultValue = ResultValueFactory.CreateTaskResultValue(initialValue); var resultAfterWhere = await resultValue.ResultValueOkToCollectionTaskAsync(NumberToCollection); Assert.True(resultAfterWhere.OkStatus); Assert.True(NumberToCollection(initialValue).SequenceEqual(resultAfterWhere.Value)); }
public async Task ResultValueBindBadTaskAsync_Ok_ReturnInitial() { int initialValue = Numbers.Number; var resultValue = ResultValueFactory.CreateTaskResultValue(initialValue); var resultAfterWhere = await resultValue.ResultValueBindBadTaskAsync(errors => new ResultValue <int>(errors.Count)); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(initialValue, resultAfterWhere.Value); }
public async Task ResultValueBindBadTaskAsync_Bad_ReturnNewValue() { var errorsInitial = CreateErrorListTwoTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <int>(errorsInitial); var resultAfterWhere = await resultValue.ResultValueBindBadTaskAsync(errors => new ResultValue <int>(errors.Count)); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(errorsInitial.Count, resultAfterWhere.Value); }
public async Task ResultValueBindOkTaskAsync_Ok_ReturnNewValue() { int initialValue = Numbers.Number; var resultValue = ResultValueFactory.CreateTaskResultValue(initialValue); var resultAfterWhere = await resultValue.ResultValueBindOkTaskAsync(number => new ResultValue <string>(number.ToString())); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(initialValue.ToString(), resultAfterWhere.Value); }
public async Task ResultValueBindOkTaskAsync_Bad_ReturnInitial() { var errorInitial = CreateErrorTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <int>(errorInitial); var resultAfterWhere = await resultValue.ResultValueBindOkTaskAsync(number => new ResultValue <string>(number.ToString())); Assert.True(resultAfterWhere.HasErrors); Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last())); }
public async Task ResultValueOkToCollectionTaskAsync_Bad_ReturnInitial() { var errorInitial = CreateErrorTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <int>(errorInitial); var resultAfterWhere = await resultValue.ResultValueOkToCollectionTaskAsync(NumberToCollection); Assert.True(resultAfterWhere.HasErrors); Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last())); }
public async Task ResultValueTryOkTaskAsync_ErrorResult_ExceptionTry() { var initialError = CreateErrorTest(); var numberResult = ResultValueFactory.CreateTaskResultValueError <int>(initialError); var numberAfterTry = await numberResult.ResultValueTryOkTaskAsync(Division, Exceptions.ExceptionError()); Assert.True(numberAfterTry.HasErrors); Assert.True(initialError.Equals(numberAfterTry.Errors.First())); }
public async Task ToResultCollectionTaskAsync_ReadOnlyCollection_OkStatus() { var collection = GetRangeNumber().ToList().AsReadOnly(); var resultNoError = ResultValueFactory.CreateTaskResultValue(collection); var resultValue = await resultNoError.ToResultCollectionTaskAsync(); Assert.True(resultValue.OkStatus); Assert.True(collection.SequenceEqual(resultValue.Value)); }
public async Task ToResultCollectionTaskAsync_Enumerable_OkStatus() { var collection = GetRangeNumber(); var resultNoError = ResultValueFactory.CreateTaskResultValue <IEnumerable <int> >(collection); var resultValue = await resultNoError.ToResultCollectionTaskAsync(); Assert.True(resultValue.OkStatus); Assert.True(collection.SequenceEqual(resultValue.Value)); }
public async Task ResultValueTryOkTaskAsync_OkResult_OkTry() { int initialValue = Numbers.Number; var numberResult = ResultValueFactory.CreateTaskResultValue(initialValue); var numberAfterTry = await numberResult.ResultValueTryOkTaskAsync(Division, CreateErrorTest()); Assert.True(numberAfterTry.OkStatus); Assert.Equal(Division(initialValue), numberAfterTry.Value); }
public async Task ResultValueBindTryOkAsync_OkResult_ExceptionTry() { const int initialNumber = 0; var numberResult = new ResultValue <int>(initialNumber); var numberAfterTry = await numberResult.ResultValueBindTryOkAsync( numbers => ResultValueFactory.CreateTaskResultValue(Division(numbers)), Exceptions.ExceptionError()); Assert.True(numberAfterTry.HasErrors); Assert.Equal(ErrorResultType.DivideByZero, numberAfterTry.Errors.First().ErrorResultType); }
public async Task ToResultCollectionTaskAsync_IReadOnlyCollection_HasErrors() { var error = CreateErrorTest(); var resultHasError = ResultValueFactory.CreateTaskResultValueError <IReadOnlyCollection <int> >(error); var resultValue = await resultHasError.ToResultCollectionTaskAsync(); Assert.True(resultValue.HasErrors); Assert.Single(resultValue.Errors); Assert.True(error.Equals(resultValue.Errors.Last())); }
public async Task ResultValueBindTryOkAsync_OkResult_OkTry() { int initialValue = Numbers.Number; var numberResult = new ResultValue <int>(initialValue); var numberAfterTry = await numberResult.ResultValueBindTryOkAsync( numbers => ResultValueFactory.CreateTaskResultValue(Division(numbers)), Exceptions.ExceptionError()); Assert.True(numberAfterTry.OkStatus); Assert.Equal(await AsyncFunctions.DivisionAsync(initialValue), numberAfterTry.Value); }
public async Task ResultValueCurryOkTaskAsync_OkStatus_AddOkStatus_FiveArguments() { int initialValue = Numbers.Number; var resultValueFunc = ResultValueFactory.CreateTaskResultValue(CurryFunctions.AggregateFiveToStringAsync); var resultArgument = new ResultValue <int>(initialValue); var resultOut = await resultValueFunc.ResultValueCurryOkTaskAsync(resultArgument); Assert.True(resultOut.OkStatus); Assert.Equal((initialValue * 5).ToString(), await resultOut.Value.Invoke(initialValue, initialValue, initialValue, initialValue)); }
public async Task ToResultBindValue_OkStatus() { var resultNoError = ResultErrorFactory.CreateTaskResultError(); const string value = "OkStatus"; var resultValue = ResultValueFactory.CreateTaskResultValue(value); var resultValueAfter = await resultNoError.ToResultBindValueBindAsync(resultValue); Assert.True(resultValueAfter.OkStatus); Assert.Equal(value, resultValueAfter.Value); }
public async Task ResultValueCurryOkAsync_OkStatus_AddOkStatus_TwoArguments() { int initialValue = Numbers.Number; var resultValueFunc = new ResultValue <Func <int, int, Task <string> > >(CurryFunctions.AggregateTwoToStringAsync); var resultArgument = ResultValueFactory.CreateTaskResultValue(initialValue); var resultOut = await resultValueFunc.ResultValueCurryOkAsync(resultArgument); Assert.True(resultOut.OkStatus); Assert.Equal((initialValue + initialValue).ToString(), await resultOut.Value.Invoke(initialValue)); }
public async Task ToResultBindValue_HasErrorsBind() { var resultNoError = ResultErrorFactory.CreateTaskResultError(); var error = CreateErrorTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <string>(error); var resultValueAfter = await resultNoError.ToResultBindValueBindAsync(resultValue); Assert.True(resultValueAfter.HasErrors); Assert.Single(resultValueAfter.Errors); Assert.True(error.Equals(resultValueAfter.Errors.Last())); }
public async Task ResultValueBindOkBadTaskAsync_Bad_ReturnNewValueByErrors() { var errorsInitial = CreateErrorListTwoTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <int>(errorsInitial); var resultAfterWhere = await resultValue.ResultValueBindOkBadTaskAsync( okFunc : _ => new ResultValue <string>(String.Empty), badFunc : errors => new ResultValue <string>(errors.Count.ToString())); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(errorsInitial.Count.ToString(), resultAfterWhere.Value); }
public async Task ResultValueBindContinueTaskAsync_Bad_ReturnNewError() { var errorInitial = CreateErrorTest(); var resultValue = ResultValueFactory.CreateTaskResultValueError <int>(errorInitial); var resultAfterWhere = await resultValue.ResultValueBindContinueTaskAsync(number => false, okFunc : _ => new ResultValue <string>(String.Empty), badFunc : _ => CreateErrorListTwoTest()); Assert.True(resultAfterWhere.HasErrors); Assert.Single(resultAfterWhere.Errors); }
public async Task ResultValueBindWhereTaskAsync_Ok_ReturnNewValue() { int initialValue = Numbers.Number; var resultValue = ResultValueFactory.CreateTaskResultValue(initialValue); var resultAfterWhere = await resultValue.ResultValueBindWhereTaskAsync(number => true, okFunc : number => new ResultValue <string>(number.ToString()), badFunc : _ => new ResultValue <string>(CreateErrorListTwoTest())); Assert.True(resultAfterWhere.OkStatus); Assert.Equal(initialValue.ToString(), resultAfterWhere.Value); }
public async Task ResultValueCurryOkAsync_OkStatus_AddBadStatus() { var resultValueFunc = new ResultValue <Func <int, Task <string> > >(CurryFunctions.IntToStringAsync); var errorArgument = CreateErrorTest(); var resultArgument = ResultValueFactory.CreateTaskResultValueError <int>(errorArgument); var resultOut = await resultValueFunc.ResultValueCurryOkAsync(resultArgument); Assert.True(resultOut.HasErrors); Assert.Single(resultOut.Errors); Assert.True(errorArgument.Equals(resultOut.Errors.Last())); }