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 CreateTaskResultCollectionAsync_Ok()
{
var initialValue = GetRangeNumber();
var resultValue = await ResultCollectionFactory.CreateTaskResultCollectionAsync(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 CreateTaskResultCollectionAsync_Error()
{
var initialError = CreateErrorTest();
var resultValue = await ResultCollectionFactory.CreateTaskResultCollectionErrorAsync <int>(initialError);
Assert.True(resultValue.HasErrors);
Assert.True(initialError.Equals(resultValue.Errors.First()));
}
public async Task CreateTaskResultCollectionAsync_Errors()
{
var initialError = CreateErrorListTwoTest();
var resultValue = await ResultCollectionFactory.CreateTaskResultCollectionErrorAsync <int>(initialError);
Assert.True(resultValue.HasErrors);
Assert.True(initialError.SequenceEqual(resultValue.Errors));
}
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_Bad_ReturnInitial()
{
var errorInitial = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorInitial);
var resultAfterWhere = await resultCollection.ResultCollectionOkToValueTaskAsync(Collections.AggregateToString);
Assert.True(resultAfterWhere.HasErrors);
Assert.True(errorInitial.Equals(resultAfterWhere.Errors.Last()));
}
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 ResultCollectionTryTaskAsyncOk_ErrorResult_ExceptionTry()
{
var initialError = CreateErrorTest();
var numbersResult = ResultCollectionFactory.CreateTaskResultCollectionError <int>(initialError);
var numberAfterTry = await numbersResult.ResultCollectionTryOkTaskAsync(DivisionCollectionByZero, Exceptions.ExceptionError());
Assert.True(numberAfterTry.HasErrors);
Assert.True(initialError.Equals(numberAfterTry.Errors.First()));
}
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 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 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 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 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 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 ToActionResultCollectionAsync_NotFound()
{
var initialError = ErrorData.NotFoundError;
var testTransfer = ResultCollectionFactory.CreateTaskResultCollectionError <ITestTransfer>(initialError);
var actionResult = await testTransfer.ToActionResultCollectionTaskAsync <TestEnum, ITestTransfer>();
Assert.IsType <NotFoundResult>(actionResult.Result);
var notFoundRequest = (NotFoundResult)actionResult.Result;
Assert.Equal(StatusCodes.Status404NotFound, notFoundRequest.StatusCode);
}
public async Task ResultCollectionBadTaskAsync_Bad_ReturnNewValueByError()
{
var errorsInitial = CreateErrorListTwoTest();
var resultValue = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorsInitial);
var resultAfterWhere = await resultValue.ResultCollectionBadTaskAsync(errors => new List <int> {
errors.Count
});
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(errorsInitial.Count, resultAfterWhere.Value.First());
}
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 ResultCollectionBindWhereTaskAsync_Bad_ReturnNewValue()
{
var errorInitial = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindWhereTaskAsync(number => true,
okFunc : numbers => new ResultCollection <string>(CollectionToString(numbers)),
badFunc : _ => new ResultCollection <string>(CreateErrorListTwoTest()));
Assert.True(resultAfterWhere.HasErrors);
Assert.Single(resultAfterWhere.Errors);
}
public async Task ResultCollectionBindContinueBindAsync_Bad_ReturnNewError()
{
var errorsInitial = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorsInitial);
var resultAfterWhere = await resultCollection.ResultCollectionBindContinueBindAsync(number => false,
okFunc : numbers => ResultCollectionFactory.CreateTaskResultCollection(CollectionToString(numbers)),
badFunc : _ => CreateErrorListTwoTestTask());
Assert.True(resultAfterWhere.HasErrors);
Assert.Single(resultAfterWhere.Errors);
}
public async Task ResultCollectionContinueToValueTaskAsync_Bad_ReturnNewError()
{
var errorInitial = CreateErrorTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorInitial);
var resultAfterWhere = await resultCollection.ResultCollectionContinueToValueTaskAsync(number => false,
okFunc : _ => String.Empty,
badFunc : _ => CreateErrorListTwoTest());
Assert.True(resultAfterWhere.HasErrors);
Assert.Single(resultAfterWhere.Errors);
}
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 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 ResultCollectionOkBadToValueTaskAsync_Bad_ReturnNewValueByErrors()
{
var errorsInitial = CreateErrorListTwoTest();
var resultCollection = ResultCollectionFactory.CreateTaskResultCollectionError <int>(errorsInitial);
var resultAfterWhere = await resultCollection.ResultCollectionOkBadToValueTaskAsync(
okFunc : _ => String.Empty,
badFunc : errors => errors.Count.ToString());
Assert.True(resultAfterWhere.OkStatus);
Assert.Equal(errorsInitial.Count.ToString(), 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 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);
}
