Recurrence validator tests

mrm9084 · mrm9084 · commit ab57af1071b1 · 2025-04-04T10:58:08.000-07:00
diff --git a/featuremanagement/_time_window_filter/_recurrence_validator.py b/featuremanagement/_time_window_filter/_recurrence_validator.py
@@ -29,7 +29,7 @@ def validate_settings(recurrence: Recurrence, start: datetime, end: datetime) ->
     """
     if not recurrence:
         raise ValueError("Recurrence is required")
-    
+
     _validate_start_end_parameter(start, end)
     _validate_recurrence_pattern(recurrence.pattern, start, end)
     _validate_recurrence_range(recurrence.range, start)
@@ -67,7 +67,7 @@ def _validate_weekly_recurrence_pattern(pattern: RecurrencePattern, start: datet
 
     # Check whether "Start" is a valid first occurrence
     if start.weekday() not in pattern.days_of_week:
-        raise ValueError(NOT_MATCHED % "start")
+        raise ValueError(NOT_MATCHED % start.strftime("%A"))
 
     # Time window duration must be shorter than how frequently it occurs
     _validate_time_window_duration(pattern, start, end)
@@ -116,10 +116,12 @@ def _is_duration_compliant_with_days_of_week(pattern: RecurrencePattern, start:
     sorted_days_of_week = _sort_days_of_week(days_of_week, first_day_of_week)
 
     # Loop the whole week to get the min gap between the two consecutive recurrences
-    prev_occurrence = None
+    prev_occurrence = first_date_of_week + timedelta(
+        days=_get_passed_week_days(sorted_days_of_week[0], first_day_of_week)
+    )
     min_gap = timedelta(days=DAYS_PER_WEEK)
 
-    for day in sorted_days_of_week:
+    for day in sorted_days_of_week[1:]:
         date = first_date_of_week + timedelta(days=_get_passed_week_days(day, first_day_of_week))
         if prev_occurrence is not None:
             current_gap = date - prev_occurrence
@@ -132,9 +134,6 @@ def _is_duration_compliant_with_days_of_week(pattern: RecurrencePattern, start:
             days=DAYS_PER_WEEK + _get_passed_week_days(sorted_days_of_week[0], first_day_of_week)
         )
 
-        if not prev_occurrence:
-            return False
-
         current_gap = date - prev_occurrence
         min_gap = min(min_gap, current_gap)
 
diff --git a/tests/time_window_filter/recurrence_util.py b/tests/time_window_filter/recurrence_util.py
@@ -0,0 +1,48 @@
+from datetime import datetime, timedelta
+from featuremanagement._time_window_filter._models import Recurrence
+
+DATE_FORMAT = "%a, %d %b %Y %H:%M:%S"
+
+START_STRING = "Mon, 31 Mar 2025 00:00:00"
+START = datetime.strptime(START_STRING, DATE_FORMAT)
+END_STRING = "Mon, 31 Mar 2025 23:59:59"
+END = datetime.strptime(END_STRING, DATE_FORMAT)
+
+
+def valid_daily_pattern():
+    return {
+        "Type": "Daily",
+        "Interval": 1,
+        "DaysOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+        "FirstDayOfWeek": "Sunday",
+    }
+
+
+def valid_no_end_range():
+    return {
+        "Type": "NoEnd",
+        "EndDate": None,
+        "NumberOfOccurrences": 10,
+    }
+
+
+def valid_daily_recurrence():
+    return Recurrence(
+        {
+            "Pattern": valid_daily_pattern(),
+            "Range": valid_no_end_range(),
+        }
+    )
+
+
+def valid_daily_end_date_recurrence():
+    return Recurrence(
+        {
+            "Pattern": valid_daily_pattern(),
+            "Range": {
+                "Type": "EndDate",
+                "EndDate": (START + timedelta(days=10)).strftime(DATE_FORMAT),
+                "NumberOfOccurrences": 10,
+            },
+        }
+    )
diff --git a/tests/time_window_filter/test_recurrence_validator.py b/tests/time_window_filter/test_recurrence_validator.py
@@ -1,88 +1,139 @@
+from datetime import timedelta, datetime
 import pytest
-from datetime import datetime, timedelta
+from recurrence_util import valid_daily_recurrence, valid_daily_end_date_recurrence, valid_no_end_range, START, END
 from featuremanagement._time_window_filter._models import Recurrence
 from featuremanagement._time_window_filter._recurrence_validator import validate_settings
 
-def valid_daily_pattern():
-    return {
-        "Type": "Daily",
-        "Interval": 1,
-        "DaysOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
-        "FirstDayOfWeek": "Sunday",
-    }
-
-def valid_daily_recurrence():
-    return Recurrence(
-        {
-            "Pattern": valid_daily_pattern(),
-            "Range": {"Type": "NoEnd", "EndDate": None, "NumberOfOccurrences": 10},
-        }
-    )
-
-def valid_daily_end_date_recurrence():
-    return Recurrence(
-        {
-            "Pattern": valid_daily_pattern(),
-            "Range": {"Type": "EndDate", "EndDate": datetime.now() + timedelta(days=10), "NumberOfOccurrences": 10},
-        }
-    )
-
-def valid_weekly_recurrence():
-    return Recurrence(
-        {
-            "Pattern": {
-                "Type": "Weekly",
-                "Interval": 1,
-                "DaysOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
-                "FirstDayOfWeek": "Monday",
-            },
-            "Range": {"Type": "NoEnd", "EndDate": None, "NumberOfOccurrences": 10},
-        }
-    )
-
 
 def test_validate_settings_valid_daily():
-    start = datetime.now()
-    end = start + timedelta(days=1)
-    validate_settings(valid_daily_recurrence(), start, end)
+    validate_settings(valid_daily_recurrence(), START, END)
+
 
 def test_validate_settings_valid_daily_end_date():
-    start = datetime.now()
-    end = start + timedelta(days=1)
-    validate_settings(valid_daily_end_date_recurrence(), start, end)
+    validate_settings(valid_daily_end_date_recurrence(), START, END)
+
+
+def test_validate_settings_valid_weekly_one_day():
+    validate_settings(
+        Recurrence(
+            {
+                "Pattern": {
+                    "Type": "Weekly",
+                    "Interval": 1,
+                    "DaysOfWeek": ["Monday"],
+                    "FirstDayOfWeek": "Monday",
+                },
+                "Range": valid_no_end_range(),
+            }
+        ),
+        START,
+        END,
+    )
 
 
 def test_validate_settings_valid_weekly():
-    start = datetime.now()
-    end = start + timedelta(days=1)
-    validate_settings(valid_weekly_recurrence(), start, end)
+    validate_settings(
+        Recurrence(
+            {
+                "Pattern": {
+                    "Type": "Weekly",
+                    "Interval": 1,
+                    "DaysOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+                    "FirstDayOfWeek": "Monday",
+                },
+                "Range": valid_no_end_range(),
+            }
+        ),
+        START,
+        END,
+    )
+
 
 def test_validate_settings_duration_exceeds_ten_years():
-    start = datetime.now()
-    end = start + timedelta(days=3651)
+    end = START + timedelta(days=3651)
     with pytest.raises(ValueError, match="Time window duration exceeds ten years: end"):
-        validate_settings(valid_daily_recurrence(), start, end)
+        validate_settings(valid_daily_recurrence(), START, end)
+
 
 def test_validate_settings_invalid_start_end():
-    start = datetime.now() + timedelta(days=1)
-    end = datetime.now()
+    start = START + timedelta(days=2)
     with pytest.raises(ValueError, match="The filter start date Start needs to before the End date."):
-        validate_settings(valid_daily_recurrence(), start, end)
+        validate_settings(valid_daily_recurrence(), start, END)
+
 
 def test_validate_settings_end_date_in_past():
-    start = datetime.now()
-    end = datetime.now() - timedelta(days=1)
+    end = START - timedelta(days=1)
     with pytest.raises(ValueError, match="The filter start date Start needs to before the End date."):
-        validate_settings(valid_daily_recurrence(), start, end)
+        validate_settings(valid_daily_recurrence(), START, end)
+
 
 def test_validate_settings_missing_recurrence():
-    start = datetime.now()
-    end = start + timedelta(days=1)
     with pytest.raises(ValueError, match="Recurrence is required"):
-        validate_settings(None, start, end)
+        validate_settings(None, START, END)
+
 
 def test_validate_settings_invalid_recurrence_pattern():
     with pytest.raises(ValueError, match="Invalid value: InvalidType"):
-         Recurrence({"Pattern": {"Type": "InvalidType"}, "Range": {"Type": "NoEnd"}})
-
+        Recurrence({"Pattern": {"Type": "InvalidType"}, "Range": {"Type": "NoEnd"}})
+
+
+def test_validate_settings_weekly_recurrence_invalid_start_day():
+    with pytest.raises(ValueError, match="Start day does not match any day of the week: Monday"):
+        validate_settings(
+            Recurrence(
+                {
+                    "Pattern": {
+                        "Type": "Weekly",
+                        "Interval": 1,
+                        "DaysOfWeek": ["Tuesday", "Wednesday", "Thursday", "Friday"],
+                        "FirstDayOfWeek": "Monday",
+                    },
+                    "Range": valid_no_end_range(),
+                }
+            ),
+            START,
+            END,
+        )
+
+
+def test_validate_settings_period_too_long():
+    end = START + timedelta(days=7)
+    with pytest.raises(ValueError, match="Time window duration is out of range:"):
+        validate_settings(valid_daily_recurrence(), START, end)
+
+
+def test_validate_settings_no_days_of_week():
+    with pytest.raises(ValueError, match="Required parameter: Recurrence.Pattern.DaysOfWeek"):
+        validate_settings(
+            Recurrence(
+                {
+                    "Pattern": {
+                        "Type": "Weekly",
+                        "Interval": 1,
+                        "FirstDayOfWeek": "Monday",
+                    },
+                    "Range": valid_no_end_range(),
+                }
+            ),
+            START,
+            END,
+        )
+
+
+def test_validate_settings_end_date_before_start():
+    with pytest.raises(ValueError, match="The Recurrence.Range.EndDate should be after the Start"):
+        validate_settings(valid_daily_end_date_recurrence(), START + timedelta(days=11), END + timedelta(days=11))
+
+
+def test_is_duration_compliant_with_days_of_week_false():
+    pattern = {
+        "Type": "Weekly",
+        "Interval": 1,
+        "DaysOfWeek": ["Monday", "Wednesday"],
+        "FirstDayOfWeek": "Monday",
+    }
 
+    start = datetime(2025, 4, 7, 9, 0, 0)  # Monday
+    end = datetime(2025, 4, 10, 9, 0, 0)  # Wednesday (48 hours duration)
+    with pytest.raises(ValueError, match="Recurrence.Pattern.DaysOfWeek"):
+        validate_settings(Recurrence({"Pattern": pattern, "Range": valid_no_end_range()}), start, end)
