def test_handle_worker(self):
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
self.cam._last_worker_write.clear()
m = self.cam.handle_worker((worker.hostname, worker))
self.assertTrue(m)
self.assertTrue(m.hostname)
self.assertTrue(m.last_heartbeat)
self.assertTrue(m.is_alive())
self.assertEqual(unicode(m), unicode(m.hostname))
self.assertTrue(repr(m))
def test_handle_worker(self):
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
self.cam._last_worker_write.clear()
m = self.cam.handle_worker((worker.hostname, worker))
assert m
assert m.hostname
assert m.last_heartbeat
assert m.is_alive()
assert str(m) == str(m.hostname)
assert repr(m)
def test_handle_worker(self):
worker = Worker(hostname="fuzzie")
worker.on_online(timestamp=time())
self.cam._last_worker_write.clear()
m = self.cam.handle_worker((worker.hostname, worker))
self.assertTrue(m)
self.assertTrue(m.hostname)
self.assertTrue(m.last_heartbeat)
self.assertTrue(m.is_alive())
self.assertEqual(unicode(m), unicode(m.hostname))
self.assertTrue(repr(m))
def test_get_heartbeat(self):
worker = Worker(hostname='fuzzie')
self.assertIsNone(self.cam.get_heartbeat(worker))
t1 = time()
t2 = time()
t3 = time()
for t in t1, t2, t3:
worker.event('heartbeat', t, t, {})
self.state.workers[worker.hostname] = worker
self.assertEqual(self.cam.get_heartbeat(worker),
make_aware(datetime.fromtimestamp(t3)))
def test_equality(self):
self.assertEqual(Worker(hostname='foo').hostname, 'foo')
self.assertEqual(
Worker(hostname='foo'),
Worker(hostname='foo'),
)
self.assertNotEqual(
Worker(hostname='foo'),
Worker(hostname='bar'),
)
self.assertEqual(
hash(Worker(hostname='foo')),
hash(Worker(hostname='foo')),
)
self.assertNotEqual(
hash(Worker(hostname='foo')),
hash(Worker(hostname='bar')),
)
def test_handle_task_timezone(self):
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
self.cam.handle_worker((worker.hostname, worker))
tstamp = 1464793200.0 # 2016-06-01T15:00:00Z
with override_settings(USE_TZ=True, TIME_ZONE='Europe/Helsinki'):
task = self.create_task(
worker,
eta='2016-06-01T15:16:17.654321+00:00',
expires='2016-07-01T15:16:17.765432+03:00',
)
task.event('received', tstamp, tstamp, {})
mt = self.cam.handle_task((task.uuid, task))
assert (
mt.tstamp ==
datetime(2016, 6, 1, 15, 0, 0, tzinfo=timezone.utc)
)
assert (
mt.eta ==
datetime(2016, 6, 1, 15, 16, 17, 654321, tzinfo=timezone.utc)
)
assert (
mt.expires ==
datetime(2016, 7, 1, 12, 16, 17, 765432, tzinfo=timezone.utc)
)
task = self.create_task(worker, eta='2016-06-04T15:16:17.654321')
task.event('received', tstamp, tstamp, {})
mt = self.cam.handle_task((task.uuid, task))
assert (
mt.eta ==
datetime(2016, 6, 4, 15, 16, 17, 654321, tzinfo=timezone.utc)
)
with override_settings(USE_TZ=False, TIME_ZONE='Europe/Helsinki'):
task = self.create_task(
worker,
eta='2016-06-01T15:16:17.654321+00:00',
expires='2016-07-01T15:16:17.765432+03:00',
)
task.event('received', tstamp, tstamp, {})
mt = self.cam.handle_task((task.uuid, task))
assert mt.tstamp == datetime(2016, 6, 1, 18, 0, 0)
assert mt.eta == datetime(2016, 6, 1, 18, 16, 17, 654321)
assert mt.expires == datetime(2016, 7, 1, 15, 16, 17, 765432)
task = self.create_task(worker, eta='2016-06-04T15:16:17.654321')
task.event('received', tstamp, tstamp, {})
mt = self.cam.handle_task((task.uuid, task))
assert mt.eta == datetime(2016, 6, 4, 15, 16, 17, 654321)
def assertExpires(self, dec, expired, tasks=10):
# Cleanup leftovers from previous tests
self.cam.on_cleanup()
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
for total in range(tasks):
task = create_task(worker)
task.event('received', time() - dec, time() - dec, {})
task.event('succeeded', time() - dec, time() - dec, {'result': 42})
self.assertTrue(task.name)
self.assertTrue(self.cam.handle_task((task.uuid, task)))
self.assertEqual(self.cam.on_cleanup(), expired)
def test_compatible_with_Decimal(self):
w = Worker('*****@*****.**')
timestamp, local_received = Decimal(time()), time()
w.event('worker-online',
timestamp,
local_received,
fields={
'hostname': '*****@*****.**',
'timestamp': timestamp,
'local_received': local_received,
'freq': Decimal(5.6335431),
})
assert w.alive
def test_handle_worker(self):
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
old_last_update = timezone.now() - timedelta(hours=1)
models.WorkerState.objects.all().update(last_update=old_last_update)
m = self.cam.handle_worker((worker.hostname, worker))
assert m
assert m.hostname
assert m.last_heartbeat
assert m.last_update != old_last_update
assert m.is_alive()
assert str(m) == str(m.hostname)
assert repr(m)
def test_survives_unknown_worker_leaving(self):
s = State(on_node_leave=Mock(name='on_node_leave'))
(worker, created), subject = s.event({
'type': 'worker-offline',
'hostname': '*****@*****.**',
'timestamp': time(),
'local_received': time(),
'clock': 301030134894833,
})
assert worker == Worker('*****@*****.**')
assert not created
assert subject == 'offline'
assert '*****@*****.**' not in s.workers
s.on_node_leave.assert_called_with(worker)
def test_survives_unknown_worker_leaving(self):
s = State(on_node_leave=Mock(name='on_node_leave'))
(worker, created), subject = s.event({
'type': 'worker-offline',
'hostname': '*****@*****.**',
'timestamp': time(),
'local_received': time(),
'clock': 301030134894833,
})
self.assertEqual(worker, Worker('*****@*****.**'))
self.assertFalse(created)
self.assertEqual(subject, 'offline')
self.assertNotIn('*****@*****.**', s.workers)
s.on_node_leave.assert_called_with(worker)
def test_handle_task_received(self):
worker = Worker(hostname='fuzzie')
worker.event('online', time(), time(), {})
self.cam.handle_worker((worker.hostname, worker))
task = self.create_task(worker)
task.event('received', time(), time(), {})
assert task.state == states.RECEIVED
mt = self.cam.handle_task((task.uuid, task))
assert mt.name == task.name
assert str(mt)
assert repr(mt)
mt.eta = timezone.now()
assert 'eta' in str(mt)
assert mt in models.TaskState.objects.active()
def test_handle_task(self):
worker1 = Worker(hostname='fuzzie')
worker1.on_online(timestamp=time())
mw = self.cam.handle_worker((worker1.hostname, worker1))
task1 = create_task(worker1)
task1.on_received(timestamp=time())
mt = self.cam.handle_task((task1.uuid, task1))
self.assertEqual(mt.worker, mw)
worker2 = Worker(hostname=None)
task2 = create_task(worker2)
task2.on_received(timestamp=time())
mt = self.cam.handle_task((task2.uuid, task2))
self.assertIsNone(mt.worker)
task1.on_succeeded(timestamp=time(), result=42)
mt = self.cam.handle_task((task1.uuid, task1))
self.assertEqual(mt.name, task1.name)
self.assertEqual(mt.result, 42)
task3 = create_task(worker1, name=None)
task3.on_revoked(timestamp=time())
mt = self.cam.handle_task((task3.uuid, task3))
self.assertIsNone(mt)
def test_handle_task_received(self):
worker = Worker(hostname='fuzzie')
worker.on_online(timestamp=time())
self.cam.handle_worker((worker.hostname, worker))
task = create_task(worker)
task.on_received(timestamp=time())
self.assertEqual(task.state, 'RECEIVED')
mt = self.cam.handle_task((task.uuid, task))
self.assertEqual(mt.name, task.name)
self.assertTrue(unicode(mt))
self.assertTrue(repr(mt))
mt.eta = celery.now()
self.assertIn('eta', unicode(mt))
self.assertIn(mt, models.TaskState.objects.active())
def test_reduce_direct(self):
w = Worker('*****@*****.**')
w.event('worker-online', 10.0, 13.0, fields={
'hostname': '*****@*****.**',
'timestamp': 10.0,
'local_received': 13.0,
'freq': 60,
})
fun, args = w.__reduce__()
w2 = fun(*args)
assert w2.hostname == w.hostname
assert w2.pid == w.pid
assert w2.freq == w.freq
assert w2.heartbeats == w.heartbeats
assert w2.clock == w.clock
assert w2.active == w.active
assert w2.processed == w.processed
assert w2.loadavg == w.loadavg
assert w2.sw_ident == w.sw_ident
def test_reduce_direct(self):
w = Worker('*****@*****.**')
w.event('worker-online',
10.0,
13.0,
fields={
'hostname': '*****@*****.**',
'timestamp': 10.0,
'local_received': 13.0,
'freq': 60,
})
fun, args = w.__reduce__()
w2 = fun(*args)
self.assertEqual(w2.hostname, w.hostname)
self.assertEqual(w2.pid, w.pid)
self.assertEqual(w2.freq, w.freq)
self.assertEqual(w2.heartbeats, w.heartbeats)
self.assertEqual(w2.clock, w.clock)
self.assertEqual(w2.active, w.active)
self.assertEqual(w2.processed, w.processed)
self.assertEqual(w2.loadavg, w.loadavg)
self.assertEqual(w2.sw_ident, w.sw_ident)
def test_eq_ne_other(self):
assert Worker('*****@*****.**') == Worker('*****@*****.**')
assert Worker('*****@*****.**') != Worker('*****@*****.**')
assert Worker('*****@*****.**') != object()
def test_equality(self):
assert Worker(hostname='foo').hostname == 'foo'
assert Worker(hostname='foo') == Worker(hostname='foo')
assert Worker(hostname='foo') != Worker(hostname='bar')
assert hash(Worker(hostname='foo')) == hash(Worker(hostname='foo'))
assert hash(Worker(hostname='foo')) != hash(Worker(hostname='bar'))
def test_repr(self):
self.assertTrue(repr(Worker(hostname='foo')))
def test_survives_missing_timestamp(self):
worker = Worker(hostname='foo')
worker.event('heartbeat')
self.assertEqual(worker.heartbeats, [])
args='args', kwargs='kwargs', result='result', traceback='traceback',
timestamp=123, state='state')
T_DATA = copy.copy(T_DATA_PB)
T_DATA.update(pre_state='other', created=False) # miss you py3.5
W_DATA_PB = dict(hostname='hostname', pid=12000, sw_sys='sw_sys', sw_ident='sw_ident',
sw_ver='sw_ver', loadavg=[1, 2, 3], processed=789789,
freq=5)
W_DATA = copy.copy(W_DATA_PB)
W_DATA.update(state='state', pre_state='other', created=False, alive=True, last_heartbeat=1) # miss you py3.5
@pytest.mark.parametrize('event, key, data', [
(TaskData(**T_DATA), 'task', T_DATA_PB),
(Task(**T_DATA_PB), 'task', T_DATA_PB),
(WorkerData(**W_DATA), 'worker', W_DATA_PB),
(Worker(**W_DATA_PB), 'worker', W_DATA_PB),
])
def test_server_event_to_pb_valid(event, key, data, mocked_server):
result_key, result_obj = mocked_server._event_to_pb(event)
assert result_key == key
assert all(getattr(result_obj, k) == v
for k, v in data.items())
@pytest.mark.parametrize('event, key', [
(1, ValueError),
('wrong', ValueError),
({'wrong': True}, ValueError),
])
def test_server_event_to_pb_invalid(event, key, mocked_server):
with pytest.raises(key):
def test_drift_warning(self):
worker = Worker(hostname='foo')
with patch('celery.events.state.warn') as warn:
worker.event(None, time() + (HEARTBEAT_DRIFT_MAX * 2), time())
warn.assert_called()
assert 'Substantial drift' in warn.call_args[0][0]
def test_survives_missing_timestamp(self):
worker = Worker(hostname='foo')
worker.event('heartbeat')
assert worker.heartbeats == []
result_meta='meta')
WORKER = dict(hostname='hostname',
pid=12000,
sw_sys='sw_sys',
sw_ident='sw_ident',
sw_ver='sw_ver',
loadavg=[1., 2., 3.],
processed=789789,
freq=5,
heartbeats=[1])
@pytest.mark.parametrize('obj, to_type, data', [
(Task(**TASK), TaskMessage, TASK),
(Worker(**WORKER), WorkerMessage, WORKER),
])
def test_server_obj_to_message_valid(obj, to_type, data):
obj.timestamp, obj.state = 123.1, 'state'
message = obj_to_message(obj, to_type)
assert all(getattr(message, k) == v for k, v in data.items())
@pytest.mark.parametrize('obj, to_type', [
(1, TaskMessage),
(1, WorkerMessage),
('wrong', TaskMessage),
('wrong', WorkerMessage),
({
'wrong': True
}, TaskMessage),
def test_eq_ne_other(self):
self.assertEqual(Worker('*****@*****.**'), Worker('*****@*****.**'))
self.assertNotEqual(Worker('*****@*****.**'), Worker('*****@*****.**'))
self.assertNotEqual(Worker('*****@*****.**'), object())
def test_repr(self):
assert repr(Worker(hostname='foo'))
def test_drift_warning(self):
worker = Worker(hostname='foo')
with patch('celery.events.state.warn') as warn:
worker.update_heartbeat(time(), time() + (HEARTBEAT_DRIFT_MAX * 2))
self.assertTrue(warn.called)
self.assertIn('Substantial drift', warn.call_args[0][0])
def test_survives_missing_timestamp(self):
worker = Worker(hostname="foo")
worker.on_heartbeat(timestamp=None)
self.assertEqual(worker.heartbeats, [])
def test_update_heartbeat(self):
worker = Worker(hostname='foo')
worker.update_heartbeat(time(), time())
self.assertEqual(len(worker.heartbeats), 1)
worker.update_heartbeat(time() - 10, time())
self.assertEqual(len(worker.heartbeats), 1)
