public void NotInThrowsExceptionIfPassedEmptyCollection()
{
// Arrange
var r = new WhenRequiredRule("ARule").Property("AProperty");
// Act
r.In(new List <string>());
}
private void RequiredThrowsExceptionOnNullEquivalent(string RequiredProperty)
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("AProperty").Equals("AValue").Then();
// Act
r.Required(RequiredProperty);
}
private void NotEqualsThrowsExceptionWhenValueIsNullEquivalent(string Value)
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("AProperty");
// Act
r.NotEquals(Value);
}
public void NotEqualsThrowsExceptionWhenPropertyNameNotDeclared()
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
// Act
r.NotEquals("AStringValue");
}
private void PropertyThrowsExceptionOnNullEquivalent(string property)
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
// Act
r.Property(property);
}
public void ThenThrowsExceptionIfNoWhenComparisonsDefined()
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
// Act
r.Then();
}
public void PropertyThrowsExceptionWhenThenHasBeenCalled()
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("AProperty").Equals("AValue").Then();
// Act
r.Property("BProperty");
}
public void PropertyThrowsExceptionWhenPropertyNameIsSetTwice()
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
r.Property("APropertyName");
// Act
r.Property("BPropertyName");
}
public void ThenThrowsExceptionIfPropertyDeclaredWithoutComparison()
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
r.Property("APropertyName");
// Act
r.Then();
}
public void NotInThrowsExceptionWhenPropertyNameNotDeclared()
{
// Arrange
var r = new WhenRequiredRule("ARuleName");
// Act
r.NotIn(new List <string>(1)
{
"AStringValue"
});
}
private void NotInThrowsExceptionWhenValueIsNullEquivalent(string Value)
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("AProperty");
// Act
r.NotIn(new List <string>(1)
{
Value
});
}
public void RequiredAddsToRequiredProperties()
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("AProperty").Equals("AValue").Then();
// Act
r.Required("RequiredProperty");
// Assert
Assert.AreEqual(1, r.RequiredProperties.Count);
Assert.AreEqual("RequiredProperty", r.RequiredProperties[0]);
}
public void GetPropertyNamesReferencedReturnsValue()
{
// Arrange
var r = new WhenRequiredRule("ARuleName").Property("Name").Equals("George").Then().Required("City").Required("State");
// Act
var properties = r.GetPropertyNamesReferenced();
// Assert
Assert.AreEqual(3, properties.Count);
Assert.IsTrue(properties.Contains("Name"));
Assert.IsTrue(properties.Contains("City"));
Assert.IsTrue(properties.Contains("State"));
}
public void ConstructorReturnsRule()
{
// Arrange
var ruleName = "A rule name";
// Act
var r = new WhenRequiredRule(ruleName);
// Assert
Assert.IsNotNull(r);
Assert.AreEqual(ruleName, r.RuleName);
Assert.AreEqual(0, r.WhenComparisons.Count);
Assert.AreEqual(0, r.RequiredProperties.Count);
}
private void IsValidReturnsFalseWhenRequiredPropertyIsNullEquivalent(string missingValue)
{
// Arrange
var r = new WhenRequiredRule("ARequiredRule").Property("Name").Equals("George").Then().Required("State");
Dictionary <string, string> Values = new Dictionary <string, string>()
{
{ "Name", "George" },
{ "State", missingValue }
};
// Act
var result = r.IsValid(Values);
// Assert
Assert.IsFalse(result);
Assert.AreEqual("The following properties are required but not provided: State", r.ErrorMessage);
}
public void IsValidReturnsTrue()
{
// Arrange
var r = new WhenRequiredRule("ARequiredRule").Property("Name").Equals("George").Then().Required("State");
Dictionary <string, string> Values = new Dictionary <string, string>()
{
{ "Name", "George" },
{ "State", "This is not null" }
};
// Act
var result = r.IsValid(Values);
// Assert
Assert.IsTrue(result);
Assert.IsNull(r.ErrorMessage);
}
public void IsValidReturnsFalseWhenMultiplePropertiesAreTestedAndOneFails()
{
// Arrange
var r = new WhenRequiredRule("ARequiredRule").Property("FirstName").Equals("George").Then().Required("State").Required("LastName");
Dictionary <string, string> Values = new Dictionary <string, string>()
{
{ "FirstName", "George" },
{ "LastName", null },
{ "State", "This is also not null" }
};
// Act
var result = r.IsValid(Values);
// Assert
Assert.IsFalse(result);
Assert.AreEqual("The following properties are required but not provided: LastName", r.ErrorMessage);
}
public static void Parse(string Line, ImportDefinition ID)
{
Helpers.ParametersValid(Line, ID, "RULE-REQUIRED-WHEN");
var index = Line.IndexOf(' ') + 1;
var rulename = Line.GetNextWord(index);
index += rulename.Length + 1;
var r = new WhenRequiredRule(rulename);
while (index < Line.Length)
{
index = ParseRequiredWhenRulePhrase(Line, index, r, ID);
}
ID.Rules.Add(r);
}
private void ConstructorThrowsExceptionWhenRuleNameIsNullEquivalent(string ruleName)
{
// Act
var r = new WhenRequiredRule(ruleName);
}
private static int ParseRequiredWhenRulePhrase(string line, int index, WhenRequiredRule r, ImportDefinition id)
{
var propertyName = line.GetNextWord(index);
index += propertyName.Length + 1;
if (propertyName == "THEN")
{
r.Then();
var extraction = line.ExtractDelimitedSection('{', '}', index);
string[] requiredValues = extraction.Item1.Split(',');
foreach (var s in requiredValues)
{
if (!string.IsNullOrWhiteSpace(s))
{
r.Required(s.Trim());
}
}
index += extraction.Item2 + 3;
return(index);
}
r.Property(propertyName);
var opAsString = line.GetNextWord(index);
index += opAsString.Length + 1;
Enums.ComparisonOperators compop = Enums.ComparisonOperators.EQ;
try
{
compop = (Enums.ComparisonOperators)Enum.Parse(typeof(Enums.ComparisonOperators), opAsString);
}
catch
{
throw new InvalidOperationException("Operation type is not a valid value: " + opAsString);
}
if (compop == Enums.ComparisonOperators.EQ ||
compop == Enums.ComparisonOperators.NOTEQ)
{
var extraction = line.ExtractDelimitedSection('{', '}', index);
index += extraction.Item2 + 3; // Includes opening delimiter, closing delimiter, and whitespace
if (string.IsNullOrWhiteSpace(extraction.Item1))
{
throw new Exception("Rule " + r.RuleName + " contains a valid value that is an empty string.");
}
if (compop == Enums.ComparisonOperators.EQ)
{
r.Equals(extraction.Item1);
}
else if (compop == Enums.ComparisonOperators.NOTEQ)
{
r.NotEquals(extraction.Item1);
}
}
if (compop == Enums.ComparisonOperators.IN ||
compop == Enums.ComparisonOperators.NOTIN)
{
var extraction = line.ExtractDelimitedSection('{', '}', index);
List <string> values = extraction.Item1.ExtractListItems('"', '"', ',', 0);
index += extraction.Item2 + 3;
foreach (var v in values)
{
if (string.IsNullOrWhiteSpace(v))
{
throw new Exception("Rule " + r.RuleName + " contains a valid value that is an empty string.");
}
}
if (compop == Enums.ComparisonOperators.IN)
{
r.In(values);
}
else if (compop == Enums.ComparisonOperators.NOTIN)
{
r.NotIn(values);
}
}
return(index);
}
private static int ParseWhenRulePhrase(string line, int index, WhenRuleThen r, ImportDefinition id)
{
bool createRequiredRule = false;
var propertyName = line.GetNextWord(index);
index += propertyName.Length + 1;
if (propertyName == "THEN")
{
r.Then();
propertyName = line.GetNextWord(index);
index += propertyName.Length + 1;
}
r.Property(propertyName);
var opAsString = line.GetNextWord(index);
index += opAsString.Length + 1;
if (opAsString == "REQUIRED")
{
createRequiredRule = true;
opAsString = line.GetNextWord(index);
index += opAsString.Length + 1;
}
Enums.ComparisonOperators compop = Enums.ComparisonOperators.EQ;
try
{
compop = (Enums.ComparisonOperators)Enum.Parse(typeof(Enums.ComparisonOperators), opAsString);
}
catch
{
throw new InvalidOperationException("Operation type is not a valid value: " + opAsString);
}
if (compop == Enums.ComparisonOperators.EQ ||
compop == Enums.ComparisonOperators.NOTEQ)
{
var extraction = line.ExtractDelimitedSection('{', '}', index);
index += extraction.Item2 + 3; // Includes opening delimiter, closing delimiter, and whitespace
if (string.IsNullOrWhiteSpace(extraction.Item1))
{
throw new Exception("Rule " + r.RuleName + " contains a valid value that is an empty string.");
}
if (compop == Enums.ComparisonOperators.EQ)
{
r.Equals(extraction.Item1);
}
else if (compop == Enums.ComparisonOperators.NOTEQ)
{
r.NotEquals(extraction.Item1);
}
}
if (compop == Enums.ComparisonOperators.IN ||
compop == Enums.ComparisonOperators.NOTIN)
{
var extraction = line.ExtractDelimitedSection('{', '}', index);
List <string> values = extraction.Item1.ExtractListItems('"', '"', ',', 0);
index += extraction.Item2 + 3;
foreach (var v in values)
{
if (string.IsNullOrWhiteSpace(v))
{
throw new Exception("Rule " + r.RuleName + " contains a valid value that is an empty string.");
}
}
if (compop == Enums.ComparisonOperators.IN)
{
r.In(values);
}
else if (compop == Enums.ComparisonOperators.NOTIN)
{
r.NotIn(values);
}
}
if (createRequiredRule)
{
var reqRule = new WhenRequiredRule(propertyName + "-WHEN-REQUIRED");
reqRule.WhenComparisons.AddRange(r.WhenComparisons);
reqRule.Required(propertyName);
id.Rules.Add(reqRule);
}
return(index);
}
