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