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