def test_ignore_mongo_db_when_appropriate(self, mock_db_connection, mock_imap): sched_instance = scheduler.Scheduler() sched_instance.setup_schedule() self.assertTrue(not mock_db_connection.initialize.called) self.assertTrue(scheduler.Scheduler._mongo_initialized)
def test_calls_trim(self, mock_celerybeatlock, mock_worker_watcher, mock_tick, mock_trim): sched_instance = scheduler.Scheduler() sched_instance.tick() mock_trim.assert_called_once_with()
def test_initialize_mongo_db_correctly(self, mock_db_connection, mock_imap): sched_instance = scheduler.Scheduler() sched_instance.setup_schedule() mock_db_connection.initialize.assert_called_once_with() self.assertTrue(scheduler.Scheduler._mongo_initialized)
def test_calls_handle_heartbeat(self, mock_celerybeatlock, mock_worker_watcher, mock_tick): sched_instance = scheduler.Scheduler() sched_instance.tick() mock_worker_watcher.assert_called_once()
def test_schedule_changed(self, mock_setup_schedule): sched_instance = scheduler.Scheduler() sched_instance.schedule # make sure it called the setup_schedule() method mock_setup_schedule.assert_called_once_with()
def test_returns_superclass_value(self, mock_apply_async, mock_setup_schedule): sched_instance = scheduler.Scheduler() mock_entry = mock.MagicMock() ret = sched_instance.apply_async(mock_entry) self.assertTrue(ret is mock_apply_async.return_value)
def test_schedule_returns_value(self, mock_setup_schedule, mock_schedule_changed): sched_instance = scheduler.Scheduler() sched_instance._schedule = mock.Mock() ret = sched_instance.schedule self.assertTrue(ret is sched_instance._schedule)
def test_heartbeat_lock_update(self, mock_tick, mock_celerybeatlock, mock_worker_watcher): mock_celerybeatlock.objects.return_value.update.return_value = 1 sched_instance = scheduler.Scheduler() sched_instance.tick() mock_tick.assert_called_once_with()
def test_failure_threshold(self, mock_apply_async, mock_setup_schedule): sched_instance = scheduler.Scheduler() entry = dispatch.ScheduledCall.from_db(SCHEDULES[0]).as_schedule_entry() sched_instance.apply_async(entry) # make sure the entry was added, because it has a failure threshold self.assertEqual(len(sched_instance._failure_watcher), 1)
def test_spawn_pulp_monitor_threads(self, mock_celery_timeout_monitor): my_scheduler = scheduler.Scheduler() my_scheduler.spawn_pulp_monitor_threads() mock_celery_timeout_monitor.assert_called_once_with() self.assertTrue(mock_celery_timeout_monitor.return_value.daemon) mock_celery_timeout_monitor.return_value.start.assert_called_once()
def test_celery_entry(self, mock_apply_async, mock_setup_schedule): sched_instance = scheduler.Scheduler() call = dispatch.ScheduledCall('PT1H', 'fake.task') entry = call.as_schedule_entry() sched_instance.apply_async(entry) self.assertEqual(len(sched_instance._failure_watcher), 0)
def test_not_custom_entry(self, mock_apply_async, mock_setup_schedule): sched_instance = scheduler.Scheduler() mock_entry = mock.MagicMock() ret = sched_instance.apply_async(mock_entry) self.assertTrue(ret is mock_apply_async.return_value) self.assertEqual(len(sched_instance._failure_watcher), 0)
def test_schedule_is_None(self, mock_get_schedule): sched_instance = scheduler.Scheduler() sched_instance._schedule = None sched_instance.schedule # make sure it called the get_schedule() method inherited from the baseclass mock_get_schedule.assert_called_once_with()
def test_heartbeat_lock_exception(self, mock_tick, mock_celerybeatlock, mock_worker_watcher): mock_celerybeatlock.objects.return_value.update.return_value = 0 mock_celerybeatlock.return_value.save.side_effect = NotUniqueError() sched_instance = scheduler.Scheduler() sched_instance.tick() self.assertFalse(mock_tick.called)
def test_calls_handle_heartbeat(self, mock_celerybeatlock, mock_worker_watcher, mock_time, mock_tick): sched_instance = scheduler.Scheduler() mock_time.time.return_value = 1449261335.275528 sched_instance.tick() mock_worker_watcher.handle_worker_heartbeat.assert_called_once_with('test@some_host') mock_worker_watcher.assert_called_once()
def test_loads_app_schedules(self, mock_get_enabled): sched_instance = scheduler.Scheduler() # make sure we have some real data to test with self.assertTrue(len(sched_instance.app.conf.CELERYBEAT_SCHEDULE) > 0) for key in sched_instance.app.conf.CELERYBEAT_SCHEDULE: self.assertTrue(key in sched_instance._schedule) self.assertTrue(isinstance(sched_instance._schedule.get(key), ScheduleEntry))
def test_new_updated(self, mock_updated_since, mock_get_enabled): mock_get_enabled.return_value = SCHEDULES sched_instance = scheduler.Scheduler() mock_get_enabled.return_value = mock.MagicMock() mock_get_enabled.return_value.count.return_value = sched_instance._loaded_from_db_count mock_updated_since.return_value.count.return_value = 1 self.assertTrue(sched_instance.schedule_changed is True)
def test_no_changes(self, mock_updated_since, mock_get_enabled): mock_updated_since.return_value.count.return_value = 0 mock_get_enabled.return_value = SCHEDULES sched_instance = scheduler.Scheduler() mock_get_enabled.return_value = mock.MagicMock() # -1 because there is an ignored schedule that has 0 remaining runs mock_get_enabled.return_value.count.return_value = len(SCHEDULES) - 1 self.assertTrue(sched_instance.schedule_changed is False)
def test_heartbeat_lock_insert_success(self, mock_tick, mock_celerybeatlock, mock_worker_watcher, mock_timestamp): sched_instance = scheduler.Scheduler() sched_instance.tick() lock_timestamp = mock_timestamp.utcnow() celerybeat_name = constants.SCHEDULER_WORKER_NAME + "@" + platform.node() mock_celerybeatlock.assert_called_once_with( timestamp=lock_timestamp, name=celerybeat_name) mock_celerybeatlock.objects().save().assert_called_once()
def test_spawn_pulp_monitor_threads(self, mock_worker_timeout_monitor, mock_event_monitor): my_scheduler = scheduler.Scheduler() my_scheduler.spawn_pulp_monitor_threads() mock_event_monitor.assert_called_once_with(my_scheduler._failure_watcher) self.assertTrue(mock_event_monitor.return_value.daemon) mock_event_monitor.return_value.start.assert_called_once() mock_worker_timeout_monitor.assert_called_once_with() self.assertTrue(mock_worker_timeout_monitor.return_value.daemon) mock_worker_timeout_monitor.return_value.start.assert_called_once()
def test__init__(self, mock_spawn_pulp_monitor_threads, mock_base_init): arg1 = mock.Mock() arg2 = mock.Mock() kwarg1 = mock.Mock() kwarg2 = mock.Mock() my_scheduler = scheduler.Scheduler(arg1, arg2, kwarg1=kwarg1, kwarg2=kwarg2) self.assertTrue(my_scheduler._schedule is None) self.assertTrue(my_scheduler._loaded_from_db_count == 0) self.assertTrue(not mock_spawn_pulp_monitor_threads.called) self.assertTrue(scheduler.Scheduler._mongo_initialized is False) mock_base_init.assert_called_once_with(arg1, arg2, app=app, kwarg1=kwarg1, kwarg2=kwarg2)
def test_count_changed(self, mock_updated_since, mock_get_enabled): """ This test ensures that if the number of enabled schedules changes, the schedule_changed property returns True. """ mock_updated_since.return_value.count.return_value = 0 mock_get_enabled.return_value = SCHEDULES sched_instance = scheduler.Scheduler() mock_get_enabled.return_value = mock.MagicMock() mock_get_enabled.return_value.count.return_value = sched_instance._loaded_from_db_count + 1 self.assertTrue(sched_instance.schedule_changed is True)
def test_calls_handle_heartbeat(self, mock_celerybeatlock, mock_worker_watcher, time, node, mock_tick): node.return_value = 'some_host' sched_instance = scheduler.Scheduler() time.time.return_value = 1449261335.275528 sched_instance.tick() expected_event = { 'timestamp': 1449261335.275528, 'local_received': 1449261335.275528, 'type': 'scheduler-event', 'hostname': SCHEDULER_WORKER_NAME + '@some_host' } mock_worker_watcher.handle_worker_heartbeat.assert_called_once_with(expected_event) mock_worker_watcher.assert_called_once()
def test_loads_db_schedules(self, mock_get_enabled): mock_get_enabled.return_value = SCHEDULES sched_instance = scheduler.Scheduler() # remove schedules we're not testing for for key in scheduler.app.conf.CELERYBEAT_SCHEDULE: del sched_instance._schedule[key] self.assertEqual(len(sched_instance._schedule), 2) self.assertTrue(isinstance(sched_instance._schedule.get('529f4bd93de3a31d0ec77338'), dispatch.ScheduleEntry)) # make sure it chose the maximum enabled timestamp self.assertEqual(sched_instance._most_recent_timestamp, 1387218569.811224) # make sure the entry with no remaining runs does not go into the schedule self.assertTrue('529f4bd93de3a31d0ec77340' not in sched_instance._schedule)
def test__init__lazy_is_False(self, mock_event_monitor, mock_spawn_pulp_monitor_threads): mock_app = mock.Mock() scheduler.Scheduler(mock_app, lazy=False) self.assertTrue(mock_spawn_pulp_monitor_threads.called)
def test__init__lazy_is_True(self, mock_spawn_pulp_monitor_threads): mock_app = mock.Mock() scheduler.Scheduler(mock_app, lazy=True) self.assertTrue(not mock_spawn_pulp_monitor_threads.called)
def test_not_implemented(self, mock_setup_schedule): sched_instance = scheduler.Scheduler() self.assertRaises(NotImplementedError, sched_instance.add)
def test_calls_handle_heartbeat(self, mock_heartbeat, mock_tick): sched_instance = scheduler.Scheduler() sched_instance.tick() mock_heartbeat.assert_called_once()
def test_calls_superclass(self, mock_tick): sched_instance = scheduler.Scheduler() sched_instance.tick() mock_tick.assert_called_once_with()
def test_calls_trim(self, mock_tick, mock_trim): sched_instance = scheduler.Scheduler() sched_instance.tick() mock_trim.assert_called_once_with()