mirror of
https://github.com/dgtlmoon/changedetection.io.git
synced 2026-04-30 23:00:30 +00:00
dgtlmoon
805 lines
30 KiB
Python
805 lines
30 KiB
Python
#!/usr/bin/env python3
|
|
|
|
"""
|
|
Comprehensive tests for time_handler module refactored to use arrow.
|
|
|
|
Run from project root:
|
|
python3 -m pytest changedetectionio/tests/unit/test_time_handler.py -v
|
|
"""
|
|
|
|
import unittest
|
|
import unittest.mock
|
|
import arrow
|
|
from changedetectionio import time_handler
|
|
|
|
|
|
class TestAmIInsideTime(unittest.TestCase):
|
|
"""Tests for the am_i_inside_time function."""
|
|
|
|
def test_current_time_within_schedule(self):
|
|
"""Test that current time is detected as within schedule."""
|
|
# Get current time in a specific timezone
|
|
timezone_str = 'Europe/Berlin'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = now.format('HH:00') # Current hour, 0 minutes
|
|
duration = 60 # 60 minutes
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result, f"Current time should be within {duration} minute window starting at {time_str}")
|
|
|
|
def test_current_time_outside_schedule(self):
|
|
"""Test that time in the past is not within current schedule."""
|
|
timezone_str = 'Europe/Berlin'
|
|
# Get yesterday's date
|
|
yesterday = arrow.now(timezone_str).shift(days=-1)
|
|
day_of_week = yesterday.format('dddd')
|
|
time_str = yesterday.format('HH:mm')
|
|
duration = 30 # Only 30 minutes
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertFalse(result, "Yesterday's time should not be within current schedule")
|
|
|
|
def test_timezone_pacific_within_schedule(self):
|
|
"""Test with US/Pacific timezone."""
|
|
timezone_str = 'US/Pacific'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = now.format('HH:00')
|
|
duration = 120 # 2 hours
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result)
|
|
|
|
def test_timezone_tokyo_within_schedule(self):
|
|
"""Test with Asia/Tokyo timezone."""
|
|
timezone_str = 'Asia/Tokyo'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = now.format('HH:00')
|
|
duration = 90 # 1.5 hours
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result)
|
|
|
|
def test_schedule_crossing_midnight(self):
|
|
"""Test schedule that crosses midnight."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
|
|
# Set schedule to start 23:30 with 120 minute duration (crosses midnight)
|
|
day_of_week = now.format('dddd')
|
|
time_str = "23:30"
|
|
duration = 120 # 2 hours - goes into next day
|
|
|
|
# If we're at 00:15 the next day, we should still be in the schedule
|
|
if now.hour == 0 and now.minute < 30:
|
|
# We're in the time window that spilled over from yesterday
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
# This might be true or false depending on exact time
|
|
self.assertIsInstance(result, bool)
|
|
|
|
def test_invalid_day_of_week(self):
|
|
"""Test that invalid day raises ValueError."""
|
|
with self.assertRaises(ValueError) as context:
|
|
time_handler.am_i_inside_time(
|
|
day_of_week="Funday",
|
|
time_str="12:00",
|
|
timezone_str="UTC",
|
|
duration=60
|
|
)
|
|
self.assertIn("Invalid day_of_week", str(context.exception))
|
|
|
|
def test_invalid_time_format(self):
|
|
"""Test that invalid time format raises ValueError."""
|
|
with self.assertRaises(ValueError) as context:
|
|
time_handler.am_i_inside_time(
|
|
day_of_week="Monday",
|
|
time_str="25:99",
|
|
timezone_str="UTC",
|
|
duration=60
|
|
)
|
|
self.assertIn("Invalid time_str", str(context.exception))
|
|
|
|
def test_invalid_time_format_non_numeric(self):
|
|
"""Test that non-numeric time raises ValueError."""
|
|
with self.assertRaises(ValueError) as context:
|
|
time_handler.am_i_inside_time(
|
|
day_of_week="Monday",
|
|
time_str="twelve:thirty",
|
|
timezone_str="UTC",
|
|
duration=60
|
|
)
|
|
self.assertIn("Invalid time_str", str(context.exception))
|
|
|
|
def test_invalid_timezone(self):
|
|
"""Test that invalid timezone raises ValueError."""
|
|
with self.assertRaises(ValueError) as context:
|
|
time_handler.am_i_inside_time(
|
|
day_of_week="Monday",
|
|
time_str="12:00",
|
|
timezone_str="Invalid/Timezone",
|
|
duration=60
|
|
)
|
|
self.assertIn("Invalid timezone_str", str(context.exception))
|
|
|
|
def test_short_duration(self):
|
|
"""Test with very short duration (15 minutes default)."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = now.format('HH:mm')
|
|
duration = 15 # Default duration
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result, "Current time should be within 15 minute window")
|
|
|
|
def test_long_duration(self):
|
|
"""Test with long duration (24 hours)."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
# Set time to current hour
|
|
time_str = now.format('HH:00')
|
|
duration = 1440 # 24 hours in minutes
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result, "Current time should be within 24 hour window")
|
|
|
|
def test_case_insensitive_day(self):
|
|
"""Test that day of week is case insensitive."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd').lower() # lowercase day
|
|
time_str = now.format('HH:00')
|
|
duration = 60
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
self.assertTrue(result, "Lowercase day should work")
|
|
|
|
def test_edge_case_midnight(self):
|
|
"""Test edge case at exactly midnight."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = "00:00"
|
|
duration = 60
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
# Should be true if we're in the first hour of the day
|
|
if now.hour == 0:
|
|
self.assertTrue(result)
|
|
|
|
def test_edge_case_end_of_day(self):
|
|
"""Test edge case near end of day."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
day_of_week = now.format('dddd')
|
|
time_str = "23:45"
|
|
duration = 30 # 30 minutes crosses midnight
|
|
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str=time_str,
|
|
timezone_str=timezone_str,
|
|
duration=duration
|
|
)
|
|
|
|
# Result depends on current time
|
|
self.assertIsInstance(result, bool)
|
|
|
|
def test_24_hour_schedule_from_midnight(self):
|
|
"""Test 24-hour schedule starting at midnight covers entire day."""
|
|
timezone_str = 'UTC'
|
|
# Test at a specific time: Monday 00:00
|
|
test_time = arrow.get('2024-01-01 00:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd') # Monday
|
|
|
|
# Mock current time for testing
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="00:00",
|
|
timezone_str=timezone_str,
|
|
duration=1440 # 24 hours
|
|
)
|
|
self.assertTrue(result, "Should be active at start of 24-hour schedule")
|
|
|
|
def test_24_hour_schedule_at_end_of_day(self):
|
|
"""Test 24-hour schedule is active at 23:59:59."""
|
|
timezone_str = 'UTC'
|
|
# Test at Monday 23:59:59
|
|
test_time = arrow.get('2024-01-01 23:59:59', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd') # Monday
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="00:00",
|
|
timezone_str=timezone_str,
|
|
duration=1440 # 24 hours
|
|
)
|
|
self.assertTrue(result, "Should be active at end of 24-hour schedule")
|
|
|
|
def test_24_hour_schedule_at_midnight_transition(self):
|
|
"""Test 24-hour schedule at exactly midnight transition."""
|
|
timezone_str = 'UTC'
|
|
# Test at Tuesday 00:00:00 (end of Monday's 24-hour schedule)
|
|
test_time = arrow.get('2024-01-02 00:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
monday = test_time.shift(days=-1).format('dddd') # Monday
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=monday,
|
|
time_str="00:00",
|
|
timezone_str=timezone_str,
|
|
duration=1440 # 24 hours
|
|
)
|
|
self.assertTrue(result, "Should include exactly midnight at end of 24-hour schedule")
|
|
|
|
def test_schedule_crosses_midnight_before_midnight(self):
|
|
"""Test schedule crossing midnight - before midnight."""
|
|
timezone_str = 'UTC'
|
|
# Monday 23:30
|
|
test_time = arrow.get('2024-01-01 23:30:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd') # Monday
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="23:00",
|
|
timezone_str=timezone_str,
|
|
duration=120 # 2 hours (until 01:00 next day)
|
|
)
|
|
self.assertTrue(result, "Should be active before midnight in cross-midnight schedule")
|
|
|
|
def test_schedule_crosses_midnight_after_midnight(self):
|
|
"""Test schedule crossing midnight - after midnight."""
|
|
timezone_str = 'UTC'
|
|
# Tuesday 00:30
|
|
test_time = arrow.get('2024-01-02 00:30:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
monday = test_time.shift(days=-1).format('dddd') # Monday
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=monday,
|
|
time_str="23:00",
|
|
timezone_str=timezone_str,
|
|
duration=120 # 2 hours (until 01:00 Tuesday)
|
|
)
|
|
self.assertTrue(result, "Should be active after midnight in cross-midnight schedule")
|
|
|
|
def test_schedule_crosses_midnight_at_exact_end(self):
|
|
"""Test schedule crossing midnight at exact end time."""
|
|
timezone_str = 'UTC'
|
|
# Tuesday 01:00 (exact end of Monday 23:00 + 120 minutes)
|
|
test_time = arrow.get('2024-01-02 01:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
monday = test_time.shift(days=-1).format('dddd') # Monday
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=monday,
|
|
time_str="23:00",
|
|
timezone_str=timezone_str,
|
|
duration=120 # 2 hours
|
|
)
|
|
self.assertTrue(result, "Should include exact end time of schedule")
|
|
|
|
def test_duration_60_minutes(self):
|
|
"""Test that duration of 60 minutes works correctly."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 12:30:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=60 # Exactly 60 minutes
|
|
)
|
|
self.assertTrue(result, "60-minute duration should work")
|
|
|
|
def test_duration_at_exact_end_minute(self):
|
|
"""Test at exact end of 60-minute window."""
|
|
timezone_str = 'UTC'
|
|
# Exactly 13:00 (end of 12:00 + 60 minutes)
|
|
test_time = arrow.get('2024-01-01 13:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=60
|
|
)
|
|
self.assertTrue(result, "Should include exact end minute")
|
|
|
|
def test_one_second_after_schedule_ends(self):
|
|
"""Test one second after schedule should end."""
|
|
timezone_str = 'UTC'
|
|
# 13:00:01 (one second after 12:00 + 60 minutes)
|
|
test_time = arrow.get('2024-01-01 13:00:01', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=60
|
|
)
|
|
self.assertFalse(result, "Should be False one second after schedule ends")
|
|
|
|
def test_multi_day_schedule(self):
|
|
"""Test schedule longer than 24 hours (48 hours)."""
|
|
timezone_str = 'UTC'
|
|
# Tuesday 12:00 (36 hours after Monday 00:00)
|
|
test_time = arrow.get('2024-01-02 12:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
monday = test_time.shift(days=-1).format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=monday,
|
|
time_str="00:00",
|
|
timezone_str=timezone_str,
|
|
duration=2880 # 48 hours
|
|
)
|
|
self.assertTrue(result, "Should support multi-day schedules")
|
|
|
|
def test_schedule_one_minute_duration(self):
|
|
"""Test very short 1-minute schedule."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 12:00:30', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=1 # Just 1 minute
|
|
)
|
|
self.assertTrue(result, "1-minute schedule should work")
|
|
|
|
def test_schedule_at_exact_start_time(self):
|
|
"""Test at exact start time (00:00:00.000000)."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 12:00:00.000000', 'YYYY-MM-DD HH:mm:ss.SSSSSS').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=30
|
|
)
|
|
self.assertTrue(result, "Should include exact start time")
|
|
|
|
def test_schedule_one_microsecond_before_start(self):
|
|
"""Test one microsecond before schedule starts."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 11:59:59.999999', 'YYYY-MM-DD HH:mm:ss.SSSSSS').replace(tzinfo=timezone_str)
|
|
day_of_week = test_time.format('dddd')
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.am_i_inside_time(
|
|
day_of_week=day_of_week,
|
|
time_str="12:00",
|
|
timezone_str=timezone_str,
|
|
duration=30
|
|
)
|
|
self.assertFalse(result, "Should not include time before start")
|
|
|
|
|
|
class TestIsWithinSchedule(unittest.TestCase):
|
|
"""Tests for the is_within_schedule function."""
|
|
|
|
def test_schedule_disabled(self):
|
|
"""Test that disabled schedule returns False."""
|
|
time_schedule_limit = {'enabled': False}
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertFalse(result)
|
|
|
|
def test_schedule_none(self):
|
|
"""Test that None schedule returns False."""
|
|
result = time_handler.is_within_schedule(None)
|
|
self.assertFalse(result)
|
|
|
|
def test_schedule_empty_dict(self):
|
|
"""Test that empty dict returns False."""
|
|
result = time_handler.is_within_schedule({})
|
|
self.assertFalse(result)
|
|
|
|
def test_schedule_enabled_but_day_disabled(self):
|
|
"""Test schedule enabled but current day disabled."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': False,
|
|
'start_time': '09:00',
|
|
'duration': {'hours': 8, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertFalse(result, "Disabled day should return False")
|
|
|
|
def test_schedule_enabled_within_time(self):
|
|
"""Test schedule enabled and within time window."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 2, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Current time should be within schedule")
|
|
|
|
def test_schedule_enabled_outside_time(self):
|
|
"""Test schedule enabled but outside time window."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
# Set time to 3 hours ago
|
|
past_time = now.shift(hours=-3).format('HH:mm')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': past_time,
|
|
'duration': {'hours': 1, 'minutes': 0} # Only 1 hour duration
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertFalse(result, "3 hours ago with 1 hour duration should be False")
|
|
|
|
def test_schedule_with_default_timezone(self):
|
|
"""Test schedule without timezone uses default."""
|
|
now = arrow.now('America/New_York')
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
# No timezone specified
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 2, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
# Should use default UTC, but since we're testing with NY time,
|
|
# the result depends on time difference
|
|
result = time_handler.is_within_schedule(
|
|
time_schedule_limit,
|
|
default_tz='America/New_York'
|
|
)
|
|
self.assertTrue(result, "Should work with default timezone")
|
|
|
|
def test_schedule_different_timezones(self):
|
|
"""Test schedule works correctly across different timezones."""
|
|
# Test with Tokyo timezone
|
|
timezone_str = 'Asia/Tokyo'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 1, 'minutes': 30}
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result)
|
|
|
|
def test_schedule_with_minutes_in_duration(self):
|
|
"""Test schedule with minutes specified in duration."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_time = now.format('HH:mm')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_time,
|
|
'duration': {'hours': 0, 'minutes': 45}
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should handle minutes in duration")
|
|
|
|
def test_schedule_with_timezone_whitespace(self):
|
|
"""Test that timezone with whitespace is handled."""
|
|
timezone_str = ' UTC '
|
|
now = arrow.now('UTC')
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 1, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should handle timezone with whitespace")
|
|
|
|
def test_schedule_with_60_minutes(self):
|
|
"""Test schedule with duration of 0 hours and 60 minutes."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 0, 'minutes': 60} # 60 minutes
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should accept 60 minutes as valid duration")
|
|
|
|
def test_schedule_with_24_hours(self):
|
|
"""Test schedule with duration of 24 hours and 0 minutes."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
start_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': start_hour,
|
|
'duration': {'hours': 24, 'minutes': 0} # Full 24 hours
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should accept 24 hours as valid duration")
|
|
|
|
def test_schedule_with_90_minutes(self):
|
|
"""Test schedule with duration of 0 hours and 90 minutes."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 0, 'minutes': 90} # 90 minutes = 1.5 hours
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should accept 90 minutes as valid duration")
|
|
|
|
def test_schedule_24_hours_from_midnight(self):
|
|
"""Test 24-hour schedule from midnight using is_within_schedule."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 12:00:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
current_day = test_time.format('dddd').lower() # monday
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': '00:00',
|
|
'duration': {'hours': 24, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "24-hour schedule from midnight should cover entire day")
|
|
|
|
def test_schedule_24_hours_at_end_of_day(self):
|
|
"""Test 24-hour schedule at 23:59 using is_within_schedule."""
|
|
timezone_str = 'UTC'
|
|
test_time = arrow.get('2024-01-01 23:59:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
current_day = test_time.format('dddd').lower()
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': '00:00',
|
|
'duration': {'hours': 24, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should be active at 23:59 in 24-hour schedule")
|
|
|
|
def test_schedule_crosses_midnight_with_is_within_schedule(self):
|
|
"""Test schedule crossing midnight using is_within_schedule."""
|
|
timezone_str = 'UTC'
|
|
# Tuesday 00:30
|
|
test_time = arrow.get('2024-01-02 00:30:00', 'YYYY-MM-DD HH:mm:ss').replace(tzinfo=timezone_str)
|
|
# Get Monday as that's when the schedule started
|
|
monday = test_time.shift(days=-1).format('dddd').lower()
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
'monday': {
|
|
'enabled': True,
|
|
'start_time': '23:00',
|
|
'duration': {'hours': 2, 'minutes': 0} # Until 01:00 Tuesday
|
|
},
|
|
'tuesday': {
|
|
'enabled': False,
|
|
'start_time': '09:00',
|
|
'duration': {'hours': 8, 'minutes': 0}
|
|
}
|
|
}
|
|
|
|
with unittest.mock.patch('arrow.now', return_value=test_time):
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
# Note: This checks Tuesday's schedule, not Monday's overlap
|
|
# So it should be False because Tuesday is disabled
|
|
self.assertFalse(result, "Should check current day (Tuesday), which is disabled")
|
|
|
|
def test_schedule_with_mixed_hours_minutes(self):
|
|
"""Test schedule with both hours and minutes (23 hours 60 minutes = 24 hours)."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
current_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': current_hour,
|
|
'duration': {'hours': 23, 'minutes': 60} # = 1440 minutes = 24 hours
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should handle 23 hours + 60 minutes = 24 hours")
|
|
|
|
def test_schedule_48_hours(self):
|
|
"""Test schedule with 48-hour duration."""
|
|
timezone_str = 'UTC'
|
|
now = arrow.now(timezone_str)
|
|
current_day = now.format('dddd').lower()
|
|
start_hour = now.format('HH:00')
|
|
|
|
time_schedule_limit = {
|
|
'enabled': True,
|
|
'timezone': timezone_str,
|
|
current_day: {
|
|
'enabled': True,
|
|
'start_time': start_hour,
|
|
'duration': {'hours': 48, 'minutes': 0} # 2 full days
|
|
}
|
|
}
|
|
|
|
result = time_handler.is_within_schedule(time_schedule_limit)
|
|
self.assertTrue(result, "Should support 48-hour (multi-day) schedules")
|
|
|
|
|
|
class TestWeekdayEnum(unittest.TestCase):
|
|
"""Tests for the Weekday enum."""
|
|
|
|
def test_weekday_values(self):
|
|
"""Test that weekday enum has correct values."""
|
|
self.assertEqual(time_handler.Weekday.Monday, 0)
|
|
self.assertEqual(time_handler.Weekday.Tuesday, 1)
|
|
self.assertEqual(time_handler.Weekday.Wednesday, 2)
|
|
self.assertEqual(time_handler.Weekday.Thursday, 3)
|
|
self.assertEqual(time_handler.Weekday.Friday, 4)
|
|
self.assertEqual(time_handler.Weekday.Saturday, 5)
|
|
self.assertEqual(time_handler.Weekday.Sunday, 6)
|
|
|
|
def test_weekday_string_access(self):
|
|
"""Test accessing weekday enum by string."""
|
|
self.assertEqual(time_handler.Weekday['Monday'], 0)
|
|
self.assertEqual(time_handler.Weekday['Sunday'], 6)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|