Added more operators and tests, reorganised ordering.

Author: ayeshalshukri1-nhs

src/eligibility_signposting_api/model/rules.py

@@ -44,36 +44,41 @@ class RuleOperator(str, Enum):
     contains = "contains"
     not_contains = "not_contains"
     starts_with = "starts_with"
+    not_starts_with = "not_starts_with"
     ends_with = "ends_with"
+
     is_in = "in"
     not_in = "not_in"
+
+    member_of = "MemberOf"
+    not_member_of = "NotaMemberOf"
+
     is_null = "is_null"
     is_not_null = "is_not_null"
+
     between = "between"
     not_between = "not_between"
+
     is_empty = "is_empty"
     is_not_empty = "is_not_empty"
+
     is_true = "is_true"
     is_false = "is_false"
 
     day_lte = "D<="
-    week_lte = "W<="
-    year_lte = "Y<="
-
+    day_lt = "D<"
     day_gte = "D>="
-    week_gte = "W>="
-    year_gte = "Y>="
+    day_gt = "D>"
 
-    day_lt = "D<"
+    week_lte = "W<="
     week_lt = "W<"
-    year_lt = "Y<"
-
-    day_gt = "D>"
+    week_gte = "W>="
     week_gt = "W>"
-    year_gt = "Y>"
 
-    member_of = "MemberOf"
-    not_member_of = "NotaMemberOf"
+    year_lte = "Y<="
+    year_lt = "Y<"
+    year_gte = "Y>="
+    year_gt = "Y>"
 
 
 class RuleAttributeLevel(str, Enum):

src/eligibility_signposting_api/services/eligibility_services.py

@@ -102,31 +102,79 @@ def evaluate_rule(iteration_rule: IterationRule, attribute_value: Any) -> bool:
 
             case RuleOperator.starts_with:
                 return str(attribute_value).startswith(iteration_rule.comparator)
+            case RuleOperator.not_starts_with:
+                return not str(attribute_value).startswith(iteration_rule.comparator)
+
+            case RuleOperator.ends_with:
+                return str(attribute_value).endswith(iteration_rule.comparator)
 
             case RuleOperator.is_in:
                 comparators = str(iteration_rule.comparator).split(",")
                 return str(attribute_value) in comparators
             case RuleOperator.not_in:
                 comparators = str(iteration_rule.comparator).split(",")
                 return str(attribute_value) not in comparators
+
             case RuleOperator.member_of:
                 attribute_values = str(attribute_value).split(",")
                 return iteration_rule.comparator in attribute_values
             case RuleOperator.not_member_of:
                 attribute_values = str(attribute_value).split(",")
                 return iteration_rule.comparator not in attribute_values
+
+            case RuleOperator.is_null:
+                return attribute_value in (None, "")
+            case RuleOperator.is_not_null:
+                return attribute_value not in (None, "")
+
+            case RuleOperator.between:
+                if attribute_value in (None, ""): return False
+                low_comparator_str, high_comparator_str = str(iteration_rule.comparator).split(",")
+                low_comparator = min(int(low_comparator_str), int(high_comparator_str))
+                high_comparator = max(int(low_comparator_str), int(high_comparator_str))
+                return low_comparator <= int(attribute_value) <= high_comparator
+
+            case RuleOperator.not_between:
+                if attribute_value in (None, ""): return False
+                low_comparator_str, high_comparator_str = str(iteration_rule.comparator).split(",")
+                low_comparator = min(int(low_comparator_str), int(high_comparator_str))
+                high_comparator = max(int(low_comparator_str), int(high_comparator_str))
+                return int(attribute_value) < low_comparator or int(attribute_value) > high_comparator
+
+            case RuleOperator.is_empty:
+                msg = f"{iteration_rule.operator} not implemented"
+                raise NotImplementedError(msg)
+
+            case RuleOperator.is_not_empty:
+                msg = f"{iteration_rule.operator} not implemented"
+                raise NotImplementedError(msg)
+
+            case RuleOperator.is_true:
+                return attribute_value is True
+            case RuleOperator.is_false:
+                return attribute_value is False
+
+
+            case RuleOperator.day_lte:
+                attribute_date = datetime.strptime(str(attribute_value), '%Y%m%d') if attribute_value else None  # noqa: DTZ007
+                today_date = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
+                cutoff = today_date + relativedelta(days=int(iteration_rule.comparator))
+                return (attribute_date <= cutoff) if attribute_date else False
+
+            case RuleOperator.day_gte:
+                attribute_date = datetime.strptime(str(attribute_value),'%Y%m%d') if attribute_value else None  # noqa: DTZ007
+                today_date = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
+                cutoff = today_date + relativedelta(days=int(iteration_rule.comparator))
+                return (attribute_date >= cutoff) if attribute_date else False
+
+
             case RuleOperator.year_gt:
                 attribute_date = datetime.strptime(str(attribute_value),
                                                    "%Y%m%d") if attribute_value else None  # noqa: DTZ007
                 today = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
                 cutoff = today + relativedelta(years=int(iteration_rule.comparator))
                 return (attribute_date > cutoff) if attribute_date else False
