Feature/eli 328 cohort validations

src/rules_validation_api/validators/actions_mapper_validator.py

@@ -3,9 +3,9 @@
 from eligibility_signposting_api.model.campaign_config import ActionsMapper
 
 
-class ActionsMapperValidator(ActionsMapper):
+class ActionsMapperValidation(ActionsMapper):
     @model_validator(mode="after")
-    def validate_keys(self) -> "ActionsMapperValidator":
+    def validate_keys(self) -> "ActionsMapperValidation":
         invalid_keys = [key for key in self.root if key is None or key == ""]
         if invalid_keys:
             msg = f"Invalid keys found in ActionsMapper: {invalid_keys}"

src/rules_validation_api/validators/campaign_config_validator.py

@@ -8,8 +8,8 @@
 
 
 class CampaignConfigValidation(CampaignConfig):
-    @classmethod
     @field_validator("iterations")
+    @classmethod
     def validate_iterations(cls, iterations: list[Iteration]) -> list[IterationValidation]:
         return [IterationValidation(**i.model_dump()) for i in iterations]
 

src/rules_validation_api/validators/iteration_cohort_validator.py

@@ -0,0 +1,5 @@
+from eligibility_signposting_api.model.campaign_config import IterationCohort
+
+
+class IterationCohortValidation(IterationCohort):
+    pass

src/rules_validation_api/validators/iteration_rules_validator.py

@@ -1,5 +1,18 @@
-from eligibility_signposting_api.model.campaign_config import IterationRule
+from typing import Self
+
+from pydantic import model_validator
+
+from eligibility_signposting_api.model.campaign_config import IterationRule, RuleAttributeLevel, RuleAttributeName
 
 
 class IterationRuleValidation(IterationRule):
-    pass
+    @model_validator(mode="after")
+    def check_cohort_attribute_name(self) -> Self:
+        if (
+            self.attribute_level == RuleAttributeLevel.COHORT
+            and self.attribute_name
+            and self.attribute_name != RuleAttributeName("COHORT_LABEL")
+        ):
+            msg = "When attribute_level is COHORT, attribute_name must be COHORT_LABEL or None (default:COHORT_LABEL)"
+            raise ValueError(msg)
+        return self

src/rules_validation_api/validators/iteration_validator.py

@@ -1,37 +1,152 @@
 import typing
 
-from pydantic import ValidationError, field_validator, model_validator
+from pydantic import Field, ValidationError, field_validator, model_validator
 from pydantic_core import InitErrorDetails
 
-from eligibility_signposting_api.model.campaign_config import ActionsMapper, Iteration, IterationRule
-from rules_validation_api.validators.actions_mapper_validator import ActionsMapperValidator
+from eligibility_signposting_api.model.campaign_config import (
+    ActionsMapper,
+    Iteration,
+    IterationCohort,
+    IterationRule,
+    RuleType,
+)
+from rules_validation_api.validators.actions_mapper_validator import ActionsMapperValidation
+from rules_validation_api.validators.iteration_cohort_validator import IterationCohortValidation
 from rules_validation_api.validators.iteration_rules_validator import IterationRuleValidation
 
 
 class IterationValidation(Iteration):
-    @classmethod
+    iteration_cohorts: list[IterationCohort] = Field(..., alias="IterationCohorts")
+    iteration_rules: list[IterationRule] = Field(..., alias="IterationRules")
+    actions_mapper: ActionsMapper = Field(..., alias="ActionsMapper")
+
     @field_validator("iteration_rules")
-    def validate_iterations(cls, iteration_rules: list[IterationRule]) -> list[IterationRuleValidation]:
+    @classmethod
+    def validate_iteration_rules(cls, iteration_rules: list[IterationRule]) -> list[IterationRuleValidation]:
         return [IterationRuleValidation(**i.model_dump()) for i in iteration_rules]
 
+    @field_validator("iteration_cohorts")
     @classmethod
+    def validate_iteration_cohorts(cls, iteration_cohorts: list[IterationCohort]) -> list[IterationCohortValidation]:
+        return [IterationCohortValidation(**i.model_dump()) for i in iteration_cohorts]
+
     @field_validator("actions_mapper", mode="after")
+    @classmethod
     def transform_actions_mapper(cls, action_mapper: ActionsMapper) -> ActionsMapper:
-        ActionsMapperValidator.model_validate(action_mapper.model_dump())
+        ActionsMapperValidation.model_validate(action_mapper.model_dump())
         return action_mapper
 
     @model_validator(mode="after")
+    def action_mapper_validation(self) -> typing.Self:
+        all_errors = []
+
+        for validator in [
+            self.validate_default_comms_routing_in_actions_mapper,
+            self.validate_default_not_eligible_routing_in_actions_mapper,
+            self.validate_default_not_actionable_routing_in_actions_mapper,
+            self.validate_iteration_rules_against_actions_mapper,
+        ]:
+            try:
+                validator()
+            except ValidationError as ve:
+                all_errors.extend(ve.errors(include_input=False))
+
+        if all_errors:
+            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=all_errors)
+
+        return self
+
     def validate_default_comms_routing_in_actions_mapper(self) -> typing.Self:
