class TestLiveClockWithLoopTimer:
def setup(self):
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
# Fixture Setup
self.handler = []
self.clock = LiveClock(loop=self.loop)
self.clock.register_default_handler(self.handler.append)
def teardown(self):
self.clock.cancel_timers()
def test_unix_timestamp(self):
# Arrange
# Act
result = self.clock.timestamp()
# Assert
assert type(result) == float
assert result > 0
def test_unix_timestamp_ns(self):
# Arrange
# Act
result = self.clock.timestamp_ns()
# Assert
assert type(result) == int
assert result > 0
def test_set_time_alert(self):
async def run_test():
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=100)
alert_time = self.clock.utc_now() + interval
# Act
self.clock.set_time_alert(name, alert_time)
await asyncio.sleep(0.3)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 1
assert isinstance(self.handler[0], TimeEvent)
self.loop.run_until_complete(run_test())
def test_cancel_time_alert(self):
async def run_test():
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=300)
alert_time = self.clock.utc_now() + interval
self.clock.set_time_alert(name, alert_time)
# Act
self.clock.cancel_timer(name)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) == 0
self.loop.run_until_complete(run_test())
def test_set_multiple_time_alerts(self):
async def run_test():
# Arrange
alert_time1 = self.clock.utc_now() + timedelta(milliseconds=200)
alert_time2 = self.clock.utc_now() + timedelta(milliseconds=300)
# Act
self.clock.set_time_alert("TEST_ALERT1", alert_time1)
self.clock.set_time_alert("TEST_ALERT2", alert_time2)
await asyncio.sleep(0.7)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 2
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
self.loop.run_until_complete(run_test())
def test_set_timer_with_immediate_start_time(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
# Act
self.clock.set_timer(
name=name,
interval=timedelta(milliseconds=100),
start_time=None,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert isinstance(self.handler[0], TimeEvent)
self.loop.run_until_complete(run_test())
def test_set_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert len(self.handler) >= 2
assert isinstance(self.handler[0], TimeEvent)
self.loop.run_until_complete(run_test())
def test_set_timer_with_stop_time(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 1
assert isinstance(self.handler[0], TimeEvent)
self.loop.run_until_complete(run_test())
def test_cancel_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
self.clock.set_timer(name=name, interval=interval)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) <= 4
self.loop.run_until_complete(run_test())
def test_set_repeating_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert len(self.handler) >= 3
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
assert isinstance(self.handler[2], TimeEvent)
self.loop.run_until_complete(run_test())
def test_cancel_repeating_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + timedelta(seconds=5)
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
assert len(self.handler) <= 5
self.loop.run_until_complete(run_test())
def test_set_two_repeating_timers(self):
async def run_test():
# Arrange
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + timedelta(milliseconds=100)
# Act
self.clock.set_timer(
name="TEST_TIMER1",
interval=interval,
start_time=start_time,
stop_time=None,
)
self.clock.set_timer(
name="TEST_TIMER2",
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.9)
# Assert
assert len(self.handler) >= 8
self.loop.run_until_complete(run_test())
class TestLiveClockWithThreadTimer:
def setup(self):
# Fixture Setup
self.handler = []
self.clock = LiveClock()
self.clock.register_default_handler(self.handler.append)
def teardown(self):
self.clock.cancel_timers()
def test_instantiated_clock(self):
# Arrange
# Act
# Assert
assert self.clock.is_default_handler_registered
assert not self.clock.is_test_clock
assert self.clock.timer_names() == []
def test_utc_now(self):
# Arrange
# Act
result = self.clock.utc_now()
# Assert
assert type(result) == datetime
assert result.tzinfo == pytz.utc
def test_local_now(self):
# Arrange
# Act
result = self.clock.local_now(pytz.timezone("Australia/Sydney"))
# Assert
assert type(result) == datetime
assert str(result).endswith("+11:00") or str(result).endswith("+10:00")
def test_delta(self):
# Arrange
start = self.clock.utc_now()
# Act
time.sleep(0.1)
result = self.clock.delta(start)
# Assert
assert result > timedelta(0)
assert type(result) == timedelta
def test_set_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=100)
alert_time = self.clock.utc_now() + interval
# Act
self.clock.set_time_alert(name, alert_time)
time.sleep(0.3)
# Assert
assert len(self.handler) == 1
assert isinstance(self.handler[0], TimeEvent)
def test_cancel_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=300)
alert_time = self.clock.utc_now() + interval
self.clock.set_time_alert(name, alert_time)
# Act
self.clock.cancel_timer(name)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) == 0
def test_set_multiple_time_alerts(self):
# Arrange
alert_time1 = self.clock.utc_now() + timedelta(milliseconds=200)
alert_time2 = self.clock.utc_now() + timedelta(milliseconds=300)
# Act
self.clock.set_time_alert("TEST_ALERT1", alert_time1)
self.clock.set_time_alert("TEST_ALERT2", alert_time2)
time.sleep(0.6)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) == 2
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
def test_set_timer_with_immediate_start_time(self):
# Arrange
name = "TEST_TIMER"
# Act
self.clock.set_timer(
name=name,
interval=timedelta(milliseconds=100),
start_time=None,
stop_time=None,
)
time.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert isinstance(self.handler[0], TimeEvent)
def test_set_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert len(self.handler) >= 2
assert isinstance(self.handler[0], TimeEvent)
def test_set_timer_with_stop_time(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
time.sleep(0.5)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 1
assert isinstance(self.handler[0], TimeEvent)
def test_cancel_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
self.clock.set_timer(name=name, interval=interval)
# Act
time.sleep(0.3)
self.clock.cancel_timer(name)
time.sleep(0.3)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) <= 4
def test_set_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.5)
# Assert
assert len(self.handler) >= 3
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
assert isinstance(self.handler[2], TimeEvent)
def test_cancel_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + timedelta(seconds=5)
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
# Act
time.sleep(0.3)
self.clock.cancel_timer(name)
time.sleep(0.3)
# Assert
assert len(self.handler) <= 5
def test_set_two_repeating_timers(self):
# Arrange
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + timedelta(milliseconds=100)
# Act
self.clock.set_timer(
name="TEST_TIMER1",
interval=interval,
start_time=start_time,
stop_time=None,
)
self.clock.set_timer(
name="TEST_TIMER2",
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.9)
# Assert
assert len(self.handler) >= 8
class LiveClockWithLoopTimerTests(unittest.TestCase):
def setUp(self):
# Fresh isolated loop testing pattern
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
# Fixture Setup
self.handler = []
self.clock = LiveClock(loop=self.loop)
self.clock.register_default_handler(self.handler.append)
def tearDown(self):
self.clock.cancel_timers()
def test_set_time_alert(self):
async def run_test():
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=100)
alert_time = self.clock.utc_now() + interval
# Act
self.clock.set_time_alert(name, alert_time)
await asyncio.sleep(0.3)
# Assert
self.assertTrue(len(self.handler) >= 1)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.loop.run_until_complete(run_test())
def test_cancel_time_alert(self):
async def run_test():
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=300)
alert_time = self.clock.utc_now() + interval
self.clock.set_time_alert(name, alert_time)
# Act
self.clock.cancel_timer(name)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertEqual(0, len(self.handler))
self.loop.run_until_complete(run_test())
def test_set_multiple_time_alerts(self):
async def run_test():
# Arrange
alert_time1 = self.clock.utc_now() + timedelta(milliseconds=200)
alert_time2 = self.clock.utc_now() + timedelta(milliseconds=300)
# Act
self.clock.set_time_alert("TEST_ALERT1", alert_time1)
self.clock.set_time_alert("TEST_ALERT2", alert_time2)
await asyncio.sleep(0.7)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertTrue(len(self.handler) >= 2)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.assertTrue(isinstance(self.handler[1], TimeEvent))
self.loop.run_until_complete(run_test())
def test_set_timer_with_immediate_start_time(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
# Act
self.clock.set_timer(
name=name,
interval=timedelta(milliseconds=100),
start_time=None,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
self.assertEqual([name], self.clock.timer_names())
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.loop.run_until_complete(run_test())
def test_set_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
self.assertEqual([name], self.clock.timer_names())
self.assertTrue(len(self.handler) >= 2)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.loop.run_until_complete(run_test())
def test_set_timer_with_stop_time(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
await asyncio.sleep(0.5)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertTrue(len(self.handler) >= 1)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.loop.run_until_complete(run_test())
def test_cancel_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
self.clock.set_timer(name=name, interval=interval)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertTrue(len(self.handler) <= 4)
self.loop.run_until_complete(run_test())
def test_set_repeating_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
self.assertTrue(len(self.handler) >= 3)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.assertTrue(isinstance(self.handler[1], TimeEvent))
self.assertTrue(isinstance(self.handler[2], TimeEvent))
self.loop.run_until_complete(run_test())
def test_cancel_repeating_timer(self):
async def run_test():
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + timedelta(seconds=5)
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
self.assertTrue(len(self.handler) <= 5)
self.loop.run_until_complete(run_test())
def test_set_two_repeating_timers(self):
async def run_test():
# Arrange
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + timedelta(milliseconds=100)
# Act
self.clock.set_timer(
name="TEST_TIMER1",
interval=interval,
start_time=start_time,
stop_time=None,
)
self.clock.set_timer(
name="TEST_TIMER2",
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.9)
# Assert
self.assertTrue(len(self.handler) >= 8)
self.loop.run_until_complete(run_test())
class TestLiveClockWithLoopTimer:
def setup(self):
# Fixture Setup
self.loop = asyncio.get_event_loop()
self.loop.set_debug(True)
self.handler = []
self.clock = LiveClock(loop=self.loop)
self.clock.register_default_handler(self.handler.append)
def teardown(self):
self.clock.cancel_timers()
def test_timestamp(self):
# Arrange, Act
result = self.clock.timestamp()
# Assert
assert isinstance(result, float)
assert result > 0
def test_timestamp_ms(self):
# Arrange, Act
result = self.clock.timestamp_ms()
# Assert
assert isinstance(result, int)
assert result > 0
def test_timestamp_ns(self):
# Arrange, Act
result = self.clock.timestamp_ns()
# Assert
assert isinstance(result, int)
assert result > 0
@pytest.mark.asyncio
async def test_set_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=100)
alert_time = self.clock.utc_now() + interval
# Act
self.clock.set_time_alert(name, alert_time)
await asyncio.sleep(0.3)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 1
assert isinstance(self.handler[0], TimeEvent)
@pytest.mark.asyncio
async def test_cancel_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=300)
alert_time = self.clock.utc_now() + interval
self.clock.set_time_alert(name, alert_time)
# Act
self.clock.cancel_timer(name)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) == 0
@pytest.mark.asyncio
async def test_set_multiple_time_alerts(self):
# Arrange
alert_time1 = self.clock.utc_now() + timedelta(milliseconds=200)
alert_time2 = self.clock.utc_now() + timedelta(milliseconds=300)
# Act
self.clock.set_time_alert("TEST_ALERT1", alert_time1)
self.clock.set_time_alert("TEST_ALERT2", alert_time2)
await asyncio.sleep(0.7)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 2
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
@pytest.mark.asyncio
async def test_set_timer_with_immediate_start_time(self):
# Arrange
name = "TEST_TIMER"
# Act
self.clock.set_timer(
name=name,
interval=timedelta(milliseconds=100),
start_time=None,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert isinstance(self.handler[0], TimeEvent)
@pytest.mark.asyncio
async def test_set_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == [name]
assert len(self.handler) >= 2
assert isinstance(self.handler[0], TimeEvent)
@pytest.mark.asyncio
async def test_set_timer_with_stop_time(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
await asyncio.sleep(0.5)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) >= 1
assert isinstance(self.handler[0], TimeEvent)
@pytest.mark.asyncio
async def test_cancel_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
self.clock.set_timer(name=name, interval=interval)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
assert self.clock.timer_names() == []
assert len(self.handler) <= 4
@pytest.mark.asyncio
async def test_set_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.5)
# Assert
assert len(self.handler) >= 3
assert isinstance(self.handler[0], TimeEvent)
assert isinstance(self.handler[1], TimeEvent)
assert isinstance(self.handler[2], TimeEvent)
@pytest.mark.asyncio
async def test_cancel_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + timedelta(seconds=5)
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
# Act
await asyncio.sleep(0.3)
self.clock.cancel_timer(name)
await asyncio.sleep(0.3)
# Assert
assert len(self.handler) <= 5
@pytest.mark.asyncio
async def test_set_two_repeating_timers(self):
# Arrange
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + timedelta(milliseconds=100)
# Act
self.clock.set_timer(
name="TEST_TIMER1",
interval=interval,
start_time=start_time,
stop_time=None,
)
self.clock.set_timer(
name="TEST_TIMER2",
interval=interval,
start_time=start_time,
stop_time=None,
)
await asyncio.sleep(0.9)
# Assert
assert len(self.handler) >= 8
class LiveClockWithThreadTimerTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.handler = []
self.clock = LiveClock()
self.clock.register_default_handler(self.handler.append)
def tearDown(self):
self.clock.cancel_timers()
def test_instantiated_clock(self):
# Arrange
# Act
# Assert
self.assertTrue(self.clock.is_default_handler_registered)
self.assertFalse(self.clock.is_test_clock)
self.assertEqual([], self.clock.timer_names())
def test_utc_now(self):
# Arrange
# Act
result = self.clock.utc_now()
# Assert
self.assertEqual(datetime, type(result))
self.assertEqual(pytz.utc, result.tzinfo)
def test_local_now(self):
# Arrange
# Act
result = self.clock.local_now(pytz.timezone("Australia/Sydney"))
# Assert
self.assertEqual(datetime, type(result))
self.assertTrue(str(result).endswith("+11:00"))
def test_delta(self):
# Arrange
start = self.clock.utc_now()
# Act
time.sleep(0.1)
result = self.clock.delta(start)
# Assert
self.assertTrue(result > timedelta(0))
self.assertEqual(timedelta, type(result))
def test_unix_time(self):
# Arrange
# Act
result = self.clock.unix_time()
# Assert
self.assertEqual(float, type(result))
self.assertTrue(result > 0)
def test_set_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=100)
alert_time = self.clock.utc_now() + interval
# Act
self.clock.set_time_alert(name, alert_time)
time.sleep(0.3)
# Assert
self.assertEqual(1, len(self.handler))
self.assertTrue(isinstance(self.handler[0], TimeEvent))
def test_cancel_time_alert(self):
# Arrange
name = "TEST_ALERT"
interval = timedelta(milliseconds=300)
alert_time = self.clock.utc_now() + interval
self.clock.set_time_alert(name, alert_time)
# Act
self.clock.cancel_timer(name)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertEqual(0, len(self.handler))
def test_set_multiple_time_alerts(self):
# Arrange
alert_time1 = self.clock.utc_now() + timedelta(milliseconds=200)
alert_time2 = self.clock.utc_now() + timedelta(milliseconds=300)
# Act
self.clock.set_time_alert("TEST_ALERT1", alert_time1)
self.clock.set_time_alert("TEST_ALERT2", alert_time2)
time.sleep(0.6)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertEqual(2, len(self.handler))
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.assertTrue(isinstance(self.handler[1], TimeEvent))
def test_set_timer_with_immediate_start_time(self):
# Arrange
name = "TEST_TIMER"
# Act
self.clock.set_timer(
name=name,
interval=timedelta(milliseconds=100),
start_time=None,
stop_time=None,
)
time.sleep(0.5)
# Assert
self.assertEqual([name], self.clock.timer_names())
self.assertTrue(isinstance(self.handler[0], TimeEvent))
def test_set_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.5)
# Assert
self.assertEqual([name], self.clock.timer_names())
self.assertTrue(len(self.handler) >= 2)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
def test_set_timer_with_stop_time(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + interval
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
time.sleep(0.5)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertTrue(len(self.handler) >= 1)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
def test_cancel_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
self.clock.set_timer(name=name, interval=interval)
# Act
time.sleep(0.3)
self.clock.cancel_timer(name)
time.sleep(0.3)
# Assert
self.assertEqual([], self.clock.timer_names())
self.assertTrue(len(self.handler) <= 4)
def test_set_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
# Act
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.5)
# Assert
self.assertTrue(len(self.handler) >= 3)
self.assertTrue(isinstance(self.handler[0], TimeEvent))
self.assertTrue(isinstance(self.handler[1], TimeEvent))
self.assertTrue(isinstance(self.handler[2], TimeEvent))
def test_cancel_repeating_timer(self):
# Arrange
name = "TEST_TIMER"
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now()
stop_time = start_time + timedelta(seconds=5)
self.clock.set_timer(
name=name,
interval=interval,
start_time=start_time,
stop_time=stop_time,
)
# Act
time.sleep(0.3)
self.clock.cancel_timer(name)
time.sleep(0.3)
# Assert
self.assertTrue(len(self.handler) <= 5)
def test_set_two_repeating_timers(self):
# Arrange
interval = timedelta(milliseconds=100)
start_time = self.clock.utc_now() + timedelta(milliseconds=100)
# Act
self.clock.set_timer(
name="TEST_TIMER1",
interval=interval,
start_time=start_time,
stop_time=None,
)
self.clock.set_timer(
name="TEST_TIMER2",
interval=interval,
start_time=start_time,
stop_time=None,
)
time.sleep(0.9)
# Assert
self.assertTrue(len(self.handler) >= 8)
