test for campaign config rules

Karthikeyannhs · Karthikeyannhs · commit 33b6f18c16d2 · 2025-07-30T13:40:41.000+01:00
diff --git a/src/rules_validation_api/app.py b/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()
diff --git a/src/rules_validation_api/validators/campaign_config_validator.py b/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
-
diff --git a/src/rules_validation_api/validators/iteration_rules_validator.py b/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):
diff --git a/src/rules_validation_api/validators/iteration_validator.py b/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
-
-
diff --git a/tests/unit/validation/__init__.py b/tests/unit/validation/__init__.py
diff --git a/tests/unit/validation/test_campaign_config_validator.py b/tests/unit/validation/test_campaign_config_validator.py
@@ -0,0 +1,265 @@
+import pytest
+from pydantic import ValidationError
+
+from rules_validation_api.validators.campaign_config_validator import CampaignConfigValidation
+
+valid_base = {
+    "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": {},
+        }
+    ],
+}
+
+
+class TestMandateFields:
+    def test_valid_base_configuration(self):
+        try:
+            CampaignConfigValidation(**valid_base)
+        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):
+        data = valid_base.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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "IterationType": iter_type}
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    # 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_end_dates(self, start_date, end_date):
+        data = valid_base.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_end_dates(self, start_date, end_date):
+        data = valid_base.copy()
+        data["StartDate"] = start_date
+        data["EndDate"] = end_date
+        with pytest.raises(ValidationError):
+            CampaignConfigValidation(**data)
+
+    @pytest.mark.parametrize(
+        "start_date",
+        [
+            "",  # empty string
+            "invalid-date",  # malformed value
+        ],
+    )
+    def test_invalid_start_date_only(self, start_date):
+        data = valid_base.copy()
+        data["StartDate"] = start_date
+        data["EndDate"] = "20250101"  # valid end date
+
+        with pytest.raises(ValidationError) as exc_info:
+            CampaignConfigValidation(**data)
+
+        errors = exc_info.value.errors()
+        for error in errors:
+            assert error["loc"][0] == "StartDate"
+
+    @pytest.mark.parametrize(
+        "end_date",
+        [
+            "",  # empty string
+            "31032025",  # malformed value
+        ],
+    )
+    def test_invalid_end_date_only(self, end_date):
+        data = valid_base.copy()
+        data["StartDate"] = "20250101"  # valid start date
+        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 TestOptionalFields:
+    @pytest.mark.parametrize("manager", ["alice", "bob", "carol"])
+    def test_manager_field(self, manager):
+        data = {**valid_base, "Manager": manager}
+        model = CampaignConfigValidation(**data)
+        assert model.manager == manager
+
+    @pytest.mark.parametrize("approver", ["bob", "dave", "rachel"])
+    def test_approver_field(self, approver):
+        data = {**valid_base, "Approver": approver}
+        model = CampaignConfigValidation(**data)
+        assert model.approver == approver
+
+    @pytest.mark.parametrize("reviewer", ["carol", "eve", "zane"])
+    def test_reviewer_field(self, reviewer):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "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):
+        data = {**valid_base, "ApprovalMaximum": max_approval}
+        model = CampaignConfigValidation(**data)
+        assert model.approval_maximum == max_approval