-        default_routing = self.default_comms_routing
-        actions_mapper = self.actions_mapper.root.keys()
-
-        if default_routing and (not actions_mapper or default_routing not in actions_mapper):
-            error = InitErrorDetails(
-                type="value_error",
-                loc=("actions_mapper",),
-                input=actions_mapper,
-                ctx={"error": f"Missing entry for DefaultCommsRouting '{default_routing}' in ActionsMapper"},
-            )
-            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=[error])
+        default_routes = self.default_comms_routing
+        actions_keys = list(self.actions_mapper.root.keys())
+        line_errors = []
+
+        for routing in default_routes.split("|"):
+            cleaned_routing = routing.strip()
+            if cleaned_routing and (not actions_keys or cleaned_routing not in actions_keys):
+                error = InitErrorDetails(
+                    type="value_error",
+                    loc=("actions_mapper",),
+                    input=actions_keys,
+                    ctx={"error": f"Missing entry for DefaultCommsRouting '{cleaned_routing}' in ActionsMapper"},
+                )
+                line_errors.append(error)
+
+        if line_errors:
+            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=line_errors)
+
+        return self
+
+    def validate_default_not_eligible_routing_in_actions_mapper(self) -> typing.Self:
+        default_not_eligibile_routes = self.default_not_eligible_routing
+        actions_keys = list(self.actions_mapper.root.keys())
+        line_errors = []
+
+        for routing in default_not_eligibile_routes.split("|"):
+            cleaned_routing = routing.strip()
+            if cleaned_routing and (not actions_keys or cleaned_routing not in actions_keys):
+                error = InitErrorDetails(
+                    type="value_error",
+                    loc=("actions_mapper",),
+                    input=actions_keys,
+                    ctx={"error": f"Missing entry for DefaultNotEligibleRouting '{cleaned_routing}' in ActionsMapper"},
+                )
+                line_errors.append(error)
+
+        if line_errors:
+            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=line_errors)
+
+        return self
+
+    def validate_default_not_actionable_routing_in_actions_mapper(self) -> typing.Self:
+        default_not_actionable_routes = self.default_not_actionable_routing
+        actions_keys = list(self.actions_mapper.root.keys())
+        line_errors = []
+
+        for routing in default_not_actionable_routes.split("|"):
+            cleaned_routing = routing.strip()
+            if cleaned_routing and (not actions_keys or cleaned_routing not in actions_keys):
+                error = InitErrorDetails(
+                    type="value_error",
+                    loc=("actions_mapper",),
+                    input=actions_keys,
+                    ctx={
+                        "error": f"Missing entry for DefaultNotActionableRouting '{cleaned_routing}' in ActionsMapper"
+                    },
+                )
+                line_errors.append(error)
+
+        if line_errors:
+            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=line_errors)
+
+        return self
+
+    def validate_iteration_rules_against_actions_mapper(self) -> typing.Self:
+        actions_keys = list(self.actions_mapper.root.keys())
+        line_errors = []
+
+        for rule in self.iteration_rules:
+            if (
+                rule.type
+                in [
+                    RuleType.redirect,
+                    RuleType.not_actionable_actions,
+                    RuleType.not_eligible_actions,
+                ]
+                and rule.comms_routing
+            ):
+                for routing in rule.comms_routing.split("|"):
+                    cleaned_routing = routing.strip()
+                    if cleaned_routing and (not actions_keys or cleaned_routing not in actions_keys):
+                        error = InitErrorDetails(
+                            type="value_error",
+                            loc=("iteration_rules",),
+                            input=actions_keys,
+                            ctx={"error": f"Missing entry for CommsRouting '{cleaned_routing}' in ActionsMapper"},
+                        )
+                        line_errors.append(error)
+
+        if line_errors:
+            raise ValidationError.from_exception_data(title="IterationValidation", line_errors=line_errors)
 
         return self

src/rules_validation_api/validators/rules_validator.py

@@ -5,7 +5,7 @@
 
 
 class RulesValidation(Rules):
-    @classmethod
     @field_validator("campaign_config")
+    @classmethod
     def validate_campaign_config(cls, campaign_config: CampaignConfig) -> CampaignConfig:
         return CampaignConfigValidation(**campaign_config.model_dump())

tests/test_data/test_config/test_config.json

@@ -8,13 +8,24 @@
     "Manager": ["person@test.com"],
     "Approver": ["person@test.com"],
     "Reviewer": ["person@test.com"],
