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()
