ELI-615 | wip

Karthikeyannhs · Karthikeyannhs · commit e72c9c3a2f77 · 2026-03-09T12:16:56.000Z
diff --git a/src/eligibility_signposting_api/services/calculators/eligibility_calculator.py b/src/eligibility_signposting_api/services/calculators/eligibility_calculator.py
@@ -81,13 +81,13 @@ def get_the_best_cohort_memberships(
 
         return best_status, best_cohorts
 
-    def get_eligibility_status(self, include_actions: str, conditions: list[str], category: str) -> EligibilityStatus:
+    def get_eligibility_status(self, include_actions: str, conditions: list[str], requested_category: str) -> EligibilityStatus:
         include_actions_flag = include_actions.upper() == "Y"
         condition_results: dict[ConditionName, IterationResult] = {}
         final_result = []
 
-        requested_grouped_campaigns = self.campaign_evaluator.get_requested_grouped_campaigns(
-            self.campaign_configs, conditions, category
+        requested_grouped_campaigns = self.campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
+            self.campaign_configs, conditions, requested_category
         )
         for condition_name, campaign_group in requested_grouped_campaigns:
             best_iteration_result = self.get_best_iteration_result(campaign_group)
diff --git a/src/eligibility_signposting_api/services/processors/campaign_evaluator.py b/src/eligibility_signposting_api/services/processors/campaign_evaluator.py
@@ -1,4 +1,3 @@
-import logging
 from collections.abc import Collection, Iterator
 from itertools import groupby
 from operator import attrgetter
@@ -8,8 +7,6 @@
 from eligibility_signposting_api.model import eligibility_status
 from eligibility_signposting_api.model.campaign_config import CampaignConfig
 
-logger = logging.getLogger(__name__)
-
 
 @service
 class CampaignEvaluator:
@@ -18,43 +15,22 @@ class CampaignEvaluator:
     def get_active_campaigns(self, campaign_configs: Collection[CampaignConfig]) -> list[CampaignConfig]:
         return [cc for cc in campaign_configs if cc.campaign_live]
 
-    def get_campaign_with_latest_iteration(self, active_campaigns: list[CampaignConfig]) -> CampaignConfig | None:
-        """
-        Returns the campaign with the latest active iteration date.
-
-        1. Collect all campaigns with an active iteration.
-        2. Sort by iteration date (descending).
-        3. Extract the lead campaign, throwing an error if a tie for the latest date exists.
-        """
-
-        valid_items = []
-
-        for cc in active_campaigns:
-            try:
-                valid_items.append((cc.current_iteration.iteration_date, cc))
-            except StopIteration:
-                logger.info(
-                    "Skipping campaign ID %s as no active iteration was found.",
-                    cc.id,
-                )
-
-        if not valid_items:
-            latest_campaign = None
-        else:
-            max_date = max(item[0] for item in valid_items)
-            cc_with_max_iteration_date: list[CampaignConfig] = [item[1] for item in valid_items if item[0] == max_date]
-            if len(cc_with_max_iteration_date) > 1:
-                err_msg = (
-                    f"Ambiguous result: '{len(cc_with_max_iteration_date)}' active iterations "
-                    f"for target {cc_with_max_iteration_date[0].target} "
-                    f"found for date '{max_date}' "
-                    f"across campaign(s) {[cc.id for cc in cc_with_max_iteration_date]}"
-                )
-                raise ValueError(err_msg)
-
-            latest_campaign = cc_with_max_iteration_date[0]
-
-        return latest_campaign
+    def get_latest_campaign(self, campaign_group: list[CampaignConfig]):
+        if not campaign_group:
+            return None
+
+        latest_date = max(c.start_date for c in campaign_group)
+
+        latest = [c for c in campaign_group if c.start_date == latest_date]
+
+        if len(latest) == 1:
+            return latest[0]
+
+        if len(latest) > 1:
+            raise ValueError(
+                f"Multiple campaigns share the latest start_date: {latest_date}")  # TODO handle it in FHIR format
+
+        return None
 
     def get_campaign_with_latest_active_iteration_per_target(
         self, campaign_configs: Collection[CampaignConfig], conditions: list[str], requested_category: str
@@ -76,10 +52,6 @@ def get_campaign_with_latest_active_iteration_per_target(
             sorted(active_campaigns, key=attrgetter("target")),
             key=attrgetter("target"),
         ):
-            filtered_campaigns = [
-                c for c in campaign_group if filter_all_conditions or str(condition_name) in conditions
-            ]
+            campaigns = [c for c in allowed_campaigns if filter_all_conditions or str(condition_name) in conditions]
 
-            campaign = self.get_campaign_with_latest_iteration(filtered_campaigns)
-            if campaign is not None:
-                yield (condition_name, campaign)
+            yield condition_name, self.get_latest_campaign(campaigns)
diff --git a/tests/unit/services/processors/test_campaign_evaluator.py b/tests/unit/services/processors/test_campaign_evaluator.py
@@ -16,29 +16,25 @@ def campaign_evaluator():
 @pytest.mark.parametrize(
     ("campaign_target", "campaign_type", "conditions_filter", "category_filter", "expected_result"),
     [
-        ("RSV", "V", ["RSV"], "VACCINATIONS", ("RSV", "V")),
-        ("RSV", "V", ["COVID"], "VACCINATIONS", None),
-        ("RSV", "S", ["RSV"], "ALL", ("RSV", "S")),
-        ("RSV", "S", ["ALL"], "ALL", ("RSV", "S")),
-        ("RSV", "S", ["RSV"], "VACCINATIONS", None),
-        ("RSV", "V", ["RSV"], "ALL", ("RSV", "V")),
-        ("FLU", "V", ["COVID", "RSV"], "ALL", None),
-        ("FLU", "S", ["ALL"], "ALL", ("FLU", "S")),
-        ("COVID", "V", ["UNKNOWN"], "VACCINATIONS", None),
-        ("FLU", "V", ["COVID", "FLU"], "VACCINATIONS", ("FLU", "V")),
+        ("RSV", "V", ["RSV"], "VACCINATIONS", [("RSV", "V")]),
+        ("RSV", "V", ["COVID"], "VACCINATIONS", []),
+        ("RSV", "S", ["RSV"], "ALL", [("RSV", "S")]),
+        ("RSV", "S", ["ALL"], "ALL", [("RSV", "S")]),
+        ("RSV", "S", ["RSV"], "VACCINATIONS", []),
+        ("RSV", "V", ["RSV"], "ALL", [("RSV", "V")]),
+        ("FLU", "V", ["COVID", "RSV"], "ALL", []),
+        ("FLU", "S", ["ALL"], "ALL", [("FLU", "S")]),
+        ("COVID", "V", ["UNKNOWN"], "VACCINATIONS", []),
+        ("FLU", "V", ["COVID", "FLU"], "VACCINATIONS", [("FLU", "V")]),
     ],
 )
 def test_campaigns_grouped_by_condition_name_filters_correctly(  # noqa: PLR0913
     campaign_evaluator, campaign_target, campaign_type, conditions_filter, category_filter, expected_result
 ):
     campaign = rule.CampaignConfigFactory.build(target=campaign_target, type=campaign_type)
 
-    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
-        [campaign], conditions_filter, category_filter
-    )
-
-    actual = next(((str(name), camp.type) for name, camp in result if camp is not None), None)
-    assert actual == expected_result
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], conditions_filter, category_filter)
+    assert_that([(str(name), group[0].type) for name, group in result], is_(expected_result))
 
 
 def test_campaigns_grouped_by_condition_name_with_no_campaigns(campaign_evaluator):