+    "StartDate": "20250101",
+    "EndDate": "20260101",
+    "ApprovalMinimum": 1,
+    "ApprovalMaximum": 5000000,
     "IterationFrequency": "X",
     "IterationType": "M",
     "IterationTime": "07:00:00",
-    "DefaultCommsRouting": "Default_Comms_1",
     "Iterations": [
       {
         "ID": "id_100",
+        "Version": "1",
+        "Name": "Test Config",
+        "Type": "M",
+        "IterationDate": "20250101",
+        "IterationNumber": 1,
+        "CommsType": "R",
+        "ApprovalMinimum": 1,
+        "ApprovalMaximum": 5000000,
         "DefaultCommsRouting": "INTERNALCONTACTGP1",
         "DefaultNotActionableRouting": "INTERNALCONTACTGP1",
         "DefaultNotEligibleRouting": "INTERNALCONTACTGP1",
@@ -119,20 +130,8 @@
             "Comparator": "19000101",
             "CommsRouting": "YRULEID1|INTERNALTESCO"
           }
-        ],
-        "Version": "1",
-        "Name": "Test Config",
-        "Type": "M",
-        "IterationDate": "20250101",
-        "IterationNumber": 1,
-        "CommsType": "R",
-        "ApprovalMinimum": 1,
-        "ApprovalMaximum": 5000000
+        ]
       }
-    ],
-    "StartDate": "20250101",
-    "EndDate": "20260101",
-    "ApprovalMinimum": 1,
-    "ApprovalMaximum": 5000000
+    ]
   }
 }

tests/unit/validation/conftest.py

@@ -23,20 +23,12 @@ def valid_campaign_config_with_only_mandatory_fields():
                 "ApprovalMinimum": 10,
                 "ApprovalMaximum": 100,
                 "Type": "A",
-                "DefaultCommsRouting": "BOOK_NBS",
-                "DefaultNotEligibleRouting": "RouteB",
-                "DefaultNotActionableRouting": "RouteC",
+                "DefaultCommsRouting": "",
+                "DefaultNotEligibleRouting": "",
+                "DefaultNotActionableRouting": "",
                 "IterationCohorts": [],
                 "IterationRules": [],
-                "ActionsMapper": {
-                    "BOOK_NBS": {
-                        "ExternalRoutingCode": "BookNBS",
-                        "ActionDescription": "",
-                        "ActionType": "ButtonWithAuthLink",
-                        "UrlLink": "http://www.nhs.uk/book-rsv",
-                        "UrlLabel": "Continue to booking",
-                    }
-                },
+                "ActionsMapper": {},
             }
         ],
     }

tests/unit/validation/test_actions_mapper_validator.py

@@ -2,7 +2,7 @@
 from pydantic import ValidationError
 
 from eligibility_signposting_api.model.campaign_config import AvailableAction
-from rules_validation_api.validators.actions_mapper_validator import ActionsMapperValidator
+from rules_validation_api.validators.actions_mapper_validator import ActionsMapperValidation
 
 
 @pytest.fixture
@@ -25,16 +25,31 @@ def test_valid_actions_mapper(self, valid_available_action):
             "action1": self.make_action(valid_available_action),
             "action2": self.make_action({**valid_available_action, "ExternalRoutingCode": "AltCode"}),
         }
-        mapper = ActionsMapperValidator(root=data)
+        mapper = ActionsMapperValidation(root=data)
 
         expected_action_count = 2
-        assert isinstance(mapper, ActionsMapperValidator)
+        assert isinstance(mapper, ActionsMapperValidation)
         assert len(mapper.root) == expected_action_count
 
+    @pytest.mark.parametrize(
+        "invalid_action",
+        [
+            {"action1": ""},
+            {"action1": "invalid_action"},
+            {"action3": None},
+            {"action1": "", "action3": None},
+            {"action1": "invalid_action", "action2": ""},
+        ],
+    )
+    def test_if_exception_raised_when_adding_invalid_actions_to_action_mapper(self, invalid_action):
+        data = {"": invalid_action}
+        with pytest.raises(ValidationError):
+            ActionsMapperValidation(root=data)
+
     def test_invalid_actions_mapper_empty_key(self, valid_available_action):
         data = {"": self.make_action(valid_available_action), "action2": self.make_action(valid_available_action)}
         with pytest.raises(ValidationError) as exc_info:
-            ActionsMapperValidator(root=data)
+            ActionsMapperValidation(root=data)
         assert "Invalid keys found in ActionsMapper" in str(exc_info.value)
         assert "['']" in str(exc_info.value)
 
@@ -45,5 +60,5 @@ def test_invalid_keys_parametrized(self, bad_key, valid_available_action):
             "valid_key": self.make_action(valid_available_action),
         }
         with pytest.raises(ValidationError) as exc_info:
-            ActionsMapperValidator(root=data)
+            ActionsMapperValidation(root=data)
         assert "Invalid keys found in ActionsMapper" in str(exc_info.value)