private static bool IsValidStringRule(StringDataUnit validStringDataUnit, StringValueRule stringValueRule)
{
RuleToApply ruleToApply = RuleToApply.NOTEQUALTO;
if (!string.IsNullOrEmpty(stringValueRule.ShouldBeGreaterThan) || !string.IsNullOrEmpty(stringValueRule.ShouldBeLessThan))
{
ruleToApply = RuleToApply.GREATERORLESSER;
}
else if (!string.IsNullOrEmpty(stringValueRule.ShouldBeEqualTo))
{
ruleToApply = RuleToApply.EQUALTO;
}
else if (!string.IsNullOrEmpty(stringValueRule.ShouldNotBeEqualTo))
{
ruleToApply = RuleToApply.NOTEQUALTO;
}
else
{
throw new Exception($"String Value rule needs to have a proper value");
}
switch (ruleToApply)
{
case RuleToApply.GREATERORLESSER:
if (!string.IsNullOrEmpty(stringValueRule.ShouldBeGreaterThan) &&
!string.IsNullOrEmpty(stringValueRule.ShouldBeLessThan))
{
if (validStringDataUnit.Value.CompareTo(stringValueRule.ShouldBeGreaterThan) >= 0 &&
validStringDataUnit.Value.CompareTo(stringValueRule.ShouldBeLessThan) <= 0)
{
return(true);
}
return(false);
}
else if (!string.IsNullOrEmpty(stringValueRule.ShouldBeGreaterThan) && validStringDataUnit.Value.CompareTo(stringValueRule.ShouldBeGreaterThan) >= 0)
{
return(true);
}
else if (!string.IsNullOrEmpty(stringValueRule.ShouldBeLessThan) && validStringDataUnit.Value.CompareTo(stringValueRule.ShouldBeLessThan) <= 0)
{
return(true);
}
return(false);
case RuleToApply.EQUALTO:
return(validStringDataUnit.Value == stringValueRule.ShouldBeEqualTo);
case RuleToApply.NOTEQUALTO:
return(validStringDataUnit.Value != stringValueRule.ShouldNotBeEqualTo);
default:
throw new NotSupportedException("The given type is not valid");
}
}
private static StringValueRule GetStringValueRule(Rules rules)
{
if (StringValueRule != null)
{
return(StringValueRule);
}
StringValueRule = new StringValueRule(
rules.StringValueRule.ShouldBeGreaterThan,
rules.StringValueRule.ShouldBeLessThan,
rules.StringValueRule.ShouldBeEqualTo,
rules.StringValueRule.ShouldNotBeEqualTo);
return(StringValueRule);
}
public async Task GetValidationLogicShouldReturnRuleThatUsesCorrectInterfaceWhenOriginalLogicWasAmbiguousBetweenRuleAndValueRule([Frozen] IResolvesRule ruleResolver,
ValidationLogicFactory sut,
string str,
[RuleContext] RuleContext context)
{
var value = new ManifestValue {
ValidatedType = typeof(string)
};
var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(StringValueRule)));
value.Rules.Add(rule);
var ruleBody = new StringValueRule();
Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringValueRule))).Returns(ruleBody);
var result = sut.GetValidationLogic(rule);
await result.GetResultAsync(str, null, context);
Assert.That(ruleBody.ExecutedAsRule, Is.True);
}
public async Task GetValidationLogicShouldReturnWorkingLogicForValueRule([Frozen] IResolvesRule ruleResolver,
ValidationLogicFactory sut,
string str,
[RuleContext] RuleContext context)
{
var value = new ManifestValue {
ValidatedType = typeof(string), Parent = new ManifestValue {
ValidatedType = typeof(ComplexObject)
}
};
var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(StringValueRule)));
value.Rules.Add(rule);
var ruleBody = new StringValueRule();
Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringValueRule))).Returns(ruleBody);
var result = sut.GetValidationLogic(rule);
await result.GetResultAsync(str, null, context);
Assert.That(ruleBody.ExecutedAsValueRule, Is.True);
}
public void RulesService_IsValidRule_StringDataUnitTests()
{
var actual = false;
Rules rules = new Rules();
InputDataUnit dataUnit = new InputDataUnit(SignalName, StringType, "HIGH");
StringValueRule stringValueRule = new StringValueRule(null, null, null, null);
rules.StringValueRule = stringValueRule;
//Negative Tests :
stringValueRule.ShouldBeGreaterThan = "B";
dataUnit.Value = "A";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
stringValueRule.ShouldBeGreaterThan = null;
stringValueRule.ShouldBeLessThan = "A";
dataUnit.Value = "B";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
stringValueRule.ShouldBeGreaterThan = "C";
stringValueRule.ShouldBeLessThan = "F";
dataUnit.Value = "B";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dataUnit.Value = "G";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
stringValueRule.ShouldBeGreaterThan = null;
stringValueRule.ShouldBeLessThan = null;
stringValueRule.ShouldBeEqualTo = "AA";
dataUnit.Value = "BB";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
stringValueRule.ShouldBeEqualTo = null;
stringValueRule.ShouldNotBeEqualTo = "AA";
dataUnit.Value = "AA";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
//Postitive test cases
//Resetting to null
stringValueRule.ShouldBeGreaterThan = null;
stringValueRule.ShouldNotBeEqualTo = null;
stringValueRule.ShouldBeEqualTo = null;
stringValueRule.ShouldNotBeEqualTo = null;
stringValueRule.ShouldBeGreaterThan = "A";
dataUnit.Value = "B";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
stringValueRule.ShouldBeGreaterThan = null;
stringValueRule.ShouldBeLessThan = "B";
dataUnit.Value = "A";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
stringValueRule.ShouldBeGreaterThan = "A";
stringValueRule.ShouldBeLessThan = "C";
dataUnit.Value = "B";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
stringValueRule.ShouldBeGreaterThan = null;
stringValueRule.ShouldBeLessThan = null;
stringValueRule.ShouldBeEqualTo = "AAA";
dataUnit.Value = "AAA";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
stringValueRule.ShouldBeEqualTo = null;
stringValueRule.ShouldNotBeEqualTo = "ABC";
dataUnit.Value = "BCA";
RulesService.RulesService.StringValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
}