@@ -51,9 +47,7 @@ def test_campaigns_grouped_by_condition_name_with_no_active_campaigns(campaign_e
         target="RSV", type="V", start_date=datetime.date(2025, 4, 20), end_date=datetime.date(2025, 4, 21)
     )
 
-    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
-        [campaign], ["RSV"], "VACCINATIONS"
-    )
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["RSV"], "VACCINATIONS")
     assert_that(list(result), is_([]))
 
 
@@ -69,81 +63,55 @@ def test_campaigns_grouped_by_condition_name_with_various_categories(
     campaign_evaluator, category_filter, campaign_type, expected_count
 ):
     campaign = rule.CampaignConfigFactory.build(target="COVID", type=campaign_type)
-    result = list(
-        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["COVID"], category_filter)
-    )
+    result = list(campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["COVID"], category_filter))
     assert_that(len(result), is_(expected_count))
     if expected_count > 0:
         assert_that(str(result[0][0]), is_("COVID"))
 
 
 def test_campaigns_grouped_by_condition_name_with_empty_conditions_filter(campaign_evaluator):
     campaign = rule.CampaignConfigFactory.build(target="RSV", type="V")
-    result = list(
-        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], [], "VACCINATIONS")
-    )
-
-    assert_that(result, is_([]))
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], [], "VACCINATIONS")
+    assert_that(list(result), is_([]))
 
 
 def test_campaigns_grouped_by_condition_name_groups_multiple_campaigns_for_same_target(campaign_evaluator):
