def test_message_sender_send_multiple_messages(self):
'''The message sender should send all messages to their correct queues
when send_message is called multiple times'''
msg1 = TransportUserMessage.send(
to_addr='+1234', content='test1', transport_name='testtransport')
yield self.message_sender.send_message(
msg1, routing_key='testtransport')
msg2 = TransportUserMessage.send(
to_addr='+1234', content='test2', transport_name='testtransport')
yield self.message_sender.send_message(
msg2, routing_key='testtransport')
[rec_msg1, rec_msg2] = self.get_dispatched_messages('testtransport')
self.assertEqual(rec_msg1, msg1)
self.assertEqual(rec_msg2, msg2)
def send_to(self, to_addr, content, tag='default', **kw):
if tag not in self.SEND_TO_TAGS:
raise ValueError("Tag %r not defined in SEND_TO_TAGS" % (tag, ))
options = copy.deepcopy(self.send_to_options[tag])
options.update(kw)
msg = TransportUserMessage.send(to_addr, content, **options)
return self._publish_message(msg)
def test_send_to(self):
sent_msg = yield self.worker.send_to('+12345', "Hi!")
sends = self.recv()
expecteds = [TransportUserMessage.send('+12345', "Hi!",
transport_name='default_transport')]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_send_to(self):
sent_msg = yield self.send_to('+12345', "Hi!")
sends = self.app_helper.get_dispatched_outbound()
expecteds = [TransportUserMessage.send('+12345', "Hi!",
transport_name='default_transport')]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def send_message(self, sender, outbounds, msg):
'''Sends a message.'''
event_url = msg.get('event_url')
msg = message_from_api(self.id, msg)
msg = TransportUserMessage.send(**msg)
msg = yield self._send_message(sender, outbounds, event_url, msg)
returnValue(api_from_message(msg))
def send_to(self, to_addr, content, tag='default', **kw):
if tag not in self.SEND_TO_TAGS:
raise ValueError("Tag %r not defined in SEND_TO_TAGS" % (tag,))
options = copy.deepcopy(self.send_to_options[tag])
options.update(kw)
msg = TransportUserMessage.send(to_addr, content, **options)
return self._publish_message(msg)
def test_send_to_with_tag(self):
sent_msg = yield self.worker.send_to('+12345', "Hi!", "outbound1",
transport_type=TransportUserMessage.TT_USSD)
sends = self.recv()
expecteds = [TransportUserMessage.send('+12345', "Hi!",
transport_type=TransportUserMessage.TT_USSD,
transport_name='outbound1_transport')]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_store_vumi_message(self):
'''Stores the vumi message.'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield store.store_vumi_message('channel_id', vumi_msg)
msg = yield self.redis.hget(
'channel_id:inbound_messages:%s' % vumi_msg.get('message_id'),
'message')
self.assertEqual(vumi_msg, TransportUserMessage.from_json(msg))
def test_send_to_with_different_endpoint(self):
sent_msg = yield self.worker.send_to(
"+12345", "Hi!", endpoint="outbound1", transport_type=TransportUserMessage.TT_USSD
)
sends = self.app_helper.get_dispatched_outbound()
expecteds = [TransportUserMessage.send("+12345", "Hi!", transport_type=TransportUserMessage.TT_USSD)]
expecteds[0].set_routing_endpoint("outbound1")
self.assert_msgs_match(sends, [sent_msg])
self.assert_msgs_match(sends, expecteds)
def test_send_message_storing(self):
"""Inbound messages should be stored in the InboundMessageStore"""
msg = TransportUserMessage.send(to_addr="+1234", content="testcontent")
yield self.worker.consume_user_message(msg)
redis = self.worker.redis
key = "%s:inbound_messages:%s" % (self.worker.config["transport_name"], msg["message_id"])
msg_json = yield redis.hget(key, "message")
self.assertEqual(TransportUserMessage.from_json(msg_json), msg)
def test_send_message(self):
"""A sent message should be forwarded to the configured URL"""
msg = TransportUserMessage.send(to_addr="+1234", content="testcontent")
yield self.worker.consume_user_message(msg)
[req] = self.logging_api.requests
self.assert_request(req, method="POST", headers={"content-type": ["application/json"]})
self.assert_body_contains(req, to="+1234", content="testcontent")
def test_store_vumi_message(self):
'''Stores the vumi message.'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield store.store_vumi_message('channel_id', vumi_msg)
msg = yield self.redis.hget(
'channel_id:inbound_messages:%s' % vumi_msg.get('message_id'),
'message')
self.assertEqual(vumi_msg, TransportUserMessage.from_json(msg))
def test_message_sender_bad_routing_key(self):
'''If the routing key is invalid, the message sender should raise an
error'''
msg = TransportUserMessage.send(
to_addr='+1234', content='test', transport_name='testtransport')
err = yield self.assertFailure(
self.message_sender.send_message(msg, routing_key='Foo'),
RoutingKeyError)
self.assertTrue('Foo' in str(err))
def test_message_sender_send_message(self):
'''The message sender should add a message to the correct queue when
send_message is called'''
msg = TransportUserMessage.send(
to_addr='+1234', content='test', transport_name='testtransport')
yield self.message_sender.send_message(
msg, routing_key='testtransport')
[rec_msg] = self.get_dispatched_messages('testtransport')
self.assertEqual(rec_msg, msg)
def test_send_to_with_options(self):
sent_msg = yield self.send_to("+12345", "Hi!", transport_type=TransportUserMessage.TT_USSD)
sends = self.app_helper.get_dispatched_outbound()
expecteds = [
TransportUserMessage.send(
"+12345", "Hi!", transport_type=TransportUserMessage.TT_USSD, transport_name="default_transport"
)
]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_send_to_with_endpoint(self):
sent_msg = yield self.send_to('+12345', "Hi!", "outbound1",
transport_type=TransportUserMessage.TT_USSD)
sends = self.app_helper.get_dispatched_outbound()
expecteds = [TransportUserMessage.send('+12345', "Hi!",
transport_type=TransportUserMessage.TT_USSD,
transport_name='outbound1_transport')]
expecteds[0].set_routing_endpoint("outbound1")
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_send_to(self):
sent_msg = yield self.worker.send_to('+12345', "Hi!")
sends = self.recv()
expecteds = [
TransportUserMessage.send('+12345',
"Hi!",
transport_name='default_transport')
]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_store_message(self):
'''Stores the message under the correct key'''
store = yield self.create_store()
msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield store.store_message('channel_id', api_from_message(msg))
msg_json = yield self.redis.hget(
'channel_id:outbound_messages:{}'.format(msg['message_id']),
'message')
self.assertEqual(msg_json, to_json(api_from_message(msg)))
def test_send_message_storing(self):
'''Inbound messages should be stored in the InboundMessageStore'''
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
redis = self.worker.redis
key = '%s:inbound_messages:%s' % (self.worker.config['transport_name'],
msg['message_id'])
msg_json = yield redis.hget(key, 'message')
self.assertEqual(TransportUserMessage.from_json(msg_json), msg)
def test_transport_user_message_send(self):
msg = TransportUserMessage.send('123', 'Hi!')
self.assertEqual(msg['to_addr'], '123')
self.assertEqual(msg['from_addr'], None)
self.assertEqual(msg['session_event'], msg.SESSION_NONE)
self.assertEqual(msg['in_reply_to'], None)
self.assertEqual(msg['transport_name'], None)
self.assertEqual(msg['transport_type'], None)
self.assertEqual(msg['transport_metadata'], {})
self.assertEqual(msg['helper_metadata'], {})
def test_message_sender_send_message_no_connection(self):
'''The message sender should raise an error when there is no
connection to send the message over'''
self.message_sender.client = None
msg = TransportUserMessage.send(
to_addr='+1234', content='test', transport_name='testtransport')
err = self.assertRaises(
AmqpConnectionError, self.message_sender.send_message, msg,
routing_key='testtransport')
self.assertTrue('Message not sent' in str(err))
def test_transport_user_message_send(self):
msg = TransportUserMessage.send('123', 'Hi!')
self.assertEqual(msg['to_addr'], '123')
self.assertEqual(msg['from_addr'], None)
self.assertEqual(msg['session_event'], msg.SESSION_NONE)
self.assertEqual(msg['in_reply_to'], None)
self.assertEqual(msg['transport_name'], None)
self.assertEqual(msg['transport_type'], None)
self.assertEqual(msg['transport_metadata'], {})
self.assertEqual(msg['helper_metadata'], {})
def test_send_message_storing(self):
'''Inbound messages should be stored in the InboundMessageStore'''
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
redis = self.worker.redis
key = '%s:inbound_messages:%s' % (
self.worker.config['transport_name'], msg['message_id'])
msg_json = yield redis.hget(key, 'message')
self.assertEqual(TransportUserMessage.from_json(msg_json), msg)
def test_send_to(self):
sent_msg = yield self.send_to('+12345', "Hi!")
sends = self.app_helper.get_dispatched_outbound()
expecteds = [
TransportUserMessage.send('+12345',
"Hi!",
transport_name='default_transport')
]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_load_event_auth_token(self):
'''Returns the event auth token under the message ID'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
msg = {'event_auth_token': 'the-auth-token'}
msg.update(api_from_message(vumi_msg))
yield store.store_message('channel_id', msg)
event_auth_token = yield store.load_event_auth_token(
'channel_id', vumi_msg.get('message_id'))
self.assertEqual(event_auth_token, "the-auth-token")
def test_load_event_url(self):
'''Returns a vumi message from the stored json'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
msg = {'event_url': "http://test.org"}
msg.update(api_from_message(vumi_msg))
yield store.store_message('channel_id', msg)
event_url = yield store.load_event_url(
'channel_id', vumi_msg.get('message_id'))
self.assertEqual(event_url, 'http://test.org')
def test_load_vumi_message(self):
'''Returns a vumi message from the stored json'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield self.redis.hset(
'channel_id:inbound_messages:%s' % vumi_msg.get('message_id'),
'message', vumi_msg.to_json())
message = yield store.load_vumi_message(
'channel_id', vumi_msg.get('message_id'))
self.assertEqual(message, vumi_msg)
def test_load_event_url(self):
'''Returns a vumi message from the stored json'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield self.redis.hset(
'channel_id:outbound_messages:%s' % vumi_msg.get('message_id'),
'event_url', 'http://test.org')
event_url = yield store.load_event_url(
'channel_id', vumi_msg.get('message_id'))
self.assertEqual(event_url, 'http://test.org')
def send_to(self, to_addr, content, endpoint=None, **kw):
if endpoint is None:
endpoint = 'default'
self.check_endpoint(self.ALLOWED_ENDPOINTS, endpoint)
options = copy.deepcopy(
self.get_static_config().send_to.get(endpoint, {}))
options.update(kw)
msg = TransportUserMessage.send(to_addr, content, **options)
return self._publish_message(msg, endpoint_name=endpoint)
def send_to(self, to_addr, content, endpoint=None, **kw):
if endpoint is None:
endpoint = 'default'
self.check_endpoint(self.ALLOWED_ENDPOINTS, endpoint)
options = copy.deepcopy(self.get_static_config().send_to.get(
endpoint, {}))
options.update(kw)
msg = TransportUserMessage.send(to_addr, content, **options)
return self._publish_message(msg, endpoint_name=endpoint)
def test_load_event_url(self):
'''Returns a vumi message from the stored json'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield self.redis.hset(
'channel_id:outbound_messages:%s' % vumi_msg.get('message_id'),
'event_url', 'http://test.org')
event_url = yield store.load_event_url('channel_id',
vumi_msg.get('message_id'))
self.assertEqual(event_url, 'http://test.org')
def test_receive_message_amqp(self):
'''A received message on the configured queue should be forwarded to
the transport queue if the config option is set.'''
worker = yield self.get_worker(config={'message_queue': 'testqueue'})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.app_helper.dispatch_outbound(msg,
connector_name='testqueue')
[dispatched_msg] = yield self.app_helper.wait_for_dispatched_outbound(
connector_name=worker.transport_name)
self.assertEqual(dispatched_msg, msg)
def test_load_vumi_message(self):
'''Returns a vumi message from the stored json'''
store = yield self.create_store()
vumi_msg = TransportUserMessage.send(to_addr='+213', content='foo')
yield self.redis.hset(
'channel_id:inbound_messages:%s' % vumi_msg.get('message_id'),
'message', vumi_msg.to_json())
message = yield store.load_vumi_message('channel_id',
vumi_msg.get('message_id'))
self.assertEqual(message, vumi_msg)
def test_send_message_http(self):
'''A sent message should be forwarded to the configured URL if a URL
is set.'''
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
[req] = self.logging_api.requests
self.assert_request(req,
method='POST',
headers={'content-type': ['application/json']})
self.assert_body_contains(req, to='+1234', content='testcontent')
def test_send_message_http(self):
'''A sent message should be forwarded to the configured URL if a URL
is set.'''
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
[req] = self.logging_api.requests
self.assert_request(req, method='POST', headers={
'content-type': ['application/json']
})
self.assert_body_contains(req, to='+1234', content='testcontent')
def test_send_message_bad_response(self):
"""If there is an error sending a message to the configured URL, the
error and message should be logged"""
self.patch_logger()
self.worker = yield self.get_worker({"transport_name": "testtransport", "mo_message_url": self.url + "/bad/"})
msg = TransportUserMessage.send(to_addr="+1234", content="testcontent")
yield self.worker.consume_user_message(msg)
self.assert_was_logged("'content': 'testcontent'")
self.assert_was_logged("'to': '+1234'")
self.assert_was_logged("500")
self.assert_was_logged("test-error-response")
def test_send_message_amqp(self):
'''A sent message should be forwarded to the correct AMQP queue if
the config option is set.'''
worker = yield self.get_worker(config={'message_queue': 'testqueue'})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield worker.consume_user_message(msg)
[dispatched_msg
] = self.app_helper.get_dispatched('testqueue', 'inbound',
TransportUserMessage)
self.assertEqual(dispatched_msg, msg)
def test_receive_message_amqp(self):
'''A received message on the configured queue should be forwarded to
the transport queue if the config option is set.'''
worker = yield self.get_worker(config={
'message_queue': 'testqueue'
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.app_helper.dispatch_outbound(
msg, connector_name='testqueue')
[dispatched_msg] = yield self.app_helper.wait_for_dispatched_outbound(
connector_name=worker.transport_name)
self.assertEqual(dispatched_msg, msg)
def test_send_message_amqp(self):
'''A sent message should be forwarded to the correct AMQP queue if
the config option is set.'''
worker = yield self.get_worker(config={
'message_queue': 'testqueue'
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield worker.consume_user_message(msg)
[dispatched_msg] = self.app_helper.get_dispatched(
'testqueue', 'inbound', TransportUserMessage)
self.assertEqual(dispatched_msg, msg)
def test_send_message_imploding_response(self):
'''If there is an error connecting to the configured URL, the
error and message should be logged'''
self.patch_logger()
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': self.url + '/implode/',
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
self.assert_was_logged('Post to %s/implode/ failed because of' % (
self.url,))
self.assert_was_logged('ConnectionDone')
def test_send_to_with_different_endpoint(self):
sent_msg = yield self.worker.send_to(
'+12345',
"Hi!",
endpoint="outbound1",
transport_type=TransportUserMessage.TT_USSD)
sends = self.app_helper.get_dispatched_outbound()
expecteds = [
TransportUserMessage.send(
'+12345', "Hi!", transport_type=TransportUserMessage.TT_USSD)
]
expecteds[0].set_routing_endpoint("outbound1")
self.assert_msgs_match(sends, [sent_msg])
self.assert_msgs_match(sends, expecteds)
def test_send_message_imploding_response(self):
'''If there is an error connecting to the configured URL, the
error and message should be logged'''
self.patch_logger()
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': self.url + '/implode/',
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
self.assert_was_logged('Post to %s/implode/ failed because of' % (
self.url,))
self.assert_was_logged('ConnectionDone')
def test_message_from_api(self):
msg = message_from_api(
'channel-id', {
'from': '+1234',
'content': None,
'channel_data': {
'continue_session': True,
'voice': {},
},
})
msg = TransportUserMessage.send(**msg)
self.assertEqual(msg.get('continue_session'), True)
self.assertEqual(msg.get('helper_metadata'), {'voice': {}})
self.assertEqual(msg.get('from_addr'), '+1234')
self.assertEqual(msg.get('content'), None)
def test_message_from_api(self):
msg = message_from_api(
'channel-id', {
'from': '+1234',
'content': None,
'channel_data': {
'continue_session': True,
'voice': {},
},
})
msg = TransportUserMessage.send(**msg)
self.assertEqual(msg.get('continue_session'), True)
self.assertEqual(msg.get('helper_metadata'), {'voice': {}})
self.assertEqual(msg.get('from_addr'), '+1234')
self.assertEqual(msg.get('content'), None)
def test_send_message_bad_response(self):
'''If there is an error sending a message to the configured URL, the
error and message should be logged'''
self.patch_logger()
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': self.url + '/bad/',
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
self.assert_was_logged("'content': 'testcontent'")
self.assert_was_logged("'to': '+1234'")
self.assert_was_logged('500')
self.assert_was_logged('test-error-response')
def test_outbound_message_rates(self):
'''Outbound messages should increase the message send rates.'''
clock = self.patch_message_rate_clock()
worker = yield self.get_worker({
'message_rate_bucket': 1.0,
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield worker.consume_user_message(msg)
clock.advance(1)
self.assertEqual((yield worker.message_rate.get_messages_per_second(
'testtransport', 'inbound', 1.0)), 1.0)
def test_send_message_bad_response(self):
'''If there is an error sending a message to the configured URL, the
error and message should be logged'''
self.patch_logger()
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': self.url + '/bad/',
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
self.assert_was_logged("'content': 'testcontent'")
self.assert_was_logged("'to': '+1234'")
self.assert_was_logged('500')
self.assert_was_logged('test-error-response')
def test_send_to_with_tag(self):
sent_msg = yield self.worker.send_to(
'+12345',
"Hi!",
"outbound1",
transport_type=TransportUserMessage.TT_USSD)
sends = self.recv()
expecteds = [
TransportUserMessage.send(
'+12345',
"Hi!",
transport_type=TransportUserMessage.TT_USSD,
transport_name='outbound1_transport')
]
self.assert_msgs_match(sends, expecteds)
self.assert_msgs_match(sends, [sent_msg])
def test_send_message_with_token_auth(self):
'''If there is an error sending a message to the configured URL, the
error and message should be logged'''
self.patch_logger()
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': self.url + '/auth/',
'mo_message_url_auth_token': 'the-auth-token'
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
[logged_request] = self.logging_api.requests
self.assertEqual(logged_request, {
'Authorization': ['Token the-auth-token']
})
def test_amqp_client_publish_message_defaults(self):
'''The amqp client should call basic_publish on the channel with
the proper message details'''
factory = AmqpFactory('amqp-spec-0-8.xml', {
'vhost': '/'}, None, None)
client = factory.buildProtocol('localhost')
client.cached_channel = FakeChannel()
msg = TransportUserMessage.send(
to_addr='+1234', content='test', transport_name='testtransport')
client.publish_message(msg)
[amq_msg] = client.cached_channel.messages
self.assertEqual(amq_msg['content']['delivery mode'], 2)
self.assertEqual(amq_msg['exchange'], 'vumi')
self.assertEqual(amq_msg['routing_key'], 'routing_key')
vumi_msg = json.loads(amq_msg['content'].body)
self.assertEqual(vumi_msg['message_id'], msg['message_id'])
def test_send_message_with_basic_auth(self):
'''If there is an error sending a message to the configured URL, the
error and message should be logged'''
self.patch_logger()
# Inject the auth parameters
url = self.url.replace('http://', 'http://*****:*****@') + '/auth/'
self.worker = yield self.get_worker({
'transport_name': 'testtransport',
'mo_message_url': url,
})
msg = TransportUserMessage.send(to_addr='+1234', content='testcontent')
yield self.worker.consume_user_message(msg)
[logged_request] = self.logging_api.requests
self.assertEqual(logged_request, {
'Authorization': ['Basic %s' % (b64encode('foo:bar'),)]
})
def test_api_from_message(self):
'''The api from message function should take a vumi message, and
return a dict with the appropriate values'''
message = TransportUserMessage.send(content=None,
from_addr='+1234',
to_addr='+5432',
transport_name='testtransport',
continue_session=True,
helper_metadata={'voice': {}})
dct = api_from_message(message)
[dct.pop(f) for f in ['timestamp', 'message_id']]
self.assertEqual(
dct, {
'channel_data': {
'continue_session': True,
'voice': {},
},
'from': '+1234',
'to': '+5432',
'channel_id': 'testtransport',
'content': None,
'reply_to': None,
})
def send_message(self, sender, outbounds, msg):
'''Sends a message.'''
vumi_msg = message_from_api(self.id, msg)
vumi_msg = TransportUserMessage.send(**vumi_msg)
vumi_msg = yield self._send_message(sender, outbounds, vumi_msg, msg)
returnValue(api_from_message(vumi_msg))
