private static DateTimeValueRule GetDateTimeValueRule(Rules rules)
{
if (DateTimeValueRule != null)
{
return(DateTimeValueRule);
}
DateTime?dateTimeGreaterThan = null, dateTimeLesserThan = null, dateTimeEqualTo = null, dateTimeNotEqualTo = null;
if (DateTime.TryParse(rules.DateTimeValueRule.ShouldBeGreaterThan, out DateTime dateTimeGreater))
{
dateTimeGreaterThan = dateTimeGreater;
}
if (DateTime.TryParse(rules.DateTimeValueRule.ShouldBeLessThan, out DateTime dateTimeLesser))
{
dateTimeLesserThan = dateTimeLesser;
}
if (DateTime.TryParse(rules.DateTimeValueRule.ShouldBeEqualTo, out DateTime dateTimeEquals))
{
dateTimeEqualTo = dateTimeEquals;
}
if (DateTime.TryParse(rules.DateTimeValueRule.ShouldNotBeEqualTo, out DateTime dateTimeNotEquals))
{
dateTimeNotEqualTo = dateTimeNotEquals;
}
DateTimeValueRule = new DateTimeValueRule(dateTimeGreaterThan, dateTimeLesserThan, dateTimeEqualTo, dateTimeNotEqualTo);
return(DateTimeValueRule);
}
private static bool IsValidDateTimeRule(DateTimeDataUnit validDateTimeDataUnit, DateTimeValueRule dateTimeValueRule)
{
RuleToApply ruleToApply = RuleToApply.NOTEQUALTO;
if (dateTimeValueRule.GreaterThan.HasValue || dateTimeValueRule.LesserThan.HasValue)
{
ruleToApply = RuleToApply.GREATERORLESSER;
}
else if (dateTimeValueRule.EqualTo.HasValue)
{
ruleToApply = RuleToApply.EQUALTO;
}
else if (dateTimeValueRule.NotEqualTo.HasValue)
{
ruleToApply = RuleToApply.NOTEQUALTO;
}
else
{
throw new Exception($"DateTime Value rule needs to have a proper value");
}
switch (ruleToApply)
{
case RuleToApply.GREATERORLESSER:
if (dateTimeValueRule.GreaterThan.HasValue && dateTimeValueRule.LesserThan.HasValue)
{
if (validDateTimeDataUnit.Value.CompareTo(dateTimeValueRule.GreaterThan.Value) >= 0 &&
validDateTimeDataUnit.Value.CompareTo(dateTimeValueRule.LesserThan.Value) <= 0)
{
return(true);
}
return(false);
}
else if (dateTimeValueRule.GreaterThan.HasValue && validDateTimeDataUnit.Value.CompareTo(dateTimeValueRule.GreaterThan.Value) >= 0)
{
return(true);
}
else if (dateTimeValueRule.LesserThan.HasValue && validDateTimeDataUnit.Value.CompareTo(dateTimeValueRule.LesserThan.Value) <= 0)
{
return(true);
}
return(false);
case RuleToApply.EQUALTO:
return(validDateTimeDataUnit.Value == dateTimeValueRule.EqualTo);
case RuleToApply.NOTEQUALTO:
return(validDateTimeDataUnit.Value != dateTimeValueRule.NotEqualTo);
default:
throw new NotSupportedException("The given type is not valid");
}
}
public void RulesService_IsValidRule_DateTimeDataUnitTests()
{
var actual = false;
Rules rules = new Rules();
InputDataUnit dataUnit = new InputDataUnit(SignalName, DateTimeType, "HIGH");
DateTimeValueRule dateTimeValueRule = new DateTimeValueRule(null, null, null, null);
rules.DateTimeValueRule = dateTimeValueRule;
var dateVeryBig = "23/07/2025 00:00:00.0000";
var dateBig = "23/07/2023 00:00:00.0000";
var dateSmall = "23/07/2021 00:00:00.0000";
var dateMiddle = "23/07/2022 00:00:00.0000";
//Negative Tests :
dateTimeValueRule.ShouldBeGreaterThan = dateMiddle;
dataUnit.Value = dateSmall;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dateTimeValueRule.ShouldBeGreaterThan = null;
dateTimeValueRule.ShouldBeLessThan = dateMiddle;
dataUnit.Value = dateBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dateTimeValueRule.ShouldBeGreaterThan = dateMiddle;
dateTimeValueRule.ShouldBeLessThan = dateBig;
dataUnit.Value = dateSmall;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dataUnit.Value = dateVeryBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dateTimeValueRule.ShouldBeGreaterThan = null;
dateTimeValueRule.ShouldBeLessThan = null;
dateTimeValueRule.ShouldBeEqualTo = dateMiddle;
dataUnit.Value = dateSmall;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
dateTimeValueRule.ShouldBeEqualTo = null;
dateTimeValueRule.ShouldNotBeEqualTo = dateVeryBig;
dataUnit.Value = dateVeryBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsFalse(actual);
//Postitive test cases
//Resetting to null
dateTimeValueRule.ShouldBeGreaterThan = null;
dateTimeValueRule.ShouldNotBeEqualTo = null;
dateTimeValueRule.ShouldBeEqualTo = null;
dateTimeValueRule.ShouldNotBeEqualTo = null;
dateTimeValueRule.ShouldBeGreaterThan = dateMiddle;
dataUnit.Value = dateBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
dateTimeValueRule.ShouldBeGreaterThan = null;
dateTimeValueRule.ShouldBeLessThan = dateVeryBig;
dataUnit.Value = dateSmall;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
dateTimeValueRule.ShouldBeGreaterThan = dateMiddle;
dateTimeValueRule.ShouldBeLessThan = dateVeryBig;
dataUnit.Value = dateBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
dateTimeValueRule.ShouldBeGreaterThan = null;
dateTimeValueRule.ShouldBeLessThan = null;
dateTimeValueRule.ShouldBeEqualTo = dateSmall;
dataUnit.Value = dateSmall;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
dateTimeValueRule.ShouldBeEqualTo = null;
dateTimeValueRule.ShouldNotBeEqualTo = dateBig;
dataUnit.Value = dateVeryBig;
RulesService.RulesService.DateTimeValueRule = null;
actual = RulesService.RulesService.IsValidRule(dataUnit, rules);
Assert.IsTrue(actual);
}