-            case RuleOperator.day_gte:
-                attribute_date = datetime.strptime(str(attribute_value),
-                                                   '%Y%m%d') if attribute_value else None  # noqa: DTZ007
-                today_date = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
-                cutoff = today_date + relativedelta(days=int(iteration_rule.comparator))
-                return (attribute_date >= cutoff) if attribute_date else False
+
             case _:
                 msg = f"{iteration_rule.operator} not implemented"
                 raise NotImplementedError(msg)

tests/unit/services/test_eligibility_services.py

@@ -235,17 +235,31 @@ def test_starts_with_rule():
     rule = IterationRuleFactory.build(operator=RuleOperator.starts_with, comparator="YY66")
     assert EligibilityService.evaluate_rule(rule, "YY66")
     assert EligibilityService.evaluate_rule(rule, "YY66095")
-
     assert not EligibilityService.evaluate_rule(rule, "BB11")
     assert not EligibilityService.evaluate_rule(rule, "BYY66095")
     assert not EligibilityService.evaluate_rule(rule, "  YY66")
-
     assert not EligibilityService.evaluate_rule(rule, None)
     assert not EligibilityService.evaluate_rule(rule, "")
 
 
+def test_not_starts_with_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.not_starts_with, comparator="YY66")
+    assert not EligibilityService.evaluate_rule(rule, "YY66")
+    assert not EligibilityService.evaluate_rule(rule, "YY66095")
+    assert EligibilityService.evaluate_rule(rule, "BB11")
+    assert EligibilityService.evaluate_rule(rule, "BYY66095")
+    assert EligibilityService.evaluate_rule(rule, "  YY66")
+    assert EligibilityService.evaluate_rule(rule, None)
+    assert EligibilityService.evaluate_rule(rule, "")
+
+
 def test_ends_with_rule():
-    pass
+    rule = IterationRuleFactory.build(operator=RuleOperator.ends_with, comparator="2BA")
+    assert EligibilityService.evaluate_rule(rule, "2BA")
+    assert EligibilityService.evaluate_rule(rule, "002BA")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, "2BA00")
 
 
 def test_in_rule():
@@ -264,44 +278,139 @@ def test_not_in_rule():
     assert not EligibilityService.evaluate_rule(rule, "QH8")
 
 
-def test_is_null_rule():
-    pass
+def test_member_of_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.member_of, comparator="cohort1")
+    assert EligibilityService.evaluate_rule(rule, "cohort1,cohort2")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, "cohort3")
 
 
-def test_is_not_null_rule():
-    pass
+def test_not_member_of_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.not_member_of, comparator="cohort1")
+    assert not EligibilityService.evaluate_rule(rule, "cohort1,cohort2")
+    assert EligibilityService.evaluate_rule(rule, None)
+    assert EligibilityService.evaluate_rule(rule, "")
+    assert EligibilityService.evaluate_rule(rule, "cohort3")
 
 
+def test_is_null_rule():
+    # Check email flag is null
+    rule = IterationRuleFactory.build(operator=RuleOperator.is_null)
+    assert EligibilityService.evaluate_rule(rule, "")
+    assert EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "email_flag")
+    assert not EligibilityService.evaluate_rule(rule, 42)
+
 def test_is_not_null_rule():
-    pass
+    # Check email flag is not null
+    rule = IterationRuleFactory.build(operator=RuleOperator.is_not_null)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert EligibilityService.evaluate_rule(rule, "email_flag")
+    assert EligibilityService.evaluate_rule(rule, 42)
 
 
 def test_between_rule():
