campaign config validation

Author: Karthikeyannhs

src/rules_validation_api/app.py

@@ -7,8 +7,8 @@
 
 def main() -> None:
     print("Starting rules validation")
-    with open('campaign_config.json', 'r') as file:
-        json_data = json.load(file) # this validates json
+    with open("campaign_config.json") as file:
+        json_data = json.load(file)  # this validates json
 
     try:
         user = CampaignConfigValidation(**json_data["CampaignConfig"])
@@ -17,6 +17,5 @@ def main() -> None:
         print(e)
 
 
-
 if __name__ == "__main__":
     main()

src/rules_validation_api/validators/campaign_config_validator.py

@@ -1,13 +1,11 @@
-from typing import List
+from pydantic import Field, field_validator
 
-from pydantic import field_validator, Field
-
-from eligibility_signposting_api.model.campaign_config import CampaignConfig, Iteration
+from eligibility_signposting_api.model.campaign_config import CampaignConfig
 from rules_validation_api.validators.iteration_validator import IterationValidation
 
 
 class CampaignConfigValidation(CampaignConfig):
-    iterations: List[IterationValidation] = Field(..., min_length=1, alias="Iterations")
+    iterations: list[IterationValidation] = Field(..., min_length=1, alias="Iterations")
 
     @field_validator("id")
     def validate_name(cls, value: str) -> str:
@@ -21,4 +19,3 @@ def validate_type(cls, value: str) -> str:
         if value not in allowed_values:
             raise ValueError(f"type must be one of {allowed_values}")
         return value
-

src/rules_validation_api/validators/iteration_rules_validator.py

@@ -1,6 +1,6 @@
 from pydantic import field_validator
 
-from eligibility_signposting_api.model.campaign_config import ActionsMapper, IterationRule
+from eligibility_signposting_api.model.campaign_config import IterationRule
 
 
 class IterationRuleValidation(IterationRule):

src/rules_validation_api/validators/iteration_validator.py

@@ -1,13 +1,11 @@
-from typing import List
-
-from pydantic import field_validator, BaseModel, Field
+from pydantic import Field, field_validator
 
 from eligibility_signposting_api.model.campaign_config import Iteration
 from rules_validation_api.validators.iteration_rules_validator import IterationRuleValidation
 
 
 class IterationValidation(Iteration):
-    iteration_rules: List[IterationRuleValidation] = Field(..., min_length=1, alias="IterationRules")
+    iteration_rules: list[IterationRuleValidation] = Field(..., min_length=1, alias="IterationRules")
 
     @field_validator("id")
     @classmethod
@@ -22,5 +20,3 @@ def validate_name(cls, value: str) -> str:
         if not value.strip():
             raise ValueError("ID must not be empty")
         return value
-
-

tests/unit/validation/__init__.py

@@ -0,0 +1,48 @@
+import pytest
+
+
+@pytest.fixture
+def valid_campaign_config_with_only_mandate_fields():
+    return {
+        "ID": "CAMP001",
+        "Version": "v1.0",
+        "Name": "Spring Campaign",
+        "Type": "V",
+        "Target": "COVID",
+        "IterationFrequency": "M",
+        "IterationType": "A",
+        "StartDate": "20250101",
+        "EndDate": "20250331",
+        "Iterations": [
+            {
+                "ID": "ITER001",
+                "Version": "v1.0",
+                "Name": "Mid-January Push",
+                "IterationDate": "20250101",
+                "IterationNumber": 1,
+                "ApprovalMinimum": 10,
+                "ApprovalMaximum": 100,
+                "Type": "A",
+                "DefaultCommsRouting": "RouteA",
+                "DefaultNotEligibleRouting": "RouteB",
+                "DefaultNotActionableRouting": "RouteC",
+                "IterationCohorts": [],
+                "IterationRules": [
+                    {
+                        "Type": "F",
+                        "Name": "Assure only already vaccinated taken from magic cohort",
+                        "Description": "Exclude anyone who has NOT been given a dose of RSV "
+                        "Vaccination from the magic cohort",
+                        "Operator": "is_empty",
+                        "Comparator": "",
+                        "AttributeTarget": "RSV",
+                        "AttributeLevel": "TARGET",
+                        "AttributeName": "LAST_SUCCESSFUL_DATE",
+                        "CohortLabel": "elid_all_people",
+                        "Priority": 100,
+                    }
+                ],
+                "ActionsMapper": {},
+            }
+        ],
+    }

