public async Task ToResultValue_Ok()
{
var numbers = Collections.GetRangeNumber();
var resultCollectionTask = ResultCollectionFactory.CreateTaskResultCollection(numbers);
var resultValue = await resultCollectionTask.ToResultValue();
Assert.IsAssignableFrom <IResultValue <IReadOnlyCollection <int> > >(resultValue);
}
public async Task CreateTaskResultCollection_Ok()
{
var initialValue = GetRangeNumber();
var resultValue = await ResultCollectionFactory.CreateTaskResultCollection(initialValue);
Assert.True(resultValue.OkStatus);
Assert.True(initialValue.SequenceEqual(resultValue.Value));
}
public async Task ToActionResultCollectionAsync_OkRequest()
{
var initialTransfer = TransferData.GetTestTransfers();
var testTransfer = ResultCollectionFactory.CreateTaskResultCollection(initialTransfer);
var actionResult = await testTransfer.ToActionResultCollectionTaskAsync <TestEnum, ITestTransfer>();
Assert.True(initialTransfer.SequenceEqual(actionResult.Value));
}
public async Task ResultCollectionOkTaskAsync_Ok_ReturnNewValue()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultAfterWhere = await resultCollection.ResultCollectionOkTaskAsync(CollectionToString);
Assert.True(resultAfterWhere.OkStatus);
Assert.True((await CollectionToStringAsync(initialCollection)).SequenceEqual(resultAfterWhere.Value));
}
public async Task ResultCollectionTryTaskAsyncOk_OkResult_OkTry()
{
var initialNumbers = GetRangeNumber();
var numbersResult = ResultCollectionFactory.CreateTaskResultCollection(initialNumbers);
var numbersAfterTry = await numbersResult.ResultCollectionTryOkTaskAsync(DivisionByCollection, CreateErrorTest());
Assert.True(numbersAfterTry.OkStatus);
Assert.True(DivisionByCollection(initialNumbers).SequenceEqual(numbersAfterTry.Value));
}
public async Task ResultCollectionOkToValueTaskAsync_Ok_ReturnNewValue()
{
var numberCollection = Collections.GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(numberCollection);
var resultAfterWhere = await resultCollection.ResultCollectionOkToValueTaskAsync(Collections.AggregateToString);
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(await Collections.AggregateToStringAsync(numberCollection), resultAfterWhere.Value);
}
public async Task ResultCollectionTryTaskAsyncOk_OkResult_ExceptionTry()
{
var initialNumbers = GetRangeNumber();
var numberResult = ResultCollectionFactory.CreateTaskResultCollection(initialNumbers);
var numbersAfterTry = await numberResult.ResultCollectionTryOkTaskAsync(DivisionCollectionByZero, Exceptions.ExceptionError());
Assert.True(numbersAfterTry.HasErrors);
Assert.Equal(ErrorResultType.DivideByZero, numbersAfterTry.Errors.First().ErrorResultType);
}
public async Task ResultCollectionBindOkAsync_Bad_ReturnInitial()
{
var errorInitial = CreateErrorTest();
var resultCollection = new ResultCollection <int>(errorInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindOkAsync(
numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)));
Assert.True(resultAfterWhere.HasErrors);
Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last()));
}
public async Task ResultCollectionBindBadAsync_Ok_ReturnInitial()
{
var numberCollection = GetRangeNumber();
var resultCollection = new ResultCollection <int>(numberCollection);
var resultAfterWhere = await resultCollection.ResultCollectionBindBadAsync(
errors => ResultCollectionFactory.CreateTaskResultCollection(GetListByErrorsCount(errors)));
Assert.True(resultAfterWhere.OkStatus);
Assert.True(numberCollection.SequenceEqual(resultAfterWhere.Value));
}
public async Task ResultCollectionBindBadAsync_Bad_ReturnNewValue()
{
var errorsInitial = CreateErrorListTwoTest();
var resultCollection = new ResultCollection <int>(errorsInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindBadAsync(
errors => ResultCollectionFactory.CreateTaskResultCollection(GetListByErrorsCount(errors)));
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(errorsInitial.Count, resultAfterWhere.Value.First());
}
public async Task ResultValueBindOkToCollectionAsync_Bad_ReturnInitial()
{
var errorInitial = CreateErrorTest();
var resultValue = new ResultValue <int>(errorInitial);
var resultAfterWhere = await resultValue.ResultValueBindOkToCollectionAsync(
number => ResultCollectionFactory.CreateTaskResultCollection(NumberToCollection(number)));
Assert.True(resultAfterWhere.HasErrors);
Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last()));
}
public async Task ResultValueBindOkToCollectionAsync_Ok_ReturnNewValue()
{
int initialValue = Numbers.Number;
var resultValue = new ResultValue <int>(initialValue);
var resultAfterWhere = await resultValue.ResultValueBindOkToCollectionAsync(
number => ResultCollectionFactory.CreateTaskResultCollection(NumberToCollection(number)));
Assert.True(resultAfterWhere.OkStatus);
Assert.True(NumberToCollection(initialValue).SequenceEqual(resultAfterWhere.Value));
}
public async Task ResultCollectionBindOkAsync_Ok_ReturnNewValue()
{
var numberCollection = GetRangeNumber();
var resultCollection = new ResultCollection <int>(numberCollection);
var resultAfterWhere = await resultCollection.ResultCollectionBindOkAsync(
numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)));
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(await CollectionToStringAsync(numberCollection), resultAfterWhere.Value);
}
public async Task ResultCollectionBindWhereBindAsync_Ok_ReturnNewValue()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultAfterWhere = await resultCollection.ResultCollectionBindWhereBindAsync(numbers => true,
okFunc : numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)),
badFunc : _ => ResultCollectionFactory.CreateTaskResultCollectionError <string>(CreateErrorListTwoTest()));
Assert.True(resultAfterWhere.OkStatus);
Assert.True((await CollectionToStringAsync(initialCollection)).SequenceEqual(resultAfterWhere.Value));
}
public async Task ResultCollectionWhereTaskAsync_Ok_ReturnNewValue()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultAfterWhere = await resultCollection.ResultCollectionWhereTaskAsync(numbers => true,
okFunc : CollectionToString,
badFunc : _ => GetEmptyStringList());
Assert.True(resultAfterWhere.OkStatus);
Assert.True((await CollectionToStringAsync(initialCollection)).SequenceEqual(resultAfterWhere.Value));
}
public async Task ResultCollectionContinueToValueTaskAsync_Ok_ReturnNewValue()
{
var numberCollection = Collections.GetRangeNumber();
var resultCollectionTask = ResultCollectionFactory.CreateTaskResultCollection(numberCollection);
var resultAfterWhere = await resultCollectionTask.ResultCollectionContinueToValueTaskAsync(numbers => true,
okFunc : Collections.AggregateToString,
badFunc : _ => CreateErrorListTwoTest());
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(await Collections.AggregateToStringAsync(numberCollection), resultAfterWhere.Value);
}
public async Task ResultCollectionBadTaskAsync_Ok_ReturnInitial()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultAfterWhere = await resultCollection.ResultCollectionBadTaskAsync(errors => new List <int> {
errors.Count
});
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(initialCollection, resultAfterWhere.Value);
}
public async Task ResultCollectionVoidOkBadTaskAsync_Ok()
{
var initialCollection = GetRangeNumber();
var resultOk = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = await resultOk.ResultCollectionVoidOkBadTaskAsync(numbers => voidObjectMock.Object.TestNumbersVoid(numbers),
_ => voidObjectMock.Object.TestVoid());
Assert.True(resultAfterVoid.Equals(resultOk.Result));
Assert.Equal(initialCollection, resultAfterVoid.Value);
voidObjectMock.Verify(voidObject => voidObject.TestNumbersVoid(initialCollection), Times.Once);
}
public async Task ResultCollectionOkBindAsync_Ok_CallVoid()
{
var initialCollection = GetRangeNumber();
var resultOkTask = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = await resultOkTask.ResultCollectionVoidOkTaskAsync(
numbers => voidObjectMock.Object.TestNumbersVoid(numbers));
Assert.True(resultAfterVoid.Equals(resultOkTask.Result));
Assert.True(initialCollection.SequenceEqual(resultAfterVoid.Value));
voidObjectMock.Verify(voidObject => voidObject.TestNumbersVoid(It.IsAny <IEnumerable <int> >()), Times.Once);
}
public async Task ResultCollectionContinueTaskAsync_Ok_ReturnNewError()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var errorsBad = CreateErrorListTwoTest();
var resultAfterWhere = await resultCollection.ResultCollectionContinueTaskAsync(number => false,
okFunc : _ => GetEmptyStringList(),
badFunc : number => errorsBad);
Assert.True(resultAfterWhere.HasErrors);
Assert.Equal(errorsBad.Count, resultAfterWhere.Errors.Count);
}
public async Task ResultCollectionBindContinueBindAsync_Ok_ReturnNewError()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var errorsBad = CreateErrorListTwoTest();
var resultAfterWhere = await resultCollection.ResultCollectionBindContinueBindAsync(number => false,
okFunc : numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)),
badFunc : number => ToTaskEnumerable(errorsBad));
Assert.True(resultAfterWhere.HasErrors);
Assert.Equal(errorsBad.Count, resultAfterWhere.Errors.Count);
}
public async Task ResultCollectionContinueToValueTaskAsync_Ok_ReturnNewError()
{
var numberCollection = Collections.GetRangeNumber();
var resultCollectionTask = ResultCollectionFactory.CreateTaskResultCollection(numberCollection);
var errorsBad = CreateErrorListTwoTest();
var resultAfterWhere = await resultCollectionTask.ResultCollectionContinueToValueTaskAsync(numbers => false,
okFunc : _ => String.Empty,
badFunc : numbers => errorsBad);
Assert.True(resultAfterWhere.HasErrors);
Assert.Equal(errorsBad.Count, resultAfterWhere.Errors.Count);
}
public async Task ResultCollectionBindErrorsOkBindAsync_NoError()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultError = new ResultError();
var resultFunctionsMock = GetNumberToError(resultError);
var resultAfterWhere = await resultCollection.ResultCollectionBindErrorsOkBindAsync(
numbers => resultFunctionsMock.Object.NumbersToResultAsync(numbers));
Assert.True(resultAfterWhere.OkStatus);
Assert.True(initialCollection.SequenceEqual(resultAfterWhere.Value));
resultFunctionsMock.Verify(resultFunctions => resultFunctions.NumbersToResultAsync(It.IsAny <IReadOnlyCollection <int> >()), Times.Once);
}
public async Task ResultCollectionWhereTaskAsync_Ok_ReturnNewValueByErrors()
{
var initialCollection = GetRangeNumber();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultAfterWhere = await resultCollection.ResultCollectionWhereTaskAsync(number => false,
okFunc : _ => GetEmptyStringList(),
badFunc : numbers => new List <string> {
numbers.Count.ToString()
});
Assert.True(resultAfterWhere.OkStatus);
Assert.Single(resultAfterWhere.Value);
Assert.Equal(initialCollection.Count.ToString(), resultAfterWhere.Value.First());
}
public async Task ResultCollectionBindErrorsOkBindAsync_HasError()
{
var initialCollection = GetRangeNumber();
var initialError = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollection(initialCollection);
var resultError = new ResultError(initialError);
var resultFunctionsMock = GetNumberToError(resultError);
var resultAfterWhere = await resultCollection.ResultCollectionBindErrorsOkBindAsync(
number => resultFunctionsMock.Object.NumbersToResultAsync(number));
Assert.True(resultAfterWhere.HasErrors);
Assert.True(initialError.Equals(resultAfterWhere.Errors.First()));
resultFunctionsMock.Verify(resultFunctions => resultFunctions.NumbersToResultAsync(It.IsAny <IReadOnlyCollection <int> >()), Times.Once);
}
public async Task ResultCollectionBindWhereBindAsync_Bad_ReturnNewValue()
{
var errorInitial = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindWhereBindAsync(number => true,
okFunc : numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)),
badFunc : _ => ResultCollectionFactory.CreateTaskResultCollectionError <string>(CreateErrorListTwoTest()));
Assert.True(resultAfterWhere.HasErrors);
Assert.Single(resultAfterWhere.Errors);
}
public async Task ResultCollectionBindContinueAsync_Bad_ReturnNewError()
{
var errorsInitial = CreateErrorTest();
var resultCollection = new ResultCollection <int>(errorsInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindContinueAsync(number => false,
okFunc : numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)),
badFunc : _ => CreateErrorListTwoTestTask());
Assert.True(resultAfterWhere.HasErrors);
Assert.Single(resultAfterWhere.Errors);
}