def test_send_reply_message(self):
'''send_reply_message should place the correct reply message on the
correct queue'''
channel = yield self.create_channel(self.service,
self.redis,
id='channel-id')
in_msg = TransportUserMessage(from_addr='+2789',
to_addr='+1234',
transport_name='channel-id',
transport_type='_',
transport_metadata={'foo': 'bar'})
yield self.api.inbounds.store_vumi_message('channel-id', in_msg)
msg = yield channel.send_reply_message(
self.message_sender, self.outbounds, self.inbounds, {
'reply_to': in_msg['message_id'],
'content': 'testcontent',
})
expected = in_msg.reply(content='testcontent')
expected = conjoin(api_from_message(expected), {
'timestamp': msg['timestamp'],
'message_id': msg['message_id']
})
self.assertEqual(msg, expected)
[dispatched] = self.get_dispatched_messages('channel-id.outbound')
self.assertEqual(msg['message_id'], dispatched['message_id'])
self.assertEqual(api_from_message(dispatched), expected)
def test_send_reply_message(self):
'''send_reply_message should place the correct reply message on the
correct queue'''
yield self.create_channel(
self.service, self.redis, TelnetServerTransport, id='channel-id')
in_msg = TransportUserMessage(
from_addr='+2789',
to_addr='+1234',
transport_name='channel-id',
transport_type='_',
transport_metadata={'foo': 'bar'})
yield self.api.inbounds.store_vumi_message('channel-id', in_msg)
msg = yield Channel.send_reply_message(
'channel-id', self.message_sender, self.outbounds, self.inbounds, {
'reply_to': in_msg['message_id'],
'content': 'testcontent',
})
expected = in_msg.reply(content='testcontent')
expected = conjoin(api_from_message(expected), {
'timestamp': msg['timestamp'],
'message_id': msg['message_id']
})
self.assertEqual(msg, expected)
[dispatched] = self.get_dispatched_messages('channel-id.outbound')
self.assertEqual(msg['message_id'], dispatched['message_id'])
self.assertEqual(api_from_message(dispatched), expected)
def make_request(self, session_type, session_id, reply=None,
continue_session=True, expect_msg=True,
defer_response=False, **kw):
url_suffix = "session/%s/%s" % (session_id, session_type)
method = self.SESSION_HTTP_METHOD.get(session_type, "POST")
request_data = self.DEFAULT_SESSION_DATA[session_type].copy()
request_data.update(kw)
deferred_req = http_request(self.worker_url + url_suffix,
json.dumps(request_data), method=method)
if not expect_msg:
msg = None
else:
[msg] = yield self.broker.wait_messages("vumi",
"test_infobip.inbound",
1)
self.broker.clear_messages("vumi", "test_infobip.inbound")
msg = TransportUserMessage(**msg.payload)
if reply is not None:
reply_msg = msg.reply(reply, continue_session=continue_session)
self.broker.publish_message("vumi", "test_infobip.outbound",
reply_msg)
if defer_response:
response = deferred_req
else:
response = yield deferred_req
returnValue((msg, response))
def test_inbound_resume_close(self):
args = "/?ussdSessionId=123&msisdn=555&provider=web&request=1"
url = "%s%s?%s" % (
self.transport_url,
self.config['web_path'],
urlencode({
'ussdSessionId': 123,
'msisdn': 555,
'provider': 'web',
'request': 1,
})
)
d = http_request(url, '', method='GET')
msg, = yield self.wait_for_dispatched_messages(1)
payload = msg.payload
self.assertEqual(payload['transport_name'], self.transport_name)
self.assertEqual(payload['transport_type'], "ussd")
self.assertEqual(payload['transport_metadata'],
{"session_id": "123"})
self.assertEqual(payload['session_event'],
TransportUserMessage.SESSION_RESUME)
self.assertEqual(payload['from_addr'], '555')
self.assertEqual(payload['to_addr'], '')
self.assertEqual(payload['content'], '1')
tum = TransportUserMessage(**payload)
rep = tum.reply("OK", False)
self.dispatch(rep)
response = yield d
correct_response = '<request>\n\t<headertext>OK' + \
'</headertext>\n</request>'
self.assertEqual(response, correct_response)
def test_inbound_resume_continue(self):
url = "%s%s?%s" % (
self.transport_url,
self.config['web_path'],
urlencode({
'ussdSessionId': 123,
'msisdn': 555,
'provider': 'web',
'request': 1,
})
)
d = http_request(url, '', method='GET')
msg, = yield self.wait_for_dispatched_messages(1)
payload = msg.payload
self.assertEqual(payload['transport_name'], self.transport_name)
self.assertEqual(payload['transport_type'], "ussd")
self.assertEqual(payload['transport_metadata'],
{"session_id": "123"})
self.assertEqual(payload['session_event'],
TransportUserMessage.SESSION_RESUME)
self.assertEqual(payload['from_addr'], '555')
self.assertEqual(payload['to_addr'], '')
self.assertEqual(payload['content'], '1')
tum = TransportUserMessage(**payload)
rep = tum.reply("OK")
self.dispatch(rep)
response = yield d
correct_response = '<request>\n\t<headertext>OK</headertext>\n\t' \
'<options>\n\t\t<option command="1" order="1" ' \
'callback="http://localhost/foo" display="False" >' \
'</option>\n\t</options>\n</request>'
self.assertEqual(response, correct_response)
def make_request(self,
session_type,
session_id,
reply=None,
continue_session=True,
expect_msg=True,
defer_response=False,
**kw):
url_suffix = "session/%s/%s" % (session_id, session_type)
method = self.SESSION_HTTP_METHOD.get(session_type, "POST")
request_data = self.DEFAULT_SESSION_DATA[session_type].copy()
request_data.update(kw)
deferred_req = http_request(self.worker_url + url_suffix,
json.dumps(request_data),
method=method)
if not expect_msg:
msg = None
else:
[msg] = yield self.broker.wait_messages("vumi",
"test_infobip.inbound", 1)
self.broker.clear_messages("vumi", "test_infobip.inbound")
msg = TransportUserMessage(**msg.payload)
if reply is not None:
reply_msg = msg.reply(reply, continue_session=continue_session)
self.broker.publish_message("vumi", "test_infobip.outbound",
reply_msg)
if defer_response:
response = deferred_req
else:
response = yield deferred_req
returnValue((msg, response))
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_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_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_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_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_inbound(self):
d = http_request(self.worker_url + "foo", '', method='GET')
msg, = yield self.broker.wait_messages("vumi",
"test_ok_transport.inbound", 1)
payload = msg.payload
tum = TransportUserMessage(**payload)
rep = tum.reply("OK")
self.broker.publish_message("vumi", "test_ok_transport.outbound",
rep)
response = yield d
self.assertEqual(response, 'OK')
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 consume_user_message(self, msg):
regex_KEYWORD = re.compile('KEYWORD')
log.debug("Consumer user message %s" % (msg,))
if msg['timestamp']:
timestamp = time_to_vusion_format(msg['timestamp'])
self.unmatchable_reply_collection.save(
{'participant-phone': msg['from_addr'],
'to': msg['to_addr'],
'message-content': msg['content'],
'timestamp': timestamp,
})
code = self.shortcodes_collection.find_one({
'shortcode': msg['to_addr']})
if code is None:
return
template = self.templates_collection.find_one({
'_id': ObjectId(code['error-template'])})
if template is None:
return
error_message = TransportUserMessage(**{
'from_addr': msg['to_addr'],
'to_addr': msg['from_addr'],
'transport_name': msg['transport_name'],
'transport_type': msg['transport_type'],
'transport_metadata': msg['transport_metadata'],
'content': re.sub(
regex_KEYWORD, get_first_word(msg['content']),
template['template']
)
})
yield self.transport_publisher.publish_message(error_message)
log.debug("Reply '%s' sent to %s" %
(error_message['content'], error_message['to_addr']))
def test_sending_messages(self):
yield self.get_configured_transport()
msg = self.tx_helper.make_outbound(
"outbound", session_event=TransportUserMessage.SESSION_CLOSE)
d = self.tx_helper.dispatch_outbound(msg)
req = yield self.get_next_request()
received_msg = json.loads(req.content.read())
self.assertEqual(received_msg, {
'content': msg['content'],
'in_reply_to': None,
'to_addr': msg['to_addr'],
'message_id': msg['message_id'],
'session_event': TransportUserMessage.SESSION_CLOSE,
'helper_metadata': {},
})
remote_id = TransportUserMessage.generate_id()
reply = msg.copy()
reply['message_id'] = remote_id
req.write(reply.to_json().encode('utf-8'))
req.finish()
yield d
[ack] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(ack['user_message_id'], msg['message_id'])
self.assertEqual(ack['sent_message_id'], remote_id)
def test_outbound_non_reply_logs_error(self):
msg = TransportUserMessage(to_addr="1234",
from_addr="5678",
transport_name="test_infobip",
transport_type="ussd",
transport_metadata={})
with LogCatcher() as logger:
self.broker.publish_message("vumi", "test_infobip.outbound", msg)
yield self.broker.kick_delivery()
[error, logged_failure] = logger.errors
expected_error = ("Infobip transport cannot process outbound message"
" that is not a reply.")
twisted_failure = logged_failure['failure']
self.assertEqual(self.flushLoggedErrors(PermanentFailure),
[twisted_failure])
failure = twisted_failure.value
self.assertEqual(failure.failure_code, FailureMessage.FC_PERMANENT)
self.assertEqual(str(failure), expected_error)
[errmsg] = error['message']
expected_logged_error = "'" + expected_error.replace('.', ':')
self.assertTrue(errmsg.startswith(expected_logged_error))
[msg] = yield self.broker.wait_messages("vumi",
"test_infobip.failures", 1)
self.assertEqual(msg['failure_code'], "permanent")
last_line = msg['reason'].splitlines()[-1].strip()
self.assertTrue(last_line.endswith(expected_error))
def mk_inbound_push_trigger(to_addr, conversation):
"""
Construct a dummy inbound message used to trigger a push of
a new message from a sandbox application.
"""
msg_options = {
'transport_name': None,
'transport_type': None,
'helper_metadata': {},
# mark this message as special so that it can be idenitified
# if it accidentally ends up elsewhere.
INBOUND_PUSH_TRIGGER: True,
}
conversation.set_go_helper_metadata(msg_options['helper_metadata'])
# We reverse the to_addr & from_addr since we're faking input
# from the client to start the survey.
# This generates a fake message id that is then used in the
# in_reply_to field of the outbound message. We filter these
# replies out and convert them into sends in the outbound
# resource below
msg = TransportUserMessage(from_addr=to_addr,
to_addr=None,
content=None,
**msg_options)
return msg
def assertDelivered(self, message):
delivered_messages = [
TransportUserMessage(**to_kwargs(payload))
for _, payload in self._delivery_history
]
self.assertIn(message['message_id'],
[msg['message_id'] for msg in delivered_messages])
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 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 mkmsg_out(self,
content='hello world',
session_event=TransportUserMessage.SESSION_NONE,
message_id='1',
to_addr='+41791234567',
from_addr='9292',
group=None,
in_reply_to=None,
transport_type=None,
transport_metadata=None,
helper_metadata=None,
transport_name=None):
if transport_type is None:
transport_type = transport_type
if transport_metadata is None:
transport_metadata = {}
if helper_metadata is None:
helper_metadata = {}
params = dict(
to_addr=to_addr,
from_addr=from_addr,
group=group,
message_id=message_id,
transport_name=transport_name,
transport_type=transport_type,
transport_metadata=transport_metadata,
content=content,
session_event=session_event,
in_reply_to=in_reply_to,
helper_metadata=helper_metadata,
)
return TransportUserMessage(**params)
def process_line(self, line):
data = {
'transport_name': self.transport_name,
'transport_metadata': {},
}
data.update(json.loads(line))
self.publisher.publish_message(TransportUserMessage(**to_kwargs(data)))
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 mkmsg_in(self,
content='hello world',
from_addr='+41791234567',
to_addr='9292',
session_event=TransportUserMessage.SESSION_NONE,
message_id='abc',
transport_type=None,
transport_metadata=None,
transport_name=None,
timestamp=None):
if timestamp is None:
timestamp = datetime.now()
if transport_type is None:
transport_type = transport_type
if transport_metadata is None:
transport_metadata = {}
return TransportUserMessage(
from_addr=from_addr,
to_addr=to_addr,
group=None,
message_id=message_id,
transport_name=transport_name,
transport_type=transport_type,
transport_metadata=transport_metadata,
content=content,
session_event=session_event,
timestamp=timestamp,
)
def load_vumi_message(self, channel_id, message_id):
'''Retrieves the stored vumi message, given its unique id'''
key = self.get_key(channel_id, message_id)
msg_json = yield self.load_property(key, 'message')
if msg_json is None:
returnValue(None)
returnValue(TransportUserMessage.from_json(msg_json))
def test_send_reply_message_with_event_auth_token(self):
'''Sending a message with a specified event auth token should store the
token for sending events in the future'''
channel = yield self.create_channel(self.service,
self.redis,
id='channel-id')
in_msg = TransportUserMessage(from_addr='+2789',
to_addr='+1234',
transport_name='channel-id',
transport_type='_',
transport_metadata={'foo': 'bar'})
yield self.api.inbounds.store_vumi_message('channel-id', in_msg)
msg = yield channel.send_reply_message(
self.message_sender, self.outbounds, self.inbounds, {
'reply_to': in_msg['message_id'],
'content': 'testcontent',
'event_url': 'http://test.org',
'event_auth_token': "the-auth-token",
})
event_auth_token = yield self.outbounds.load_event_auth_token(
'channel-id', msg['message_id'])
self.assertEqual(event_auth_token, "the-auth-token")
def mkmsg_in(self,
content='hello world',
message_id='abc',
to_addr='9292',
from_addr='+41791234567',
group=None,
session_event=None,
transport_type=None,
helper_metadata=None,
transport_metadata=None):
if transport_type is None:
transport_type = self.transport_type
if helper_metadata is None:
helper_metadata = {}
if transport_metadata is None:
transport_metadata = {}
return TransportUserMessage(
from_addr=from_addr,
to_addr=to_addr,
group=group,
message_id=message_id,
transport_name=self.transport_name,
transport_type=transport_type,
transport_metadata=transport_metadata,
helper_metadata=helper_metadata,
content=content,
session_event=session_event,
timestamp=datetime.now(),
)
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 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 mk_msg(self, to_addr, tag=None, from_addr="12345"):
msg = TransportUserMessage(to_addr=to_addr, from_addr=from_addr,
transport_name="dummy_connector",
transport_type="dummy_transport_type")
if tag is not None:
TaggingMiddleware.add_tag_to_msg(msg, tag)
return msg
def load_vumi_message(self, channel_id, message_id):
'''Retrieves the stored vumi message, given its unique id'''
key = self.get_key(channel_id, message_id)
msg_json = yield self.load_property(key, 'message')
if msg_json is None:
returnValue(None)
returnValue(TransportUserMessage.from_json(msg_json))
def cb(request):
self.assertEqual(request.getUser(), 'username')
self.assertEqual(request.getPassword(), 'password')
msg = TransportUserMessage.from_json(request.content.read())
self.assertEqual(msg['message_id'], 'abc')
self.assertEqual(msg['content'], 'hello world')
self.assertEqual(msg['from_addr'], '+41791234567')
return 'OK'
def cb(request):
self.assertEqual(request.getUser(), "username")
self.assertEqual(request.getPassword(), "password")
msg = TransportUserMessage.from_json(request.content.read())
self.assertEqual(msg["message_id"], "abc")
self.assertEqual(msg["content"], "hello world")
self.assertEqual(msg["from_addr"], "+41791234567")
return "OK"
def cb(request):
self.assertEqual(request.getUser(), 'username')
self.assertEqual(request.getPassword(), 'password')
msg = TransportUserMessage.from_json(request.content.read())
self.assertEqual(msg['message_id'], 'abc')
self.assertEqual(msg['content'], 'hello world')
self.assertEqual(msg['from_addr'], '+41791234567')
return 'OK'
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_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 mkmsg(content):
return TransportUserMessage(
from_addr='from',
to_addr='to',
transport_name='sphex',
transport_type='test',
transport_metadata={},
content=content,
)
def make_batch(self, batch_no, num_msgs):
return [
TransportUserMessage(to_addr="1234",
from_addr="5678",
transport_name="bench",
transport_type="sms",
content="Batch: %d. Msg: %d" % (batch_no, i))
for i in range(num_msgs)
]
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_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_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_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_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 assertJSONResultEqual(self, json_blob, messages):
"""
Asserts that the JSON response we're getting back is the same as
the list of messages provided.
There are easier ways to do this by comparing bigger JSON blogs
but then debugging the huge strings would be a pain.
"""
dictionaries = json.loads(json_blob)
self.assertEqual(len(dictionaries), len(messages),
'Unequal amount of dictionaries and messages')
for dictionary, message in zip(dictionaries, messages):
# The json dumping & reloading happening here is required to have
# the timestamp fields be parsed properly. This is an unfortunate
# side effect of how how timestamps are currently stored as
# datetime() instances in the payload instead of plain strings.
self.assertEqual(
TransportUserMessage(_process_fields=False, **message.payload),
TransportUserMessage.from_json(json.dumps(dictionary)))
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 handle_raw_inbound_message(self, request):
try:
data = json.loads(request.content.read())
msg = TransportUserMessage(_process_fields=True, **to_kwargs(data))
yield self.handle_inbound_message(msg)
request.finish()
except Exception as e:
log.err(e)
request.setResponseCode(400)
request.finish()
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_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 test_transport_user_message_reply_no_group(self):
msg = TransportUserMessage(
to_addr='123',
from_addr='456',
transport_name='sphex',
transport_type='sms',
transport_metadata={'foo': 'bar'},
helper_metadata={'otherfoo': 'otherbar'},
)
reply = msg.reply(content='Hi!')
self.assertEqual(reply['from_addr'], '123')
self.assertEqual(reply['to_addr'], '456')
self.assertEqual(reply['group'], None)
self.assertEqual(reply['session_event'], reply.SESSION_NONE)
self.assertEqual(reply['in_reply_to'], msg['message_id'])
self.assertEqual(reply['transport_name'], msg['transport_name'])
self.assertEqual(reply['transport_type'], msg['transport_type'])
self.assertEqual(reply['transport_metadata'],
msg['transport_metadata'])
self.assertEqual(reply['helper_metadata'], msg['helper_metadata'])
