def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config["twisted_endpoint"] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(self.config,
start=False)
self.expected_delivery_status = 'delivered'
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTransport))
server_config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"twisted_endpoint": "tcp:0",
"transport_type": "smpp",
}
server_config.update(self.CONFIG_OVERRIDE)
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
host = self.service.listening.getHost()
client_config = server_config.copy()
client_config['twisted_endpoint'] = 'tcp:host=%s:port=%s' % (host.host,
host.port)
self.transport = yield self.tx_helper.get_transport(client_config,
start=False)
self.expected_delivery_status = 'delivered'
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config["twisted_endpoint"] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(
self.config, start=False)
self.expected_delivery_status = 'delivered'
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTransport))
server_config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"twisted_endpoint": "tcp:0",
"transport_type": "smpp",
}
server_config.update(self.CONFIG_OVERRIDE)
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
host = self.service.listening.getHost()
client_config = server_config.copy()
client_config['twisted_endpoint'] = 'tcp:host=%s:port=%s' % (
host.host, host.port)
self.transport = yield self.tx_helper.get_transport(
client_config, start=False)
self.expected_delivery_status = 'delivered'
class TestEsmeToSmscRx(VumiTestCase):
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def setUp(self):
from twisted.internet.base import DelayedCall
DelayedCall.debug = True
self.tx_helper = self.add_helper(TransportHelper(MockSmppRxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config['twisted_endpoint'] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(
self.config, start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
@inlineCallbacks
def test_deliver(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# 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)
[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'], "SMS from server")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
@inlineCallbacks
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"))
@inlineCallbacks
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, [])
class TestEsmeToSmscTx(VumiTestCase):
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config["twisted_endpoint"] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(
self.config, start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def test_submit(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# Next the Client submits a SMS to the Server
# and recieves an ack
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] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(ack['message_type'], 'event')
self.assertEqual(ack['event_type'], 'ack')
self.assertEqual(ack['user_message_id'], user_message_id)
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
class EsmeToSmscTestCase(VumiTestCase):
CONFIG_OVERRIDE = {}
@inlineCallbacks
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTransport))
server_config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"twisted_endpoint": "tcp:0",
"transport_type": "smpp",
}
server_config.update(self.CONFIG_OVERRIDE)
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
host = self.service.listening.getHost()
client_config = server_config.copy()
client_config['twisted_endpoint'] = 'tcp:host=%s:port=%s' % (
host.host, host.port)
self.transport = yield self.tx_helper.get_transport(
client_config, start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def clear_link_pdus(self):
for expected in [
mk_expected_pdu("inbound", 1, "bind_transceiver"),
mk_expected_pdu("outbound", 1, "bind_transceiver_resp"),
mk_expected_pdu("inbound", 2, "enquire_link"),
mk_expected_pdu("outbound", 2, "enquire_link_resp")]:
pdu = yield self.service.factory.smsc.pdu_queue.get()
self.assert_server_pdu(expected, pdu)
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def test_handshake_submit_and_deliver(self):
# 1111111111111111111111111111111111111111111111111
expected_pdus_1 = [
mk_expected_pdu("inbound", 1, "bind_transceiver"),
mk_expected_pdu("outbound", 1, "bind_transceiver_resp"),
mk_expected_pdu("inbound", 2, "enquire_link"),
mk_expected_pdu("outbound", 2, "enquire_link_resp"),
]
# 2222222222222222222222222222222222222222222222222
expected_pdus_2 = [
mk_expected_pdu("inbound", 3, "submit_sm"),
mk_expected_pdu("outbound", 3, "submit_sm_resp"),
# the delivery report
mk_expected_pdu("outbound", 1, "deliver_sm"),
mk_expected_pdu("inbound", 1, "deliver_sm_resp"),
]
# 3333333333333333333333333333333333333333333333333
expected_pdus_3 = [
# a sms delivered by the smsc
mk_expected_pdu("outbound", 555, "deliver_sm"),
mk_expected_pdu("inbound", 555, "deliver_sm_resp"),
]
## Startup
yield self.startTransport()
yield self.transport._block_till_bind
# 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
for expected_message in expected_pdus_1:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
# 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")
for expected_message in expected_pdus_2:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
# 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)
for expected_message in expected_pdus_3:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
[mess] = self.tx_helper.get_dispatched_inbound()
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "SMS from server")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
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)
@inlineCallbacks
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, [])
@inlineCallbacks
def test_submit_sm_encoding(self):
# Startup
yield self.startTransport()
self.transport.submit_sm_encoding = 'latin-1'
yield self.transport._block_till_bind
yield self.clear_link_pdus()
yield self.tx_helper.make_dispatch_outbound(u'Zoë destroyer of Ascii!')
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
sms = submit_sm_pdu['pdu']['body']['mandatory_parameters']
self.assertEqual(
sms['short_message'],
u'Zoë destroyer of Ascii!'.encode('latin-1'))
# clear ack and nack
yield self.tx_helper.wait_for_dispatched_events(2)
@inlineCallbacks
def test_submit_sm_data_coding(self):
# Startup
yield self.startTransport()
self.transport.submit_sm_data_coding = 8
yield self.transport._block_till_bind
yield self.clear_link_pdus()
yield self.tx_helper.make_dispatch_outbound("hello world")
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
sms = submit_sm_pdu['pdu']['body']['mandatory_parameters']
self.assertEqual(sms['data_coding'], 8)
# clear ack and nack
yield self.tx_helper.wait_for_dispatched_events(2)
@inlineCallbacks
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())
@inlineCallbacks
def test_submit_and_deliver_ussd_close(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",
session_event=TransportUserMessage.SESSION_CLOSE)
# 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('0001', 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', '0001')
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_CLOSE)
self.assertEqual([], self.tx_helper.get_dispatched_failures())
@inlineCallbacks
def test_submit_and_deliver_with_missing_id_lookup(self):
def r_failing_get(third_party_id):
return succeed(None)
self.transport.r_get_id_for_third_party_id = r_failing_get
# 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
lc = LogCatcher(message="Failed to retrieve message id")
with lc:
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] = yield self.tx_helper.wait_for_dispatched_events(1)
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)
# 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,))
class TestEsmeToSmscRx(VumiTestCase):
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def setUp(self):
from twisted.internet.base import DelayedCall
DelayedCall.debug = True
self.tx_helper = self.add_helper(TransportHelper(MockSmppRxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config['twisted_endpoint'] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(self.config,
start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
@inlineCallbacks
def test_deliver(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# 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)
[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'], "SMS from server")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
@inlineCallbacks
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"))
@inlineCallbacks
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, [])
class TestEsmeToSmscTx(VumiTestCase):
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTxTransport))
self.config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"host": "127.0.0.1",
"transport_type": "smpp",
}
server_config = self.config.copy()
server_config["twisted_endpoint"] = "tcp:0"
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.tx_helper.get_transport(self.config,
start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def test_submit(self):
# Startup
yield self.startTransport()
yield self.transport._block_till_bind
# Next the Client submits a SMS to the Server
# and recieves an ack
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] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(ack['message_type'], 'event')
self.assertEqual(ack['event_type'], 'ack')
self.assertEqual(ack['user_message_id'], user_message_id)
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
class EsmeToSmscTestCase(VumiTestCase):
CONFIG_OVERRIDE = {}
@inlineCallbacks
def setUp(self):
self.tx_helper = self.add_helper(TransportHelper(MockSmppTransport))
server_config = {
"transport_name": self.tx_helper.transport_name,
"system_id": "VumiTestSMSC",
"password": "******",
"twisted_endpoint": "tcp:0",
"transport_type": "smpp",
}
server_config.update(self.CONFIG_OVERRIDE)
self.service = SmppService(None, config=server_config)
self.add_cleanup(self.cleanup_service)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
host = self.service.listening.getHost()
client_config = server_config.copy()
client_config['twisted_endpoint'] = 'tcp:host=%s:port=%s' % (host.host,
host.port)
self.transport = yield self.tx_helper.get_transport(client_config,
start=False)
self.expected_delivery_status = 'delivered'
@inlineCallbacks
def cleanup_service(self):
yield self.service.listening.stopListening()
yield self.service.listening.loseConnection()
def assert_pdu_header(self, expected, actual, field):
self.assertEqual(expected['pdu']['header'][field],
actual['pdu']['header'][field])
def assert_server_pdu(self, expected, actual):
self.assertEqual(expected['direction'], actual['direction'])
self.assert_pdu_header(expected, actual, 'sequence_number')
self.assert_pdu_header(expected, actual, 'command_status')
self.assert_pdu_header(expected, actual, 'command_id')
@inlineCallbacks
def clear_link_pdus(self):
for expected in [
mk_expected_pdu("inbound", 1, "bind_transceiver"),
mk_expected_pdu("outbound", 1, "bind_transceiver_resp"),
mk_expected_pdu("inbound", 2, "enquire_link"),
mk_expected_pdu("outbound", 2, "enquire_link_resp")
]:
pdu = yield self.service.factory.smsc.pdu_queue.get()
self.assert_server_pdu(expected, pdu)
@inlineCallbacks
def startTransport(self):
self.transport._block_till_bind = Deferred()
yield self.transport.startWorker()
@inlineCallbacks
def test_handshake_submit_and_deliver(self):
# 1111111111111111111111111111111111111111111111111
expected_pdus_1 = [
mk_expected_pdu("inbound", 1, "bind_transceiver"),
mk_expected_pdu("outbound", 1, "bind_transceiver_resp"),
mk_expected_pdu("inbound", 2, "enquire_link"),
mk_expected_pdu("outbound", 2, "enquire_link_resp"),
]
# 2222222222222222222222222222222222222222222222222
expected_pdus_2 = [
mk_expected_pdu("inbound", 3, "submit_sm"),
mk_expected_pdu("outbound", 3, "submit_sm_resp"),
# the delivery report
mk_expected_pdu("outbound", 1, "deliver_sm"),
mk_expected_pdu("inbound", 1, "deliver_sm_resp"),
]
# 3333333333333333333333333333333333333333333333333
expected_pdus_3 = [
# a sms delivered by the smsc
mk_expected_pdu("outbound", 555, "deliver_sm"),
mk_expected_pdu("inbound", 555, "deliver_sm_resp"),
]
## Startup
yield self.startTransport()
yield self.transport._block_till_bind
# 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
for expected_message in expected_pdus_1:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
# 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")
for expected_message in expected_pdus_2:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
# 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)
for expected_message in expected_pdus_3:
actual_message = yield pdu_queue.get()
self.assert_server_pdu(expected_message, actual_message)
[mess] = self.tx_helper.get_dispatched_inbound()
self.assertEqual(mess['message_type'], 'user_message')
self.assertEqual(mess['transport_name'], self.tx_helper.transport_name)
self.assertEqual(mess['content'], "SMS from server")
dispatched_failures = self.tx_helper.get_dispatched_failures()
self.assertEqual(dispatched_failures, [])
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)
@inlineCallbacks
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, [])
@inlineCallbacks
def test_submit_sm_encoding(self):
# Startup
yield self.startTransport()
self.transport.submit_sm_encoding = 'latin-1'
yield self.transport._block_till_bind
yield self.clear_link_pdus()
yield self.tx_helper.make_dispatch_outbound(u'Zoë destroyer of Ascii!')
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
sms = submit_sm_pdu['pdu']['body']['mandatory_parameters']
self.assertEqual(sms['short_message'],
u'Zoë destroyer of Ascii!'.encode('latin-1'))
# clear ack and nack
yield self.tx_helper.wait_for_dispatched_events(2)
@inlineCallbacks
def test_submit_sm_data_coding(self):
# Startup
yield self.startTransport()
self.transport.submit_sm_data_coding = 8
yield self.transport._block_till_bind
yield self.clear_link_pdus()
yield self.tx_helper.make_dispatch_outbound("hello world")
pdu_queue = self.service.factory.smsc.pdu_queue
submit_sm_pdu = yield pdu_queue.get()
sms = submit_sm_pdu['pdu']['body']['mandatory_parameters']
self.assertEqual(sms['data_coding'], 8)
# clear ack and nack
yield self.tx_helper.wait_for_dispatched_events(2)
@inlineCallbacks
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())
@inlineCallbacks
def test_submit_and_deliver_ussd_close(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",
session_event=TransportUserMessage.SESSION_CLOSE)
# 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('0001', 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', '0001')
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_CLOSE)
self.assertEqual([], self.tx_helper.get_dispatched_failures())
@inlineCallbacks
def test_submit_and_deliver_with_missing_id_lookup(self):
def r_failing_get(third_party_id):
return succeed(None)
self.transport.r_get_id_for_third_party_id = r_failing_get
# 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
lc = LogCatcher(message="Failed to retrieve message id")
with lc:
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] = yield self.tx_helper.wait_for_dispatched_events(1)
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)
# 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, ))
