def test_create(self):
fixed_dt = datetime_now() + timedelta(seconds=10)
schedule = TaskSchedule.create({'run_at': fixed_dt})
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.SCHEDULE, schedule.action)
schedule = {'run_at': fixed_dt, 'priority': 2,
'action': TaskSchedule.RESCHEDULE_EXISTING}
schedule = TaskSchedule.create(schedule)
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(2, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
schedule = TaskSchedule.create(0)
self._within_one_second(schedule.run_at, datetime_now())
schedule = TaskSchedule.create(10)
self._within_one_second(schedule.run_at,
datetime_now() + timedelta(seconds=10))
schedule = TaskSchedule.create(TaskSchedule(run_at=fixed_dt))
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.SCHEDULE, schedule.action)
def test_create(self):
fixed_dt = datetime_now() + timedelta(seconds=10)
schedule = TaskSchedule.create({'run_at': fixed_dt})
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.SCHEDULE, schedule.action)
schedule = {
'run_at': fixed_dt,
'priority': 2,
'action': TaskSchedule.RESCHEDULE_EXISTING
}
schedule = TaskSchedule.create(schedule)
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(2, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
schedule = TaskSchedule.create(0)
self._within_one_second(schedule.run_at, datetime_now())
schedule = TaskSchedule.create(10)
self._within_one_second(schedule.run_at,
datetime_now() + timedelta(seconds=10))
schedule = TaskSchedule.create(TaskSchedule(run_at=fixed_dt))
self.assertEqual(schedule.run_at, fixed_dt)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.SCHEDULE, schedule.action)
def test_non_default_schedule_used(self):
default_run_at = datetime_now() + timedelta(seconds=90)
@tasks.background(name='non_default_schedule_used',
schedule={'run_at': default_run_at, 'priority': 2})
def default_schedule_used_for_priority():
pass
run_at = datetime_now().replace(microsecond=0) + timedelta(seconds=60)
default_schedule_used_for_priority(schedule=run_at)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual(run_at, task.run_at)
def test_non_default_schedule_used(self):
default_run_at = datetime_now() + timedelta(seconds=90)
@tasks.background(name='non_default_schedule_used',
schedule={
'run_at': default_run_at,
'priority': 2
})
def default_schedule_used_for_priority():
pass
run_at = datetime_now().replace(microsecond=0) + timedelta(seconds=60)
default_schedule_used_for_priority(schedule=run_at)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual(run_at, task.run_at)
def test_run_at(self):
for schedule in [None, 0, timedelta(seconds=0)]:
now = datetime_now()
run_at = TaskSchedule(run_at=schedule).run_at
self._within_one_second(run_at, now)
now = datetime_now()
run_at = TaskSchedule(run_at=now).run_at
self._within_one_second(run_at, now)
fixed_dt = datetime_now() + timedelta(seconds=60)
run_at = TaskSchedule(run_at=fixed_dt).run_at
self._within_one_second(run_at, fixed_dt)
run_at = TaskSchedule(run_at=90).run_at
self._within_one_second(run_at, datetime_now() + timedelta(seconds=90))
run_at = TaskSchedule(run_at=timedelta(seconds=35)).run_at
self._within_one_second(run_at, datetime_now() + timedelta(seconds=35))
def test_run_at(self):
for schedule in [None, 0, timedelta(seconds=0)]:
now = datetime_now()
run_at = TaskSchedule(run_at=schedule).run_at
self._within_one_second(run_at, now)
now = datetime_now()
run_at = TaskSchedule(run_at=now).run_at
self._within_one_second(run_at, now)
fixed_dt = datetime_now() + timedelta(seconds=60)
run_at = TaskSchedule(run_at=fixed_dt).run_at
self._within_one_second(run_at, fixed_dt)
run_at = TaskSchedule(run_at=90).run_at
self._within_one_second(run_at, datetime_now() + timedelta(seconds=90))
run_at = TaskSchedule(run_at=timedelta(seconds=35)).run_at
self._within_one_second(run_at, datetime_now() + timedelta(seconds=35))
def test_merge(self):
default = TaskSchedule(run_at=10, priority=2,
action=TaskSchedule.RESCHEDULE_EXISTING)
schedule = TaskSchedule.create(20).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=20),
schedule.run_at)
self.assertEqual(2, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
schedule = TaskSchedule.create({'priority': 0}).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=10),
schedule.run_at)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
action = TaskSchedule.CHECK_EXISTING
schedule = TaskSchedule.create({'action': action}).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=10),
schedule.run_at)
self.assertEqual(2, schedule.priority)
self.assertEqual(action, schedule.action)
def test_default_schedule_used_for_priority(self):
@tasks.background(name='default_schedule_used_for_priority',
schedule={'priority': 2})
def default_schedule_used_for_priority():
pass
now = datetime_now()
default_schedule_used_for_priority()
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual(2, task.priority)
def test_default_schedule_used_for_priority(self):
@tasks.background(name='default_schedule_used_for_priority',
schedule={'priority': 2})
def default_schedule_used_for_priority():
pass
now = datetime_now()
default_schedule_used_for_priority()
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual(2, task.priority)
def test_merge(self):
default = TaskSchedule(run_at=10,
priority=2,
action=TaskSchedule.RESCHEDULE_EXISTING)
schedule = TaskSchedule.create(20).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=20),
schedule.run_at)
self.assertEqual(2, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
schedule = TaskSchedule.create({'priority': 0}).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=10),
schedule.run_at)
self.assertEqual(0, schedule.priority)
self.assertEqual(TaskSchedule.RESCHEDULE_EXISTING, schedule.action)
action = TaskSchedule.CHECK_EXISTING
schedule = TaskSchedule.create({'action': action}).merge(default)
self._within_one_second(datetime_now() + timedelta(seconds=10),
schedule.run_at)
self.assertEqual(2, schedule.priority)
self.assertEqual(action, schedule.action)
def test_default_schedule_used_for_run_at(self):
@tasks.background(name='default_schedule_used_for_run_at', schedule=60)
def default_schedule_used_for_time():
pass
now = datetime_now()
default_schedule_used_for_time()
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.failUnless(now < task.run_at)
self.failUnless((task.run_at - now) <= timedelta(seconds=61))
self.failUnless((task.run_at - now) >= timedelta(seconds=59))
def test_default_schedule_used_for_run_at(self):
@tasks.background(name='default_schedule_used_for_run_at', schedule=60)
def default_schedule_used_for_time():
pass
now = datetime_now()
default_schedule_used_for_time()
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.failUnless(now < task.run_at)
self.failUnless((task.run_at - now) <= timedelta(seconds=61))
self.failUnless((task.run_at - now) >= timedelta(seconds=59))
def test_check_existing(self):
check_existing = TaskSchedule.CHECK_EXISTING
@tasks.background(name='test_check_existing',
schedule=TaskSchedule(action=check_existing))
def check_fn():
pass
# this should only end up with the first call
# scheduled
check_fn()
check_fn(schedule=90)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual('test_check_existing', task.task_name)
# check new task is scheduled for the earlier time
now = datetime_now()
self.failUnless(now - timedelta(seconds=1) < task.run_at)
self.failUnless(now + timedelta(seconds=1) > task.run_at)
def test_reschedule_existing(self):
reschedule_existing = TaskSchedule.RESCHEDULE_EXISTING
@tasks.background(name='test_reschedule_existing',
schedule=TaskSchedule(action=reschedule_existing))
def reschedule_fn():
pass
# this should only end up with one task
# and it should be scheduled for the later time
reschedule_fn()
reschedule_fn(schedule=90)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual('test_reschedule_existing', task.task_name)
# check task is scheduled for later on
now = datetime_now()
self.failUnless(now + timedelta(seconds=89) < task.run_at)
self.failUnless(now + timedelta(seconds=91) > task.run_at)
def test_check_existing(self):
check_existing = TaskSchedule.CHECK_EXISTING
@tasks.background(name='test_check_existing',
schedule=TaskSchedule(action=check_existing))
def check_fn():
pass
# this should only end up with the first call
# scheduled
check_fn()
check_fn(schedule=90)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual('test_check_existing', task.task_name)
# check new task is scheduled for the earlier time
now = datetime_now()
self.failUnless(now - timedelta(seconds=1) < task.run_at)
self.failUnless(now + timedelta(seconds=1) > task.run_at)
def test_reschedule_existing(self):
reschedule_existing = TaskSchedule.RESCHEDULE_EXISTING
@tasks.background(name='test_reschedule_existing',
schedule=TaskSchedule(action=reschedule_existing))
def reschedule_fn():
pass
# this should only end up with one task
# and it should be scheduled for the later time
reschedule_fn()
reschedule_fn(schedule=90)
all_tasks = Task.objects.all()
self.assertEqual(1, all_tasks.count())
task = all_tasks[0]
self.assertEqual('test_reschedule_existing', task.task_name)
# check task is scheduled for later on
now = datetime_now()
self.failUnless(now + timedelta(seconds=89) < task.run_at)
self.failUnless(now + timedelta(seconds=91) > task.run_at)
