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_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_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_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_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))