public void ShouldStringifyGivenIntegerWhenApplyIsCalled()
{
var input = Any.Integer();
var outputBuilder = Substitute.For <IOutputBuilder>();
var rule = new IntegerRule(Any.Boolean(), Any.InstanceOf <IRule>(), outputBuilder);
rule.Apply(input);
outputBuilder.Received().Append(input.ToString());
}
private static object GenerateForColumn(TableColumnInfo columnInfo)
{
switch (columnInfo.ColumnType)
{
case ColumnType.String:
// generates a random string
return(Any.String(columnInfo.MaxLength));
case ColumnType.Int:
// generates a random integer
long maxValue = (int)Math.Pow(10, columnInfo.Precision - 1);
if (maxValue > int.MaxValue)
{
return(Any.Long(1, maxValue));
}
return(Any.Int(1, (int)maxValue));
case ColumnType.Decimal:
// generates a random decimal
return(Any.Double(columnInfo.Precision, columnInfo.Scale));
case ColumnType.Double:
// generates a random double
return(Any.Double(columnInfo.Precision, columnInfo.Scale));
case ColumnType.Long:
// generates a random long
return(Any.Long(1, (int)Math.Pow(10, columnInfo.Precision - 1)));
case ColumnType.Boolean:
// generates a random boolean
return(Any.Boolean());
case ColumnType.Guid:
// generates a random guid
return(Guid.NewGuid());
case ColumnType.Date:
// generates a random date
return(Any.DateTime().Date);
case ColumnType.Datetime:
// generates a random DateTime
return(Any.DateTime());
default:
return(null);
}
}
public void ShouldMatchDependingOnWhetherTheDependencyHasMatchingPackageReference()
{
//GIVEN
var packagePattern = Any.Instance <Glob>();
var condition = new HasPackageReferenceMatchingCondition(packagePattern);
var depending = Any.Instance <IProjectSearchResult>();
var dependency = Substitute.For <IDependencyPathBasedRuleTarget>();
var dependencyAnswer = Any.Boolean();
dependency.HasPackageReferenceMatching(packagePattern).Returns(dependencyAnswer);
//WHEN
var matches = condition.Matches(depending, dependency);
//THEN
matches.Should().Be(dependencyAnswer);
}
public void ShouldReturnResultOfQueryWhetherProjectHasAssembly()
{
//GIVEN
var depending = Any.Instance <IProjectSearchResult>();
var dependency = Substitute.For <IDependencyPathBasedRuleTarget>();
var pattern = Any.Instance <Glob>();
var dependencyResponse = Any.Boolean();
var condition = new HasAssemblyReferenceMatchingCondition(pattern);
dependency.HasAssemblyReferenceWithNameMatching(pattern).Returns(dependencyResponse);
//WHEN
var matches = condition.Matches(depending, dependency);
//THEN
matches.Should().Be(dependencyResponse);
}
public void ShouldMatchWhenItsInnerConditionMatches()
{
//GIVEN
var innerCondition = Substitute.For <IDependencyCondition>();
var innerMatching = Any.Boolean();
var condition = new DescribedCondition(innerCondition, Any.Instance <RuleDescription>());
var depending = Any.Instance <IProjectSearchResult>();
var dependency = Any.Instance <IDependencyPathBasedRuleTarget>();
innerCondition.Matches(depending, dependency).Returns(innerMatching);
//WHEN
var matches = condition.Matches(depending, dependency);
//THEN
matches.Should().Be(innerMatching);
}
public void ShouldSayItIsARootWhenItHasNoReferencingProjectsOtherwiseNo()
{
//GIVEN
var referencingProjects = Substitute.For <IReferencingProjects>();
var areThereAnyReferencingProjects = Any.Boolean();
var project = new DotNetStandardProjectBuilder
{
ReferencingProjects = referencingProjects
}.Build();
referencingProjects.AreEmpty().Returns(areThereAnyReferencingProjects);
//WHEN
var isRoot = project.IsRoot();
//THEN
isRoot.Should().Be(areThereAnyReferencingProjects);
}
public void PlainGenerators()
{
Any.Integer();
Any.Instance <int>();
Any.DateTime();
Any.Instance <DateTime>();
Any.Boolean();
Any.Instance <bool>();
Any.Char();
Any.Instance <char>();
//...etc
Any.Uri();
Any.IpAddress();
//...
}
public void ShouldReturnsMatchBasedOnInnerConditionsMatchLogicalProduct()
{
//GIVEN
var condition1 = Substitute.For <IDependencyCondition>();
var condition2 = Substitute.For <IDependencyCondition>();
var depending = Any.Instance <IProjectSearchResult>();
var dependency = Any.Instance <IDependencyPathBasedRuleTarget>();
var condition1Result = Any.Boolean();
var condition2Result = Any.Boolean();
var joinedCondition = new JoinedDescribedCondition(condition1, condition2, Any.Instance <RuleDescription>());
condition1.Matches(depending, dependency).Returns(condition1Result);
condition2.Matches(depending, dependency).Returns(condition2Result);
//WHEN
var matches = joinedCondition.Matches(depending, dependency);
//THEN
matches.Should().Be(condition1Result && condition2Result);
}
public bool IsSatisfied()
{
return(Any.Boolean());
}
public static bool IsWeekend()
{
return(Any.Boolean());
}
public static bool IsNight()
{
return(Any.Boolean());
}
