work in progress

Author: TOEL2

src/eligibility_signposting_api/services/processors/rule_processor.py

@@ -78,9 +78,22 @@ def is_actionable(
         priority_getter = attrgetter("priority")
         suppression_reasons = []
 
-        sorted_rules_by_priority = sorted(self.get_exclusion_rules(cohort, suppression_rules), key=priority_getter)
+        sorted_rules_by_priority = sorted(suppression_rules, key=priority_getter)
 
         for _, rule_group in groupby(sorted_rules_by_priority, key=priority_getter):
+            group_rules = list(rule_group)
+            cohort_specific_rules = [rule for rule in group_rules if rule.cohort_label is not None]
+            matching_specific_rules = [
+                rule for rule in cohort_specific_rules if rule.cohort_label == cohort.cohort_label
+            ]
+            if cohort_specific_rules and not matching_specific_rules:
+                continue
+
+            applicable_rules = list(self.get_exclusion_rules(cohort, group_rules))
+
+            if not applicable_rules:
+                continue
+
             status, group_exclusion_reasons, rule_stop = self.evaluate_rules_priority_group(person, rule_group)
             if status.is_exclusion:
                 is_actionable = False

tests/integration/conftest.py

@@ -480,6 +480,40 @@ def campaign_config(s3_client: BaseClient, rules_bucket: BucketName) -> Generato
     yield campaign
     s3_client.delete_object(Bucket=rules_bucket, Key=f"{campaign.name}.json")
 
+@pytest.fixture(scope="class")
+def campaign_config_with_and_rule(s3_client: BaseClient, rules_bucket: BucketName) -> Generator[CampaignConfig]:
+    campaign: CampaignConfig = rule.CampaignConfigFactory.build(
+        target="RSV",
+        iterations=[
+            rule.IterationFactory.build(
+                iteration_rules=[
+                    rule.PostcodeSuppressionRuleFactory.build(cohort_label="cohort2",),
+                    rule.PersonAgeSuppressionRuleFactory.build(),
+                ],
+                iteration_cohorts=[
+                    rule.IterationCohortFactory.build(
+                        cohort_label="cohort1",
+                        cohort_group="cohort_group1",
+                        positive_description="positive_description",
+                        negative_description="negative_description",
+                    ),
+                    rule.IterationCohortFactory.build(
+                        cohort_label="cohort2",
+                        cohort_group="cohort_group2",
+                        positive_description="positive_description",
+                        negative_description="negative_description",
+                    )
+                ],
+            )
+        ],
+    )
+    campaign_data = {"CampaignConfig": campaign.model_dump(by_alias=True)}
+    s3_client.put_object(
+        Bucket=rules_bucket, Key=f"{campaign.name}.json", Body=json.dumps(campaign_data), ContentType="application/json"
+    )
+    yield campaign
+    s3_client.delete_object(Bucket=rules_bucket, Key=f"{campaign.name}.json")
+
 
 @pytest.fixture(scope="class")
 def multiple_campaign_configs(s3_client: BaseClient, rules_bucket: BucketName) -> Generator[list[CampaignConfig]]:

tests/integration/in_process/test_eligibility_endpoint.py

@@ -238,6 +238,57 @@ def test_actionable(
         )
 
 
+    def test_actionable_with_and_rule(
+        self,
+        client: FlaskClient,
+        persisted_person: NHSNumber,
+        campaign_config_with_and_rule: CampaignConfig,  # noqa: ARG002
+    ):
+        # Given
+
+        # When
+        response = client.get(f"/patient-check/{persisted_person}?includeActions=Y")
+
+        # Then
+        assert_that(
+            response,
+            is_response()
+            .with_status_code(HTTPStatus.OK)
+            .and_text(
+                is_json_that(
+                    has_entry(
+                        "processedSuggestions",
+                        equal_to(
+                            [
+                                {
+                                    "condition": "RSV",
+                                    "status": "Actionable",
+                                    "eligibilityCohorts": [
+                                        {
+                                            "cohortCode": "cohort_group1",
+                                            "cohortStatus": "Actionable",
+                                            "cohortText": "positive_description",
+                                        }
+                                    ],
+                                    "actions": [
+                                        {
+                                            "actionCode": "action_code",
+                                            "actionType": "defaultcomms",
+                                            "description": "",
+                                            "urlLabel": "",
+                                            "urlLink": "",
+                                        }
+                                    ],
+                                    "suitabilityRules": [],
+                                    "statusText": "You should have the RSV vaccine",
+                                }
+                            ]
+                        ),
+                    )
+                )
+            ),
+        )
+
 class TestMagicCohortResponse:
     def test_not_eligible_by_rule_when_only_magic_cohort_is_present(
         self,

tests/unit/services/processors/test_rule_processor.py

@@ -144,6 +144,47 @@ def test_evaluate_rules_priority_group_with_rule_stop(mock_rule_calculator_class
     assert_that(is_rule_stop, is_(True))
 
 
+@patch.object(RuleProcessor, "evaluate_rules_priority_group")
+def test_general_rule_should_not_evaluate_in_isolation_without_matching_specific_rule(
+    mock_evaluate_rules_priority_group,
+    rule_processor,
+):
+    # Person is in COHORT_B
+    cohort = rule_builder.IterationCohortFactory.build(
+        cohort_label="COHORT_B",
+        positive_description="Eligible"
+    )
+    cohort_results = {}
+
+    # Rule 1: cohort-specific to COHORT_A — should be filtered out
+    rule_specific = rule_builder.IterationRuleFactory.build(
+        priority=510,
+        type=RuleType.suppression,
+        cohort_label="COHORT_A",
+        name="SPECIFIC_RULE"
+    )
+
+    # Rule 2: General rule
+    rule_general = rule_builder.IterationRuleFactory.build(
+        priority=510,
+        type=RuleType.suppression,
+        cohort_label=None,
+        name="GENERAL_RULE"
+    )
+
+    suppression_rules = [rule_specific, rule_general]
+
+    # Act
+    rule_processor.is_actionable(MOCK_PERSON_DATA, cohort, cohort_results, suppression_rules)
+
+    # ❌ BUG: General rule should not be evaluated in isolation.
+    mock_evaluate_rules_priority_group.assert_not_called()
+
+    # Cohort remains actionable
+    assert_that(cohort_results["COHORT_B"].status, is_(Status.actionable))
+
+
+
 @patch.object(RuleProcessor, "evaluate_rules_priority_group")
 @patch.object(RuleProcessor, "get_exclusion_rules", side_effect=lambda cohort, rules_to_filter: rules_to_filter)  # noqa: ARG005
 def test_is_eligible_by_filter_rules_eligible(