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