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); }