Test various rule operators.

Author: acerathereinspirative-nhs-nvir

src/eligibility_signposting_api/services/eligibility_services.py

@@ -87,18 +87,18 @@ def evaluate_rule(iteration_rule: IterationRule, attribute_value: Any) -> bool:
             case RuleOperator.ne:
                 return attribute_value != iteration_rule.comparator
             case RuleOperator.lt:
-                return attribute_value < iteration_rule.comparator
+                return int(attribute_value) < int(iteration_rule.comparator)
             case RuleOperator.lte:
-                return attribute_value <= iteration_rule.comparator
+                return int(attribute_value) <= int(iteration_rule.comparator)
             case RuleOperator.gt:
-                return attribute_value > iteration_rule.comparator
+                return int(attribute_value) > int(iteration_rule.comparator)
             case RuleOperator.gte:
-                return attribute_value >= iteration_rule.comparator
+                return int(attribute_value) >= int(iteration_rule.comparator)
             case RuleOperator.year_gt:
-                attribute_date = datetime.strptime(str(attribute_value), "%Y%m%d")  # noqa: DTZ007
+                attribute_date = datetime.strptime(str(attribute_value), "%Y%m%d") if attribute_value else None  # noqa: DTZ007
                 today = datetime.today()  # noqa: DTZ002
                 cutoff = today + relativedelta(years=int(iteration_rule.comparator))
-                return (attribute_date > cutoff) if attribute_value else False
+                return (attribute_date > cutoff) if attribute_date else False
             case _:
                 msg = f"{iteration_rule.operator} not implemented"
                 raise NotImplementedError(msg)

tests/integration/conftest.py

@@ -261,6 +261,7 @@ def campaign_config(s3_client: BaseClient, bucket: BucketName) -> Generator[Camp
                         operator=RuleOperator.lt,
                         attribute_level=RuleAttributeLevel.PERSON,
                         attribute_name="DATE_OF_BIRTH",
+                        comparator="-75"
                     )
                 ]
             )

tests/unit/services/test_eligibility_services.py

@@ -1,7 +1,9 @@
+from datetime import datetime
 from unittest.mock import MagicMock
 
 import pytest
 from brunns.matchers.object import false, true
+from dateutil.relativedelta import relativedelta
 from faker import Faker
 from hamcrest import assert_that
 
@@ -152,3 +154,74 @@ def test_simple_rule_ineligible(faker: Faker):
 
     # Then
     assert_that(actual, is_eligibility_status().with_eligible(false()))
+
+
+def test_equals_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.equals, comparator="42")
+    assert EligibilityService.evaluate_rule(rule, "42")
+    assert not EligibilityService.evaluate_rule(rule, "99")
+
+
+def test_not_equals_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.ne, comparator="42")
+    assert EligibilityService.evaluate_rule(rule, "99")
+    assert not EligibilityService.evaluate_rule(rule, "42")
+
+
+def test_less_than_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.lt, comparator="100")
+    assert EligibilityService.evaluate_rule(rule, "42")
+    assert EligibilityService.evaluate_rule(rule, "99")
+    assert not EligibilityService.evaluate_rule(rule, "100")
+    assert not EligibilityService.evaluate_rule(rule, "101")
+
+
+def test_less_than_or_equal_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.lte, comparator="100")
+    assert EligibilityService.evaluate_rule(rule, "99")
+    assert EligibilityService.evaluate_rule(rule, "100")
+    assert not EligibilityService.evaluate_rule(rule, "101")
+
+
+def test_greater_than_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.gt, comparator="100")
+    assert EligibilityService.evaluate_rule(rule, "101")
+    assert not EligibilityService.evaluate_rule(rule, "100")
+    assert not EligibilityService.evaluate_rule(rule, "99")
+
+
+def test_greater_than_or_equal_rule():
+    rule = IterationRuleFactory.build(operator=RuleOperator.gte, comparator="100")
+    assert EligibilityService.evaluate_rule(rule, "100")
+    assert EligibilityService.evaluate_rule(rule, "101")
+    assert not EligibilityService.evaluate_rule(rule, "99")
+
+
+def test_year_gt_rule_future_date():
+    today = datetime.today()  # noqa: DTZ002
+    years_offset = 2
+    future_date = today + relativedelta(years=years_offset + 1)
+    attribute_value = future_date.strftime("%Y%m%d")
+    rule = IterationRuleFactory.build(operator=RuleOperator.year_gt, comparator=str(years_offset))
+    assert EligibilityService.evaluate_rule(rule, attribute_value)
+
+
+def test_year_gt_rule_past_date():
+    today = datetime.today()  # noqa: DTZ002
+    years_offset = 2
+    past_date = today + relativedelta(years=years_offset - 1)
+    attribute_value = past_date.strftime("%Y%m%d")
+    rule = IterationRuleFactory.build(operator=RuleOperator.year_gt, comparator=str(years_offset))
+    assert not EligibilityService.evaluate_rule(rule, attribute_value)
+
+
+def test_year_gt_rule_empty_value():
+    rule = IterationRuleFactory.build(operator=RuleOperator.year_gt, comparator="2")
+    assert not EligibilityService.evaluate_rule(rule, None)
+    assert not EligibilityService.evaluate_rule(rule, "")
+
+
+def test_unimplemented_operator():
+    rule = IterationRuleFactory.build(operator=RuleOperator.member_of, comparator="something")
+    with pytest.raises(NotImplementedError, match="not implemented"):
+        EligibilityService.evaluate_rule(rule, "any_value")