def test_validate_first_message(data, raises):
mock_message = mock.Mock(data=data)
if raises is None:
assert SlackBot._validate_first_message(mock_message) is None
else:
with pytest.raises(raises):
SlackBot._validate_first_message(mock_message)
def test_instruction_list():
bot = SlackBot(None, 'foo', None)
instructions = bot._instruction_list([Unhandled()])
assert instructions.startswith(SlackBot.INSTRUCTIONS.strip())
assert '"@foo: help"' in instructions
assert '"@foo: version"' in instructions
assert instructions.endswith('a dummy handler')
def test_validate_first_message(data, raises):
mock_message = mock.Mock(data=data)
if raises is None:
assert SlackBot._validate_first_message(mock_message) is None
else:
with pytest.raises(raises):
SlackBot._validate_first_message(mock_message)
def test_format_message(randint):
bot = SlackBot(None, None, None)
expected = dict(
id=randint.return_value,
channel='foo',
text='bar',
type='message',
)
assert json.loads(bot._format_message('foo', 'bar')) == expected
def test_format_message(randint):
bot = SlackBot(None, None, None)
expected = dict(
id=randint.return_value,
channel='foo',
text='bar',
type='message',
)
assert json.loads(bot._format_message('foo', 'bar')) == expected
def test_instruction_list():
bot = SlackBot(None, 'foo', None)
def filter_():
"""foo"""
def dispatch():
"""bar"""
instructions = bot._instruction_list({filter_: dispatch})
assert instructions.endswith('foo bar')
assert instructions.startswith(SlackBot.INSTRUCTIONS.strip())
assert '"@foo: help"' in instructions and '"@foo: version"' in instructions
async def test_handle_help_message(randint):
bot = SlackBot('foo', None, None)
mock_msg = mock.Mock(data=json.dumps(
dict(channel='bar', text='<@foo>: help', type='message'), ), )
expected = dict(
channel='bar',
id=randint.return_value,
text=bot._instruction_list({}),
type='message',
)
response = await bot.handle_message(mock_msg, {})
assert json.loads(response) == expected
def test_instruction_list():
bot = SlackBot(None, 'foo', None)
def filter_():
"""foo"""
def dispatch():
"""bar"""
instructions = bot._instruction_list({filter_: dispatch})
assert instructions.endswith('foo bar')
assert instructions.startswith(SlackBot.INSTRUCTIONS.strip())
assert '"@foo: help"' in instructions and '"@foo: version"' in instructions
async def test_handle_message_dispatch(randint):
bot = SlackBot(None, None, None)
mock_message = mock.Mock(data='{"channel": 123}')
mock_socket = mock.MagicMock()
bot.socket = mock_socket
dummy_response = 'bar'
await bot.handle_message(mock_message, [Handled(dummy_response)])
expected = dict(
channel=123,
id=randint.return_value,
text=dummy_response,
type='message',
)
assert json.loads(mock_socket.send_str.call_args[0][0]) == expected
async def test_handle_help_message(randint):
bot = SlackBot('foo', None, None)
mock_msg = mock.Mock(
data=json.dumps(
dict(channel='bar', text='<@foo>: help', type='message'),
),
)
expected = dict(
channel='bar',
id=randint.return_value,
text=bot._instruction_list({}),
type='message',
)
response = await bot.handle_message(mock_msg, {})
assert json.loads(response) == expected
def test_bot_handler_matching():
bot = SlackBot('foo', None, None)
handler = BotMessageHandler(bot)
handler.PHRASE = 'bar'
text = '<@foo>: bar'
assert handler.matches(dict(type='message', text=text))
assert handler.text == text
async def test_join_rtm_messages(ws_connect):
mock_msg = mock.Mock(
data='{"type": "hello", "channel": 123}',
tp=aiohttp.MsgType.text,
)
mock_socket = AsyncIterable.from_test_data(
mock_msg,
close=None,
receive=mock.Mock(data='{"type": "hello"}'),
send_str=None,
)
ws_connect.return_value = AsyncContextManager(mock_socket)
api = mock.CoroutineMock(
spec=SlackBotApi,
**{'execute_method.return_value': {'url': 'foo'}},
)
bot = SlackBot(None, None, api)
data = {'channel': 'foo', 'text': 'bar'}
await bot.join_rtm([Handled(data)])
api.execute_method.assert_called_once_with(
'rtm.start',
simple_latest=True,
no_unreads=True,
)
assert mock_socket.send_str.call_count == 1
async def test_handle_version_message(randint):
bot = SlackBot('foo', None, None)
mock_msg = mock.Mock(
data=json.dumps(
dict(channel='bar', text='<@foo>: version', type='message'),
),
)
expected = dict(
channel='bar',
id=randint.return_value,
text=bot.VERSION,
type='message',
)
mock_socket = mock.MagicMock()
bot.socket = mock_socket
await bot.handle_message(mock_msg, [])
assert json.loads(mock_socket.send_str.call_args[0][0]) == expected
def test_init(randint):
args = dict(id_='foo', user='******', api='baz')
bot = SlackBot(**args)
for attr, val in args.items():
assert getattr(bot, attr) == val
assert bot.address_as == '<@foo>: '
assert bot.full_name == '<@foo>'
assert next(bot._msg_ids) == randint.return_value
randint.assert_called_once_with(1, 1000)
async def test_get_socket_url():
api = mock.CoroutineMock(
spec=SlackBotApi,
**{'execute_method.return_value': {'url': 'foo'}},
)
bot = SlackBot(None, None, api)
url = await bot._get_socket_url()
assert url == 'foo'
api.execute_method.assert_called_once_with(
'rtm.start',
simple_latest=True,
no_unreads=True,
)
async def test_handle_message_dispatch(randint):
bot = SlackBot(None, None, None)
mock_message = mock.Mock(data='{}')
mock_filter_ = mock.Mock(return_value=True)
mock_dispatch = mock.CoroutineMock(
return_value=dict(channel='foo', text='bar'))
response = await bot.handle_message(mock_message,
{mock_filter_: mock_dispatch})
expected = dict(
id=randint.return_value,
type='message',
**mock_dispatch.return_value,
)
assert json.loads(response) == expected
mock_filter_.assert_called_once_with(bot, {})
mock_dispatch.assert_called_once_with(bot, {})
async def test_join_rtm_simple(ws_connect):
ws_connect.return_value = AsyncContextManager(
AsyncIterable.from_test_data(
receive=mock.Mock(data='{"type": "hello"}'),
)
)
api = mock.CoroutineMock(
spec=SlackBotApi,
**{'execute_method.return_value': {'url': 'foo'}},
)
bot = SlackBot(None, None, api)
await bot.join_rtm()
api.execute_method.assert_called_once_with(
'rtm.start',
simple_latest=True,
no_unreads=True,
)
async def test_join_rtm_error_messages(ws_connect, closed, calls):
mock_msg = mock.Mock(tp=aiohttp.MsgType.closed)
mock_socket = AsyncIterable.from_test_data(
mock_msg,
close=None,
receive=mock.Mock(data='{"type": "hello"}'),
)
mock_socket.closed = closed
ws_connect.return_value = AsyncContextManager(mock_socket)
api = mock.CoroutineMock(
spec=SlackBotApi,
**{'execute_method.return_value': {'url': 'foo'}},
)
bot = SlackBot(None, None, api)
await bot.join_rtm()
api.execute_method.assert_called_once_with(
'rtm.start',
simple_latest=True,
no_unreads=True,
)
assert mock_socket.close.call_count == calls
async def test_handle_unfiltered_message():
bot = SlackBot(None, None, None)
mock_msg = mock.Mock(data=json.dumps(dict(type='message')))
await bot.handle_message(mock_msg, {lambda self, msg: False: None})
def test_unpack_message_broken_json():
mock_message = mock.Mock(data='broken.json')
with pytest.raises(json.JSONDecodeError):
SlackBot._unpack_message(mock_message)
def test_to_me(input_, output):
bot = SlackBot('foo', None, None)
assert bot.message_is_to_me(input_) == output
async def test_handle_unfiltered_message():
bot = SlackBot(None, None, None)
mock_msg = mock.Mock(data=json.dumps(dict(type='message')))
await bot.handle_message(mock_msg, [Unhandled()])
async def test_handle_error_message():
bot = SlackBot(None, None, None)
mock_msg = mock.Mock(data=json.dumps(dict(error={}, type='error')))
with pytest.raises(SlackApiError):
await bot.handle_message(mock_msg, [])
def test_to_me(input_, output):
bot = SlackBot('foo', None, None)
assert bot.message_is_to_me(input_) == output
def test_unpack_message_success():
data = {'bar': 'foo'}
mock_message = mock.Mock(data=json.dumps(data))
assert SlackBot._unpack_message(mock_message) == data
def test_unpack_message_no_data():
with pytest.raises(AttributeError):
SlackBot._unpack_message(object())
def test_unpack_message_success():
data = {'bar': 'foo'}
mock_message = mock.Mock(data=json.dumps(data))
assert SlackBot._unpack_message(mock_message) == data
def test_unpack_message_no_data():
with pytest.raises(AttributeError):
SlackBot._unpack_message(object())
def test_mentions_me(input_, output):
bot = SlackBot('foo', None, None)
assert bot.message_mentions_me(input_) == output
def test_mentions_me(input_, output):
bot = SlackBot('foo', None, None)
assert bot.message_mentions_me(input_) == output
def test_unpack_message_broken_json():
mock_message = mock.Mock(data='broken.json')
with pytest.raises(json.JSONDecodeError):
SlackBot._unpack_message(mock_message)
