fix formatting

Author: mrm9084

featuremanagement/_time_window_filter/_models.py

@@ -104,8 +104,8 @@ def __init__(self, range_data: Dict[str, Any]):
             end_date_str = range_data.get("EndDate", "")
             try:
                 self.end_date = parsedate_to_datetime(end_date_str) if end_date_str else None
-            except ValueError:
-                raise ValueError(f"Invalid value for EndDate: {end_date_str}")
+            except ValueError as e:
+                raise ValueError(f'Invalid value for EndDate: {end_date_str}') from e
         self.num_of_occurrences = range_data.get("NumberOfOccurrences", math.pow(2, 63) - 1)
         if self.num_of_occurrences < 0:
             raise ValueError("The number of occurrences must be greater than or equal to 0.")

tests/time_window_filter/test_recurrence_validator.py

@@ -188,27 +188,28 @@ def test_is_duration_compliant_with_days_of_week_false():
     with pytest.raises(ValueError, match="Recurrence.Pattern.DaysOfWeek"):
         validate_settings(Recurrence({"Pattern": pattern, "Range": valid_no_end_range()}), start, end)
 
+
 def test_sort_days_of_week():
-    days_of_week = [0, 3, 5] # Monday, Thursday, Saturday
+    days_of_week = [0, 3, 5]  # Monday, Thursday, Saturday
     sorted_days = _sort_days_of_week(days_of_week, 6)
     assert sorted_days == [0, 3, 5]
 
-    days_of_week = [5, 0, 3] # Saturday, Monday, Thursday
+    days_of_week = [5, 0, 3]  # Saturday, Monday, Thursday
     sorted_days = _sort_days_of_week(days_of_week, 6)
     assert sorted_days == [0, 3, 5]
 
-    days_of_week = [0, 1, 2, 3, 4, 5, 6] # All days of the week
+    days_of_week = [0, 1, 2, 3, 4, 5, 6]  # All days of the week
     sorted_days = _sort_days_of_week(days_of_week, 6)
     assert sorted_days == [6, 0, 1, 2, 3, 4, 5]
 
-    days_of_week = [6, 5, 4, 3, 2, 1, 0] # All days of the week in reverse order
+    days_of_week = [6, 5, 4, 3, 2, 1, 0]  # All days of the week in reverse order
     sorted_days = _sort_days_of_week(days_of_week, 6)
     assert sorted_days == [6, 0, 1, 2, 3, 4, 5]
 
-    days_of_week = [0, 2, 4, 6] # Monday, Wednesday, Friday, Sunday
+    days_of_week = [0, 2, 4, 6]  # Monday, Wednesday, Friday, Sunday
     sorted_days = _sort_days_of_week(days_of_week, 2)
     assert sorted_days == [2, 4, 6, 0]
 
-    days_of_week = [1] # Tuesday
+    days_of_week = [1]  # Tuesday
     sorted_days = _sort_days_of_week(days_of_week, 0)
-    assert sorted_days == [1]
+    assert sorted_days == [1]

tests/time_window_filter/test_time_window_filter_models.py

@@ -3,10 +3,17 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # -------------------------------------------------------------------------
-from featuremanagement._time_window_filter._models import RecurrencePatternType, RecurrenceRangeType, RecurrencePattern, RecurrenceRange, Recurrence
+from featuremanagement._time_window_filter._models import (
+    RecurrencePatternType,
+    RecurrenceRangeType,
+    RecurrencePattern,
+    RecurrenceRange,
+    Recurrence,
+)
 from datetime import datetime
 import math
 
+
 def test_recurrence_pattern_type():
     assert RecurrencePatternType.from_str("Daily") == RecurrencePatternType.DAILY
     assert RecurrencePatternType.from_str("Weekly") == RecurrencePatternType.WEEKLY
@@ -15,6 +22,7 @@ def test_recurrence_pattern_type():
     except ValueError as e:
         assert str(e) == "Invalid value: Invalid"
 
+
 def test_recurrence_range_type():
     assert RecurrenceRangeType.from_str("NoEnd") == RecurrenceRangeType.NO_END
     assert RecurrenceRangeType.from_str("EndDate") == RecurrenceRangeType.END_DATE
@@ -24,64 +32,97 @@ def test_recurrence_range_type():
     except ValueError as e:
         assert str(e) == "Invalid value: Invalid"
 
+
 def test_recurrence_pattern():
-    pattern = RecurrencePattern({"Type":"Daily", "Interval":1, "DaysOfWeek":["Monday", "Tuesday"]})
+    pattern = RecurrencePattern({"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Monday", "Tuesday"]})
     assert pattern.type == RecurrencePatternType.DAILY
     assert pattern.interval == 1
     assert pattern.days_of_week == [0, 1]
     assert pattern.first_day_of_week == 6
 