-    pass
+    # check if numerical value is between two give values (inclusive)
+    rule = IterationRuleFactory.build(operator=RuleOperator.between, comparator="1,3")
+    assert not EligibilityService.evaluate_rule(rule, "0")
+    assert EligibilityService.evaluate_rule(rule, "1")
+    assert EligibilityService.evaluate_rule(rule, "2")
+    assert EligibilityService.evaluate_rule(rule, "3")
+    assert not EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+
+    rule = IterationRuleFactory.build(operator=RuleOperator.between, comparator="3,1")
+    assert not EligibilityService.evaluate_rule(rule, "0")
+    assert EligibilityService.evaluate_rule(rule, "1")
+    assert EligibilityService.evaluate_rule(rule, "2")
+    assert EligibilityService.evaluate_rule(rule, "3")
+    assert not EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+
+    rule = IterationRuleFactory.build(operator=RuleOperator.between, comparator="3,3")
+    assert not EligibilityService.evaluate_rule(rule, "2")
+    assert EligibilityService.evaluate_rule(rule, "3")
+    assert not EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+
+    rule = IterationRuleFactory.build(operator=RuleOperator.between, comparator="20100302,20100304")
+    assert not EligibilityService.evaluate_rule(rule, "20100301")
+    assert EligibilityService.evaluate_rule(rule, "20100302")
+    assert EligibilityService.evaluate_rule(rule, "20100303")
+    assert EligibilityService.evaluate_rule(rule, "20100304")
+    assert not EligibilityService.evaluate_rule(rule, "20100305")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+
 
 
 def test_not_between_rule():
-    pass
+    # check if numerical value is NOT between two give values (inclusive)
+    rule = IterationRuleFactory.build(operator=RuleOperator.not_between, comparator="1,3")
+    assert EligibilityService.evaluate_rule(rule, "0")
+    assert not EligibilityService.evaluate_rule(rule, "1")
+    assert not EligibilityService.evaluate_rule(rule, "2")
+    assert not EligibilityService.evaluate_rule(rule, "3")
+    assert EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
 
+    rule = IterationRuleFactory.build(operator=RuleOperator.not_between, comparator="3,1")
+    assert EligibilityService.evaluate_rule(rule, "0")
+    assert not EligibilityService.evaluate_rule(rule, "1")
+    assert not EligibilityService.evaluate_rule(rule, "2")
+    assert not EligibilityService.evaluate_rule(rule, "3")
+    assert EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
 
-def test_is_empty_rule():
-    pass
+    rule = IterationRuleFactory.build(operator=RuleOperator.not_between, comparator="3,3")
+    assert EligibilityService.evaluate_rule(rule, "2")
+    assert not EligibilityService.evaluate_rule(rule, "3")
+    assert EligibilityService.evaluate_rule(rule, "4")
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
 
 
+def test_is_empty_rule():
+    pass # clarify definition
+
 def test_is_not_empty_rule():
-    pass
+    pass # clarify definition
 
 
 def test_is_true_rule():
-    pass
+    rule = IterationRuleFactory.build(operator=RuleOperator.is_true)
+    assert EligibilityService.evaluate_rule(rule, True)
+    assert not EligibilityService.evaluate_rule(rule, False)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "True")
 
 
 def test_is_false_rule():
-    pass
+    rule = IterationRuleFactory.build(operator=RuleOperator.is_false)
+    assert EligibilityService.evaluate_rule(rule, False)
+    assert not EligibilityService.evaluate_rule(rule, True)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "False")
 
 
 def test_day_lte_rule():
-    pass
+    today = datetime.today()  # noqa: DTZ002
+    days_offset = 2
+    future_date = today + relativedelta(days=days_offset - 3)
+    attribute_value = future_date.strftime("%Y%m%d")
+    rule = IterationRuleFactory.build(operator=RuleOperator.day_lte, comparator=str(days_offset))
+    assert EligibilityService.evaluate_rule(rule, attribute_value)
+    assert not EligibilityService.evaluate_rule(rule, "")
+    assert not EligibilityService.evaluate_rule(rule, None)
 
 
 def test_week_lte_rule():
@@ -406,22 +515,6 @@ def test_year_gt_rule_same_date():
     assert not EligibilityService.evaluate_rule(rule, None)
 
 
-def test_member_of_rule():
-    rule = IterationRuleFactory.build(operator=RuleOperator.member_of, comparator="cohort1")
-    assert EligibilityService.evaluate_rule(rule, "cohort1,cohort2")
-    assert not EligibilityService.evaluate_rule(rule, None)
-    assert not EligibilityService.evaluate_rule(rule, "")
-    assert not EligibilityService.evaluate_rule(rule, "cohort3")
-
-
-def test_not_member_of_rule():
-    rule = IterationRuleFactory.build(operator=RuleOperator.not_member_of, comparator="cohort1")
-    assert not EligibilityService.evaluate_rule(rule, "cohort1,cohort2")
-    assert EligibilityService.evaluate_rule(rule, None)
-    assert EligibilityService.evaluate_rule(rule, "")
-    assert EligibilityService.evaluate_rule(rule, "cohort3")
-
-
 @pytest.mark.skip(reason="Skipping this test since all the operators are implemented")
 def test_unimplemented_operator():
     rule = IterationRuleFactory.build(operator=RuleOperator.member_of, comparator="something")