def test_await_pdus_arrived(self):
"""
The caller can wait for multiple PDU that have already arrived.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
yield client.write(EnquireLink(1).get_bin())
yield client.write(EnquireLink(2).get_bin())
self.assertEqual(self.successResultOf(fake_smsc.await_pdus(2)), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).get_bin())])
def test_await_pdus_arrived(self):
"""
The caller can wait for multiple PDU that have already arrived.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
yield client.write(EnquireLink(1).get_bin())
yield client.write(EnquireLink(2).get_bin())
self.assertEqual(self.successResultOf(fake_smsc.await_pdus(2)), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).get_bin())
])
def send_pdu(self, pdu):
data = pdu.get_bin()
unpacked = unpack_pdu(data)
command_id = unpacked['header']['command_id']
if command_id not in ('enquire_link', 'enquire_link_resp'):
log.debug('OUTGOING >>>> %s' % unpacked)
self.transport.write(data)
def send_pdu(self, pdu):
data = pdu.get_bin()
unpacked = unpack_pdu(data)
command_id = unpacked['header']['command_id']
if command_id not in ('enquire_link', 'enquire_link_resp'):
log.debug('OUTGOING >>>> %s' % unpacked)
self.transport.write(data)
def test_data_sm_message_payload_None(self):
"""A message in the `message_payload` field should be delivered."""
esme = yield self.get_esme(
deliver_sm=self.assertion_cb(u'', 'short_message'))
sm = DataSM(1, short_message='')
sm.add_message_payload('')
yield esme.handle_data_sm(unpack_pdu(sm.get_bin()))
def test_validity_period(self):
"""
Should be able to pack and unpack a PDU with a valid validity_period.
"""
submit_sm = {
'header': {
'command_length': 67,
'command_id': 'submit_sm',
'command_status': 'ESME_ROK',
'sequence_number': 0,
},
'body': {
'mandatory_parameters': {
'service_type': '',
'source_addr_ton': 'international',
'source_addr_npi': 'unknown',
'source_addr': '',
'dest_addr_ton': 'international',
'dest_addr_npi': 'unknown',
'destination_addr': '',
'esm_class': 0,
'protocol_id': 0,
'priority_flag': 0,
'schedule_delivery_time': '',
'validity_period': '000001234567800R',
'registered_delivery': 0,
'replace_if_present_flag': 0,
'data_coding': 0,
'sm_default_msg_id': 0,
'sm_length': 18,
'short_message': 'Test Short Message',
},
},
}
self.assertEqual(pdu.unpack_pdu(pdu.pack_pdu(submit_sm)), submit_sm)
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_sm_sms_multipart_udh(self):
"""Submit a long SMS message using multipart user data headers."""
esme = yield self.get_esme(config={
'send_multipart_udh': True,
})
long_message = 'This is a long message.' * 20
seq_nums = yield esme.submit_sm(short_message=long_message)
self.assertEqual([2, 3, 4, 5], seq_nums)
self.assertEqual(4, len(esme.fake_sent_pdus))
msg_parts = []
msg_refs = []
for i, sm_pdu in enumerate(esme.fake_sent_pdus):
sm = unpack_pdu(sm_pdu.get_bin())
mandatory_parameters = sm['body']['mandatory_parameters']
self.assertEqual('submit_sm', sm['header']['command_id'])
msg = mandatory_parameters['short_message']
udh_hlen, udh_tag, udh_len, udh_ref, udh_tot, udh_seq = [
ord(octet) for octet in msg[:6]]
self.assertEqual(5, udh_hlen)
self.assertEqual(0, udh_tag)
self.assertEqual(3, udh_len)
msg_refs.append(udh_ref)
self.assertEqual(4, udh_tot)
self.assertEqual(i + 1, udh_seq)
self.assertTrue(len(msg) <= 136)
msg_parts.append(msg[6:])
self.assertEqual(0x40, mandatory_parameters['esm_class'])
self.assertEqual(long_message, ''.join(msg_parts))
self.assertEqual(1, len(set(msg_refs)))
def test_submit_sm_sms_multipart_sar(self):
"""Submit a long SMS message using multipart sar fields."""
esme = yield self.get_esme(config={
'send_multipart_sar': True,
})
long_message = 'This is a long message.' * 20
seq_nums = yield esme.submit_sm(short_message=long_message)
self.assertEqual([2, 3, 4, 5], seq_nums)
self.assertEqual(4, len(esme.fake_sent_pdus))
msg_parts = []
msg_refs = []
for i, sm_pdu in enumerate(esme.fake_sent_pdus):
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
mandatory_parameters = sm['body']['mandatory_parameters']
self.assertEqual('submit_sm', sm['header']['command_id'])
msg_parts.append(mandatory_parameters['short_message'])
self.assertTrue(len(mandatory_parameters['short_message']) <= 130)
msg_refs.append(pdu_opts['sar_msg_ref_num'])
self.assertEqual(i + 1, pdu_opts['sar_segment_seqnum'])
self.assertEqual(4, pdu_opts['sar_total_segments'])
self.assertEqual(long_message, ''.join(msg_parts))
self.assertEqual(1, len(set(msg_refs)))
def test_submit_sm_sms_multipart_udh(self):
"""Submit a long SMS message using multipart user data headers."""
esme = yield self.get_esme(config={
'send_multipart_udh': True,
})
long_message = 'This is a long message.' * 20
seq_nums = yield esme.submit_sm(short_message=long_message)
self.assertEqual([2, 3, 4, 5], seq_nums)
self.assertEqual(4, len(esme.fake_sent_pdus))
msg_parts = []
msg_refs = []
for i, sm_pdu in enumerate(esme.fake_sent_pdus):
sm = unpack_pdu(sm_pdu.get_bin())
mandatory_parameters = sm['body']['mandatory_parameters']
self.assertEqual('submit_sm', sm['header']['command_id'])
msg = mandatory_parameters['short_message']
udh_hlen, udh_tag, udh_len, udh_ref, udh_tot, udh_seq = [
ord(octet) for octet in msg[:6]
]
self.assertEqual(5, udh_hlen)
self.assertEqual(0, udh_tag)
self.assertEqual(3, udh_len)
msg_refs.append(udh_ref)
self.assertEqual(4, udh_tot)
self.assertEqual(i + 1, udh_seq)
self.assertTrue(len(msg) <= 136)
msg_parts.append(msg[6:])
self.assertEqual(0x40, mandatory_parameters['esm_class'])
self.assertEqual(long_message, ''.join(msg_parts))
self.assertEqual(1, len(set(msg_refs)))
def test_submit_sm_sms_multipart_sar(self):
"""Submit a long SMS message using multipart sar fields."""
esme = yield self.get_esme(config={
'send_multipart_sar': True,
})
long_message = 'This is a long message.' * 20
seq_nums = yield esme.submit_sm(short_message=long_message)
self.assertEqual([2, 3, 4, 5], seq_nums)
self.assertEqual(4, len(esme.fake_sent_pdus))
msg_parts = []
msg_refs = []
for i, sm_pdu in enumerate(esme.fake_sent_pdus):
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
mandatory_parameters = sm['body']['mandatory_parameters']
self.assertEqual('submit_sm', sm['header']['command_id'])
msg_parts.append(mandatory_parameters['short_message'])
self.assertTrue(len(mandatory_parameters['short_message']) <= 130)
msg_refs.append(pdu_opts['sar_msg_ref_num'])
self.assertEqual(i + 1, pdu_opts['sar_segment_seqnum'])
self.assertEqual(4, pdu_opts['sar_total_segments'])
self.assertEqual(long_message, ''.join(msg_parts))
self.assertEqual(1, len(set(msg_refs)))
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 handle_data(self, data):
pdu = unpack_pdu(data)
command_id = pdu['header']['command_id']
if command_id not in ('enquire_link', 'enquire_link_resp'):
log.debug('INCOMING <<<< %s' % binascii.b2a_hex(data))
log.debug('INCOMING <<<< %s' % pdu)
handler = getattr(self, 'handle_%s' % (command_id, ),
self._command_handler_not_found)
yield handler(pdu)
def handle_data(self, data):
pdu = unpack_pdu(data)
command_id = pdu['header']['command_id']
if command_id not in ('enquire_link', 'enquire_link_resp'):
log.debug('INCOMING <<<< %s' % binascii.b2a_hex(data))
log.debug('INCOMING <<<< %s' % pdu)
handler = getattr(self, 'handle_%s' % (command_id,),
self._command_handler_not_found)
yield handler(pdu)
def create_pdu_asserts():
pdu_index = 0
for pdu_ in pdu_objects:
pdu_index += 1
pstr = "\n########################################\n"
pstr += "pdu_json_"
pstr += ('%010d' % pdu_index)
pstr += " = '''"
pstr += prettydump(unpack_pdu(pack_pdu(pdu_)))
pstr += "'''"
def test_submit_sm_sms(self):
"""Submit a USSD message with a session continue flag."""
esme = yield self.get_esme()
yield esme.submit_sm(short_message='hello')
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual('hello',
sm['body']['mandatory_parameters']['short_message'])
self.assertEqual([], sm['body'].get('optional_parameters', []))
def test_submit_sm_sms(self):
"""Submit a USSD message with a session continue flag."""
esme = yield self.get_esme()
yield esme.submit_sm(short_message='hello')
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual(
'hello', sm['body']['mandatory_parameters']['short_message'])
self.assertEqual([], sm['body'].get('optional_parameters', []))
def test_pack_unpack_performance(self):
"""
Pack & unpack 500 submit_sm PDUs in under 1 second
"""
submit_sm = {
'header': {
'command_length': 0,
'command_id': 'submit_sm',
'command_status': 'ESME_ROK',
'sequence_number': 0,
},
'body': {
'mandatory_parameters': {
'service_type': '',
'source_addr_ton': 1,
'source_addr_npi': 1,
'source_addr': '',
'dest_addr_ton': 1,
'dest_addr_npi': 1,
'destination_addr': '',
'esm_class': 0,
'protocol_id': 0,
'priority_flag': 0,
'schedule_delivery_time': '',
'validity_period': '',
'registered_delivery': 0,
'replace_if_present_flag': 0,
'data_coding': 0,
'sm_default_msg_id': 0,
'sm_length': 1,
'short_message': '',
},
},
}
start = datetime.now()
for x in range(500):
x += 1
submit_sm['header']['sequence_number'] = x
sm = 'testing: x = '+str(x)+''
submit_sm['body']['mandatory_parameters']['short_message'] = sm
unpack_pdu(pack_pdu(submit_sm))
delta = datetime.now() - start
self.assertTrue(delta < timedelta(seconds=1))
def test_await_pdus(self):
"""
The caller can wait for multiple PDUs to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdus_d = fake_smsc.await_pdus(2)
# No PDUs yet.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(1).get_bin())
# One PDU received, no result.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(2).get_bin())
# Both PDUs received.
self.assertEqual(self.successResultOf(pdus_d), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).get_bin())])
def test_await_pdus(self):
"""
The caller can wait for multiple PDUs to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdus_d = fake_smsc.await_pdus(2)
# No PDUs yet.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(1).get_bin())
# One PDU received, no result.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(2).get_bin())
# Both PDUs received.
self.assertEqual(self.successResultOf(pdus_d), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).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_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_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_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_bind_no_timeout(self):
esme = self.get_esme()
esme.connectionMade()
self.assertEqual(True, esme.transport.connected)
self.assertNotEqual(None, esme._lose_conn)
esme.handle_bind_transceiver_resp(
unpack_pdu(BindTransceiverResp(1).get_bin()))
self.assertEqual(True, esme.transport.connected)
self.assertEqual(None, esme._lose_conn)
esme.lc_enquire.stop()
def test_bind_no_timeout(self):
esme = self.get_esme()
esme.connectionMade()
self.assertEqual(True, esme.transport.connected)
self.assertNotEqual(None, esme._lose_conn)
esme.handle_bind_transceiver_resp(unpack_pdu(
BindTransceiverResp(1).get_bin()))
self.assertEqual(True, esme.transport.connected)
self.assertEqual(None, esme._lose_conn)
esme.lc_enquire.stop()
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_ignore_invalid_null_after_short_message_field(self):
"""
At least one provider sends us an invalid deliver_sm PDU with a null
byte after the short_message field.
"""
deliver_sm = {
'header': {
'command_length': 0,
'command_id': 'deliver_sm',
'command_status': 'ESME_ROK',
'sequence_number': 0,
},
'body': {
'mandatory_parameters': {
'service_type': '',
'source_addr_ton': 1,
'source_addr_npi': 1,
'source_addr': '',
'dest_addr_ton': 1,
'dest_addr_npi': 1,
'destination_addr': '',
'esm_class': 0,
'protocol_id': 0,
'priority_flag': 0,
'schedule_delivery_time': '',
'validity_period': '',
'registered_delivery': 0,
'replace_if_present_flag': 0,
'data_coding': 0,
'sm_default_msg_id': 0,
'sm_length': 1,
'short_message': 'test',
},
},
}
packed_pdu = pdu.pack_pdu(deliver_sm)
unpacked_pdu = pdu.unpack_pdu(packed_pdu)
unpacked_dodgy_pdu = pdu.unpack_pdu(packed_pdu + '\x00')
self.assertEqual(unpacked_pdu, unpacked_dodgy_pdu)
def test_submit_sm_ussd_close(self):
"""Submit a USSD message with a session close flag."""
esme = yield self.get_esme()
yield esme.submit_sm(
short_message='hello', message_type='ussd', continue_session=False)
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual(
'hello', sm['body']['mandatory_parameters']['short_message'])
self.assertEqual('02', pdu_opts['ussd_service_op'])
self.assertEqual('0001', pdu_opts['its_session_info'])
def test_drop_link(self):
protocol = yield self.get_protocol()
transport = yield connect_transport(protocol)
[bind_pdu] = yield wait_for_pdus(transport, 1)
self.assertCommand(bind_pdu, 'bind_transceiver')
self.assertFalse(protocol.is_bound())
self.assertEqual(protocol.state, EsmeTransceiver.OPEN_STATE)
self.assertFalse(transport.disconnecting)
self.clock.advance(protocol.config.smpp_bind_timeout + 1)
[unbind_pdu] = yield wait_for_pdus(transport, 1)
self.assertCommand(unbind_pdu, 'unbind')
unbind_resp_pdu = UnbindResp(sequence_number=seq_no(unbind_pdu))
yield protocol.on_pdu(unpack_pdu(unbind_resp_pdu.get_bin()))
self.assertTrue(transport.disconnecting)
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 cb(pdus):
data_stream = transport.value()
pdu_found = chop_pdu_stream(data_stream)
if pdu_found is not None:
pdu_data, remainder = pdu_found
pdu = unpack_pdu(pdu_data)
pdus.append(pdu)
transport.clear()
transport.write(remainder)
if len(pdus) == count:
d.callback(pdus)
else:
reactor.callLater(0, cb, pdus)
def test_pack_unpack_performance(self):
import platform
if platform.python_implementation() == "PyPy":
# Skip this test on pypy, because the JIT warmup time dominates.
return
print ''
"""
Pack & unpack 500 submit_sm PDUs in under 1 second
"""
submit_sm = {
'header': {
'command_length': 0,
'command_id': 'submit_sm',
'command_status': 'ESME_ROK',
'sequence_number': 0,
},
'body': {
'mandatory_parameters': {
'service_type': '',
'source_addr_ton': 1,
'source_addr_npi': 1,
'source_addr': '',
'dest_addr_ton': 1,
'dest_addr_npi': 1,
'destination_addr': '',
'esm_class': 0,
'protocol_id': 0,
'priority_flag': 0,
'schedule_delivery_time': '',
'validity_period': '',
'registered_delivery': 0,
'replace_if_present_flag': 0,
'data_coding': 0,
'sm_default_msg_id': 0,
'sm_length': 1,
'short_message': '',
},
},
}
start = datetime.now()
for x in range(500):
x += 1
submit_sm['header']['sequence_number'] = x
sm = 'testing: x = '+str(x)+''
submit_sm['body']['mandatory_parameters']['short_message'] = sm
u = pdu.unpack_pdu(pdu.pack_pdu(submit_sm))
delta = datetime.now() - start
print '... 500 pack & unpacks in:', delta
self.assertTrue(delta < timedelta(seconds=1))
def __recv(self):
pdu = None
length_bin = self.conn.recv(4)
if not length_bin:
return None
else:
# print 'length_bin', len(length_bin), length_bin
if len(length_bin) == 4:
length = int(binascii.b2a_hex(length_bin), 16)
rest_bin = self.conn.recv(length-4)
pdu = unpack_pdu(length_bin + rest_bin)
print '...', pdu['header']['sequence_number'],
print '>', pdu['header']['command_id'],
print '...', pdu['header']['command_status']
return pdu
def test_pack_unpack_pdu_objects(self):
"""
Take a dictionary, pack and unpack it and dump it as JSON correctly
"""
pdu_index = 0
for pdu_ in pdu_objects:
pdu_index += 1
padded_index = '%010d' % pdu_index
self.assertEquals(
re.sub(
'\n *', '',
prettydump(unpack_pdu(pack_pdu(pdu_)))),
re.sub(
'\n *', '',
eval('pdu_asserts.pdu_json_'+padded_index)))
def test_pack_unpack_pdu_objects(self):
print ''
"""
Take a dictionary, pack and unpack it and dump it as JSON correctly
"""
pdu_index = 0
for pdu_object in pdu_objects:
pdu_index += 1
padded_index = '%010d' % pdu_index
print '...', padded_index
str_eval = re.sub('null', 'None', getattr(pdu_asserts, 'pdu_json_' + padded_index))
self.assertEquals(
pdu.unpack_pdu(pdu.pack_pdu(pdu_object)),
eval(str_eval)
)
def test_submit_sm_ussd_close(self):
"""Submit a USSD message with a session close flag."""
esme = yield self.get_esme()
yield esme.submit_sm(short_message='hello',
message_type='ussd',
continue_session=False)
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual('hello',
sm['body']['mandatory_parameters']['short_message'])
self.assertEqual('02', pdu_opts['ussd_service_op'])
self.assertEqual('0001', pdu_opts['its_session_info'])
def test_enquire_link_looping(self):
transport, protocol = yield self.setup_bind(clear=False)
enquire_link_resp = EnquireLinkResp(1)
protocol.clock.advance(protocol.idle_timeout - 1)
protocol.dataReceived(enquire_link_resp.get_bin())
protocol.clock.advance(protocol.idle_timeout - 1)
self.assertFalse(transport.disconnecting)
protocol.clock.advance(1)
[unbind_pdu] = yield wait_for_pdus(transport, 1)
self.assertCommand(unbind_pdu, 'unbind')
unbind_resp_pdu = UnbindResp(sequence_number=seq_no(unbind_pdu))
yield protocol.on_pdu(unpack_pdu(unbind_resp_pdu.get_bin()))
self.assertTrue(transport.disconnecting)
def test_submit_sm_sms_long(self):
"""Submit a USSD message with a session continue flag."""
esme = yield self.get_esme(config={
'send_long_messages': True,
})
long_message = 'This is a long message.' * 20
yield esme.submit_sm(short_message=long_message)
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual(
None, sm['body']['mandatory_parameters']['short_message'])
self.assertEqual(''.join('%02x' % ord(c) for c in long_message),
pdu_opts['message_payload'])
def test_submit_sm_sms_long(self):
"""Submit a USSD message with a session continue flag."""
esme = yield self.get_esme(config={
'send_long_messages': True,
})
long_message = 'This is a long message.' * 20
yield esme.submit_sm(short_message=long_message)
[sm_pdu] = esme.fake_sent_pdus
sm = unpack_pdu(sm_pdu.get_bin())
pdu_opts = unpacked_pdu_opts(sm)
self.assertEqual('submit_sm', sm['header']['command_id'])
self.assertEqual(None,
sm['body']['mandatory_parameters']['short_message'])
self.assertEqual(''.join('%02x' % ord(c) for c in long_message),
pdu_opts['message_payload'])
def handle_data(self, data):
pdu = unpack_pdu(data)
log.msg('INCOMING <<<< %s' % binascii.b2a_hex(data))
log.msg('INCOMING <<<< %s' % pdu)
# TODO: convert this to a dispatch map
if pdu['header']['command_id'] == 'bind_transceiver_resp':
self.handle_bind_transceiver_resp(pdu)
if pdu['header']['command_id'] == 'submit_sm_resp':
self.handle_submit_sm_resp(pdu)
if pdu['header']['command_id'] == 'submit_multi_resp':
self.handle_submit_multi_resp(pdu)
if pdu['header']['command_id'] == 'deliver_sm':
self.handle_deliver_sm(pdu)
if pdu['header']['command_id'] == 'enquire_link':
self.handle_enquire_link(pdu)
if pdu['header']['command_id'] == 'enquire_link_resp':
self.handle_enquire_link_resp(pdu)
log.msg('STATE: %s' % (self.state))
def handle_data(self, data):
pdu = unpack_pdu(data)
log.msg('INCOMING <<<< %s' % binascii.b2a_hex(data))
log.msg('INCOMING <<<< %s' % pdu)
# TODO: convert this to a dispatch map
if pdu['header']['command_id'] == 'bind_transceiver_resp':
self.handle_bind_transceiver_resp(pdu)
if pdu['header']['command_id'] == 'submit_sm_resp':
self.handle_submit_sm_resp(pdu)
if pdu['header']['command_id'] == 'submit_multi_resp':
self.handle_submit_multi_resp(pdu)
if pdu['header']['command_id'] == 'deliver_sm':
self.handle_deliver_sm(pdu)
if pdu['header']['command_id'] == 'enquire_link':
self.handle_enquire_link(pdu)
if pdu['header']['command_id'] == 'enquire_link_resp':
self.handle_enquire_link_resp(pdu)
log.msg('STATE: %s' % (self.state))
def test_bind_and_disconnect(self):
callbacks_called = []
esme = yield self.get_unbound_esme(callbacks={
'connect': lambda client: callbacks_called.append('connect'),
'disconnect': lambda: callbacks_called.append('disconnect'),
})
yield esme.connectionMade()
esme.handle_bind_transceiver_resp(unpack_pdu(
BindTransceiverResp(1).get_bin()))
self.assertEqual(['connect'], callbacks_called)
esme.lc_enquire.stop()
yield esme.lc_enquire.deferred
yield esme.transport.loseConnection()
self.assertEqual(['connect', 'disconnect'], callbacks_called)
self.assertEqual(False, esme.transport.connected)
def test_await_pdu(self):
"""
The caller can wait for a PDU to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdu_d = fake_smsc.await_pdu()
# No PDU yet.
self.assertNoResult(pdu_d)
client.write(EnquireLink(1).get_bin()) # No yield.
# PDU sent, not yet received.
self.assertNoResult(pdu_d)
yield wait0()
# PDU received.
self.assertEqual(
self.successResultOf(pdu_d), unpack_pdu(EnquireLink(1).get_bin()))
def test_await_pdu(self):
"""
The caller can wait for a PDU to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdu_d = fake_smsc.await_pdu()
# No PDU yet.
self.assertNoResult(pdu_d)
client.write(EnquireLink(1).get_bin()) # No yield.
# PDU sent, not yet received.
self.assertNoResult(pdu_d)
yield wait0()
# PDU received.
self.assertEqual(self.successResultOf(pdu_d),
unpack_pdu(EnquireLink(1).get_bin()))
def handleData(self, data):
pdu = unpack_pdu(data)
log.msg('INCOMING <<<< %s' % binascii.b2a_hex(data))
log.msg('INCOMING <<<< %s' % pdu)
error_handler = self.command_status_dispatch(pdu)
error_handler(pdu=pdu)
if pdu['header']['command_id'] == 'bind_transceiver_resp':
self.handle_bind_transceiver_resp(pdu)
if pdu['header']['command_id'] == 'submit_sm_resp':
self.handle_submit_sm_resp(pdu)
if pdu['header']['command_id'] == 'submit_multi_resp':
self.handle_submit_multi_resp(pdu)
if pdu['header']['command_id'] == 'deliver_sm':
self.handle_deliver_sm(pdu)
if pdu['header']['command_id'] == 'enquire_link':
self.handle_enquire_link(pdu)
if pdu['header']['command_id'] == 'enquire_link_resp':
self.handle_enquire_link_resp(pdu)
log.msg('%s STATE: %s' % (self.name, self.state))
def test_bind_and_disconnect(self):
callbacks_called = []
esme = yield self.get_unbound_esme(
callbacks={
'connect': lambda client: callbacks_called.append('connect'),
'disconnect': lambda: callbacks_called.append('disconnect'),
})
yield esme.connectionMade()
esme.handle_bind_transceiver_resp(
unpack_pdu(BindTransceiverResp(1).get_bin()))
self.assertEqual(['connect'], callbacks_called)
esme.lc_enquire.stop()
yield esme.lc_enquire.deferred
yield esme.transport.loseConnection()
self.assertEqual(['connect', 'disconnect'], callbacks_called)
self.assertEqual(False, esme.transport.connected)
def test_pack_unpack_of_unicode(self):
"""
SMPP module should be able to pack & unpack unicode characters
without a problem
"""
submit_sm = {
'header': {
'command_length': 67,
'command_id': 'submit_sm',
'command_status': 'ESME_ROK',
'sequence_number': 0,
},
'body': {
'mandatory_parameters': {
'service_type': '',
'source_addr_ton': 'international',
'source_addr_npi': 'unknown',
'source_addr': '',
'dest_addr_ton': 'international',
'dest_addr_npi': 'unknown',
'destination_addr': '',
'esm_class': 0,
'protocol_id': 0,
'priority_flag': 0,
'schedule_delivery_time': '',
'validity_period': '',
'registered_delivery': 0,
'replace_if_present_flag': 0,
'data_coding': 0,
'sm_default_msg_id': 0,
'sm_length': 34,
'short_message':
u'Vumi says: أبن الشرموطة'.encode('utf-8'),
},
},
}
self.assertDictEquals(
hex_to_named(submit_sm),
unpack_pdu(pack_pdu(submit_sm))
)
def get_sm(self, msg, data_coding=3):
sm = DeliverSM(1, short_message=msg, data_coding=data_coding)
return unpack_pdu(sm.get_bin())
def dataReceived(self, data):
self.buffer += data
data = self.handle_buffer()
while data is not None:
self.on_pdu(unpack_pdu(data))
data = self.handle_buffer()
def send_pdu(self, pdu):
data = pdu.get_bin()
log.msg('OUTGOING >>>> %s' % unpack_pdu(data))
self.transport.write(data)
