private static void createPropRuleXml(XmlElement propDMElement, IPropRule propRule)
{
if (propRule == null)
{
return;
}
if (propRule.Name == null)
{
return;
}
if (propRule.Parameters.Count == 0)
{
return;
}
if (new List <object>(propRule.Parameters.Values).TrueForAll(o => o == null))
{
return;
}
//if (!propRule.HasRule) return;
XmlElement ruleElement = XmlUtilities.createXmlElement(propDMElement, "rule");
XmlUtilities.setXmlAttribute(ruleElement, "name", propRule.Name);
//TODO Mark 28 Sep 2009: Investigate what is needed to support custom rules
//if (propRule.IsCustomRule)
//{
// XmlUtilities.setXmlAttribute(ruleElement, "class", propRule.ClassName);
// XmlUtilities.setXmlAttribute(ruleElement, "assembly", propRule.AssemblyName);
//}
XmlUtilities.setXmlAttribute(ruleElement, "message", propRule.Message);
foreach (KeyValuePair <string, object> pair in propRule.Parameters)
{
addKeyValuePair(ruleElement, pair.Key, pair.Value, null);
}
}
public void TestCustomRuleClass()
{
IPropRule rule = _loader.LoadRule("CustomProperty",
@"<rule name=""TestCustom"" class=""Habanero.Test.BO.Loaders.MyRule"" assembly=""Habanero.Test.BO"">
<add key=""bob"" value=""billy"" />
</rule>");
Assert.AreEqual("billy", rule.Parameters["bob"]);
}
public void TestPropRuleDecimalNoMaxValue()
{
//---------------Set up test pack-------------------
IPropRule rule =
_loader.LoadRule(typeof(Decimal).Name, @"<rule name=""TestDec""><add key=""min"" value=""1""/></rule>");
//---------------Execute Test ----------------------
Assert.AreEqual(Decimal.MaxValue, Convert.ToDecimal(rule.Parameters["max"]));
}
public void TestPropRuleIntegerNoMaxValue()
{
//---------------Execute Test ----------------------
IPropRule rule =
_loader.LoadRule(typeof(int).Name,
@"<rule name=""TestRule"" message=""Test Message""><add key=""min"" value=""1""/></rule>");
//---------------Test Result -----------------------
Assert.AreEqual(int.MaxValue, Convert.ToInt32(rule.Parameters["max"]));
}
/// <summary>
/// Loads the property rule data from the reader
/// </summary>
protected override sealed void LoadFromReader()
{
int counter = 0;
_reader.Read();
_name = _reader.GetAttribute("name");
_message = _reader.GetAttribute("message");
_class = _reader.GetAttribute("class");
_assembly = _reader.GetAttribute("assembly");
_propRule = CreatePropRule();
_ruleParameters = _propRule.Parameters;
_reader.Read();
while (_reader.Name == "add")
{
string keyAtt = _reader.GetAttribute("key");
string valueAtt = _reader.GetAttribute("value");
if (string.IsNullOrEmpty(keyAtt))
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute in the class definitions was missing the " +
"required 'key' attribute, which specifies the name " +
"of the rule to check, such as 'max' for integers.");
}
if (valueAtt == null)
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute in the class definitions was missing the " +
"required 'value' attribute, which specifies the value " +
"to compare with for the rule named in the 'key' " +
"attribute.");
}
if (!_ruleParameters.ContainsKey(keyAtt))
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute was specified for a property rule that " +
"does not apply to the property rule. The specified " +
"'add' attribute was '" + keyAtt + "' but the allowed " +
"attributes are " + String.Join(", ", _propRule.AvailableParameters.ToArray()) + ".");
}
_ruleParameters[keyAtt] = valueAtt;
counter++;
ReadAndIgnoreEndTag();
}
if (counter == 0)
{
throw new InvalidXmlDefinitionException("A 'rule' element in " +
"the class definitions must contain at least one 'add' " +
"element for each component of the rule, such as the " +
"minimum value for an integer.");
}
_propRule.Parameters = _ruleParameters;
}
public void TestPropRuleInteger_NullValues()
{
//---------------Execute Test ----------------------
IPropRule rule = _loader.LoadRule(typeof(int).Name,
@"<rule name=""Test Rule"" message=""Test Message"">
<add key=""min"" value=""""/>
<add key=""max"" value="""" /></rule>
");
//---------------Test Result -----------------------
Assert.AreEqual(Int32.MinValue, rule.Parameters["min"]);
Assert.AreEqual(Int32.MaxValue, rule.Parameters["max"]);
}
public void TestPropRuleDecimal()
{
IPropRule rule = _loader.LoadRule(typeof(Decimal).Name,
@"<rule name=""TestDec"" >
<add key=""min"" value=""1.5"" />
<add key=""max"" value=""8.2"" />
</rule>
");
Assert.AreEqual("TestDec", rule.Name, "Rule name is not being read from xml correctly.");
Assert.AreEqual(1.5, Convert.ToDecimal(rule.Parameters["min"]));
Assert.AreEqual(8.2, Convert.ToDecimal(rule.Parameters["max"]));
}
public void TestPropRuleDate_MaxValue_Today()
{
IPropRule rule = _loader.LoadRule(typeof(DateTime).Name,
@"<rule name=""TestDate"" >
<add key=""min"" value=""01 Feb 2004"" />
<add key=""max"" value=""Today"" />
</rule>
");
Assert.AreEqual("TestDate", rule.Name, "Rule name is not being read from xml correctly.");
Assert.AreEqual(new DateTime(2004, 02, 01), Convert.ToDateTime(rule.Parameters["min"]));
Assert.AreEqual("Today", rule.Parameters["max"]);
}
public void TestRuleOfInteger()
{
//---------------Execute Test ----------------------
IPropRule rule =
_loader.LoadRule(typeof(int).Name,
@"<rule name=""Test Rule"" message=""Test Message""><add key=""min"" value=""2""/><add key=""max"" value=""10"" /></rule>");
//---------------Test Result -----------------------
Assert.IsInstanceOf(typeof(IPropRule), rule);
Assert.AreEqual("Test Rule", rule.Name, "Name name is not being read from xml correctly.");
Assert.AreEqual("Test Message", rule.Message, "Message is not being read from xml correctly.");
Assert.AreEqual(2, Convert.ToInt32(rule.Parameters["min"]));
Assert.AreEqual(10, Convert.ToInt32(rule.Parameters["max"]));
}
public void TestPropRuleStringBlankAttributesTranslateToValidValues()
{
//---------------Execute Test ----------------------
IPropRule rule = _loader.LoadRule(typeof(string).Name,
@"<rule name=""TestString"" message=""String Test Message"" >
<add key=""minLength"" value="""" />
<add key=""maxLength"" value="""" />
</rule>
");
//---------------Test Result -----------------------
Assert.AreEqual(0, Convert.ToInt32(rule.Parameters["minLength"]));
Assert.AreEqual(-1, Convert.ToInt32(rule.Parameters["maxLength"]));
}
public void TestPropRuleDate_Now()
{
//---------------Execute Test ----------------------
IPropRule rule = _loader.LoadRule(typeof(DateTime).Name,
@"<rule name=""TestDate"" >
<add key=""min"" value=""Now"" />
<add key=""max"" value=""Now"" />
</rule>
");
//---------------Test Result -----------------------
Assert.AreEqual("TestDate", rule.Name, "Rule name is not being read from xml correctly.");
Assert.AreEqual("Now", rule.Parameters["min"]);
Assert.AreEqual("Now", rule.Parameters["max"]);
}
public void TestPropRuleDate()
{
IPropRule rule = _loader.LoadRule(typeof(DateTime).Name,
@"<rule name=""TestDate"" >
<add key=""min"" value=""01 Feb 2004"" />
<add key=""max"" value=""09 Oct 2004"" />
</rule>
");
Assert.AreEqual("TestDate", rule.Name, "Rule name is not being read from xml correctly.");
//Assert.AreSame(typeof(DateTime), rule.PropertyType,
// "A PropRuleDate should have DateTime as its property type.");
Assert.AreEqual(new DateTime(2004, 02, 01), Convert.ToDateTime(rule.Parameters["min"]));
Assert.AreEqual(new DateTime(2004, 10, 09), Convert.ToDateTime(rule.Parameters["max"]));
}
public void TestPropRuleStringAttributes()
{
//---------------Execute Test ----------------------
IPropRule rule = _loader.LoadRule(typeof(string).Name,
@"<rule name=""TestString"" message=""String Test Message"" >
<add key=""patternMatch"" value=""Test Pattern"" />
<add key=""minLength"" value=""5"" />
<add key=""maxLength"" value=""10"" />
</rule>
");
//---------------Test Result -----------------------
Assert.AreEqual("Test Pattern", rule.Parameters["patternMatch"]);
Assert.AreEqual(5, Convert.ToInt32(rule.Parameters["minLength"]));
Assert.AreEqual(10, Convert.ToInt32(rule.Parameters["maxLength"]));
}
public void TestPropRuleString()
{
IPropRule rule =
_loader.LoadRule(typeof(string).Name,
@"<rule name=""TestString"" message=""String Test Message""><add key=""maxLength"" value=""100""/></rule>");
Assert.AreEqual("TestString", rule.Name, "Rule name is not being read from xml correctly.");
Assert.AreEqual("String Test Message", rule.Message, "Message is not being read from xml correctly");
//Assert.AreSame(typeof(string), propRule.PropertyType,
// "A PropRuleString should have string as its property type.");
Assert.IsTrue(string.IsNullOrEmpty((string)rule.Parameters["patternMatch"]),
"An empty string should be the default pattern match string according to the dtd.");
Assert.AreEqual(0, Convert.ToInt32(rule.Parameters["minLength"]),
"0 should be the default minlength according to the dtd.");
rule =
_loader.LoadRule(typeof(string).Name,
@"<rule name=""TestString"" message=""String Test Message""><add key=""minLength"" value=""1""/></rule>");
Assert.AreEqual(-1, Convert.ToInt32(rule.Parameters["maxLength"]),
"-1 should be the default maxlength according to the dtd.");
}
public void TestPropRuleDecimal_UsingComparableInterface_MaxValue_ActualValueGT()
{
XmlRuleLoader loader = new XmlRuleLoader(new DtdLoader(), GetDefClassFactory());
IPropRule rule = loader.LoadRule(typeof(Decimal).Name,
@"<rule name=""TestDecimal"" >
<add key=""min"" value=""12.22"" />
<add key=""max"" value=""15.51"" />
</rule>");
//-----------------Assert Preconditions ---------------------------
Assert.AreEqual(12.22D, ((IPropRuleComparable <decimal>)rule).MinValue);
Assert.AreEqual(15.51D, ((IPropRuleComparable <decimal>)rule).MaxValue);
//---------------Execute ------------------------------------------
string errorMessage = "";
bool isValid = rule.IsPropValueValid("Propname", new Decimal(15.56), ref errorMessage);
//--------------Verify Result -------------------------------------
Assert.IsFalse(isValid);
Assert.IsFalse(string.IsNullOrEmpty(errorMessage));
}
public void TestPropRuleSingle_MaxValue_ActualValueLT()
{
XmlRuleLoader loader = new XmlRuleLoader(new DtdLoader(), GetDefClassFactory());
IPropRule rule = loader.LoadRule(typeof(Single).Name,
@"<rule name=""TestSingle"" >
<add key=""min"" value=""12.22"" />
<add key=""max"" value=""15.51"" />
</rule>
");
//-----------------Assert Preconditions ---------------------------
Assert.AreEqual(12.22f, ((PropRuleSingle)rule).MinValue);
Assert.AreEqual(15.51f, ((PropRuleSingle)rule).MaxValue);
//---------------Execute ------------------------------------------
string errorMessage = "";
bool isValid = rule.IsPropValueValid("Propname", 13.1f, ref errorMessage);
//--------------Verify Result -------------------------------------
Assert.IsTrue(isValid);
Assert.IsTrue(string.IsNullOrEmpty(errorMessage));
}
public void TestPropRuleDate_MaxValue_Today()
{
XmlRuleLoader loader = new XmlRuleLoader(new DtdLoader(), GetDefClassFactory());
IPropRule rule = loader.LoadRule(typeof(DateTime).Name,
@"<rule name=""TestDate"" >
<add key=""min"" value=""01 Feb 2004"" />
<add key=""max"" value=""Today"" />
</rule>
");
//-----------------Assert Preconditions ---------------------------
Assert.AreEqual(new DateTime(2004, 02, 01), ((PropRuleDate)rule).MinValue);
Assert.AreEqual(DateTime.Today.AddDays(1).AddMilliseconds(-1), ((PropRuleDate)rule).MaxValue);
//---------------Execute ------------------------------------------
string errorMessage = "";
bool isValid = rule.IsPropValueValid("Propname", DateTime.Today.AddDays(-1), ref errorMessage);
//--------------Verify Result -------------------------------------
Assert.IsTrue(isValid);
Assert.IsTrue(string.IsNullOrEmpty(errorMessage));
}
/// <summary>
/// Checks if the PropRule is of the correct Type
/// </summary>
/// <param name="rule"></param>
/// <returns></returns>
public static bool IsOfType <TRuleType>(this IPropRule rule) where TRuleType : IPropRule
{
return(rule.GetType() == typeof(TRuleType));
}
/// <summary>
/// Loads the property rule data from the reader
/// </summary>
protected override sealed void LoadFromReader()
{
int counter = 0;
_reader.Read();
_name = _reader.GetAttribute("name");
_message = _reader.GetAttribute("message");
_class = _reader.GetAttribute("class");
_assembly = _reader.GetAttribute("assembly");
_propRule = CreatePropRule();
_ruleParameters = _propRule.Parameters;
_reader.Read();
while (_reader.Name == "add")
{
string keyAtt = _reader.GetAttribute("key");
string valueAtt = _reader.GetAttribute("value");
if (string.IsNullOrEmpty(keyAtt))
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute in the class definitions was missing the " +
"required 'key' attribute, which specifies the name " +
"of the rule to check, such as 'max' for integers.");
}
if (valueAtt == null)
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute in the class definitions was missing the " +
"required 'value' attribute, which specifies the value " +
"to compare with for the rule named in the 'key' " +
"attribute.");
}
if (!_ruleParameters.ContainsKey(keyAtt))
{
throw new InvalidXmlDefinitionException("An 'add' " +
"attribute was specified for a property rule that " +
"does not apply to the property rule. The specified " +
"'add' attribute was '" + keyAtt + "' but the allowed " +
"attributes are " + String.Join(", ", _propRule.AvailableParameters.ToArray()) + ".");
}
_ruleParameters[keyAtt] = valueAtt;
counter++;
ReadAndIgnoreEndTag();
}
if (counter == 0)
{
throw new InvalidXmlDefinitionException("A 'rule' element in " +
"the class definitions must contain at least one 'add' " +
"element for each component of the rule, such as the " +
"minimum value for an integer.");
}
_propRule.Parameters = _ruleParameters;
}
private static void createPropRuleXml(XmlElement propDMElement, IPropRule propRule)
{
if (propRule == null) return;
if (propRule.Name == null) return;
if (propRule.Parameters.Count == 0) return;
if (new List<object>(propRule.Parameters.Values).TrueForAll(o => o == null)) return;
//if (!propRule.HasRule) return;
XmlElement ruleElement = XmlUtilities.createXmlElement(propDMElement, "rule");
XmlUtilities.setXmlAttribute(ruleElement, "name", propRule.Name);
//TODO Mark 28 Sep 2009: Investigate what is needed to support custom rules
//if (propRule.IsCustomRule)
//{
// XmlUtilities.setXmlAttribute(ruleElement, "class", propRule.ClassName);
// XmlUtilities.setXmlAttribute(ruleElement, "assembly", propRule.AssemblyName);
//}
XmlUtilities.setXmlAttribute(ruleElement, "message", propRule.Message);
foreach (KeyValuePair<string, object> pair in propRule.Parameters)
{
addKeyValuePair(ruleElement, pair.Key, pair.Value, null);
}
}
