public async Task RecoverValueAsyncFailure_SourceIsDefaultOrFailureAndOtherIsFailure_ExpectOther(
Result <RefType, StructType> source)
{
Result <RefType, SomeError> other = new SomeError(PlusFifteen);
var actual = await source.RecoverValueAsync(_ => ValueTask.FromResult(other));
Assert.AreEqual(other, actual);
}
public async Task ForwardAsyncMapFailure_SourceIsSuccessAndNextIsDefault_ExpectDefault(
Result <RefType, StructType> source)
{
var next = default(Result <string, SomeError>);
var mappedFailure = new SomeError(PlusFifteen);
var actual = await source.ForwardAsync(_ => Task.FromResult(next), _ => Task.FromResult(mappedFailure));
Assert.AreEqual(next, actual);
}
public void FilterAsyncWithMapFailure_CauseFactoryIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var mapped = new SomeError(MinusFifteen);
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.FilterAsync(_ => Task.FromResult(true), null !, _ => Task.FromResult(mapped)));
Assert.AreEqual("causeFactoryAsync", actualException !.ParamName);
}
public void ForwardAsyncMapFailure_MapFailureIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeError(MinusFifteen);
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.ForwardAsync(_ => Task.FromResult(next), null !));
Assert.AreEqual("mapFailureAsync", actualException !.ParamName);
}
public void ForwardAsyncMapFailure_NextFactoryAsyncIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var mappedFailure = new SomeError(PlusFifteen);
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.ForwardAsync <SomeRecord, SomeError>(null !, _ => Task.FromResult(mappedFailure)));
Assert.AreEqual("nextFactoryAsync", actualException !.ParamName);
}
public void FilterWithMapFailure_MapFailureIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var causeFailure = new SomeError(int.MinValue);
var actualException = Assert.Throws <ArgumentNullException>(
() => _ = source.Filter(_ => true, _ => causeFailure, null !));
Assert.AreEqual("mapFailure", actualException !.ParamName);
}
public void FilterWithMapFailure_CauseFactoryIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var mappedFailure = new SomeError(int.MaxValue);
var actualException = Assert.Throws <ArgumentNullException>(
() => _ = source.Filter(_ => false, null !, _ => mappedFailure));
Assert.AreEqual("causeFactory", actualException !.ParamName);
}
public async Task ForwardAsyncMapFailure_SourceIsSuccessAndNextIsFailure_ExpectNext(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = Result.Failure(new SomeError(MinusFifteen));
var mappedFailure = new SomeError(int.MinValue);
var actual = await source.ForwardAsync(_ => Task.FromResult(next), _ => Task.FromResult(mappedFailure));
Assert.AreEqual(next, actual);
}
public void TaggedUnion_ToResult_SourceUnionIsSecond_ExpectFailureResult()
{
var sourceValue = new SomeError(MinusFifteen);
var sourceUnion = TaggedUnion <RefType?, SomeError> .Second(sourceValue);
var actual = sourceUnion.ToResult();
var expected = Result <RefType?, SomeError> .Failure(sourceValue);
Assert.AreEqual(expected, actual);
}
public void RecoverWithMapSuccess_SourceIsDefaultOrFailureAndOtherIsFailure_ExpectOther(
Result <RefType, StructType> source)
{
Result <object, SomeError> other = new SomeError(PlusFifteen);
var mappedValue = new object();
var actual = source.Recover(_ => other, _ => mappedValue);
Assert.AreEqual(other, actual);
}
public async Task ForwardValueAsyncMapFailure_SourceIsSuccessAndNextIsSuccess_ExpectNext(
Result <RefType, StructType> source)
{
Result <RefType, SomeError> next = Result.Success(PlusFifteenIdRefType);
var mappedFailure = new SomeError(int.MaxValue);
var actual = await source.ForwardValueAsync(_ => ValueTask.FromResult(next), _ => ValueTask.FromResult(mappedFailure));
Assert.AreEqual(next, actual);
}
public void MapAsync_MapSuccessAsyncIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var failureResult = new SomeError(MinusFifteen);
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.MapAsync <int, SomeError>(null !, _ => Task.FromResult(failureResult)));
Assert.AreEqual("mapSuccessAsync", actualException !.ParamName);
}
public async Task MapFailureAsync_SourceIsDefaultOrFailure_FailureExpectResultOfMapFailureAsync(
Result <RefType, StructType> source)
{
var failureResult = new SomeError(PlusFifteen);
var actual = await source.MapFailureAsync(_ => Task.FromResult(failureResult));
var exected = new Result <RefType, SomeError>(failureResult);
Assert.AreEqual(exected, actual);
}
public async Task MapFailureAsync_SourceIsSuccess_ExpectResultOfSourceSuccess(
Result <RefType, StructType> source)
{
var failureResult = new SomeError(int.MaxValue);
var actual = await source.MapFailureAsync(_ => Task.FromResult(failureResult));
var exected = new Result <RefType, SomeError>(PlusFifteenIdRefType);
Assert.AreEqual(exected, actual);
}
public void ForwardMapFailure_SourceIsSuccessAndNextIsFailure_ExpectNext(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeError(MinusFifteen);
var mappedFailure = new SomeError(int.MaxValue);
var actual = source.Forward(_ => next, _ => mappedFailure);
Assert.AreEqual(next, actual);
}
public void ForwardMapFailure_NextFactoryIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var mappedFailure = new SomeError(MinusFifteen);
var actualException = Assert.Throws <ArgumentNullException>(
() => _ = source.Forward <SomeRecord, SomeError>(null !, _ => mappedFailure));
Assert.AreEqual("nextFactory", actualException !.ParamName);
}
public void MapFailure_SourceIsSuccess_ExpectResultOfSourceSuccess(
Result <RefType, StructType> source)
{
var failureResult = new SomeError(int.MaxValue);
var actual = source.MapFailure(_ => failureResult);
var exected = new Result <RefType, SomeError>(MinusFifteenIdRefType);
Assert.AreEqual(exected, actual);
}
public void MapFailure_SourceIsDefaultOrFailure_FailureExpectResultOfMapFailure(
Result <RefType, StructType> source)
{
var failureResult = new SomeError(MinusFifteen);
var actual = source.MapFailure(_ => failureResult);
var exected = new Result <RefType, SomeError>(failureResult);
Assert.AreEqual(exected, actual);
}
public async Task RecoverAsyncWithMapSuccess_SourceIsDefaultOrFailureAndOtherIsFailure_ExpectOther(
Result <RefType, StructType> source)
{
Result <string, SomeError> other = new SomeError(PlusFifteen);
var mappedValue = "Some success text value";
var actual = await source.RecoverAsync(_ => Task.FromResult(other), _ => Task.FromResult(mappedValue));
Assert.AreEqual(other, actual);
}
public void FilterWithMapFailure_PredicateIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var causeFailure = new SomeError(MinusFifteen);
var mappedFailure = new SomeError(int.MinValue);
var actualException = Assert.Throws <ArgumentNullException>(
() => _ = source.Filter(null !, _ => causeFailure, _ => mappedFailure));
Assert.AreEqual("predicate", actualException !.ParamName);
}
public void ForwardMapFailure_SourceIsDefaultOrFailure_ExpectResultOfMappedFailure(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeRecord();
var mappedFailure = new SomeError(MinusFifteen);
var actual = source.Forward(_ => next, _ => mappedFailure);
var expected = new Result <SomeRecord, SomeError>(mappedFailure);
Assert.AreEqual(expected, actual);
}
public void GetHashCode_SourceIsNotDefaultAndOtherIsSameAsSourceFailure_ExpectHashCodesAreNotEqual()
{
var failure = new SomeError(PlusFifteen);
var source = Result.Failure(failure);
var other = failure;
var sourceHashCode = source.GetHashCode();
var otherHashCode = other.GetHashCode();
Assert.AreNotEqual(sourceHashCode, otherHashCode);
}
public async Task ForwardAsyncMapFailure_SourceIsDefaultOrFailure_ExpectResultOfMappedFailure(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeRecord();
var mappedFailure = new SomeError(MinusFifteen);
var actual = await source.ForwardAsync(_ => Task.FromResult(next), _ => Task.FromResult(mappedFailure));
var expected = new Result <SomeRecord, SomeError>(mappedFailure);
Assert.AreEqual(expected, actual);
}
public void Equality_LeftFailureIsNotEqualToRightFailure_ExpectFalse()
{
var leftFailure = new SomeError(PlusFifteen);
var left = Result.Failure(leftFailure);
var rightFailure = new SomeError(MinusFifteen);
var right = Result.Failure(rightFailure);
var actual = left == right;
Assert.False(actual);
}
public async Task FoldValueAsync_SourceIsDefaultOrFailure_ExpectResultOfMapFailure(
Result <RefType, StructType> source)
{
SomeError?successResult = new SomeError(PlusFifteen);
SomeError?failureResult = null;
var actual = await source.FoldValueAsync(
_ => ValueTask.FromResult(successResult),
_ => ValueTask.FromResult(failureResult));
Assert.AreEqual(failureResult, actual);
}
public void Inequality_LeftFailureIsNotEqualToRightFailure_ExpectTrue()
{
var leftFailure = new SomeError(MinusFifteen);
var left = Result.Failure(leftFailure);
var rightFailure = new SomeError(int.MaxValue);
var right = Result.Failure(rightFailure);
var actual = left != right;
Assert.True(actual);
}
public void FilterValueAsyncWithMapFailure_PredicateIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var cause = new SomeError(MinusFifteen);
var mapped = new SomeError(int.MaxValue);
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.FilterValueAsync(
null !, _ => ValueTask.FromResult(cause), _ => ValueTask.FromResult(mapped)));
Assert.AreEqual("predicateAsync", actualException !.ParamName);
}
public void EqualsObject_SourceFailureIsNotEqualToOtherFailureAndTypesAreSame_ExpectFalse()
{
var sourceFailure = new SomeError(PlusFifteen);
var source = Result.Failure(sourceFailure);
var otherFailure = new SomeError(MinusFifteen);
object?other = Result.Failure(otherFailure);
var actual = source.Equals(other);
Assert.False(actual);
}
public void GetHashCode_SourceFailureIsNotEqualToOtherFailureAndTypesAreSame_ExpectHashCodesAreNotEqual()
{
var sourceFailure = new SomeError(PlusFifteen);
var source = Result.Failure(sourceFailure);
var otherFailure = new SomeError(MinusFifteen);
var other = Result.Failure(otherFailure);
var sourceHashCode = source.GetHashCode();
var otherHashCode = other.GetHashCode();
Assert.AreNotEqual(sourceHashCode, otherHashCode);
}
public void EqualsInequality_ResultAIsFailureAndResultBIsFailureAndValuesAreEqual_ExpectFalse()
{
var errorCode = PlusFifteen;
var aValue = new SomeError(errorCode);
var resultA = Result <DateTimeOffset, SomeError> .Failure(aValue);
var bValue = new SomeError(errorCode);
var resultB = new Result <DateTimeOffset, SomeError>(bValue);
var actual = resultA != resultB;
Assert.False(actual);
}