-    pattern = RecurrencePattern({"Type":"Daily", "Interval":1, "DaysOfWeek":["Monday", "Tuesday"], "FirstDayOfWeek":"Monday"})
+    pattern = RecurrencePattern(
+        {"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Monday", "Tuesday"], "FirstDayOfWeek": "Monday"}
+    )
     assert pattern.type == RecurrencePatternType.DAILY
     assert pattern.interval == 1
     assert pattern.days_of_week == [0, 1]
     assert pattern.first_day_of_week == 0
 
     try:
-        pattern = RecurrencePattern({"Type":"Daily", "Interval":1, "DaysOfWeek":["Monday", "Tuesday"], "FirstDayOfWeek":"Thor's day"})
+        pattern = RecurrencePattern(
+            {"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Monday", "Tuesday"], "FirstDayOfWeek": "Thor's day"}
+        )
     except ValueError as e:
         assert str(e) == "Invalid value for FirstDayOfWeek: Thor's day"
 
-    pattern = RecurrencePattern({"Type":"Weekly", "Interval":2, "DaysOfWeek":["Wednesday"]})
+    pattern = RecurrencePattern({"Type": "Weekly", "Interval": 2, "DaysOfWeek": ["Wednesday"]})
     assert pattern.type == RecurrencePatternType.WEEKLY
     assert pattern.interval == 2
     assert pattern.days_of_week == [2]
     assert pattern.first_day_of_week == 6
 
     try:
-        pattern = RecurrencePattern({"Type":"Daily", "Interval":0, "DaysOfWeek":["Monday", "Tuesday"]})
+        pattern = RecurrencePattern({"Type": "Daily", "Interval": 0, "DaysOfWeek": ["Monday", "Tuesday"]})
     except ValueError as e:
         assert str(e) == "The interval must be greater than 0."
 
     try:
-        pattern = RecurrencePattern({"Type":"Daily", "Interval":1, "DaysOfWeek":["Monday", "Thor's day"]})
+        pattern = RecurrencePattern({"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Monday", "Thor's day"]})
     except ValueError as e:
         assert str(e) == "Invalid value for DaysOfWeek: Thor's day"
 
+
 def test_recurrence_range():
     max_occurrences = math.pow(2, 63) - 1
 
-    range = RecurrenceRange({"Type":"NoEnd"})
+    range = RecurrenceRange({"Type": "NoEnd"})
     assert range.type == RecurrenceRangeType.NO_END
     assert range.end_date is None
     assert range.num_of_occurrences == max_occurrences
 
-    range = RecurrenceRange({"Type":"EndDate", "EndDate":"Mon, 31 Mar 2025 00:00:00"})
+    range = RecurrenceRange({"Type": "EndDate", "EndDate": "Mon, 31 Mar 2025 00:00:00"})
     assert range.type == RecurrenceRangeType.END_DATE
     assert range.end_date == datetime(2025, 3, 31, 0, 0, 0)
     assert range.num_of_occurrences == max_occurrences
 
-    range = RecurrenceRange({"Type":"Numbered", "NumberOfOccurrences":10})
+    range = RecurrenceRange({"Type": "Numbered", "NumberOfOccurrences": 10})
     assert range.type == RecurrenceRangeType.NUMBERED
     assert range.end_date is None
     assert range.num_of_occurrences == 10
 
     try:
-        range = RecurrenceRange({"Type":"NoEnd", "NumberOfOccurrences":-1})
+        range = RecurrenceRange({"Type": "NoEnd", "NumberOfOccurrences": -1})
     except ValueError as e:
         assert str(e) == "The number of occurrences must be greater than or equal to 0."
 
     try:
-        range = RecurrenceRange({"Type":"EndDate", "EndDate":"InvalidDate"})
+        range = RecurrenceRange({"Type": "EndDate", "EndDate": "InvalidDate"})
+    except ValueError as e:
+        assert str(e) == "Invalid value for EndDate: InvalidDate"
+
+
+def test_recurrence():
+    recurrence = Recurrence(
+        {"Pattern": {"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Monday"]}, "Range": {"Type": "NoEnd"}}
+    )
+    assert recurrence.pattern.type == RecurrencePatternType.DAILY
+    assert recurrence.range.type == RecurrenceRangeType.NO_END
+
+    try:
+        recurrence = Recurrence({"Pattern": {"Type": "Invalid"}, "Range": {"Type": "NoEnd"}})
+    except ValueError as e:
+        assert str(e) == "Invalid value: Invalid"
+
+    try:
+        recurrence = Recurrence(
+            {"Pattern": {"Type": "Daily", "Interval": 0, "DaysOfWeek": ["Monday"]}, "Range": {"Type": "NoEnd"}}
+        )
+    except ValueError as e:
+        assert str(e) == "The interval must be greater than 0."
+
+    try:
+        recurrence = Recurrence(
+            {"Pattern": {"Type": "Daily", "Interval": 1, "DaysOfWeek": ["Invalid"]}, "Range": {"Type": "NoEnd"}}
+        )
     except ValueError as e:
-        assert str(e) == "Invalid value for EndDate: InvalidDate"
+        assert str(e) == "Invalid value for DaysOfWeek: Invalid"