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