def test_deliver_sm_message_payload(self):
"""A message in the `message_payload` field should be delivered."""
esme = yield self.get_esme(
deliver_sm=self.assertion_cb(u'hello', 'short_message'))
sm = DeliverSM(1, short_message='')
sm.add_message_payload(''.join('%02x' % ord(c) for c in 'hello'))
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def send_out_of_order_multipart(self, smsc, to_addr, from_addr):
destination_addr = to_addr
source_addr = from_addr
sequence_number = 1
short_message1 = "\x05\x00\x03\xff\x03\x01back"
pdu1 = DeliverSM(sequence_number,
short_message=short_message1,
destination_addr=destination_addr,
source_addr=source_addr)
sequence_number = 2
short_message2 = "\x05\x00\x03\xff\x03\x02 at"
pdu2 = DeliverSM(sequence_number,
short_message=short_message2,
destination_addr=destination_addr,
source_addr=source_addr)
sequence_number = 3
short_message3 = "\x05\x00\x03\xff\x03\x03 you"
pdu3 = DeliverSM(sequence_number,
short_message=short_message3,
destination_addr=destination_addr,
source_addr=source_addr)
smsc.send_pdu(pdu2)
smsc.send_pdu(pdu3)
smsc.send_pdu(pdu1)
def test_mo_bad_encoding(self):
smpp_helper = yield self.get_smpp_helper()
bad_pdu = DeliverSM(555,
short_message="SMS from server containing \xa7",
destination_addr="2772222222",
source_addr="2772000000",
data_coding=1)
good_pdu = DeliverSM(555,
short_message="Next message",
destination_addr="2772222222",
source_addr="2772000000",
data_coding=1)
yield smpp_helper.handle_pdu(bad_pdu)
yield smpp_helper.handle_pdu(good_pdu)
[msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(msg['message_type'], 'user_message')
self.assertEqual(msg['transport_name'], self.tx_helper.transport_name)
self.assertEqual(msg['content'], "Next message")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
[failure] = self.flushLoggedErrors(UnicodeDecodeError)
message = failure.getErrorMessage()
codec, rest = message.split(' ', 1)
self.assertEqual(codec, "'ascii'")
self.assertTrue(
rest.startswith("codec can't decode byte 0xa7 in position 27"))
def test_submit_and_deliver_ussd_new_custom_ussd_code_field(self):
session = SessionInfo()
yield self.get_transport(deliver_config={
'ussd_code_pdu_field': 'destination_addr',
})
# Server delivers a USSD message to the Client
pdu = DeliverSM(1, short_message="*IGNORE#", destination_addr="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield self.fake_smsc.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], None)
self.assertEqual(mess['to_addr'], '*123#')
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_NEW)
self.assertEqual(
mess['transport_metadata'],
{
'session_info': {
'session_identifier': session.sixdee_id,
'ussd_service_op': '01',
}
})
def test_submit_and_deliver_ussd_close(self):
smpp_helper = yield self.get_smpp_helper()
yield self.tx_helper.make_dispatch_outbound(
"hello world", transport_type="ussd",
session_event=TransportUserMessage.SESSION_CLOSE)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
self.assertEqual(command_id(submit_sm_pdu), 'submit_sm')
self.assertEqual(pdu_tlv(submit_sm_pdu, 'ussd_service_op'), '02')
self.assertEqual(pdu_tlv(submit_sm_pdu, 'its_session_info'), '0001')
# Server delivers a USSD message to the Client
pdu = DeliverSM(seq_no(submit_sm_pdu) + 1, short_message="reply!")
pdu.add_optional_parameter('ussd_service_op', '02')
pdu.add_optional_parameter('its_session_info', '0001')
yield smpp_helper.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], "reply!")
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_CLOSE)
def test_deliver_sm_message_payload(self):
"""A message in the `message_payload` field should be delivered."""
esme = yield self.get_esme(
deliver_sm=self.assertion_cb(u'hello', 'short_message'))
sm = DeliverSM(1, short_message='')
sm.add_message_payload(''.join('%02x' % ord(c) for c in 'hello'))
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def test_submit_and_deliver_ussd_continue(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
yield self.clear_link_pdus()
# Next the Client submits a USSD message to the Server
# and recieves an ack
msg = yield self.tx_helper.make_dispatch_outbound(
"hello world", transport_type="ussd")
# First we make sure the Client binds to the Server
# and enquire_link pdu's are exchanged as expected
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
self.assert_server_pdu(
mk_expected_pdu('inbound', 3, 'submit_sm'), submit_sm_pdu)
pdu_opts = unpacked_pdu_opts(submit_sm_pdu['pdu'])
self.assertEqual('02', pdu_opts['ussd_service_op'])
self.assertEqual('0000', pdu_opts['its_session_info'])
# We need the user_message_id to check the ack
user_message_id = msg.payload["message_id"]
[ack, delv] = yield self.tx_helper.wait_for_dispatched_events(2)
self.assertEqual(ack['message_type'], 'event')
self.assertEqual(ack['event_type'], 'ack')
self.assertEqual(ack['transport_name'], self.tx_helper.transport_name)
self.assertEqual(ack['user_message_id'], user_message_id)
self.assertEqual(delv['message_type'], 'event')
self.assertEqual(delv['event_type'], 'delivery_report')
self.assertEqual(delv['transport_name'], self.tx_helper.transport_name)
self.assertEqual(delv['user_message_id'], user_message_id)
self.assertEqual(delv['delivery_status'],
self.expected_delivery_status)
# Finally the Server delivers a USSD message to the Client
pdu = DeliverSM(555,
short_message="reply!",
destination_addr="2772222222",
source_addr="2772000000")
pdu._PDU__add_optional_parameter('ussd_service_op', '02')
pdu._PDU__add_optional_parameter('its_session_info', '0000')
self.service.factory.smsc.send_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "reply!")
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_RESUME)
self.assertEqual([], self.tx_helper.get_dispatched_failures())
def test_submit_and_deliver_ussd_new(self):
session_identifier = 12345
smpp_helper = yield self.get_smpp_helper()
# Server delivers a USSD message to the Client
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('user_message_reference',
session_identifier)
yield smpp_helper.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], None)
self.assertEqual(mess['to_addr'], '*123#')
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_NEW)
self.assertEqual(
mess['transport_metadata'],
{
'session_info': {
'session_identifier': 12345
}
})
def test_deliver_bad_encoding(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# The Server delivers a SMS to the Client
bad_pdu = DeliverSM(555,
short_message="SMS from server containing \xa7",
destination_addr="2772222222",
source_addr="2772000000")
good_pdu = DeliverSM(555,
short_message="Next message",
destination_addr="2772222222",
source_addr="2772000000")
self.service.factory.smsc.send_pdu(bad_pdu)
self.service.factory.smsc.send_pdu(good_pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "Next message")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
[failure] = self.flushLoggedErrors(UnicodeDecodeError)
message = failure.getErrorMessage()
codec, rest = message.split(' ', 1)
self.assertTrue(codec in ("'utf8'", "'utf-8'"))
self.assertTrue(
rest.startswith("codec can't decode byte 0xa7 in position 27"))
def test_deliver_sm_op_codes_new(self):
session_identifier = 12345
yield self.get_transport()
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter("ussd_service_op", "01")
pdu.add_optional_parameter("user_message_reference", session_identifier)
yield self.fake_smsc.handle_pdu(pdu)
[start] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(start["session_event"], TransportUserMessage.SESSION_NEW)
def test_deliver_sm_op_codes_new(self):
session = SessionInfo()
yield self.get_transport()
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield self.fake_smsc.handle_pdu(pdu)
[start] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(start['session_event'],
TransportUserMessage.SESSION_NEW)
def test_deliver_sm(self):
calls = []
self.patch(EsmeTransceiver, 'handle_deliver_sm',
lambda p, pdu: succeed(calls.append(pdu)))
transport, protocol = yield self.setup_bind()
pdu = DeliverSM(
sequence_number=0, message_id='foo', short_message='bar')
protocol.dataReceived(pdu.get_bin())
[deliver_sm] = calls
self.assertCommand(deliver_sm, 'deliver_sm', sequence_number=0)
def test_deliver_sm_fail(self):
transport, protocol = yield self.setup_bind()
pdu = DeliverSM(
sequence_number=0, message_id='foo', data_coding=4,
short_message='string with unknown data coding')
protocol.dataReceived(pdu.get_bin())
[deliver_sm_resp] = yield wait_for_pdus(transport, 1)
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RDELIVERYFAILURE')
def test_delivery_report_for_unknown_message(self):
dr = ("id:123 sub:... dlvrd:... submit date:200101010030"
" done date:200101020030 stat:DELIVRD err:... text:Meep")
deliver = DeliverSM(1, short_message=dr)
with LogCatcher(message="Failed to retrieve message id") as lc:
yield self.esme.handle_data(deliver.get_bin())
[warning] = lc.logs
self.assertEqual(warning['message'],
("Failed to retrieve message id for delivery "
"report. Delivery report from %s "
"discarded." % self.tx_helper.transport_name, ))
def test_delivery_report_for_unknown_message(self):
dr = ("id:123 sub:... dlvrd:... submit date:200101010030"
" done date:200101020030 stat:DELIVRD err:... text:Meep")
deliver = DeliverSM(1, short_message=dr)
with LogCatcher(message="Failed to retrieve message id") as lc:
yield self.esme.handle_data(deliver.get_bin())
[warning] = lc.logs
self.assertEqual(warning['message'],
("Failed to retrieve message id for delivery "
"report. Delivery report from %s "
"discarded." % self.tx_helper.transport_name,))
def test_deliver_sm_fail(self):
self.patch(DeliverShortMessageProcessor, 'decode_pdus',
lambda *a: [str('not a unicode string')])
transport, protocol = yield self.setup_bind()
pdu = DeliverSM(
sequence_number=0, message_id='foo', short_message='bar')
protocol.dataReceived(pdu.get_bin())
[deliver_sm_resp] = yield wait_for_pdus(transport, 1)
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RDELIVERYFAILURE')
def test_deliver_sm_op_codes_new(self):
session_identifier = 12345
smpp_helper = yield self.get_smpp_helper()
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('user_message_reference',
session_identifier)
yield smpp_helper.handle_pdu(pdu)
[start] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(start['session_event'],
TransportUserMessage.SESSION_NEW)
def test_deliver_sm_fail_with_custom_error(self):
transport, protocol = yield self.setup_bind(config={
"deliver_sm_decoding_error": "ESME_RSYSERR"
})
pdu = DeliverSM(
sequence_number=0, message_id='foo', data_coding=4,
short_message='string with unknown data coding')
protocol.dataReceived(pdu.get_bin())
[deliver_sm_resp] = yield wait_for_pdus(transport, 1)
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RSYSERR')
def test_deliver_sm_delivery_report_regex_fallback_ucs2_long(self):
esme = yield self.get_esme(delivery_report=self.assertion_cb({
'message_id': '1b1720be-5f48-41c4-b3f8-6e59dbf45366',
'message_state': 'DELIVRD',
}))
dr_text = (
u'id:1b1720be-5f48-41c4-b3f8-6e59dbf45366 sub:001 dlvrd:001 '
u'submit date:120726132548 done date:120726132548 stat:DELIVRD '
u'err:000 text:').encode('utf-16be')
sm = DeliverSM(1, short_message='', data_coding=8)
sm.add_message_payload(dr_text.encode('hex'))
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def test_deliver_sm_fail_with_custom_error(self):
self.patch(DeliverShortMessageProcessor, 'decode_pdus',
lambda *a: [str('not a unicode string')])
transport, protocol = yield self.setup_bind(config={
"deliver_sm_decoding_error": "ESME_RSYSERR"
})
pdu = DeliverSM(
sequence_number=0, message_id='foo', short_message='bar')
protocol.dataReceived(pdu.get_bin())
[deliver_sm_resp] = yield wait_for_pdus(transport, 1)
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RSYSERR')
def test_mo_sms_multipart_long(self):
smpp_helper = yield self.get_smpp_helper()
content = '1' * 255
pdu = DeliverSM(sequence_number=1)
pdu.add_optional_parameter('message_payload', content.encode('hex'))
smpp_helper.send_pdu(pdu)
[deliver_sm_resp] = yield smpp_helper.wait_for_pdus(1)
self.assertEqual(1, seq_no(deliver_sm_resp))
self.assertTrue(pdu_ok(deliver_sm_resp))
[msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(msg['content'], content)
def test_mo_sms_multipart_long(self):
smpp_helper = yield self.get_smpp_helper()
content = '1' * 255
pdu = DeliverSM(sequence_number=1)
pdu.add_optional_parameter('message_payload', content.encode('hex'))
smpp_helper.send_pdu(pdu)
[deliver_sm_resp] = yield smpp_helper.wait_for_pdus(1)
self.assertEqual(1, seq_no(deliver_sm_resp))
self.assertTrue(pdu_ok(deliver_sm_resp))
[msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(msg['content'], content)
def test_mo_delivery_report_pdu(self):
smpp_helper = yield self.get_smpp_helper()
transport = smpp_helper.transport
yield transport.message_stash.set_remote_message_id('bar', 'foo')
pdu = DeliverSM(sequence_number=1)
pdu.add_optional_parameter('receipted_message_id', 'foo')
pdu.add_optional_parameter('message_state', 2)
yield smpp_helper.handle_pdu(pdu)
[event] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(event['event_type'], 'delivery_report')
self.assertEqual(event['delivery_status'], 'delivered')
self.assertEqual(event['user_message_id'], 'bar')
def test_deliver_sm_delivery_report_regex_fallback_ucs2_long(self):
esme = yield self.get_esme(
delivery_report=self.assertion_cb({
'message_id': '1b1720be-5f48-41c4-b3f8-6e59dbf45366',
'message_state': 'DELIVRD',
}))
dr_text = (
u'id:1b1720be-5f48-41c4-b3f8-6e59dbf45366 sub:001 dlvrd:001 '
u'submit date:120726132548 done date:120726132548 stat:DELIVRD '
u'err:000 text:').encode('utf-16be')
sm = DeliverSM(1, short_message='', data_coding=8)
sm.add_message_payload(dr_text.encode('hex'))
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def test_ordering(self):
"""
Out of order pieces must be re-assembled in-order
"""
sar_1 = DeliverSM(
1,
short_message='\x00\x03\xff\x04\x01There she was just a')
sar_2 = DeliverSM(
1,
short_message='\x00\x03\xff\x04\x02 walking down the street,')
sar_3 = DeliverSM(
1,
short_message='\x00\x03\xff\x04\x03 singing doo wa diddy')
sar_4 = DeliverSM(
1,
short_message='\x00\x03\xff\x04\x04 diddy dum diddy do')
multi = MultipartMessage()
multi.add_pdu(sar_3.get_obj())
multi.add_pdu(sar_4.get_obj())
multi.add_pdu(sar_2.get_obj())
multi.add_pdu(sar_1.get_obj())
self.assertEquals(multi.get_completed()['message'], (
'There she was just a walking down the street, '
'singing doo wa diddy diddy dum diddy do'))
def delivery_report(self, message_id):
sequence_number = 1
short_message = (self.delivery_report_string % (
message_id, datetime.now().strftime("%y%m%d%H%M%S"),
datetime.now().strftime("%y%m%d%H%M%S")))
pdu = DeliverSM(sequence_number, short_message=short_message)
self.send_pdu(pdu)
def test_deliver_sm_op_codes_end(self):
session = SessionInfo()
transport = yield self.get_transport()
deliver_sm_processor = transport.deliver_sm_processor
session_manager = deliver_sm_processor.session_manager
yield session_manager.create_session(
session.vumi_id, ussd_code='*123#')
pdu = DeliverSM(1, short_message="", source_addr=session.addr)
pdu.add_optional_parameter('ussd_service_op', '81')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield self.fake_smsc.handle_pdu(pdu)
[end] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(end['session_event'],
TransportUserMessage.SESSION_CLOSE)
def test_partial_pdu_data_received(self):
protocol = yield self.get_protocol()
calls = []
protocol.handle_deliver_sm = calls.append
yield self.fake_smsc.bind()
deliver_sm = DeliverSM(1, short_message='foo')
pdu = deliver_sm.get_bin()
half = len(pdu) / 2
pdu_part1, pdu_part2 = pdu[:half], pdu[half:]
yield self.fake_smsc.send_bytes(pdu_part1)
self.assertEqual([], calls)
yield self.fake_smsc.send_bytes(pdu_part2)
[handled_pdu] = calls
self.assertEqual(command_id(handled_pdu), 'deliver_sm')
self.assertEqual(seq_no(handled_pdu), 1)
self.assertEqual(short_message(handled_pdu), 'foo')
def test_partial_pdu_data_received(self):
calls = []
self.patch(EsmeTransceiver, 'handle_deliver_sm',
lambda p, pdu: calls.append(pdu))
transport, protocol = yield self.setup_bind()
deliver_sm = DeliverSM(sequence_number=1, short_message='foo')
pdu = deliver_sm.get_bin()
half = len(pdu) / 2
pdu_part1, pdu_part2 = pdu[:half], pdu[half:]
protocol.dataReceived(pdu_part1)
self.assertEqual([], calls)
protocol.dataReceived(pdu_part2)
[handled_pdu] = calls
self.assertEqual(command_id(handled_pdu), 'deliver_sm')
self.assertEqual(seq_no(handled_pdu), 1)
self.assertEqual(short_message(handled_pdu), 'foo')
def test_deliver_sm_op_codes_resume(self):
session = SessionInfo()
smpp_helper = yield self.get_smpp_helper()
deliver_sm_processor = smpp_helper.transport.deliver_sm_processor
session_manager = deliver_sm_processor.session_manager
yield session_manager.create_session(
session.vumi_id, ussd_code='*123#')
pdu = DeliverSM(1, short_message="", source_addr=session.addr)
pdu.add_optional_parameter('ussd_service_op', '12')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield smpp_helper.handle_pdu(pdu)
[resume] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(resume['session_event'],
TransportUserMessage.SESSION_RESUME)
def test_deliver_sm_op_codes_end(self):
source_addr = "msisdn"
session_identifier = 12345
vumi_session_identifier = make_vumi_session_identifier(source_addr, session_identifier)
transport = yield self.get_transport()
deliver_sm_processor = transport.deliver_sm_processor
session_manager = deliver_sm_processor.session_manager
yield session_manager.create_session(vumi_session_identifier, ussd_code="*123#")
pdu = DeliverSM(1, short_message="", source_addr=source_addr)
pdu.add_optional_parameter("ussd_service_op", "81")
pdu.add_optional_parameter("user_message_reference", session_identifier)
yield self.fake_smsc.handle_pdu(pdu)
[end] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(end["session_event"], TransportUserMessage.SESSION_CLOSE)
def test_formats(self):
"""
Testing TLV vs SAR vs CSM vs CSM16
"""
tlv = DeliverSM(1, short_message='the first message part')
tlv.set_sar_msg_ref_num(65017)
tlv.set_sar_total_segments(2)
tlv.set_sar_segment_seqnum(1)
sar = DeliverSM(
1,
short_message='\x00\x03\xff\x02\x01the first message part')
csm = DeliverSM(
1,
short_message='\x05\x00\x03\xff\x02\x01the first message part')
csm16 = DeliverSM(
1,
short_message='\x06\x00\x04\xff\xff\x02\x01the first message part')
DeliverSM(
1,
short_message='whatever')
none_short_message = DeliverSM(
1,
short_message=None)
def get_multipart(m):
return detect_multipart(unpack_pdu(m.get_bin()))
def get_multipart_type(m):
return get_multipart(m)['multipart_type']
self.assertEquals(get_multipart_type(tlv), 'TLV')
self.assertEquals(get_multipart_type(sar), 'SAR')
self.assertEquals(get_multipart_type(csm), 'CSM')
self.assertEquals(get_multipart_type(csm16), 'CSM16')
self.assertEquals(get_multipart(none_short_message), None)
def test_deliver_sm_unknown_op_code(self):
session = SessionInfo()
smpp_helper = yield self.get_smpp_helper()
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield smpp_helper.handle_pdu(pdu)
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '99')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield smpp_helper.handle_pdu(pdu)
[start, unknown] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(unknown['session_event'],
TransportUserMessage.SESSION_RESUME)
def test_deliver_sm(self):
calls = []
protocol = yield self.get_protocol()
protocol.handle_deliver_sm = lambda pdu: succeed(calls.append(pdu))
yield self.fake_smsc.bind()
yield self.fake_smsc.send_pdu(
DeliverSM(0, message_id='foo', short_message='bar'))
[deliver_sm] = calls
self.assertCommand(deliver_sm, 'deliver_sm', sequence_number=0)
def send_mo(self, sequence_number, short_message, data_coding=1, **kwargs):
"""
Send a DeliverSM PDU.
"""
return self.send_pdu(
DeliverSM(sequence_number,
short_message=short_message,
data_coding=data_coding,
**kwargs))
def test_send_pdu(self):
"""
A PDU can be sent to the client over the wire.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
self.assertEqual(client.pdus_handled, [])
pdu = DeliverSM(0)
send_d = fake_smsc.send_pdu(pdu)
# PDU sent, not yet received.
self.assertNoResult(send_d)
self.assertNotEqual(client.received, pdu.get_bin())
yield send_d
# PDU received.
self.assertEqual(client.received, pdu.get_bin())
self.assertEqual(client.pdus_handled, [])
def test_submit_and_deliver_ussd_continue(self):
user_msisdn = 'msisdn'
session_identifier = 12345
vumi_session_identifier = make_vumi_session_identifier(
user_msisdn, session_identifier)
smpp_helper = yield self.get_smpp_helper()
deliver_sm_processor = smpp_helper.transport.deliver_sm_processor
session_manager = deliver_sm_processor.session_manager
yield session_manager.create_session(
vumi_session_identifier, ussd_code='*123#')
yield self.tx_helper.make_dispatch_outbound(
"hello world", transport_type="ussd", transport_metadata={
'session_info': {
'session_identifier': session_identifier
}
}, to_addr=user_msisdn)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
self.assertEqual(command_id(submit_sm_pdu), 'submit_sm')
self.assertEqual(pdu_tlv(submit_sm_pdu, 'ussd_service_op'), '02')
self.assertEqual(
pdu_tlv(submit_sm_pdu, 'user_message_reference'),
session_identifier)
# Server delivers a USSD message to the Client
pdu = DeliverSM(seq_no(submit_sm_pdu) + 1, short_message="reply!",
source_addr=user_msisdn)
# 0x12 is 'continue'
pdu.add_optional_parameter('ussd_service_op', '12')
pdu.add_optional_parameter('user_message_reference',
session_identifier)
yield smpp_helper.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], "reply!")
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['to_addr'], '*123#')
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_RESUME)
def test_send_pdu(self):
"""
A PDU can be sent to the client over the wire.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
self.assertEqual(client.pdus_handled, [])
pdu = DeliverSM(0)
send_d = fake_smsc.send_pdu(pdu)
# PDU sent, not yet received.
self.assertNoResult(send_d)
self.assertNotEqual(client.received, pdu.get_bin())
yield send_d
# PDU received.
self.assertEqual(client.received, pdu.get_bin())
self.assertEqual(client.pdus_handled, [])
def test_deliver_sm_fail(self):
yield self.get_protocol()
yield self.fake_smsc.bind()
yield self.fake_smsc.send_pdu(DeliverSM(
sequence_number=0, message_id='foo', data_coding=4,
short_message='string with unknown data coding'))
deliver_sm_resp = yield self.fake_smsc.await_pdu()
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RDELIVERYFAILURE')
def test_submit_and_deliver(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# Next the Client submits a SMS to the Server
# and recieves an ack and a delivery_report
msg = yield self.tx_helper.make_dispatch_outbound("hello world")
# We need the user_message_id to check the ack
user_message_id = msg["message_id"]
[ack, delv] = yield self.tx_helper.wait_for_dispatched_events(2)
self.assertEqual(ack['message_type'], 'event')
self.assertEqual(ack['event_type'], 'ack')
self.assertEqual(ack['transport_name'], self.tx_helper.transport_name)
self.assertEqual(ack['user_message_id'], user_message_id)
self.assertEqual(delv['message_type'], 'event')
self.assertEqual(delv['event_type'], 'delivery_report')
self.assertEqual(delv['transport_name'], self.tx_helper.transport_name)
self.assertEqual(delv['user_message_id'], user_message_id)
self.assertEqual(delv['delivery_status'],
self.expected_delivery_status)
# Finally the Server delivers a SMS to the Client
pdu = DeliverSM(555,
short_message="SMS from server",
destination_addr="2772222222",
source_addr="2772000000")
self.service.factory.smsc.send_pdu(pdu)
# Have the server fire of an out-of-order multipart sms
self.send_out_of_order_multipart(self.service.factory.smsc,
to_addr="2772222222",
from_addr="2772000000")
[mess, multipart] = yield self.tx_helper.wait_for_dispatched_inbound(2)
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "SMS from server")
# Check the incomming multipart is re-assembled correctly
self.assertEqual(multipart['message_type'], 'user_message')
self.assertEqual(multipart['transport_name'],
self.tx_helper.transport_name)
self.assertEqual(multipart['content'], "back at you")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
def test_delivery_report_for_unknown_message(self):
dr = self.DR_TEMPLATE % ('foo', )
deliver = DeliverSM(1, short_message=dr)
smpp_helper = yield self.get_smpp_helper()
with LogCatcher(message="Failed to retrieve message id") as lc:
yield smpp_helper.handle_pdu(deliver)
[warning] = lc.logs
self.assertEqual(warning['message'],
("Failed to retrieve message id for delivery "
"report. Delivery report from %s "
"discarded." % self.tx_helper.transport_name, ))
def test_submit_and_deliver_ussd_new(self):
session_identifier = 12345
yield self.get_transport()
# Server delivers a USSD message to the Client
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter("ussd_service_op", "01")
pdu.add_optional_parameter("user_message_reference", session_identifier)
yield self.fake_smsc.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess["content"], None)
self.assertEqual(mess["to_addr"], "*123#")
self.assertEqual(mess["transport_type"], "ussd")
self.assertEqual(mess["session_event"], TransportUserMessage.SESSION_NEW)
self.assertEqual(
mess["transport_metadata"], {"session_info": {"session_identifier": 12345, "ussd_service_op": "01"}}
)
def test_respond_to_enquire_link_wrong_pdu(self):
"""
FakeSMSC will raise an exception if asked to respond to an enquire_link
that isn't an enquire_link.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
rtel_d = fake_smsc.respond_to_enquire_link()
yield client.write(DeliverSM(0).get_bin())
self.failureResultOf(rtel_d, ValueError)
def test_deliver_sm_op_codes_end(self):
source_addr = 'msisdn'
session_identifier = 12345
vumi_session_identifier = make_vumi_session_identifier(
source_addr, session_identifier)
smpp_helper = yield self.get_smpp_helper()
deliver_sm_processor = smpp_helper.transport.deliver_sm_processor
session_manager = deliver_sm_processor.session_manager
yield session_manager.create_session(
vumi_session_identifier, ussd_code='*123#')
pdu = DeliverSM(1, short_message="", source_addr=source_addr)
pdu.add_optional_parameter('ussd_service_op', '81')
pdu.add_optional_parameter('user_message_reference',
session_identifier)
yield smpp_helper.handle_pdu(pdu)
[end] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(end['session_event'],
TransportUserMessage.SESSION_CLOSE)
def test_deliver_sm_fail_with_custom_error(self):
yield self.get_protocol({
"deliver_sm_decoding_error": "ESME_RSYSERR"
})
yield self.fake_smsc.bind()
yield self.fake_smsc.send_pdu(DeliverSM(
sequence_number=0, message_id='foo', data_coding=4,
short_message='string with unknown data coding'))
deliver_sm_resp = yield self.fake_smsc.await_pdu()
self.assertCommand(
deliver_sm_resp, 'deliver_sm_resp', sequence_number=0,
status='ESME_RSYSERR')
def test_submit_and_deliver_ussd_new(self):
session = SessionInfo()
yield self.get_transport()
# Server delivers a USSD message to the Client
pdu = DeliverSM(1, short_message="*123#")
pdu.add_optional_parameter('ussd_service_op', '01')
pdu.add_optional_parameter('its_session_info', session.its_info)
yield self.fake_smsc.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], None)
self.assertEqual(mess['to_addr'], '*123#')
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_NEW)
self.assertEqual(
mess['transport_metadata'], {
'session_info': {
'session_identifier': session.sixdee_id,
'ussd_service_op': '01',
}
})
def test_submit_and_deliver_ussd_close(self):
smpp_helper = yield self.get_smpp_helper()
yield self.tx_helper.make_dispatch_outbound(
"hello world",
transport_type="ussd",
session_event=TransportUserMessage.SESSION_CLOSE)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
self.assertEqual(command_id(submit_sm_pdu), 'submit_sm')
self.assertEqual(pdu_tlv(submit_sm_pdu, 'ussd_service_op'), '02')
self.assertEqual(pdu_tlv(submit_sm_pdu, 'its_session_info'), '0001')
# Server delivers a USSD message to the Client
pdu = DeliverSM(seq_no(submit_sm_pdu) + 1, short_message="reply!")
pdu.add_optional_parameter('ussd_service_op', '02')
pdu.add_optional_parameter('its_session_info', '0001')
yield smpp_helper.handle_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['content'], "reply!")
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_CLOSE)
def test_submit_and_deliver_ussd_continue(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
yield self.clear_link_pdus()
# Next the Client submits a USSD message to the Server
# and recieves an ack
msg = yield self.tx_helper.make_dispatch_outbound(
"hello world", transport_type="ussd")
# First we make sure the Client binds to the Server
# and enquire_link pdu's are exchanged as expected
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
self.assert_server_pdu(mk_expected_pdu('inbound', 3, 'submit_sm'),
submit_sm_pdu)
pdu_opts = unpacked_pdu_opts(submit_sm_pdu['pdu'])
self.assertEqual('02', pdu_opts['ussd_service_op'])
self.assertEqual('0000', pdu_opts['its_session_info'])
# We need the user_message_id to check the ack
user_message_id = msg.payload["message_id"]
[ack, delv] = yield self.tx_helper.wait_for_dispatched_events(2)
self.assertEqual(ack['message_type'], 'event')
self.assertEqual(ack['event_type'], 'ack')
self.assertEqual(ack['transport_name'], self.tx_helper.transport_name)
self.assertEqual(ack['user_message_id'], user_message_id)
self.assertEqual(delv['message_type'], 'event')
self.assertEqual(delv['event_type'], 'delivery_report')
self.assertEqual(delv['transport_name'], self.tx_helper.transport_name)
self.assertEqual(delv['user_message_id'], user_message_id)
self.assertEqual(delv['delivery_status'],
self.expected_delivery_status)
# Finally the Server delivers a USSD message to the Client
pdu = DeliverSM(555,
short_message="reply!",
destination_addr="2772222222",
source_addr="2772000000")
pdu._PDU__add_optional_parameter('ussd_service_op', '02')
pdu._PDU__add_optional_parameter('its_session_info', '0000')
self.service.factory.smsc.send_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "reply!")
self.assertEqual(mess['transport_type'], "ussd")
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_RESUME)
self.assertEqual([], self.tx_helper.get_dispatched_failures())
def test_deliver_ussd_start(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# The Server delivers a SMS to the Client
pdu = DeliverSM(
555, destination_addr="2772222222", source_addr="2772000000")
pdu._PDU__add_optional_parameter('ussd_service_op', '01')
pdu._PDU__add_optional_parameter('its_session_info', '0000')
self.service.factory.smsc.send_pdu(pdu)
[mess] = yield self.tx_helper.wait_for_dispatched_inbound(1)
self.assertEqual(mess['transport_type'], 'ussd')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], None)
self.assertEqual(mess['session_event'],
TransportUserMessage.SESSION_NEW)
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
def test_send_mo(self):
"""
FakeSMSC can send a DeliverSM PDU.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
yield fake_smsc.send_mo(5, "hello")
# First MO received.
self.assertEqual(
client.received,
DeliverSM(5, short_message="hello", data_coding=1).get_bin())
client.received = b""
yield fake_smsc.send_mo(6, "hello again", 8, destination_addr="123")
# Second MO received.
self.assertEqual(
client.received,
DeliverSM(6,
short_message="hello again",
data_coding=8,
destination_addr="123").get_bin())
def test_deliver_sm_delivery_report_rejected(self):
esme = yield self.get_esme(
delivery_report=self.assertion_cb({
'message_id': '1b1720be-5f48-41c4-b3f8-6e59dbf45366',
'message_state': 'REJECTED',
}))
sm = DeliverSM(1, short_message='delivery report')
sm._PDU__add_optional_parameter(
'receipted_message_id', '1b1720be-5f48-41c4-b3f8-6e59dbf45366')
sm._PDU__add_optional_parameter('message_state', 8)
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def test_deliver_sm_ussd_start(self):
def assert_ussd(value):
self.assertEqual('ussd', value['message_type'])
self.assertEqual('new', value['session_event'])
self.assertEqual(None, value['short_message'])
esme = yield self.get_esme(deliver_sm=self.make_cb(assert_ussd))
sm = DeliverSM(1)
sm._PDU__add_optional_parameter('ussd_service_op', '01')
sm._PDU__add_optional_parameter('its_session_info', '0000')
yield esme.handle_deliver_sm(unpack_pdu(sm.get_bin()))
def test_mo_sms_failed_remote_id_lookup(self):
smpp_helper = yield self.get_smpp_helper()
lc = LogCatcher(message="Failed to retrieve message id")
with lc:
yield smpp_helper.handle_pdu(
DeliverSM(sequence_number=1,
short_message=self.DR_TEMPLATE % ('foo', )))
# check that failure to send delivery report was logged
[warning] = lc.logs
expected_msg = (
"Failed to retrieve message id for delivery report. Delivery"
" report from %s discarded.") % (self.tx_helper.transport_name, )
self.assertEqual(warning['message'], (expected_msg, ))
