def test_kick_not_empty_no_skip_paused(self):
bot = common.make_bot()
jobs = {}
for i in range(0, 10):
job = mock.MagicMock()
if i == 0:
job.next_run_time = self.ZERO_DT
else:
if i % 2 == 0:
job.next_run_time = self.IN_ONE_HOUR_DT
else:
job.next_run_time = None
job.id = str(i)
jobs[job.id] = job
bot.scheduler.get_jobs.return_value = list(jobs.values())
bot.scheduler.submitted_jobs = {}
bot.scheduler.submitted_jobs["1"] = self.ZERO_DT
m = common.make_message(text="periodics run all",
to_me=True,
user_id="me")
h = schedule.RunAllHandler(bot, m)
h.run(handler.HandlerMatch("skip_paused=false"))
m.reply_text.assert_called_with("Kicked 10 jobs and skipped 0 jobs.",
prefixed=False,
threaded=True)
def test_add_alias(self):
bot = common.make_bot(simple_config=True)
m = common.make_message(text="alias add b c", to_me=True, user_id="me")
h = alias.AddHandler(bot, m)
h.run(handler.HandlerMatch("b c"))
self.assertEqual(bot.brain.storage,
{'user:me': {'aliases': {'c': 'b'}}})
def test_remove_alias(self):
bot = common.make_bot(simple_config=True)
bot.brain = common.MockBrain({'user:me': {'aliases': {'c': 'b'}}})
m = common.make_message(text="alias remove c",
to_me=True, user_id="me")
h = alias.RemoveHandler(bot, m)
h.run(handler.HandlerMatch("c"))
self.assertEqual(bot.brain.storage,
{'user:me': {'aliases': {}}})
def test_arg_parsing_defaults(self):
handles_what = {
'args': {
'triggers': [
trigger.Trigger('test', True),
],
'order': ['a', 'b', 'c'],
'defaults': {
'a': "4",
},
},
}
h_cls = make_handler_cls(handles_what)
m = handler.HandlerMatch("b=3 c=4")
kwargs, _validated = h_cls.extract_arguments(m)
self.assertEqual(kwargs, {'a': '4', 'c': '4', 'b': '3'})
m = handler.HandlerMatch()
kwargs, _validated = h_cls.extract_arguments(m)
self.assertEqual(kwargs, {"a": "4"})
def test_restart_check_bot_really_restarted(self):
bot = common.make_bot()
m = common.make_message(text="restart",
to_me=True, user_id="me")
h = restart.Handler(bot, m)
h.run(handler.HandlerMatch())
self.assertEqual(e.Event.RESTART, bot.dead.value)
def test_info_with_metadata(self):
bot = common.make_bot()
m = common.make_message(text="what are you?", to_me=True, user_id="me")
h = what_are_you.Handler(bot, m)
with mock.patch('pkginfo.get_metadata'):
h.run(handler.HandlerMatch())
m.reply_text.assert_not_called()
m.reply_attachments.assert_called_once()
def test_openstack_runs_default(self):
bot = common.make_bot()
bot.topo_loader.env_names = tuple(['test'])
m = common.make_message(text="openstack server show",
to_me=True,
user_id="me")
h = openstack.DescribeServerHandler(bot, m)
h.run(handler.HandlerMatch('blah-svrnm'))
bot.topo_loader.load_one.assert_called()
def test_clear_alias(self):
bot = common.make_bot(simple_config=True)
bot.brain = common.MockBrain({
'user:me': {'aliases': {'c': 'b', 'e': 'f'}},
})
m = common.make_message(text="alias clear", to_me=True, user_id="me")
h = alias.ClearHandler(bot, m)
h.run(handler.HandlerMatch())
self.assertEqual(bot.brain.storage,
{'user:me': {'aliases': {}}})
def test_help_me_call(self):
bot = common.make_bot()
m = common.make_message(text="consult me", to_me=True, user_id="me")
with requests_mock.mock() as req_m:
req_m.get(help_me.Handler.buzz_url, text="you have been helped")
h = help_me.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once()
def handles(cls, message, channel, config):
channel_matcher = cls.handles_what['channel_matcher']
if not channel_matcher(channel):
return None
message_matcher = cls.handles_what['message_matcher']
if not message_matcher(message, cls):
return None
if config.get('event_channels'):
return handler.HandlerMatch()
else:
return None
def test_periodic_no_run_missing(self):
bot = common.make_bot()
jobs = {}
bot.scheduler.get_job.side_effect = lambda job_id: jobs.get(job_id)
m = common.make_message(text="periodics run one 1",
to_me=True,
user_id="me")
h = schedule.RunOneHandler(bot, m)
self.assertRaises(excp.NotFound, h.run, handler.HandlerMatch("1"))
def test_restart_get_message(self):
bot = common.make_bot()
m = common.make_message(text="restart",
to_me=True, user_id="me")
h = restart.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
'Restart acknowledged. Be back in a bit!',
prefixed=False, threaded=True)
def test_uptime_is_not_zero(self, mock_now):
bot = common.make_bot()
bot.started_at = datetime.now(tz=pytz.timezone('UTC'))
bot.config.tz = 'UTC'
mock_now.return_value = bot.started_at
m = common.make_message(text="uptime", to_me=True, user_id="me")
h = uptime.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
'I have been alive for 0 seconds.', prefixed=False, threaded=True)
def test_uptime_is_zero(self):
bot = common.make_bot()
bot.started_at = None
m = common.make_message(text="uptime", to_me=True, user_id="me")
h = uptime.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
"I am not alive, how are you sending this?",
threaded=True,
prefixed=False)
def test_info_without_metadata(self, get_meta):
bot = common.make_bot()
get_meta.return_value = False
m = common.make_message(text="what are you?", to_me=True, user_id="me")
h = what_are_you.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with('I am not really sure what I am.',
prefixed=False,
threaded=True)
def test_same_arg_parsing(self):
handles_what = {
'args': {
'triggers': [
trigger.Trigger('test', True),
],
'order': ['a'],
},
}
h_cls = make_handler_cls(handles_what)
m = handler.HandlerMatch("a=2 a=4 a=5")
kwargs, _validated = h_cls.extract_arguments(m)
self.assertEqual(kwargs, {'a': '5'})
def test_version_with_distribution(self, get_dist):
bot = common.make_bot()
get_dist.return_value = munch.Munch({'version': '1.0.0'})
m = common.make_message(text="version", to_me=True, user_id="me")
h = version.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with('I am padre version `1.0.0`.',
prefixed=False,
threaded=True)
def test_invalid_arg_parsing(self):
handles_what = {
'args': {
'triggers': [
trigger.Trigger('test', True),
],
'order': ['a', 'b', 'c'],
},
}
h_cls = make_handler_cls(handles_what)
m = handler.HandlerMatch("a=2 4 3")
self.assertRaises(excp.ArgumentError,
h_cls.extract_arguments, m)
m = handler.HandlerMatch("4 a=2 4")
self.assertRaises(excp.ArgumentError,
h_cls.extract_arguments, m)
m = handler.HandlerMatch("c=3 a=2 4")
self.assertRaises(excp.ArgumentError,
h_cls.extract_arguments, m)
m = handler.HandlerMatch("c=3 a=2 4")
self.assertRaises(excp.ArgumentError,
h_cls.extract_arguments, m)
def test_kick_empty(self):
bot = common.make_bot()
jobs = {}
bot.scheduler.get_jobs.return_value = list(jobs.values())
m = common.make_message(text="periodics run all",
to_me=True,
user_id="me")
h = schedule.RunAllHandler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_with("Kicked 0 jobs and skipped 0 jobs.",
prefixed=False,
threaded=True)
def test_version_without_distribution(self, get_dist):
bot = common.make_bot()
get_dist.return_value = False
m = common.make_message(text="version", to_me=True, user_id="me")
h = version.Handler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
'I am not really sure what version I am.',
prefixed=False,
threaded=True)
def test_tell_joke(self):
bot = common.make_bot()
m = common.make_message(text="tell me a joke",
to_me=True, user_id="me")
h = tell_joke.Handler(bot, m)
with requests_mock.mock() as req_m:
req_m.get(h.joke_url, json={"joke": 'an amazing joke'})
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with('an amazing joke',
prefixed=False, threaded=True)
def test_ldap_list_nonexisting_group(self):
bot = common.make_bot()
ldap_client = mock.MagicMock()
ldap_client.list_ldap_group.return_value = list()
bot.clients.ldap_client = ldap_client
m = common.make_message(text="ldap list",
to_me=True, user_id="me")
h = ldap.DescribeUserHandler(bot, m)
h.run(handler.HandlerMatch('NonExistentGroup'))
m.reply_text.assert_called_once_with(u'```\n\n```', prefixed=False,
threaded=True)
def test_joke_is_unavailable(self):
bot = common.make_bot()
m = common.make_message(text="tell me a joke",
to_me=True, user_id="me")
h = tell_joke.Handler(bot, m)
with requests_mock.mock() as req_m:
req_m.get(h.joke_url, json={})
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
'No joke found when calling `%s`.' % h.joke_url,
prefixed=False, threaded=True)
def handles(cls, message, channel, config):
channel_matcher = cls.handles_what['channel_matcher']
if not channel_matcher(channel):
return None
message_matcher = cls.handles_what['message_matcher']
if not message_matcher(message, cls):
return None
try:
event_channels = list(config.event_channels)
except AttributeError:
event_channels = []
if event_channels:
return handler.HandlerMatch()
else:
return None
def test_ldap_describe_nonexisting_user(self):
bot = common.make_bot()
ldap_client = mock.MagicMock()
ldap_client.describe_user.return_value = False
bot.clients.ldap_client = ldap_client
m = common.make_message(text="ldap describe user",
to_me=True, user_id="me")
h = ldap.DescribeUserHandler(bot, m)
h.run(handler.HandlerMatch('NonExistentUser'))
m.reply_text.assert_called_once_with(
'No user with name `NonExistentUser` found.',
prefixed=False, threaded=True)
def test_show_empty(self):
bot = common.make_bot()
jobs = {}
bot.scheduler.timezone = pytz.utc
bot.scheduler.get_jobs.return_value = list(jobs.values())
m = common.make_message(text="periodics show",
to_me=True,
user_id="me")
h = schedule.ShowHandler(bot, m)
h.run(handler.HandlerMatch())
m.reply_text.assert_called_with("Scheduler is in `UNKNOWN` state.",
prefixed=False,
threaded=True)
def test_periodic_no_run_paused(self):
bot = common.make_bot()
mock_job = mock.MagicMock()
mock_job.next_run_time = None
mock_job.id = '1'
jobs = {
mock_job.id: mock_job,
}
bot.scheduler.get_job.side_effect = lambda job_id: jobs.get(job_id)
m = common.make_message(text="periodics run one 1",
to_me=True,
user_id="me")
h = schedule.RunOneHandler(bot, m)
self.assertRaises(RuntimeError, h.run, handler.HandlerMatch("1"))
def test_ldap_describe_existing_user(self):
bot = common.make_bot()
ldap_client = mock.MagicMock()
ldap_client.describe_user.return_value = {
'name': 'Some User',
'uid': 99999
}
bot.clients.ldap_client = ldap_client
m = common.make_message(text="ldap describe user",
to_me=True, user_id="me")
h = ldap.DescribeUserHandler(bot, m)
h.run(handler.HandlerMatch('some_user'))
m.reply_text.assert_called_once_with(
u'```\nName Uid\n--------- -----\nSome User 99999\n```',
prefixed=False, threaded=True)
def test_shutdown(self):
bot = common.make_bot()
m = common.make_message(text="periodics run all",
to_me=True,
user_id="me")
h = shutdown.Handler(bot, m)
with mock.patch('random.choice') as rch:
rch.return_value = "Live long and prosper."
h.run(handler.HandlerMatch())
m.reply_text.assert_called_once_with(
'Shutdown acknowledged. Live long and prosper.',
prefixed=False,
threaded=True)
self.assertEqual(e.Event.DIE, bot.dead.value)
def test_ldap_describe_existing_group(self):
bot = common.make_bot()
ldap_client = mock.MagicMock()
ldap_client.list_ldap_group.return_value = [
"DC=dc1,OU=AwesomeGroup,CN=dc_group"
]
bot.clients.ldap_client = ldap_client
m = common.make_message(text="ldap list", to_me=True, user_id="me")
h = ldap.ListHandler(bot, m)
h.run(handler.HandlerMatch('dc_group'))
m.reply_text.assert_called_once_with(
u'```\nCN DC OU\n-------- ---- ------------\n'
u'dc_group dc1 AwesomeGroup\n```',
prefixed=False, threaded=True)