tests/unit/validation/conftest.py

@@ -0,0 +1,235 @@
+import pytest
+from pydantic import ValidationError
+
+from rules_validation_api.validators.campaign_config_validator import CampaignConfigValidation
+
+
+class TestMandateFieldsSchemaValidations:
+    def test_campaign_config_with_only_mandate_fields_configuration(self,
+                                                                    valid_campaign_config_with_only_mandate_fields):
+        try:
+            CampaignConfigValidation(**valid_campaign_config_with_only_mandate_fields)
+        except ValidationError as e:
+            pytest.fail(f"Unexpected error during model instantiation: {e}")
+
+    @pytest.mark.parametrize(
+        "mandate_field",
+        [
+            "ID",
+            "Version",
+            "Name",
+            "Type",
+            "Target",
+            "IterationFrequency",
+            "IterationType",
+            "StartDate",
+            "EndDate",
+            "Iterations",
+        ],
+    )
+    def test_missing_mandate_fields(self, mandate_field, valid_campaign_config_with_only_mandate_fields):
+        data = valid_campaign_config_with_only_mandate_fields.copy()
+        data.pop(mandate_field, None)  # Simulate missing field
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+        assert mandate_field.lower()
+
+        # ID field
+
+    # ID
+    @pytest.mark.parametrize("id_value", ["CAMP001", "12345", "X001"])
+    def test_valid_id(self, id_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "ID": id_value}
+        model = CampaignConfigValidation(**data)
+        assert model.id == id_value
+
+    # Version
+    @pytest.mark.parametrize("version_value", ["v1.0", "v2.1", "V3.0"])
+    def test_valid_version(self, version_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Version": version_value}
+        model = CampaignConfigValidation(**data)
+        assert model.version == version_value
+
+    # Name
+    @pytest.mark.parametrize("name_value", ["Spring Campaign", "COVID-Alert", "Mass Outreach"])
+    def test_valid_name(self, name_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Name": name_value}
+        model = CampaignConfigValidation(**data)
+        assert model.name == name_value
+
+    # Type
+    @pytest.mark.parametrize("type_value", ["V", "S"])
+    def test_valid_type(self, type_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Type": type_value}
+        model = CampaignConfigValidation(**data)
+        assert model.type == type_value
+
+    @pytest.mark.parametrize("type_value", ["X", "", None])
+    def test_invalid_type(self, type_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Type": type_value}
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # Target
+    @pytest.mark.parametrize("target_value", ["COVID", "FLU", "MMR", "RSV"])
+    def test_valid_target(self, target_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Target": target_value}
+        model = CampaignConfigValidation(**data)
+        assert model.target == target_value
+
+    @pytest.mark.parametrize("target_value", ["EBOLA", "HEP", "", None])
+    def test_invalid_target(self, target_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Target": target_value}
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # IterationFrequency
+    @pytest.mark.parametrize("freq_value", ["X", "D", "W", "M", "Q", "A"])
+    def test_valid_iteration_frequency(self, freq_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "IterationFrequency": freq_value}
+        model = CampaignConfigValidation(**data)
+        assert model.iteration_frequency == freq_value
+
+    @pytest.mark.parametrize("freq_value", ["Z", "", None])
+    def test_invalid_iteration_frequency(self, freq_value, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "IterationFrequency": freq_value}
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # IterationType
+    @pytest.mark.parametrize("iter_type", ["A", "M", "S", "O"])
+    def test_valid_iteration_type(self, iter_type, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "IterationType": iter_type}
+        model = CampaignConfigValidation(**data)
+        assert model.iteration_type == iter_type
+
+    @pytest.mark.parametrize("iter_type", ["B", "", None])
+    def test_invalid_iteration_type(self, iter_type, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "IterationType": iter_type}
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # StartDate
+    @pytest.mark.parametrize(
+        "start_date",
+        [
+            "",  # empty string
+            "invalid-date",  # malformed value
+        ],
+    )
+    def test_invalid_start_date(self, start_date, valid_campaign_config_with_only_mandate_fields):
+        data = valid_campaign_config_with_only_mandate_fields.copy()
+        data["StartDate"] = start_date
+
+        with pytest.raises(ValidationError) as exc_info:
+            CampaignConfigValidation(**data)
+
+        errors = exc_info.value.errors()
+        for error in errors:
+            assert error["loc"][0] == "StartDate"
+
+    # EndDates
+    @pytest.mark.parametrize(
+        "end_date",
+        [
+            "",  # empty string
+            "31032025",  # malformed value
+        ],
+    )
+    def test_invalid_end_date(self, end_date, valid_campaign_config_with_only_mandate_fields):
+        data = valid_campaign_config_with_only_mandate_fields.copy()
+        data["EndDate"] = end_date
+
+        with pytest.raises(ValidationError) as exc_info:
+            CampaignConfigValidation(**data)
+
+        errors = exc_info.value.errors()
+        for error in errors:
+            assert error["loc"][0] == "EndDate"
+
+
+class TestOptionalFieldsSchemaValidations:
+    @pytest.mark.parametrize("manager", ["alice", "bob", "carol"])
+    def test_manager_field(self, manager, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Manager": manager}
+        model = CampaignConfigValidation(**data)
+        assert model.manager == manager
+
+    @pytest.mark.parametrize("approver", ["bob", "dave", "rachel"])
+    def test_approver_field(self, approver, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Approver": approver}
+        model = CampaignConfigValidation(**data)
+        assert model.approver == approver
+
+    @pytest.mark.parametrize("reviewer", ["carol", "eve", "zane"])
+    def test_reviewer_field(self, reviewer, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Reviewer": reviewer}
+        model = CampaignConfigValidation(**data)
+        assert model.reviewer == reviewer
+
+    @pytest.mark.parametrize("iteration_time", ["14:00", "09:30", "18:45"])
+    def test_iteration_time_field(self, iteration_time, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "IterationTime": iteration_time}
+        model = CampaignConfigValidation(**data)
+        assert model.iteration_time == iteration_time
+
+    @pytest.mark.parametrize("routing", ["email", "sms", "push"])
+    def test_default_comms_routing_field(self, routing, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "DefaultCommsRouting": routing}
+        model = CampaignConfigValidation(**data)
+        assert model.default_comms_routing == routing
+
+    @pytest.mark.parametrize("min_approval", [0, 1, 2])
+    def test_approval_minimum_field(self, min_approval, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "ApprovalMinimum": min_approval}
+        model = CampaignConfigValidation(**data)
+        assert model.approval_minimum == min_approval
+
+    @pytest.mark.parametrize("max_approval", [5, 10, 15])
+    def test_approval_maximum_field(self, max_approval, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "ApprovalMaximum": max_approval}
+        model = CampaignConfigValidation(**data)
+        assert model.approval_maximum == max_approval
+
+
+class TestBUCValidations:
+
+    # StartDate and EndDates
+    @pytest.mark.parametrize(
+        ("start_date", "end_date"),
+        [
+            ("20250101", "20250331"),  # typical valid range
+            ("20250601", "20250630"),  # short range
+            ("20250101", "20250101"),  # same day
+        ],
+    )
+    def test_valid_start_and_end_dates_relationship_with_iteration_dates(self, start_date, end_date, valid_campaign_config_with_only_mandate_fields):
+        data = valid_campaign_config_with_only_mandate_fields.copy()
+        data["StartDate"] = start_date
+        data["EndDate"] = end_date
+        # If any error is raised, the test fails
+        CampaignConfigValidation(**data)
+
+    @pytest.mark.parametrize(
+        ("start_date", "end_date"),
+        [
+            ("20241231", "20250101"),  # year transition
+            ("20250331", "20250101"),  # end before start
+        ],
+    )
+    def test_invalid_start_and_end_dates_relationship_with_iteration_dates(self, start_date, end_date, valid_campaign_config_with_only_mandate_fields):
+        data = valid_campaign_config_with_only_mandate_fields.copy()
+        data["StartDate"] = start_date
+        data["EndDate"] = end_date
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # Iteration
+    def test_validate_iterations_non_empty(self, valid_campaign_config_with_only_mandate_fields):
+        data = {**valid_campaign_config_with_only_mandate_fields, "Iterations": []}
+        with pytest.raises(ValidationError) as error:
+            CampaignConfigValidation(**data)
+        # Inspect errors and check for specific field
+        errors = error.value.errors()
+        assert any(
+            e["loc"][-1] == "Iterations" for e in errors), "Expected validation error on 'Iterations'"