public void IncorrectData_ReturnExpectedResultObject <T>(T candidate, SpecificationResult expected)
{
var sut = new MockCommonSpecification <T>();
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void ValidCandidate_ReturnExpectedResultObject(string candidate, SpecificationResult expected)
{
var sut = new EmailSpecification();
var overall = sut.IsSatisfiedBy(candidate, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void Nullable_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("NotMockCommonSpecification<Nullable<Int32>>");
var sut = new MockCommonSpecification <int?>();
var overall = sut.IsNotSatisfiedBy(0, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public static SpecificationResult IsSatisfiedBy(StudentListModel studentAddUpdateModel, Expression <Func <StudentBl, bool> > predicate)
{
var spec = Specification.NotNull <Expression <Func <StudentBl, bool> > >();
var specificationResult = new SpecificationResult();
spec.IsSatisfiedBy(predicate, out specificationResult);
return(specificationResult);
}
public void ValueTypeCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("NotNullSpecification<Int32>");
var sut = new NullSpecification <int>();
var overall = sut.IsNotSatisfiedBy(0, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void HasValueFalseNull()
{
HasValueSpecification not = new HasValueSpecification("k2");
SpecificationResult result = not.Evaluate(new Dictionary <string, object> {
{ "k2", null }
});
Assert.False(result.IsSatisfied);
Assert.Equal("key k2 has null value", result.Details);
}
public void InvalidCandidate_ReturnExpectedResultObject <T>(T candidate, Type expected,
SpecificationResult expResult)
{
var sut = new IsTypeSpecification <T>(expected);
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expResult, result, new SpecificationResultComparer(candidate));
}
public void ValidCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("TrueSpecification");
var sut = new TrueSpecification();
var overall = sut.IsSatisfiedBy(true, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void CorrectNullableCandidate_ReturnExpectedResultObject(int?candidate, int?greaterThan,
SpecificationResult expected)
{
var sut = new GreaterThanOrEqualSpecification <int?>(greaterThan);
var overall = sut.IsSatisfiedBy(candidate, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void HasValueTrue()
{
HasValueSpecification not = new HasValueSpecification("k1");
SpecificationResult result = not.Evaluate(new Dictionary <string, object> {
{ "k1", "v1" }
});
Assert.True(result.IsSatisfied);
Assert.Null(result.Details);
}
public void IncorrectNullableCandidate_ReturnExpectedResultObject(int?candidate, int?lessThan,
SpecificationResult expected)
{
var sut = new LessThanSpecification <int?>(lessThan);
var overall = sut.IsSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void NullCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("NullSpecification<String>");
var sut = new NullSpecification <string>();
var overall = sut.IsSatisfiedBy(null, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public SpecificationDataRow NegationResult(int totalSpecificationsCount, string trace,
Action <ISpecificationResultCreator> creator = null)
{
_failedSpecificationDataRows.Clear();
creator?.Invoke(this);
_negationDataResult = new SpecificationResult(totalSpecificationsCount, !_overall, trace,
_failedSpecificationDataRows.Select(dr => dr.CreateFailedSpecification()).ToArray());
return(this);
}
public void CorrectNullableCandidate_ReturnExpectedResultObject(int?candidate, int?from, int?to,
SpecificationResult expected)
{
var sut = new InclusiveBetweenSpecification <int?>(from, to);
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void InvalidCandidate_ReturnExpectedResultObject(string candidate, string expected,
SpecificationResult expResult)
{
var sut = new ContainsSpecification(expected);
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expResult, result, new SpecificationResultComparer(candidate));
}
public void SingleSingleDetails()
{
EqualSpecification specification = new EqualSpecification("key", SpecificationValue.Single(1));
SpecificationResult spr = specification.Evaluate(new Dictionary <string, object> {
{ "key", 2 }
});
Assert.False(spr.IsSatisfied);
Assert.Equal("Right value(s) 1 not satisfied left value(s) 2 in key equal 1", spr.Details);
}
public void HasValueFalse()
{
HasValueSpecification not = new HasValueSpecification("k2");
SpecificationResult result = not.Evaluate(new Dictionary <string, object> {
{ "k1", "v1" }
});
Assert.False(result.IsSatisfied);
Assert.Equal("key k2 not found", result.Details);
}
public void EmptyNullable_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("EmptySpecification<Nullable<Int32>>");
var sut = new EmptySpecification <int?>();
var overall = sut.IsSatisfiedBy(null, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void EmptyCandidate_ReturnExpectedResultObject <T>(T candidate, SpecificationResult expected)
{
candidate = candidate?.ToString() != "null" ? candidate : default;
var sut = new EmptySpecification <T>();
var overall = sut.IsSatisfiedBy(candidate, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public StringContainsData()
{
SpecificationResult validResult = new SpecificationResult("ContainsSpecification"),
negationResult = new SpecificationResult("NotContainsSpecification");
Valid("lorem ipsum", "lorem ipsum")
.Result(validResult)
.NegationResult("NotContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String contains [lorem ipsum]")
.Candidate("lorem ipsum")
.AddParameter("Expected", "lorem ipsum"));
Valid("lorem ipsum", "lorem")
.Result(validResult)
.NegationResult("NotContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String contains [lorem]")
.Candidate("lorem ipsum")
.AddParameter("Expected", "lorem"));
Valid("lorem ipsum", "ipsum")
.Result(validResult)
.NegationResult("NotContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String contains [ipsum]")
.Candidate("lorem ipsum")
.AddParameter("Expected", "ipsum"));
Valid("lorem ipsum", " ")
.Result(validResult)
.NegationResult("NotContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String contains [ ]")
.Candidate("lorem ipsum")
.AddParameter("Expected", " "));
Invalid(null, "test")
.NegationResult(negationResult)
.Result("ContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String not contains [test]")
.Candidate(null)
.AddParameter("Expected", "test"));
Invalid("test", "Test")
.NegationResult(negationResult)
.Result("ContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String not contains [Test]")
.Candidate("test")
.AddParameter("Expected", "Test"));
Invalid("test", "TEST")
.NegationResult(negationResult)
.Result("ContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String not contains [TEST]")
.Candidate("test")
.AddParameter("Expected", "TEST"));
Invalid("test", "testing")
.NegationResult(negationResult)
.Result("ContainsSpecification+Failed", c => c
.FailedSpecification(typeof(ContainsSpecification), "String not contains [testing]")
.Candidate("test")
.AddParameter("Expected", "testing"));
}
public void ValueTypeCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult(false, "NullSpecification<Int32>+Failed",
new FailedSpecification(typeof(NullSpecification <int>), 0, "Object is not null"));
var sut = new NullSpecification <int>();
var overall = sut.IsSatisfiedBy(0, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void NotNullCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult(false, "NullSpecification<String>+Failed",
new FailedSpecification(typeof(NullSpecification <string>), "", "Object is not null"));
var sut = new NullSpecification <string>();
var overall = sut.IsSatisfiedBy("", out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public override bool IsSatisfiedBy(Board target)
{
if (target.Owner == null)
{
SpecificationResult.AddError(
(int)DomainErrors.BoardDoesNotHaveOwner,
DomainMessageHelper.MessageHandler.GetMessageFromEnum(DomainErrors.BoardDoesNotHaveOwner));
}
return(!SpecificationResult.HasError);
}
public void InvalidCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult(false, "TrueSpecification+Failed",
new FailedSpecification(typeof(TrueSpecification), false, "Value is False"));
var sut = new TrueSpecification();
var overall = sut.IsSatisfiedBy(false, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void NotEmptyNullable_ReturnExpectedResultObject()
{
var expected = new SpecificationResult(false, "EmptySpecification<Nullable<Int32>>+Failed",
new FailedSpecification(typeof(EmptySpecification <int?>), 0, "Object is not empty"));
var sut = new EmptySpecification <int?>();
var overall = sut.IsSatisfiedBy(0, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
/// <summary>
/// Determines whether [is satisfied by] [the specified target].
/// </summary>
/// <param name="target">The target.</param>
/// <returns></returns>
public override bool IsSatisfiedBy(TaskList target)
{
if (target.Board == null)
{
SpecificationResult.AddError(
(int)DomainErrors.TaskListDoesNothaveBoard,
DomainMessageHelper.MessageHandler.GetMessageFromEnum(DomainErrors.TaskListDoesNothaveBoard));
}
return(!SpecificationResult.HasError);
}
public void InvalidCandidate_ReturnExpectedResultObject <T>(T candidate, int minLength, int maxLength,
SpecificationResult expected)
where T : IEnumerable
{
var sut = new LengthBetweenSpecification <T>(minLength, maxLength);
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void LessThanCandidate_ReturnExpectedResultObject <T>(T candidate, T lessThan, IComparer <T> comparer,
SpecificationResult expected)
{
candidate = candidate?.ToString() != "null" ? candidate : default;
var sut = new LessThanSpecification <T>(lessThan, comparer);
var overall = sut.IsNotSatisfiedBy(candidate, out var result);
Assert.False(overall);
Assert.Equal(expected, result, new SpecificationResultComparer(candidate));
}
public void ValidCandidate_ReturnExpectedResultObject <T>(T candidate, int length,
SpecificationResult expected)
where T : IEnumerable
{
var sut = new LengthSpecification <T>(length);
var overall = sut.IsSatisfiedBy(candidate, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
public void NullCandidate_ReturnExpectedResultObject()
{
var expected = new SpecificationResult("NotMatchSpecification");
var pattern = "^[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}$";
var sut = new MatchSpecification(pattern);
var overall = sut.IsNotSatisfiedBy(null, out var result);
Assert.True(overall);
Assert.Equal(expected, result, new SpecificationResultComparer());
}
