def disable(*args, **kwargs):
sys.stdout, sys.stderr = WhateverIO(), WhateverIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
class test_Dumper(Case):
def setUp(self):
self.out = WhateverIO()
self.dumper = Dumper(out=self.out)
def test_humanize_type(self):
self.assertEqual(humanize_type('worker-offline'), 'shutdown')
self.assertEqual(humanize_type('task-started'), 'task started')
def test_format_task_event(self):
self.dumper.format_task_event('worker.example.com', time(),
'task-started', 'tasks.add', {})
self.assertTrue(self.out.getvalue())
def test_on_event(self):
event = {
'hostname': 'worker.example.com',
'timestamp': time(),
'uuid': '1ef',
'name': 'tasks.add',
'args': '(2, 2)',
'kwargs': '{}',
}
self.dumper.on_event(dict(event, type='task-received'))
self.assertTrue(self.out.getvalue())
self.dumper.on_event(dict(event, type='task-revoked'))
self.dumper.on_event(dict(event, type='worker-online'))
@patch('celery.events.EventReceiver.capture')
def test_evdump(self, capture):
evdump()
capture.side_effect = KeyboardInterrupt()
evdump()
class test_Dumper(Case):
def setUp(self):
self.out = WhateverIO()
self.dumper = Dumper(out=self.out)
def test_humanize_type(self):
self.assertEqual(humanize_type("worker-offline"), "shutdown")
self.assertEqual(humanize_type("task-started"), "task started")
def test_format_task_event(self):
self.dumper.format_task_event(
"worker.example.com", time(), "task-started", "tasks.add", {})
self.assertTrue(self.out.getvalue())
def test_on_event(self):
event = {
"hostname": "worker.example.com",
"timestamp": time(),
"uuid": "1ef",
"name": "tasks.add",
"args": "(2, 2)",
"kwargs": "{}",
}
self.dumper.on_event(dict(event, type="task-received"))
self.assertTrue(self.out.getvalue())
self.dumper.on_event(dict(event, type="task-revoked"))
self.dumper.on_event(dict(event, type="worker-online"))
@patch("celery.events.EventReceiver.capture")
def test_evdump(self, capture):
evdump()
capture.side_effect = KeyboardInterrupt()
evdump()
class test_Dumper(Case):
def setUp(self):
self.out = WhateverIO()
self.dumper = Dumper(out=self.out)
def test_humanize_type(self):
self.assertEqual(humanize_type('worker-offline'), 'shutdown')
self.assertEqual(humanize_type('task-started'), 'task started')
def test_format_task_event(self):
self.dumper.format_task_event(
'worker.example.com', time(), 'task-started', 'tasks.add', {})
self.assertTrue(self.out.getvalue())
def test_on_event(self):
event = {
'hostname': 'worker.example.com',
'timestamp': time(),
'uuid': '1ef',
'name': 'tasks.add',
'args': '(2, 2)',
'kwargs': '{}',
}
self.dumper.on_event(dict(event, type='task-received'))
self.assertTrue(self.out.getvalue())
self.dumper.on_event(dict(event, type='task-revoked'))
self.dumper.on_event(dict(event, type='worker-online'))
@patch('celery.events.EventReceiver.capture')
def test_evdump(self, capture):
capture.side_effect = KeyboardInterrupt()
evdump()
def test_run(self):
out = WhateverIO()
h = help(app=self.app, stdout=out)
h.parser = Mock()
self.assertEqual(h.run(), EX_USAGE)
self.assertTrue(out.getvalue())
self.assertTrue(h.usage('help'))
h.parser.print_help.assert_called_with()
def test_run(self):
out = WhateverIO()
h = help(app=self.app, stdout=out)
h.parser = Mock()
self.assertEqual(h.run(), EX_USAGE)
self.assertTrue(out.getvalue())
self.assertTrue(h.usage('help'))
h.parser.print_help.assert_called_with()
def test_run(self, get):
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = "Jerry"
r.run("id")
self.assertIn("Jerry", out.getvalue())
get.return_value = "Elaine"
r.run("id", task=add.name)
self.assertIn("Elaine", out.getvalue())
def test_run(self, discard_all):
out = WhateverIO()
a = purge(app=self.app, stdout=out)
discard_all.return_value = 0
a.run()
self.assertIn("No messages purged", out.getvalue())
discard_all.return_value = 100
a.run()
self.assertIn("100 messages", out.getvalue())
def test_run(self, purge_):
out = WhateverIO()
a = purge(app=self.app, stdout=out)
purge_.return_value = 0
a.run()
self.assertIn('No messages purged', out.getvalue())
purge_.return_value = 100
a.run()
self.assertIn('100 messages', out.getvalue())
def test_run(self, purge_):
out = WhateverIO()
a = purge(app=self.app, stdout=out)
purge_.return_value = 0
a.run()
self.assertIn('No messages purged', out.getvalue())
purge_.return_value = 100
a.run()
self.assertIn('100 messages', out.getvalue())
def test_run(self, discard_all):
out = WhateverIO()
a = purge(app=self.app, stdout=out)
discard_all.return_value = 0
a.run()
self.assertIn("No messages purged", out.getvalue())
discard_all.return_value = 100
a.run()
self.assertIn("100 messages", out.getvalue())
def test_run(self, get):
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = "Jerry"
r.run("id")
self.assertIn("Jerry", out.getvalue())
get.return_value = "Elaine"
r.run("id", task=add.name)
self.assertIn("Elaine", out.getvalue())
def test_run(self, get):
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = 'Jerry'
r.run('id')
self.assertIn('Jerry', out.getvalue())
get.return_value = 'Elaine'
r.run('id', task=add.name)
self.assertIn('Elaine', out.getvalue())
def test_run(self, get):
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = 'Jerry'
r.run('id')
self.assertIn('Jerry', out.getvalue())
get.return_value = 'Elaine'
r.run('id', task=add.name)
self.assertIn('Elaine', out.getvalue())
def test_run(self, inspect_):
out, err = WhateverIO(), WhateverIO()
ins = inspect_.return_value = Mock()
ins.run.return_value = []
s = status(self.app, stdout=out, stderr=err)
with self.assertRaises(Error):
s.run()
ins.run.return_value = ['a', 'b', 'c']
s.run()
self.assertIn('3 nodes online', out.getvalue())
s.run(quiet=True)
def disable(*args, **kwargs):
prev_out, prev_err = sys.stdout, sys.stderr
prev_rout, prev_rerr = sys.__stdout__, sys.__stderr__
sys.stdout = sys.__stdout__ = WhateverIO()
sys.stderr = sys.__stderr__ = WhateverIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = prev_out
sys.stderr = prev_err
sys.__stdout__ = prev_rout
sys.__stderr__ = prev_rerr
def test_run(self, inspect_):
out, err = WhateverIO(), WhateverIO()
ins = inspect_.return_value = Mock()
ins.run.return_value = []
s = status(self.app, stdout=out, stderr=err)
with self.assertRaises(Error):
s.run()
ins.run.return_value = ['a', 'b', 'c']
s.run()
self.assertIn('3 nodes online', out.getvalue())
s.run(quiet=True)
def test_write_reread_fails(self, open_, fdopen, osopen, getpid,
fsync):
getpid.return_value = 1816
osopen.return_value = 13
w = fdopen.return_value = WhateverIO()
w.close = Mock()
r = open_.return_value = WhateverIO()
r.write("11816\n")
r.seek(0)
p = PIDFile("/var/pid")
with self.assertRaises(LockFailed):
p.write_pid()
def test_run(self, real):
out = WhateverIO()
i = inspect(app=self.app, stdout=out)
with self.assertRaises(Error):
i.run()
with self.assertRaises(Error):
i.run('help')
with self.assertRaises(Error):
i.run('xyzzybaz')
i.run('ping')
self.assertTrue(real.called)
i.run('ping', destination='foo,bar')
self.assertEqual(real.call_args[1]['destination'], ['foo', 'bar'])
self.assertEqual(real.call_args[1]['timeout'], 0.2)
callback = real.call_args[1]['callback']
callback({'foo': {'ok': 'pong'}})
self.assertIn('OK', out.getvalue())
instance = real.return_value = Mock()
instance.ping.return_value = None
with self.assertRaises(Error):
i.run('ping')
out.seek(0)
out.truncate()
i.quiet = True
i.say('<-', 'hello')
self.assertFalse(out.getvalue())
def test_run(self, real):
out = WhateverIO()
i = inspect(app=self.app, stdout=out)
with self.assertRaises(Error):
i.run()
with self.assertRaises(Error):
i.run("help")
with self.assertRaises(Error):
i.run("xyzzybaz")
i.run("ping")
self.assertTrue(real.called)
i.run("ping", destination="foo,bar")
self.assertEqual(real.call_args[1]["destination"], ["foo", "bar"])
self.assertEqual(real.call_args[1]["timeout"], 0.2)
callback = real.call_args[1]["callback"]
callback({"foo": {"ok": "pong"}})
self.assertIn("OK", out.getvalue())
instance = real.return_value = Mock()
instance.ping.return_value = None
with self.assertRaises(Error):
i.run("ping")
out.seek(0)
out.truncate()
i.quiet = True
i.say('<-', "hello")
self.assertFalse(out.getvalue())
def test_run(self, migrate_tasks):
out = WhateverIO()
m = migrate(app=self.app, stdout=out, stderr=WhateverIO())
with self.assertRaises(SystemExit):
m.run()
self.assertFalse(migrate_tasks.called)
m.run('memory://foo', 'memory://bar')
self.assertTrue(migrate_tasks.called)
state = Mock()
state.count = 10
state.strtotal = 30
m.on_migrate_task(state, {'task': 'tasks.add', 'id': 'ID'}, None)
self.assertIn('10/30', out.getvalue())
def test_run(self, migrate_tasks):
out = WhateverIO()
m = migrate(app=self.app, stdout=out, stderr=WhateverIO())
with self.assertRaises(SystemExit):
m.run()
self.assertFalse(migrate_tasks.called)
m.run("memory://foo", "memory://bar")
self.assertTrue(migrate_tasks.called)
state = Mock()
state.count = 10
state.strtotal = 30
m.on_migrate_task(state, {"task": "tasks.add", "id": "ID"}, None)
self.assertIn("10/30", out.getvalue())
def test_run(self, migrate_tasks):
out = WhateverIO()
m = migrate(app=self.app, stdout=out, stderr=WhateverIO())
with self.assertRaises(SystemExit):
m.run()
self.assertFalse(migrate_tasks.called)
m.run("memory://foo", "memory://bar")
self.assertTrue(migrate_tasks.called)
state = Mock()
state.count = 10
state.strtotal = 30
m.on_migrate_task(state, {"task": "tasks.add", "id": "ID"}, None)
self.assertIn("10/30", out.getvalue())
def test_run(self):
with patch('celery.result.AsyncResult.get') as get:
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = 'Jerry'
r.run('id')
self.assertIn('Jerry', out.getvalue())
get.return_value = 'Elaine'
r.run('id', task=add.name)
self.assertIn('Elaine', out.getvalue())
with patch('celery.result.AsyncResult.traceback') as tb:
r.run('id', task=add.name, traceback=True)
self.assertIn(str(tb), out.getvalue())
def test_run(self):
with patch("celery.result.AsyncResult.get") as get:
out = WhateverIO()
r = result(app=self.app, stdout=out)
get.return_value = "Jerry"
r.run("id")
self.assertIn("Jerry", out.getvalue())
get.return_value = "Elaine"
r.run("id", task=add.name)
self.assertIn("Elaine", out.getvalue())
with patch("celery.result.AsyncResult.traceback") as tb:
r.run("id", task=add.name, traceback=True)
self.assertIn(str(tb), out.getvalue())
def test_run(self, migrate_tasks):
out = WhateverIO()
m = migrate(app=self.app, stdout=out, stderr=WhateverIO())
with self.assertRaises(SystemExit):
m.run()
self.assertFalse(migrate_tasks.called)
m.run('memory://foo', 'memory://bar')
self.assertTrue(migrate_tasks.called)
state = Mock()
state.count = 10
state.strtotal = 30
m.on_migrate_task(state, {'task': 'tasks.add', 'id': 'ID'}, None)
self.assertIn('10/30', out.getvalue())
def test_read_pid_bogus_pidfile(self, open_):
s = open_.return_value = WhateverIO()
s.write("eighteensixteen\n")
s.seek(0)
p = PIDFile("/var/pid")
with self.assertRaises(ValueError):
p.read_pid()
def test_read_pid_partially_written(self, open_):
s = open_.return_value = WhateverIO()
s.write("1816")
s.seek(0)
p = PIDFile("/var/pid")
with self.assertRaises(ValueError):
p.read_pid()
def test_get_avail_port(self, sock):
out = WhateverIO()
sock.return_value.accept.return_value = (Mock(), ['helu'])
Rdb(out=out)
with patch('celery.contrib.rdb.current_process') as curproc:
curproc.return_value.name = 'PoolWorker-10'
Rdb(out=out)
err = sock.return_value.bind.side_effect = socket.error()
err.errno = errno.ENOENT
with self.assertRaises(socket.error):
Rdb(out=out)
err.errno = errno.EADDRINUSE
with self.assertRaises(Exception):
Rdb(out=out)
called = [0]
def effect(*a, **kw):
try:
if called[0] > 50:
return True
raise err
finally:
called[0] += 1
sock.return_value.bind.side_effect = effect
Rdb(out=out)
def test_run(self, real):
out = WhateverIO()
i = inspect(app=self.app, stdout=out)
with self.assertRaises(Error):
i.run()
with self.assertRaises(Error):
i.run('help')
with self.assertRaises(Error):
i.run('xyzzybaz')
i.run('ping')
self.assertTrue(real.called)
i.run('ping', destination='foo,bar')
self.assertEqual(real.call_args[1]['destination'], ['foo', 'bar'])
self.assertEqual(real.call_args[1]['timeout'], 0.2)
callback = real.call_args[1]['callback']
callback({'foo': {'ok': 'pong'}})
self.assertIn('OK', out.getvalue())
instance = real.return_value = Mock()
instance.ping.return_value = None
with self.assertRaises(Error):
i.run('ping')
out.seek(0)
out.truncate()
i.quiet = True
i.say('<-', 'hello')
self.assertFalse(out.getvalue())
def test_run(self, real):
out = WhateverIO()
i = inspect(app=self.app, stdout=out)
with self.assertRaises(Error):
i.run()
with self.assertRaises(Error):
i.run("help")
with self.assertRaises(Error):
i.run("xyzzybaz")
i.run("ping")
self.assertTrue(real.called)
i.run("ping", destination="foo,bar")
self.assertEqual(real.call_args[1]["destination"], ["foo", "bar"])
self.assertEqual(real.call_args[1]["timeout"], 0.2)
callback = real.call_args[1]["callback"]
callback({"foo": {"ok": "pong"}})
self.assertIn("OK", out.getvalue())
instance = real.return_value = Mock()
instance.ping.return_value = None
with self.assertRaises(Error):
i.run("ping")
out.seek(0)
out.truncate()
i.quiet = True
i.say('<-', "hello")
self.assertFalse(out.getvalue())
def test_run(self):
l = list_(app=self.app, stderr=WhateverIO())
l.run('bindings')
with self.assertRaises(Error):
l.run(None)
with self.assertRaises(Error):
l.run('foo')
def test_get_logger(self):
t1 = self.createTask("c.unittest.t.t1")
logfh = WhateverIO()
logger = t1.get_logger(logfile=logfh, loglevel=0)
self.assertTrue(logger)
t1.request.loglevel = 3
logger = t1.get_logger(logfile=logfh, loglevel=None)
self.assertTrue(logger)
def test_run(self, send_task):
a = call(app=self.app, stderr=WhateverIO(), stdout=WhateverIO())
a.run('tasks.add')
self.assertTrue(send_task.called)
a.run('tasks.add', args=dumps([4, 4]), kwargs=dumps({'x': 2, 'y': 2}))
self.assertEqual(send_task.call_args[1]['args'], [4, 4])
self.assertEqual(send_task.call_args[1]['kwargs'], {'x': 2, 'y': 2})
a.run('tasks.add', expires=10, countdown=10)
self.assertEqual(send_task.call_args[1]['expires'], 10)
self.assertEqual(send_task.call_args[1]['countdown'], 10)
now = datetime.now()
iso = now.isoformat()
a.run('tasks.add', expires=iso)
self.assertEqual(send_task.call_args[1]['expires'], now)
with self.assertRaises(ValueError):
a.run('tasks.add', expires='foobaribazibar')
def test_run(self, send_task):
a = apply(app=self.app, stderr=WhateverIO(), stdout=WhateverIO())
a.run("tasks.add")
self.assertTrue(send_task.called)
a.run("tasks.add", args=dumps([4, 4]), kwargs=dumps({"x": 2, "y": 2}))
self.assertEqual(send_task.call_args[1]["args"], [4, 4])
self.assertEqual(send_task.call_args[1]["kwargs"], {"x": 2, "y": 2})
a.run("tasks.add", expires=10, countdown=10)
self.assertEqual(send_task.call_args[1]["expires"], 10)
self.assertEqual(send_task.call_args[1]["countdown"], 10)
now = datetime.now()
iso = now.isoformat()
a.run("tasks.add", expires=iso)
self.assertEqual(send_task.call_args[1]["expires"], now)
with self.assertRaises(ValueError):
a.run("tasks.add", expires="foobaribazibar")
def test_write_pid(self, open_, fdopen, osopen, getpid, fsync):
getpid.return_value = 1816
osopen.return_value = 13
w = fdopen.return_value = WhateverIO()
w.close = Mock()
r = open_.return_value = WhateverIO()
r.write("1816\n")
r.seek(0)
p = PIDFile("/var/pid")
p.write_pid()
w.seek(0)
self.assertEqual(w.readline(), "1816\n")
self.assertTrue(w.close.called)
getpid.assert_called_with()
osopen.assert_called_with(p.path, platforms.PIDFILE_FLAGS,
platforms.PIDFILE_MODE)
fdopen.assert_called_with(13, "w")
fsync.assert_called_with(13)
open_.assert_called_with(p.path)
def test_get_logger(self):
t1 = self.createTask('c.unittest.t.t1')
t1.push_request()
try:
logfh = WhateverIO()
logger = t1.get_logger(logfile=logfh, loglevel=0)
self.assertTrue(logger)
t1.request.loglevel = 3
logger = t1.get_logger(logfile=logfh, loglevel=None)
self.assertTrue(logger)
finally:
t1.pop_request()
def _test_on_failure(self, exception):
app = app_or_default()
tid = uuid()
tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
try:
raise exception
except Exception:
exc_info = ExceptionInfo(sys.exc_info())
logfh = WhateverIO()
tw.logger.handlers = []
tw.logger = app.log.setup_logger("INFO", logfh, root=False)
app.conf.CELERY_SEND_TASK_ERROR_EMAILS = True
tw.on_failure(exc_info)
logvalue = logfh.getvalue()
self.assertIn(mytask.name, logvalue)
self.assertIn(tid, logvalue)
self.assertIn("ERROR", logvalue)
app.conf.CELERY_SEND_TASK_ERROR_EMAILS = False
def test_rdb(self, get_avail_port):
sock = Mock()
get_avail_port.return_value = (sock, 8000)
sock.accept.return_value = (Mock(), ['helu'])
out = WhateverIO()
rdb = Rdb(out=out)
self.assertTrue(get_avail_port.called)
self.assertIn('helu', out.getvalue())
# set_quit
with patch('sys.settrace') as settrace:
rdb.set_quit()
settrace.assert_called_with(None)
# set_trace
with patch('celery.contrib.rdb.Pdb.set_trace') as pset:
with patch('celery.contrib.rdb._frame'):
rdb.set_trace()
rdb.set_trace(Mock())
pset.side_effect = socket.error
pset.side_effect.errno = errno.ECONNRESET
rdb.set_trace()
pset.side_effect.errno = errno.ENOENT
with self.assertRaises(socket.error):
rdb.set_trace()
# _close_session
rdb._close_session()
# do_continue
rdb.set_continue = Mock()
rdb.do_continue(Mock())
rdb.set_continue.assert_called_with()
# do_quit
rdb.set_quit = Mock()
rdb.do_quit(Mock())
rdb.set_quit.assert_called_with()
def test_rdb(self, get_avail_port):
sock = Mock()
get_avail_port.return_value = (sock, 8000)
sock.accept.return_value = (Mock(), ['helu'])
out = WhateverIO()
rdb = Rdb(out=out)
self.assertTrue(get_avail_port.called)
self.assertIn('helu', out.getvalue())
# set_quit
with patch('sys.settrace') as settrace:
rdb.set_quit()
settrace.assert_called_with(None)
# set_trace
with patch('celery.contrib.rdb.Pdb.set_trace') as pset:
with patch('celery.contrib.rdb._frame'):
rdb.set_trace()
rdb.set_trace(Mock())
pset.side_effect = socket.error
pset.side_effect.errno = errno.ECONNRESET
rdb.set_trace()
pset.side_effect.errno = errno.ENOENT
with self.assertRaises(socket.error):
rdb.set_trace()
# _close_session
rdb._close_session()
# do_continue
rdb.set_continue = Mock()
rdb.do_continue(Mock())
rdb.set_continue.assert_called_with()
# do_quit
rdb.set_quit = Mock()
rdb.do_quit(Mock())
rdb.set_quit.assert_called_with()
def _test_on_failure(self, exception):
app = app_or_default()
tid = uuid()
tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
try:
raise exception
except Exception:
exc_info = ExceptionInfo(sys.exc_info())
logfh = WhateverIO()
tw.logger.handlers = []
tw.logger = setup_logger(logfile=logfh, loglevel=logging.INFO,
root=False)
app.conf.CELERY_SEND_TASK_ERROR_EMAILS = True
tw.on_failure(exc_info)
logvalue = logfh.getvalue()
self.assertIn(mytask.name, logvalue)
self.assertIn(tid, logvalue)
self.assertIn("ERROR", logvalue)
app.conf.CELERY_SEND_TASK_ERROR_EMAILS = False
def test_to_dot(self):
s = WhateverIO()
self.graph1().to_dot(s)
self.assertTrue(s.getvalue())
def setUp(self):
self.out = WhateverIO()
self.dumper = Dumper(out=self.out)
def setUp(self):
self.fh = WhateverIO()
self.env = {}
self.t = MultiTool(env=self.env, fh=self.fh)
class test_AMQShell(AppCase):
def setup(self):
self.fh = WhateverIO()
self.app = Celery(broker='memory://', set_as_current=False)
self.adm = self.create_adm()
self.shell = AMQShell(connect=self.adm.connect, out=self.fh)
def create_adm(self, *args, **kwargs):
return AMQPAdmin(app=self.app, out=self.fh, *args, **kwargs)
def test_queue_declare(self):
self.shell.onecmd('queue.declare foo')
self.assertIn('ok', self.fh.getvalue())
def test_missing_command(self):
self.shell.onecmd('foo foo')
self.assertIn('unknown syntax', self.fh.getvalue())
def RV(self):
raise Exception(self.fh.getvalue())
def test_missing_namespace(self):
self.shell.onecmd('ns.cmd arg')
self.assertIn('unknown syntax', self.fh.getvalue())
def test_help(self):
self.shell.onecmd('help')
self.assertIn('Example:', self.fh.getvalue())
def test_help_command(self):
self.shell.onecmd('help queue.declare')
self.assertIn('passive:no', self.fh.getvalue())
def test_help_unknown_command(self):
self.shell.onecmd('help foo.baz')
self.assertIn('unknown syntax', self.fh.getvalue())
def test_exit(self):
with self.assertRaises(SystemExit):
self.shell.onecmd('exit')
self.assertIn("don't leave!", self.fh.getvalue())
def test_note_silent(self):
self.shell.silent = True
self.shell.note('foo bar')
self.assertNotIn('foo bar', self.fh.getvalue())
def test_reconnect(self):
self.shell.onecmd('queue.declare foo')
self.shell.needs_reconnect = True
self.shell.onecmd('queue.delete foo')
def test_completenames(self):
self.assertEqual(self.shell.completenames('queue.dec'),
['queue.declare'])
self.assertEqual(sorted(self.shell.completenames('declare')),
sorted(['queue.declare', 'exchange.declare']))
def test_empty_line(self):
self.shell.emptyline = Mock()
self.shell.default = Mock()
self.shell.onecmd('')
self.shell.emptyline.assert_called_with()
self.shell.onecmd('foo')
self.shell.default.assert_called_with('foo')
def test_respond(self):
self.shell.respond({'foo': 'bar'})
self.assertIn('foo', self.fh.getvalue())
def test_prompt(self):
self.assertTrue(self.shell.prompt)
def test_no_returns(self):
self.shell.onecmd('queue.declare foo')
self.shell.onecmd('exchange.declare bar direct yes')
self.shell.onecmd('queue.bind foo bar baz')
self.shell.onecmd('basic.ack 1')
def test_dump_message(self):
m = Mock()
m.body = 'the quick brown fox'
m.properties = {'a': 1}
m.delivery_info = {'exchange': 'bar'}
self.assertTrue(dump_message(m))
def test_dump_message_no_message(self):
self.assertIn('No messages in queue', dump_message(None))
def test_note(self):
self.adm.silent = True
self.adm.note('FOO')
self.assertNotIn('FOO', self.fh.getvalue())
def test_run(self):
a = self.create_adm('queue.declare foo')
a.run()
self.assertIn('ok', self.fh.getvalue())
def test_run_loop(self):
a = self.create_adm()
a.Shell = Mock()
shell = a.Shell.return_value = Mock()
shell.cmdloop = Mock()
a.run()
shell.cmdloop.assert_called_with()
shell.cmdloop.side_effect = KeyboardInterrupt()
a.run()
self.assertIn('bibi', self.fh.getvalue())
@patch('celery.bin.amqp.AMQPAdminCommand')
def test_main(self, Command):
c = Command.return_value = Mock()
main()
c.execute_from_commandline.assert_called_with()
@patch('celery.bin.amqp.AMQPAdmin')
def test_amqp(self, cls):
c = cls.return_value = Mock()
run()
c.run.assert_called_with()
@patch('celery.bin.amqp.AMQPAdmin')
def test_AMQPAdminCommand(self, cls):
c = cls.return_value = Mock()
run()
c.run.assert_called_with()
x = AMQPAdminCommand(app=self.app)
x.run()
self.assertIs(cls.call_args[1]['app'], self.app)
c.run.assert_called_with()
def setup(self):
self.fh = WhateverIO()
self.app = Celery(broker='memory://', set_as_current=False)
self.adm = self.create_adm()
self.shell = AMQShell(connect=self.adm.connect, out=self.fh)
def setUp(self):
self.fh = WhateverIO()
self.env = {}
self.t = MultiTool(env=self.env, fh=self.fh)
class test_MultiTool(Case):
def setUp(self):
self.fh = WhateverIO()
self.env = {}
self.t = MultiTool(env=self.env, fh=self.fh)
def test_note(self):
self.t.note('hello world')
self.assertEqual(self.fh.getvalue(), 'hello world\n')
def test_note_quiet(self):
self.t.quiet = True
self.t.note('hello world')
self.assertFalse(self.fh.getvalue())
def test_info(self):
self.t.verbose = True
self.t.info('hello info')
self.assertEqual(self.fh.getvalue(), 'hello info\n')
def test_info_not_verbose(self):
self.t.verbose = False
self.t.info('hello info')
self.assertFalse(self.fh.getvalue())
def test_error(self):
self.t.say = Mock()
self.t.usage = Mock()
self.assertEqual(self.t.error('foo'), 1)
self.t.say.assert_called_with('foo')
self.t.usage.assert_called_with()
self.t.say = Mock()
self.assertEqual(self.t.error(), 1)
self.assertFalse(self.t.say.called)
self.assertEqual(self.t.retcode, 1)
@patch('celery.bin.multi.Popen')
def test_waitexec(self, Popen):
self.t.note = Mock()
pipe = Popen.return_value = Mock()
pipe.wait.return_value = -10
self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 10)
Popen.assert_called_with(['path', '-m', 'foo'], env=self.t.env)
self.t.note.assert_called_with('* Child was terminated by signal 10')
pipe.wait.return_value = 2
self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 2)
self.t.note.assert_called_with(
'* Child terminated with errorcode 2',
)
pipe.wait.return_value = 0
self.assertFalse(self.t.waitexec(['-m', 'foo', 'path']))
def test_nosplash(self):
self.t.nosplash = True
self.t.splash()
self.assertFalse(self.fh.getvalue())
def test_splash(self):
self.t.nosplash = False
self.t.splash()
self.assertIn('celery multi', self.fh.getvalue())
def test_usage(self):
self.t.usage()
self.assertTrue(self.fh.getvalue())
def test_help(self):
self.t.help([])
self.assertIn(doc, self.fh.getvalue())
def test_expand(self):
self.t.expand(['foo%n', 'ask', 'klask', 'dask'])
self.assertEqual(
self.fh.getvalue(), 'fooask\nfooklask\nfoodask\n',
)
def test_restart(self):
stop = self.t._stop_nodes = Mock()
self.t.restart(['jerry', 'george'], 'celery worker')
waitexec = self.t.waitexec = Mock()
self.assertTrue(stop.called)
callback = stop.call_args[1]['callback']
self.assertTrue(callback)
waitexec.return_value = 0
callback('jerry', ['arg'], 13)
waitexec.assert_called_with(['arg'])
self.assertIn('OK', self.fh.getvalue())
self.fh.seek(0)
self.fh.truncate()
waitexec.return_value = 1
callback('jerry', ['arg'], 13)
self.assertIn('FAILED', self.fh.getvalue())
def test_stop(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [2, 3, 4]
self.t.shutdown_nodes = Mock()
self.t.stop(['a', 'b', '-INT'], 'celery worker')
self.t.shutdown_nodes.assert_called_with(
[2, 3, 4], sig=signal.SIGINT, retry=None, callback=None,
)
def test_kill(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [
('a', None, 10),
('b', None, 11),
('c', None, 12)
]
sig = self.t.signal_node = Mock()
self.t.kill(['a', 'b', 'c'], 'celery worker')
sigs = sig.call_args_list
self.assertEqual(len(sigs), 3)
self.assertEqual(sigs[0][0], ('a', 10, signal.SIGKILL))
self.assertEqual(sigs[1][0], ('b', 11, signal.SIGKILL))
self.assertEqual(sigs[2][0], ('c', 12, signal.SIGKILL))
def prepare_pidfile_for_getpids(self, Pidfile):
class pids(object):
def __init__(self, path):
self.path = path
def read_pid(self):
try:
return {'foo.pid': 10,
'bar.pid': 11}[self.path]
except KeyError:
raise ValueError()
Pidfile.side_effect = pids
@patch('celery.bin.multi.Pidfile')
@patch('socket.gethostname')
def test_getpids(self, gethostname, Pidfile):
gethostname.return_value = 'e.com'
self.prepare_pidfile_for_getpids(Pidfile)
callback = Mock()
p = NamespacedOptionParser(['foo', 'bar', 'baz'])
nodes = self.t.getpids(p, 'celery worker', callback=callback)
node_0, node_1 = nodes
self.assertEqual(node_0[0], '*****@*****.**')
self.assertEqual(
sorted(node_0[1]),
sorted(('celery worker', '--pidfile=foo.pid',
'-n [email protected]', '')),
)
self.assertEqual(node_0[2], 10)
self.assertEqual(node_1[0], '*****@*****.**')
self.assertEqual(
sorted(node_1[1]),
sorted(('celery worker', '--pidfile=bar.pid',
'-n [email protected]', '')),
)
self.assertEqual(node_1[2], 11)
self.assertTrue(callback.called)
cargs, _ = callback.call_args
self.assertEqual(cargs[0], '*****@*****.**')
self.assertItemsEqual(
cargs[1],
['celery worker', '--pidfile=baz.pid', '-n [email protected]', ''],
)
self.assertIsNone(cargs[2])
self.assertIn('DOWN', self.fh.getvalue())
# without callback, should work
nodes = self.t.getpids(p, 'celery worker', callback=None)
@patch('celery.bin.multi.Pidfile')
@patch('socket.gethostname')
@patch('celery.bin.multi.sleep')
def test_shutdown_nodes(self, slepp, gethostname, Pidfile):
gethostname.return_value = 'e.com'
self.prepare_pidfile_for_getpids(Pidfile)
self.assertIsNone(self.t.shutdown_nodes([]))
self.t.signal_node = Mock()
node_alive = self.t.node_alive = Mock()
self.t.node_alive.return_value = False
callback = Mock()
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', callback=callback)
sigs = sorted(self.t.signal_node.call_args_list)
self.assertEqual(len(sigs), 2)
self.assertIn(
('*****@*****.**', 10, signal.SIGTERM),
[tup[0] for tup in sigs],
)
self.assertIn(
('*****@*****.**', 11, signal.SIGTERM),
[tup[0] for tup in sigs],
)
self.t.signal_node.return_value = False
self.assertTrue(callback.called)
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', callback=None)
def on_node_alive(pid):
if node_alive.call_count > 4:
return True
return False
self.t.signal_node.return_value = True
self.t.node_alive.side_effect = on_node_alive
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', retry=True)
@patch('os.kill')
def test_node_alive(self, kill):
kill.return_value = True
self.assertTrue(self.t.node_alive(13))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.node_alive(13))
kill.assert_called_with(13, 0)
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.node_alive(13)
@patch('os.kill')
def test_signal_node(self, kill):
kill.return_value = True
self.assertTrue(self.t.signal_node('foo', 13, 9))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.signal_node('foo', 13, 9))
kill.assert_called_with(13, 9)
self.assertIn('Could not signal foo', self.fh.getvalue())
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.signal_node('foo', 13, 9)
def test_start(self):
self.t.waitexec = Mock()
self.t.waitexec.return_value = 0
self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celery worker'))
self.t.waitexec.return_value = 1
self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celery worker'))
def test_show(self):
self.t.show(['foo', 'bar', 'baz'], 'celery worker')
self.assertTrue(self.fh.getvalue())
@patch('socket.gethostname')
def test_get(self, gethostname):
gethostname.return_value = 'e.com'
self.t.get(['*****@*****.**', 'foo', 'bar', 'baz'], 'celery worker')
self.assertFalse(self.fh.getvalue())
self.t.get(['*****@*****.**', 'foo', 'bar', 'baz'], 'celery worker')
self.assertTrue(self.fh.getvalue())
@patch('socket.gethostname')
def test_names(self, gethostname):
gethostname.return_value = 'e.com'
self.t.names(['foo', 'bar', 'baz'], 'celery worker')
self.assertIn('[email protected]\[email protected]\[email protected]', self.fh.getvalue())
def test_execute_from_commandline(self):
start = self.t.commands['start'] = Mock()
self.t.error = Mock()
self.t.execute_from_commandline(['multi', 'start', 'foo', 'bar'])
self.assertFalse(self.t.error.called)
start.assert_called_with(['foo', 'bar'], 'celery worker')
self.t.error = Mock()
self.t.execute_from_commandline(['multi', 'frob', 'foo', 'bar'])
self.t.error.assert_called_with('Invalid command: frob')
self.t.error = Mock()
self.t.execute_from_commandline(['multi'])
self.t.error.assert_called_with()
self.t.error = Mock()
self.t.execute_from_commandline(['multi', '-foo'])
self.t.error.assert_called_with()
self.t.execute_from_commandline(
['multi', 'start', 'foo',
'--nosplash', '--quiet', '-q', '--verbose', '--no-color'],
)
self.assertTrue(self.t.nosplash)
self.assertTrue(self.t.quiet)
self.assertTrue(self.t.verbose)
self.assertTrue(self.t.no_color)
def test_stopwait(self):
self.t._stop_nodes = Mock()
self.t.stopwait(['foo', 'bar', 'baz'], 'celery worker')
self.assertEqual(self.t._stop_nodes.call_args[1]['retry'], 2)
@patch('celery.bin.multi.MultiTool')
def test_main(self, MultiTool):
m = MultiTool.return_value = Mock()
with self.assertRaises(SystemExit):
main()
m.execute_from_commandline.assert_called_with(sys.argv)
class test_AMQShell(AppCase):
def setup(self):
self.fh = WhateverIO()
self.app = Celery(broker="memory://", set_as_current=False)
self.adm = self.create_adm()
self.shell = AMQShell(connect=self.adm.connect, out=self.fh)
def create_adm(self, *args, **kwargs):
return AMQPAdmin(app=self.app, out=self.fh, *args, **kwargs)
def test_queue_declare(self):
self.shell.onecmd("queue.declare foo")
self.assertIn("ok", self.fh.getvalue())
def test_missing_command(self):
self.shell.onecmd("foo foo")
self.assertIn("unknown syntax", self.fh.getvalue())
def RV(self):
raise Exception(self.fh.getvalue())
def test_missing_namespace(self):
self.shell.onecmd("ns.cmd arg")
self.assertIn("unknown syntax", self.fh.getvalue())
def test_help(self):
self.shell.onecmd("help")
self.assertIn("Example:", self.fh.getvalue())
def test_help_command(self):
self.shell.onecmd("help queue.declare")
self.assertIn("passive:no", self.fh.getvalue())
def test_help_unknown_command(self):
self.shell.onecmd("help foo.baz")
self.assertIn("unknown syntax", self.fh.getvalue())
def test_exit(self):
with self.assertRaises(SystemExit):
self.shell.onecmd("exit")
self.assertIn("don't leave!", self.fh.getvalue())
def test_note_silent(self):
self.shell.silent = True
self.shell.note("foo bar")
self.assertNotIn("foo bar", self.fh.getvalue())
def test_reconnect(self):
self.shell.onecmd("queue.declare foo")
self.shell.needs_reconnect = True
self.shell.onecmd("queue.delete foo")
def test_completenames(self):
self.assertEqual(self.shell.completenames("queue.dec"),
["queue.declare"])
self.assertEqual(self.shell.completenames("declare"),
["queue.declare", "exchange.declare"])
def test_empty_line(self):
self.shell.emptyline = Mock()
self.shell.default = Mock()
self.shell.onecmd("")
self.shell.emptyline.assert_called_with()
self.shell.onecmd("foo")
self.shell.default.assert_called_with("foo")
def test_respond(self):
self.shell.respond({"foo": "bar"})
self.assertIn("foo", self.fh.getvalue())
def test_prompt(self):
self.assertTrue(self.shell.prompt)
def test_no_returns(self):
self.shell.onecmd("queue.declare foo")
self.shell.onecmd("exchange.declare bar direct yes")
self.shell.onecmd("queue.bind foo bar baz")
self.shell.onecmd("basic.ack 1")
def test_dump_message(self):
m = Mock()
m.body = "the quick brown fox"
m.properties = {"a": 1}
m.delivery_info = {"exchange": "bar"}
self.assertTrue(dump_message(m))
def test_dump_message_no_message(self):
self.assertIn("No messages in queue", dump_message(None))
def test_note(self):
self.adm.silent = True
self.adm.note("FOO")
self.assertNotIn("FOO", self.fh.getvalue())
def test_run(self):
a = self.create_adm("queue.declare foo")
a.run()
self.assertIn("ok", self.fh.getvalue())
def test_run_loop(self):
a = self.create_adm()
a.Shell = Mock()
shell = a.Shell.return_value = Mock()
shell.cmdloop = Mock()
a.run()
shell.cmdloop.assert_called_with()
shell.cmdloop.side_effect = KeyboardInterrupt()
a.run()
self.assertIn("bibi", self.fh.getvalue())
@patch("celery.bin.camqadm.AMQPAdminCommand")
def test_main(self, Command):
c = Command.return_value = Mock()
main()
c.execute_from_commandline.assert_called_with()
@patch("celery.bin.camqadm.AMQPAdmin")
def test_camqadm(self, cls):
c = cls.return_value = Mock()
camqadm()
c.run.assert_called_with()
@patch("celery.bin.camqadm.AMQPAdmin")
def test_AMQPAdminCommand(self, cls):
c = cls.return_value = Mock()
camqadm()
c.run.assert_called_with()
x = AMQPAdminCommand(app=self.app)
x.run()
self.assertIs(cls.call_args[1]["app"], self.app)
c.run.assert_called_with()
class test_MultiTool(Case):
def setUp(self):
self.fh = WhateverIO()
self.env = {}
self.t = MultiTool(env=self.env, fh=self.fh)
def test_note(self):
self.t.note('hello world')
self.assertEqual(self.fh.getvalue(), 'hello world\n')
def test_note_quiet(self):
self.t.quiet = True
self.t.note('hello world')
self.assertFalse(self.fh.getvalue())
def test_info(self):
self.t.verbose = True
self.t.info('hello info')
self.assertEqual(self.fh.getvalue(), 'hello info\n')
def test_info_not_verbose(self):
self.t.verbose = False
self.t.info('hello info')
self.assertFalse(self.fh.getvalue())
def test_error(self):
self.t.say = Mock()
self.t.usage = Mock()
self.assertEqual(self.t.error('foo'), 1)
self.t.say.assert_called_with('foo')
self.t.usage.assert_called_with()
self.t.say = Mock()
self.assertEqual(self.t.error(), 1)
self.assertFalse(self.t.say.called)
self.assertEqual(self.t.retcode, 1)
@patch('celery.bin.multi.Popen')
def test_waitexec(self, Popen):
self.t.note = Mock()
pipe = Popen.return_value = Mock()
pipe.wait.return_value = -10
self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 10)
Popen.assert_called_with(['path', '-m', 'foo'], env=self.t.env)
self.t.note.assert_called_with('* Child was terminated by signal 10')
pipe.wait.return_value = 2
self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 2)
self.t.note.assert_called_with(
'* Child terminated with errorcode 2')
pipe.wait.return_value = 0
self.assertFalse(self.t.waitexec(['-m', 'foo', 'path']))
def test_nosplash(self):
self.t.nosplash = True
self.t.splash()
self.assertFalse(self.fh.getvalue())
def test_splash(self):
self.t.nosplash = False
self.t.splash()
self.assertIn('celery multi', self.fh.getvalue())
def test_usage(self):
self.t.usage()
self.assertTrue(self.fh.getvalue())
def test_help(self):
self.t.help([])
self.assertIn(doc, self.fh.getvalue())
def test_expand(self):
self.t.expand(['foo%n', 'ask', 'klask', 'dask'])
self.assertEqual(self.fh.getvalue(),
'fooask\nfooklask\nfoodask\n')
def test_restart(self):
stop = self.t._stop_nodes = Mock()
self.t.restart(['jerry', 'george'], 'celery worker')
waitexec = self.t.waitexec = Mock()
self.assertTrue(stop.called)
callback = stop.call_args[1]['callback']
self.assertTrue(callback)
waitexec.return_value = 0
callback('jerry', ['arg'], 13)
waitexec.assert_called_with(['arg'])
self.assertIn('OK', self.fh.getvalue())
self.fh.seek(0)
self.fh.truncate()
waitexec.return_value = 1
callback('jerry', ['arg'], 13)
self.assertIn('FAILED', self.fh.getvalue())
def test_stop(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [2, 3, 4]
self.t.shutdown_nodes = Mock()
self.t.stop(['a', 'b', '-INT'], 'celery worker')
self.t.shutdown_nodes.assert_called_with(
[2, 3, 4], sig=signal.SIGINT, retry=None, callback=None,
)
def test_kill(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [
('a', None, 10),
('b', None, 11),
('c', None, 12)
]
sig = self.t.signal_node = Mock()
self.t.kill(['a', 'b', 'c'], 'celery worker')
sigs = sig.call_args_list
self.assertEqual(len(sigs), 3)
self.assertEqual(sigs[0][0], ('a', 10, signal.SIGKILL))
self.assertEqual(sigs[1][0], ('b', 11, signal.SIGKILL))
self.assertEqual(sigs[2][0], ('c', 12, signal.SIGKILL))
def prepare_pidfile_for_getpids(self, Pidfile):
class pids(object):
def __init__(self, path):
self.path = path
def read_pid(self):
try:
return {'foo.pid': 10,
'bar.pid': 11}[self.path]
except KeyError:
raise ValueError()
Pidfile.side_effect = pids
@patch('celery.bin.multi.Pidfile')
@patch('socket.gethostname')
def test_getpids(self, gethostname, Pidfile):
gethostname.return_value = 'e.com'
self.prepare_pidfile_for_getpids(Pidfile)
callback = Mock()
p = NamespacedOptionParser(['foo', 'bar', 'baz'])
nodes = self.t.getpids(p, 'celery worker', callback=callback)
node_0, node_1 = nodes
self.assertEqual(node_0[0], '*****@*****.**')
self.assertEqual(sorted(node_0[1]),
sorted(('celery worker', '--pidfile=foo.pid',
'-n [email protected]', '')))
self.assertEqual(node_0[2], 10)
self.assertEqual(node_1[0], '*****@*****.**')
self.assertEqual(sorted(node_1[1]),
sorted(('celery worker', '--pidfile=bar.pid',
'-n [email protected]', '')))
self.assertEqual(node_1[2], 11)
self.assertTrue(callback.called)
cargs, _ = callback.call_args
self.assertEqual(cargs[0], '*****@*****.**')
self.assertItemsEqual(cargs[1],
['celery worker', '--pidfile=baz.pid', '-n [email protected]', ''],
)
self.assertIsNone(cargs[2])
self.assertIn('DOWN', self.fh.getvalue())
# without callback, should work
nodes = self.t.getpids(p, 'celery worker', callback=None)
@patch('celery.bin.multi.Pidfile')
@patch('socket.gethostname')
@patch('celery.bin.multi.sleep')
def test_shutdown_nodes(self, slepp, gethostname, Pidfile):
gethostname.return_value = 'e.com'
self.prepare_pidfile_for_getpids(Pidfile)
self.assertIsNone(self.t.shutdown_nodes([]))
self.t.signal_node = Mock()
node_alive = self.t.node_alive = Mock()
self.t.node_alive.return_value = False
callback = Mock()
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', callback=callback)
sigs = sorted(self.t.signal_node.call_args_list)
self.assertEqual(len(sigs), 2)
self.assertIn(('*****@*****.**', 10, signal.SIGTERM),
[tup[0] for tup in sigs])
self.assertIn(('*****@*****.**', 11, signal.SIGTERM),
[tup[0] for tup in sigs])
self.t.signal_node.return_value = False
self.assertTrue(callback.called)
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', callback=None)
def on_node_alive(pid):
if node_alive.call_count > 4:
return True
return False
self.t.signal_node.return_value = True
self.t.node_alive.side_effect = on_node_alive
self.t.stop(['foo', 'bar', 'baz'], 'celery worker', retry=True)
@patch('os.kill')
def test_node_alive(self, kill):
kill.return_value = True
self.assertTrue(self.t.node_alive(13))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.node_alive(13))
kill.assert_called_with(13, 0)
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.node_alive(13)
@patch('os.kill')
def test_signal_node(self, kill):
kill.return_value = True
self.assertTrue(self.t.signal_node('foo', 13, 9))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.signal_node('foo', 13, 9))
kill.assert_called_with(13, 9)
self.assertIn('Could not signal foo', self.fh.getvalue())
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.signal_node('foo', 13, 9)
def test_start(self):
self.t.waitexec = Mock()
self.t.waitexec.return_value = 0
self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celery worker'))
self.t.waitexec.return_value = 1
self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celery worker'))
def test_show(self):
self.t.show(['foo', 'bar', 'baz'], 'celery worker')
self.assertTrue(self.fh.getvalue())
@patch('socket.gethostname')
def test_get(self, gethostname):
gethostname.return_value = 'e.com'
self.t.get(['*****@*****.**', 'foo', 'bar', 'baz'], 'celery worker')
self.assertFalse(self.fh.getvalue())
self.t.get(['*****@*****.**', 'foo', 'bar', 'baz'], 'celery worker')
self.assertTrue(self.fh.getvalue())
@patch('socket.gethostname')
def test_names(self, gethostname):
gethostname.return_value = 'e.com'
self.t.names(['foo', 'bar', 'baz'], 'celery worker')
self.assertIn('[email protected]\[email protected]\[email protected]', self.fh.getvalue())
def test_execute_from_commandline(self):
start = self.t.commands['start'] = Mock()
self.t.error = Mock()
self.t.execute_from_commandline(['multi', 'start', 'foo', 'bar'])
self.assertFalse(self.t.error.called)
start.assert_called_with(['foo', 'bar'], 'celery worker')
self.t.error = Mock()
self.t.execute_from_commandline(['multi', 'frob', 'foo', 'bar'])
self.t.error.assert_called_with('Invalid command: frob')
self.t.error = Mock()
self.t.execute_from_commandline(['multi'])
self.t.error.assert_called_with()
self.t.error = Mock()
self.t.execute_from_commandline(['multi', '-foo'])
self.t.error.assert_called_with()
self.t.execute_from_commandline(['multi', 'start', 'foo',
'--nosplash', '--quiet', '-q', '--verbose', '--no-color'])
self.assertTrue(self.t.nosplash)
self.assertTrue(self.t.quiet)
self.assertTrue(self.t.verbose)
self.assertTrue(self.t.no_color)
def test_stopwait(self):
self.t._stop_nodes = Mock()
self.t.stopwait(['foo', 'bar', 'baz'], 'celery worker')
self.assertEqual(self.t._stop_nodes.call_args[1]['retry'], 2)
@patch('celery.bin.multi.MultiTool')
def test_main(self, MultiTool):
m = MultiTool.return_value = Mock()
with self.assertRaises(SystemExit):
main()
m.execute_from_commandline.assert_called_with(sys.argv)
def test_run(self):
out = WhateverIO()
r = report(app=self.app, stdout=out)
self.assertEqual(r.run(), EX_OK)
self.assertTrue(out.getvalue())
def test_to_dot(self):
s = WhateverIO()
self.graph1().to_dot(s)
self.assertTrue(s.getvalue())
class test_MultiTool(Case):
def setUp(self):
self.fh = WhateverIO()
self.env = {}
self.t = MultiTool(env=self.env, fh=self.fh)
def test_note(self):
self.t.note("hello world")
self.assertEqual(self.fh.getvalue(), "hello world\n")
def test_note_quiet(self):
self.t.quiet = True
self.t.note("hello world")
self.assertFalse(self.fh.getvalue())
def test_info(self):
self.t.verbose = True
self.t.info("hello info")
self.assertEqual(self.fh.getvalue(), "hello info\n")
def test_info_not_verbose(self):
self.t.verbose = False
self.t.info("hello info")
self.assertFalse(self.fh.getvalue())
def test_error(self):
self.t.say = Mock()
self.t.usage = Mock()
self.assertEqual(self.t.error("foo"), 1)
self.t.say.assert_called_with("foo")
self.t.usage.assert_called_with()
self.t.say = Mock()
self.assertEqual(self.t.error(), 1)
self.assertFalse(self.t.say.called)
self.assertEqual(self.t.retcode, 1)
@patch("celery.bin.celeryd_multi.Popen")
def test_waitexec(self, Popen):
self.t.note = Mock()
pipe = Popen.return_value = Mock()
pipe.wait.return_value = -10
self.assertEqual(self.t.waitexec(["-m", "foo"], "path"), 10)
Popen.assert_called_with(["path", "-m", "foo"], env=self.t.env)
self.t.note.assert_called_with("* Child was terminated by signal 10")
pipe.wait.return_value = 2
self.assertEqual(self.t.waitexec(["-m", "foo"], "path"), 2)
self.t.note.assert_called_with("* Child terminated with failure code 2")
pipe.wait.return_value = 0
self.assertFalse(self.t.waitexec(["-m", "foo", "path"]))
def test_nosplash(self):
self.t.nosplash = True
self.t.splash()
self.assertFalse(self.fh.getvalue())
def test_splash(self):
self.t.nosplash = False
self.t.splash()
self.assertIn("celeryd-multi", self.fh.getvalue())
def test_usage(self):
self.t.usage()
self.assertTrue(self.fh.getvalue())
def test_help(self):
self.t.help([])
self.assertIn(doc, self.fh.getvalue())
def test_expand(self):
self.t.expand(["foo%n", "ask", "klask", "dask"])
self.assertEqual(self.fh.getvalue(), "fooask\nfooklask\nfoodask\n")
def test_restart(self):
stop = self.t._stop_nodes = Mock()
self.t.restart(["jerry", "george"], "celeryd")
waitexec = self.t.waitexec = Mock()
self.assertTrue(stop.called)
callback = stop.call_args[1]["callback"]
self.assertTrue(callback)
waitexec.return_value = 0
callback("jerry", ["arg"], 13)
waitexec.assert_called_with(["arg"])
self.assertIn("OK", self.fh.getvalue())
self.fh.seek(0)
self.fh.truncate()
waitexec.return_value = 1
callback("jerry", ["arg"], 13)
self.assertIn("FAILED", self.fh.getvalue())
def test_stop(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [2, 3, 4]
self.t.shutdown_nodes = Mock()
self.t.stop(["a", "b", "-INT"], "celeryd")
self.t.shutdown_nodes.assert_called_with([2, 3, 4], sig=signal.SIGINT, retry=None, callback=None)
def test_kill(self):
self.t.getpids = Mock()
self.t.getpids.return_value = [("a", None, 10), ("b", None, 11), ("c", None, 12)]
sig = self.t.signal_node = Mock()
self.t.kill(["a", "b", "c"], "celeryd")
sigs = sig.call_args_list
self.assertEqual(len(sigs), 3)
self.assertEqual(sigs[0][0], ("a", 10, signal.SIGKILL))
self.assertEqual(sigs[1][0], ("b", 11, signal.SIGKILL))
self.assertEqual(sigs[2][0], ("c", 12, signal.SIGKILL))
def prepare_pidfile_for_getpids(self, PIDFile):
class pids(object):
def __init__(self, path):
self.path = path
def read_pid(self):
try:
return {"*****@*****.**": 10, "*****@*****.**": 11}[self.path]
except KeyError:
raise ValueError()
PIDFile.side_effect = pids
@patch("celery.bin.celeryd_multi.PIDFile")
@patch("socket.gethostname")
def test_getpids(self, gethostname, PIDFile):
gethostname.return_value = "e.com"
self.prepare_pidfile_for_getpids(PIDFile)
callback = Mock()
p = NamespacedOptionParser(["foo", "bar", "baz"])
nodes = self.t.getpids(p, "celeryd", callback=callback)
self.assertEqual(
nodes,
[
("foo.e.com", ("celeryd", "[email protected]", "-n foo.e.com", ""), 10),
("bar.e.com", ("celeryd", "[email protected]", "-n bar.e.com", ""), 11),
],
)
self.assertTrue(callback.called)
callback.assert_called_with("baz.e.com", ["celeryd", "[email protected]", "-n baz.e.com", ""], None)
self.assertIn("DOWN", self.fh.getvalue())
# without callback, should work
nodes = self.t.getpids(p, "celeryd", callback=None)
@patch("celery.bin.celeryd_multi.PIDFile")
@patch("socket.gethostname")
@patch("celery.bin.celeryd_multi.sleep")
def test_shutdown_nodes(self, slepp, gethostname, PIDFile):
gethostname.return_value = "e.com"
self.prepare_pidfile_for_getpids(PIDFile)
self.assertIsNone(self.t.shutdown_nodes([]))
self.t.signal_node = Mock()
node_alive = self.t.node_alive = Mock()
self.t.node_alive.return_value = False
callback = Mock()
self.t.stop(["foo", "bar", "baz"], "celeryd", callback=callback)
sigs = self.t.signal_node.call_args_list
self.assertEqual(len(sigs), 2)
self.assertEqual(sigs[0][0], ("foo.e.com", 10, signal.SIGTERM))
self.assertEqual(sigs[1][0], ("bar.e.com", 11, signal.SIGTERM))
self.t.signal_node.return_value = False
self.assertTrue(callback.called)
self.t.stop(["foo", "bar", "baz"], "celeryd", callback=None)
def on_node_alive(pid):
if node_alive.call_count > 4:
return True
return False
self.t.signal_node.return_value = True
self.t.node_alive.side_effect = on_node_alive
self.t.stop(["foo", "bar", "baz"], "celeryd", retry=True)
@patch("os.kill")
def test_node_alive(self, kill):
kill.return_value = True
self.assertTrue(self.t.node_alive(13))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.node_alive(13))
kill.assert_called_with(13, 0)
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.node_alive(13)
@patch("os.kill")
def test_signal_node(self, kill):
kill.return_value = True
self.assertTrue(self.t.signal_node("foo", 13, 9))
esrch = OSError()
esrch.errno = errno.ESRCH
kill.side_effect = esrch
self.assertFalse(self.t.signal_node("foo", 13, 9))
kill.assert_called_with(13, 9)
self.assertIn("Could not signal foo", self.fh.getvalue())
enoent = OSError()
enoent.errno = errno.ENOENT
kill.side_effect = enoent
with self.assertRaises(OSError):
self.t.signal_node("foo", 13, 9)
def test_start(self):
self.t.waitexec = Mock()
self.t.waitexec.return_value = 0
self.assertFalse(self.t.start(["foo", "bar", "baz"], "celeryd"))
self.t.waitexec.return_value = 1
self.assertFalse(self.t.start(["foo", "bar", "baz"], "celeryd"))
def test_show(self):
self.t.show(["foo", "bar", "baz"], "celeryd")
self.assertTrue(self.fh.getvalue())
@patch("socket.gethostname")
def test_get(self, gethostname):
gethostname.return_value = "e.com"
self.t.get(["xuzzy.e.com", "foo", "bar", "baz"], "celeryd")
self.assertFalse(self.fh.getvalue())
self.t.get(["foo.e.com", "foo", "bar", "baz"], "celeryd")
self.assertTrue(self.fh.getvalue())
@patch("socket.gethostname")
def test_names(self, gethostname):
gethostname.return_value = "e.com"
self.t.names(["foo", "bar", "baz"], "celeryd")
self.assertIn("foo.e.com\nbar.e.com\nbaz.e.com", self.fh.getvalue())
def test_execute_from_commandline(self):
start = self.t.commands["start"] = Mock()
self.t.error = Mock()
self.t.execute_from_commandline(["multi", "start", "foo", "bar"])
self.assertFalse(self.t.error.called)
start.assert_called_with(["foo", "bar"], "celeryd")
self.t.error = Mock()
self.t.execute_from_commandline(["multi", "frob", "foo", "bar"])
self.t.error.assert_called_with("Invalid command: frob")
self.t.error = Mock()
self.t.execute_from_commandline(["multi"])
self.t.error.assert_called_with()
self.t.error = Mock()
self.t.execute_from_commandline(["multi", "-foo"])
self.t.error.assert_called_with()
self.t.execute_from_commandline(
["multi", "start", "foo", "--nosplash", "--quiet", "-q", "--verbose", "--no-color"]
)
self.assertTrue(self.t.nosplash)
self.assertTrue(self.t.quiet)
self.assertTrue(self.t.verbose)
self.assertTrue(self.t.no_color)
def test_stop_verify(self):
self.t._stop_nodes = Mock()
self.t.stop_verify(["foo", "bar", "baz"], "celeryd")
self.assertEqual(self.t._stop_nodes.call_args[1]["retry"], 2)
@patch("celery.bin.celeryd_multi.MultiTool")
def test_main(self, MultiTool):
m = MultiTool.return_value = Mock()
with self.assertRaises(SystemExit):
main()
m.execute_from_commandline.assert_called_with(sys.argv)