-    # providing the start_date here, because CampaignConfigFactory used it for iteration_date
-    campaign1 = rule.CampaignConfigFactory.build(
-        target="COVID",
-        type="V",
-        id="C1",
-        start_date=datetime.datetime.now(datetime.UTC).date() - datetime.timedelta(days=1),
-        iterations=[rule.IterationFactory.build()],
-    )
-    campaign2 = rule.CampaignConfigFactory.build(
-        target="COVID",
-        type="V",
-        id="C2",
-        start_date=datetime.datetime.now(datetime.UTC).date(),
-        iterations=[rule.IterationFactory.build()],
-    )
+    campaign1 = rule.CampaignConfigFactory.build(target="COVID", type="V", id="C1")
+    campaign2 = rule.CampaignConfigFactory.build(target="COVID", type="V", id="C2")
     campaign3 = rule.CampaignConfigFactory.build(target="FLU", type="V", id="F1")
     inactive_campaign = rule.CampaignConfigFactory.build(
         target="COVID", type="V", id="C3", start_date=datetime.date(2025, 4, 20), end_date=datetime.date(2025, 4, 21)
     )
 
     all_campaigns = [campaign1, campaign2, campaign3, inactive_campaign]
-    result = list(
-        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
-            all_campaigns, ["COVID", "FLU"], "VACCINATIONS"
-        )
-    )
+    result = list(campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(all_campaigns, ["COVID", "FLU"], "VACCINATIONS"))
 
     assert_that(len(result), is_(2))
 
-    result_dict = {str(name): campaign for name, campaign in result}
-
+    result_dict = {str(name): campaigns for name, campaigns in result}
     assert_that("COVID" in result_dict)
     assert_that("FLU" in result_dict)
 
-    assert_that(result_dict["COVID"].id, is_(CampaignID("C2")))
-    assert_that(result_dict["FLU"].id, is_(CampaignID("F1")))
+    assert_that(len(result_dict["COVID"]), is_(2))
+    assert_that({c.id for c in result_dict["COVID"]}, is_({CampaignID("C1"), CampaignID("C2")}))
+
+    assert_that(len(result_dict["FLU"]), is_(1))
+    assert_that(result_dict["FLU"][0].id, is_(CampaignID("F1")))
 
 
-def test_campaign_grouping_is_not_affected_by_order_for_mixed_types(campaign_evaluator):
+def test_campaign_grouping_is_affected_by_order_for_mixed_types(campaign_evaluator):
     campaign_v = rule.CampaignConfigFactory.build(target="RSV", type="V")
     campaign_s = rule.CampaignConfigFactory.build(target="RSV", type="S")
 
-    # Order: S then V
+    evaluator_s_first = campaign_evaluator
     result_s_first = list(
-        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
-            [campaign_s, campaign_v], ["RSV"], "VACCINATIONS"
-        )
+        evaluator_s_first.get_campaign_with_latest_active_iteration_per_target([campaign_s, campaign_v], ["RSV"], "VACCINATIONS")
     )
-    # Even if S is first, it is filtered out by 'allowed_types'
-    assert_that(len(result_s_first), is_(1))
-    assert_that(result_s_first[0][1].type, is_("V"))
+    assert_that(result_s_first, is_([]))
 
-    # Order: V then S
+    evaluator_v_first = campaign_evaluator
     result_v_first = list(
-        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
-            [campaign_v, campaign_s], ["RSV"], "VACCINATIONS"
-        )
+        evaluator_v_first.get_campaign_with_latest_active_iteration_per_target([campaign_v, campaign_s], ["RSV"], "VACCINATIONS")
     )
     assert_that(len(result_v_first), is_(1))
-    assert_that(result_v_first[0][1].type, is_("V"))
+    assert_that(len(result_v_first[0][1]), is_(2))
