def test_fast_forward_delay(self): """Test that fast forwarding the time works properly""" notify_event = threading.Event() virtualtime.notify_on_change(notify_event) delay_event = threading.Event() offsets = [] positions = ["start_job", ""] msg_dict = {'offsets': offsets, 'positions': positions} catcher_thread = threading.Thread(target=self.fast_forward_delayer, args=(notify_event, delay_event, msg_dict)) catcher_thread.start() start_time = virtualtime._original_time() virtualtime.fast_forward_time(2) assert virtualtime._time_offset == 2 virtualtime.restore_time() msg_dict['stop'] = True notify_event.set() catcher_thread.join() completion_time = virtualtime._original_time() assert offsets[:3] == [1.0, 2.0, 0] # depends on how long the stop event takes? assert (not offsets[3:]) or offsets[3:] == [0] assert completion_time - start_time < 0.2 assert delay_event.is_set()
def test_callback(self): self.notify_event = threading.Event() virtualtime.notify_on_change(self.notify_event) self.callback_stop = False self.callback_event = threading.Event() self.callback_logs = [] self.callback_missed = [] ct = threading.Thread(target=self.callback_thread) ct.start() virtualtime.wait_for_callback_on_change(self.callback_event) try: start_time = virtualtime._original_time() virtualtime.set_offset(1) assert len(self.callback_logs) == 1 and not self.callback_missed assert self.callback_logs[0][1:] == (1, False) offset_time = virtualtime._original_time() assert offset_time - start_time < 0.1 virtualtime.set_time(0) assert len(self.callback_logs) == 2 and not self.callback_missed assert self.callback_logs[1][ 1] < -start_time + 1 and self.callback_logs[1][2] is False set_time = virtualtime._original_time() assert set_time - offset_time < 0.1 virtualtime.restore_time() assert len(self.callback_logs) == 3 and not self.callback_missed assert self.callback_logs[1][ 1] < -start_time + 1 and self.callback_logs[1][2] is False restore_time = virtualtime._original_time() assert restore_time - set_time < 0.1 finally: # deleting this should ensure it drops out of the weak set and doesn't hang things up later... del self.callback_event self.callback_stop = True self.notify_event.set() ct.join()
def test_fast_forward_time(self): """Test that fast forwarding the time works properly""" event = threading.Event() virtualtime.notify_on_change(event) offsets = [] msg_dict = {'offsets': offsets} catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict)) catcher_thread.start() start_time = virtualtime._original_time() virtualtime.fast_forward_time(1) assert virtualtime._time_offset == 1 virtualtime.fast_forward_time(2.5) assert virtualtime._time_offset == 3.5 virtualtime.fast_forward_time(target=start_time + 9.1, step_size=2.0) assert 9 <= virtualtime._time_offset <= 9.2 virtualtime.restore_time() virtualtime.fast_forward_time(-1.3, step_size=0.9) virtualtime.restore_time() msg_dict['stop'] = True event.set() catcher_thread.join() assert offsets[:6] == [1.0, 2.0, 3.0, 3.5, 5.5, 7.5] assert 9 <= offsets[6] <= 9.2 assert offsets[7:11] == [0, -0.9, -1.3, 0] # depends on how long the stop event takes? assert (not offsets[11:]) or offsets[11:] == [0]
def test_parallel_sleeps(self): """Tests that sleep comes back quicker than normal when time is advanced, and that this works with lots of threads""" first_time = virtualtime._original_time() sleeper_threads = {} REPEATS = 100 for n in range(REPEATS): sleeper_threads[n] = sleeper_thread = threading.Thread( target=time.sleep, args=(3, ), name="test_sleep_sleeper_%d" % n) sleeper_thread.start() self.wait_sleep_started(REPEATS, 0.5) thread_time = virtualtime._original_time() setup_duration = thread_time - first_time assert setup_duration < 0.5 virtualtime.set_time(thread_time + 20) for n in range(REPEATS): sleeper_threads[n].join() join_time = virtualtime._original_time() sleep_duration = join_time - thread_time virtualtime.restore_time() if self.virtual_time_enabled: assert sleep_duration < 0.2 else: assert sleep_duration >= 3
def test_callback(self): self.notify_event = threading.Event() virtualtime.notify_on_change(self.notify_event) self.callback_stop = False self.callback_event = threading.Event() self.callback_logs = [] self.callback_missed = [] ct = threading.Thread(target=self.callback_thread) ct.start() virtualtime.wait_for_callback_on_change(self.callback_event) try: start_time = virtualtime._original_time() virtualtime.set_offset(1) assert len(self.callback_logs) == 1 and not self.callback_missed assert self.callback_logs[0][1:] == (1, False) offset_time = virtualtime._original_time() assert offset_time - start_time < 0.1 virtualtime.set_time(0) assert len(self.callback_logs) == 2 and not self.callback_missed assert self.callback_logs[1][1] < -start_time + 1 and self.callback_logs[1][2] is False set_time = virtualtime._original_time() assert set_time - offset_time < 0.1 virtualtime.restore_time() assert len(self.callback_logs) == 3 and not self.callback_missed assert self.callback_logs[1][1] < -start_time + 1 and self.callback_logs[1][2] is False restore_time = virtualtime._original_time() assert restore_time - set_time < 0.1 finally: # deleting this should ensure it drops out of the weak set and doesn't hang things up later... del self.callback_event self.callback_stop = True self.notify_event.set() ct.join()
def test_fast_forward_datetime_style(self): """Test that fast forwarding the time works properly when using datetime-style objects""" event = threading.Event() virtualtime.notify_on_change(event) offsets = [] msg_dict = {'offsets': offsets} catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict)) catcher_thread.start() start_time = virtualtime._original_datetime_now() utc_start_time = datetime_tz.localize(start_time).astimezone(pytz.utc) virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=1)) assert virtualtime._time_offset == 1 virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=2.5)) assert virtualtime._time_offset == 3.5 virtualtime.fast_forward_local_datetime(target=start_time + datetime.timedelta(seconds=9.1), step_size=datetime.timedelta(seconds=2.0)) assert 9 <= virtualtime._time_offset <= 9.2 virtualtime.fast_forward_utc_datetime(target=utc_start_time + datetime.timedelta(seconds=18.2), step_size=datetime.timedelta(seconds=20.0)) assert 18 <= virtualtime._time_offset <= 18.3 virtualtime.restore_time() virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=-1.3), step_size=datetime.timedelta(seconds=0.9)) virtualtime.restore_time() msg_dict['stop'] = True event.set() catcher_thread.join() assert offsets[:6] == [1.0, 2.0, 3.0, 3.5, 5.5, 7.5] assert 9 <= offsets[6] <= 9.2 assert 18 <= offsets[7] <= 18.3 assert offsets[8:12] == [0, -0.9, -1.3, 0] # depends on how long the stop event takes? assert (not offsets[12:]) or offsets[12:] == [0]
def test_sleep(self): """Tests that sleep comes back quicker than normal when time is advanced""" first_time = time.time() sleeper_thread = threading.Thread(target=time.sleep, args=(3,), name="test_sleep_sleeper") sleeper_thread.start() self.wait_sleep_started(1, 0.2) virtualtime.set_time(first_time + 5) sleeper_thread.join() virtualtime.restore_time() join_time = time.time() if self.virtual_time_enabled: assert join_time - first_time < 0.5 else: assert join_time - first_time >= 3
def run_time_function_tst(time_function, set_function, diff, enabled=True): """Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff Checks that the right thing will happen when virtualtime enabled/disabled""" first_time = time_function() set_function(first_time + diff) late_time = time_function() set_function(first_time - diff) early_time = time_function() virtualtime.restore_time() last_time = time_function() if enabled: assert early_time < first_time < last_time < late_time else: assert first_time <= late_time <= early_time <= last_time
def test_fast_forward_time_long(self): """Test that fast forwarding the time a long way works properly""" event = threading.Event() virtualtime.notify_on_change(event) offsets = [] msg_dict = {'offsets': offsets} catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict)) catcher_thread.start() start_time = virtualtime._original_time() virtualtime.fast_forward_time(1000, step_size=1) virtualtime.restore_time() msg_dict['stop'] = True event.set() catcher_thread.join() assert offsets == list(range(1, 1001)) + [0]
def test_sleep(self): """Tests that sleep comes back quicker than normal when time is advanced""" first_time = time.time() sleeper_thread = threading.Thread(target=time.sleep, args=(3, ), name="test_sleep_sleeper") sleeper_thread.start() self.wait_sleep_started(1, 0.2) virtualtime.set_time(first_time + 5) sleeper_thread.join() virtualtime.restore_time() join_time = time.time() if self.virtual_time_enabled: assert join_time - first_time < 0.5 else: assert join_time - first_time >= 3
def run_time_derived_function_tst(derived_function, time_function, set_function, diff, min_diff=None, enabled=True): """Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff Checks that the right thing will happen when virtualtime enabled/disabled""" first_derived, first_time = derived_function(), time_function() set_function(first_time + diff) late_derived = derived_function() set_function(first_time - diff) early_derived = derived_function() virtualtime.restore_time() if min_diff: time.sleep(min_diff) last_derived = derived_function() if enabled: assert early_derived < first_derived < last_derived < late_derived else: assert first_derived <= late_derived <= early_derived <= last_derived
def test_notify_on_change(self): self.notify_event = threading.Event() virtualtime.notify_on_change(self.notify_event) start_time = virtualtime._original_time() virtualtime.set_offset(1) assert self.notify_event.wait(0.1) self.notify_event.clear() offset_time = virtualtime._original_time() assert offset_time - start_time < 0.1 virtualtime.set_time(0) assert self.notify_event.wait(0.1) self.notify_event.clear() set_time = virtualtime._original_time() assert set_time - offset_time < 0.1 virtualtime.restore_time() assert self.notify_event.wait(0.1) self.notify_event.clear() restore_time = virtualtime._original_time() assert restore_time - set_time < 0.1
def test_parallel_sleeps(self): """Tests that sleep comes back quicker than normal when time is advanced, and that this works with lots of threads""" first_time = virtualtime._original_time() sleeper_threads = {} REPEATS = 100 for n in range(REPEATS): sleeper_threads[n] = sleeper_thread = threading.Thread(target=time.sleep, args=(3,), name="test_sleep_sleeper_%d" % n) sleeper_thread.start() self.wait_sleep_started(REPEATS, 0.5) thread_time = virtualtime._original_time() setup_duration = thread_time - first_time assert setup_duration < 0.5 virtualtime.set_time(thread_time + 20) for n in range(REPEATS): sleeper_threads[n].join() join_time = virtualtime._original_time() sleep_duration = join_time - thread_time virtualtime.restore_time() if self.virtual_time_enabled: assert sleep_duration < 0.2 else: assert sleep_duration >= 3
def test_fast_forward_datetime_style(self): """Test that fast forwarding the time works properly when using datetime-style objects""" event = threading.Event() virtualtime.notify_on_change(event) offsets = [] msg_dict = {'offsets': offsets} catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict)) catcher_thread.start() start_time = virtualtime._original_datetime_now() utc_start_time = datetime_tz.localize(start_time).astimezone(pytz.utc) virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=1)) assert virtualtime._time_offset == 1 virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=2.5)) assert virtualtime._time_offset == 3.5 virtualtime.fast_forward_local_datetime( target=start_time + datetime.timedelta(seconds=9.1), step_size=datetime.timedelta(seconds=2.0)) assert 9 <= virtualtime._time_offset <= 9.2 virtualtime.fast_forward_utc_datetime( target=utc_start_time + datetime.timedelta(seconds=18.2), step_size=datetime.timedelta(seconds=20.0)) assert 18 <= virtualtime._time_offset <= 18.3 virtualtime.restore_time() virtualtime.fast_forward_timedelta( datetime.timedelta(seconds=-1.3), step_size=datetime.timedelta(seconds=0.9)) virtualtime.restore_time() msg_dict['stop'] = True event.set() catcher_thread.join() assert offsets[:6] == [1.0, 2.0, 3.0, 3.5, 5.5, 7.5] assert 9 <= offsets[6] <= 9.2 assert 18 <= offsets[7] <= 18.3 assert offsets[8:12] == [0, -0.9, -1.3, 0] # depends on how long the stop event takes? assert (not offsets[12:]) or offsets[12:] == [0]
def restore_time_after(test_function, *args, **kwargs): try: return test_function(*args, **kwargs) finally: virtualtime.restore_time()
def tearDown(self): """Restores normal time after the method has finished""" virtualtime.restore_time()
def setUp(self): """Restores normal time to ensure tests start cleanly""" virtualtime.restore_time()