def setUp(self): self.connector1 = HttpConnector('abc', 'http://127.0.0.1') self.connector2 = HttpConnector('def', 'http://127.0.0.1') self.connector3 = HttpConnector('ghi', 'http://127.0.0.1') self.connector4 = SmppServerSystemIdConnector('jkl') self.mt_filter1 = [SourceAddrFilter('^10\d+')] self.mt_filter2 = [DestinationAddrFilter('^90\d+')] self.transparent_filter = [TransparentFilter()] self.route1 = StaticMORoute(self.mt_filter1, self.connector1) self.route2 = StaticMORoute(self.mt_filter2, self.connector2) self.route3 = StaticMORoute(self.transparent_filter, self.connector3) self.route4 = DefaultRoute(self.connector4) self.PDU_dst_1 = DeliverSM( source_addr='100', destination_addr='200', short_message='hello world', ) self.PDU_dst_2 = DeliverSM( source_addr='x', destination_addr='900', short_message='hello world', ) self.PDU_dst_3 = DeliverSM( source_addr='x', destination_addr='y', short_message='hello world', ) self.routable_matching_route1 = RoutableDeliverSm(self.PDU_dst_1, self.connector1) self.routable_matching_route2 = RoutableDeliverSm(self.PDU_dst_2, self.connector1) self.routable_notmatching_any = RoutableDeliverSm(self.PDU_dst_3, self.connector1)
def gotConnection(conn, username, password): yield conn.authenticate(username, password) chan = yield conn.channel(1) yield chan.channel_open() DeliverSmPDU = DeliverSM( source_addr = '584141111330', destination_addr = '24247', short_message = 'Prueba 01 !', seqNum = 1,) content = DeliverSmContent(DeliverSmPDU, 'SIMULATOR' ) #print DeliverSmPDU yield chan.basic_publish(exchange='messaging', routing_key='deliver.sm.SIMULATOR', content=content) # A clean way to tear down and stop yield chan.channel_close() chan0 = yield conn.channel(0) yield chan0.connection_close() reactor.stop()
def test_delivery_HttpConnector(self): yield self.connect('127.0.0.1', self.pbPort) # Connect to SMSC source_connector = Connector(id_generator()) yield self.prepareRoutingsAndStartConnector(source_connector) # Send a deliver_sm from the SMSC pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='any content', ) yield self.triggerDeliverSmFromSMSC([pdu]) # Run tests # Test callback in router self.assertEquals(self.pbRoot_f.deliver_sm_callback.call_count, 1) # Destination connector must receive the message one time (no retries) self.assertEqual(self.AckServerResource.render_GET.call_count, 1) # Assert received args receivedHttpReq = self.AckServerResource.last_request.args self.assertEqual(len(receivedHttpReq), 8) self.assertEqual(receivedHttpReq['from'], [pdu.params['source_addr']]) self.assertEqual(receivedHttpReq['to'], [pdu.params['destination_addr']]) self.assertEqual(receivedHttpReq['content'], [pdu.params['short_message']]) self.assertEqual(receivedHttpReq['binary'], [binascii.hexlify(pdu.params['short_message'])]) self.assertEqual(receivedHttpReq['origin-connector'], [source_connector.cid]) # Disconnector from SMSC yield self.stopConnector(source_connector)
def test_delivery_failover_route(self): """#467: Will ensure a failover route will deliver the message""" yield self.connect('127.0.0.1', self.pbPort) # Connect to SMSC source_connector = Connector(id_generator()) wrong_port = self.AckServer.getHost().port + 1000 route = FailoverMORoute([TransparentFilter()], [ HttpConnector(id_generator(), 'http://127.0.0.1:%s/send' % wrong_port), HttpConnector(id_generator(), 'http://127.0.0.1:%s/send' % self.AckServer.getHost().port)]) yield self.prepareRoutingsAndStartConnector(source_connector, route) # Send a deliver_sm from the SMSC pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='any content', ) yield self.triggerDeliverSmFromSMSC([pdu]) # Run tests # Test callback in router self.assertEquals(self.pbRoot_f.deliver_sm_callback.call_count, 1) # Destination connector must receive the message one time (no retries) self.assertEqual(self.AckServerResource.render_GET.call_count, 1) # Disconnector from SMSC yield self.stopConnector(source_connector)
def gotConnection(conn, username, password,src,dest,text): yield conn.authenticate(username, password) #print 'Connected to RabbitMQ' chan = yield conn.channel(1) yield chan.channel_open() DeliverSmPDU = DeliverSM( source_addr = src, source_addr_ton = AddrTon.NATIONAL, source_addr_npi = AddrNpi.ISDN, destination_addr = dest, dest_addr_ton = AddrTon.NATIONAL, dest_addr_npi = AddrNpi.ISDN, esm_class=EsmClass(EsmClassMode.DEFAULT, EsmClassType.DEFAULT), protocol_id=0, priority_flag=PriorityFlag.LEVEL_0, registered_delivery=RegisteredDelivery(RegisteredDeliveryReceipt.NO_SMSC_DELIVERY_RECEIPT_REQUESTED), replace_if_present_flag=ReplaceIfPresentFlag.DO_NOT_REPLACE, short_message = text, seqNum = 1,) content = DeliverSmContent(DeliverSmPDU, 'SIMULATOR' ) #print DeliverSmPDU yield chan.basic_publish(exchange='messaging', routing_key='deliver.sm.SIMULATOR', content=content) # A clean way to tear down and stop yield chan.channel_close() chan0 = yield conn.channel(0) yield chan0.connection_close()
def setUp(self): # Initiating config objects without any filename # will lead to setting defaults and that's what we # need to run the tests AMQPServiceConfigInstance = AmqpConfig() AMQPServiceConfigInstance.reconnectOnConnectionLoss = False self.amqpBroker = AmqpFactory(AMQPServiceConfigInstance) yield self.amqpBroker.connect() yield self.amqpBroker.getChannelReadyDeferred() # Initiating config objects without any filename # will lead to setting defaults and that's what we # need to run the tests deliverSmThrowerConfigInstance = deliverSmThrowerConfig() # Lower the timeout config to pass the timeout tests quickly deliverSmThrowerConfigInstance.timeout = 2 deliverSmThrowerConfigInstance.retry_delay = 1 deliverSmThrowerConfigInstance.max_retries = 2 # Launch the deliverSmThrower self.deliverSmThrower = deliverSmThrower() self.deliverSmThrower.setConfig(deliverSmThrowerConfigInstance) # Add the broker to the deliverSmThrower yield self.deliverSmThrower.addAmqpBroker(self.amqpBroker) # Test vars: self.testDeliverSMPdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='hello !', )
def test_delivery_HttpConnector_message_payload_when_short_message_empty(self): """Related to #470 Consider 'message_payload' when 'short_message' is empty""" yield self.connect('127.0.0.1', self.pbPort) # Connect to SMSC source_connector = Connector(id_generator()) yield self.prepareRoutingsAndStartConnector(source_connector) # Send a deliver_sm from the SMSC assert_content = 'Some content' pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='', message_payload=assert_content ) yield self.triggerDeliverSmFromSMSC([pdu]) # Run tests # Test callback in router self.assertEquals(self.pbRoot_f.deliver_sm_callback.call_count, 1) # Destination connector must receive the message one time (no retries) self.assertEqual(self.AckServerResource.render_GET.call_count, 1) # Assert received args receivedHttpReq = self.AckServerResource.last_request.args self.assertEqual(len(receivedHttpReq), 8) self.assertEqual(receivedHttpReq['content'], [assert_content]) self.assertEqual(receivedHttpReq['binary'], [binascii.hexlify(assert_content)]) # Disconnector from SMSC yield self.stopConnector(source_connector)
def setUp(self): yield SMPPClientTestCases.setUp(self) # Initiating config objects without any filename # will lead to setting defaults and that's what we # need to run the tests deliverSmThrowerConfigInstance = deliverSmThrowerConfig() # Lower the timeout config to pass the timeout tests quickly deliverSmThrowerConfigInstance.timeout = 2 deliverSmThrowerConfigInstance.retry_delay = 1 deliverSmThrowerConfigInstance.max_retries = 2 # Launch the deliverSmThrower self.deliverSmThrower = deliverSmThrower() self.deliverSmThrower.setConfig(deliverSmThrowerConfigInstance) # Add the broker to the deliverSmThrower yield self.deliverSmThrower.addAmqpBroker(self.amqpBroker) # Add SMPPs factory to DLRThrower self.deliverSmThrower.addSmpps(self.smpps_factory) # Test vars: self.testDeliverSMPdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='hello !', )
def test_long_content_delivery_UDH_HttpConnector(self): yield self.connect('127.0.0.1', self.pbPort) # Connect to SMSC source_connector = Connector(id_generator()) yield self.prepareRoutingsAndStartConnector(source_connector) # Build a UDH baseUdh = [] baseUdh.append(struct.pack('!B', 5)) # Length of User Data Header baseUdh.append(struct.pack('!B', 0)) # Information Element Identifier, equal to 00 (Concatenated short messages, 8-bit reference number) baseUdh.append(struct.pack('!B', 3)) # Length of the header, excluding the first two fields; equal to 03 baseUdh.append(struct.pack('!B', int(id_generator(size=2, chars=string.digits)))) # msg_ref_num baseUdh.append(struct.pack('!B', 3)) # total_segments # Send a deliver_sm from the SMSC basePdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='', esm_class=EsmClass(EsmClassMode.DEFAULT, EsmClassType.DEFAULT, [EsmClassGsmFeatures.UDHI_INDICATOR_SET]), ) pdu_part1 = copy.deepcopy(basePdu) udh_part1 = copy.deepcopy(baseUdh) pdu_part2 = copy.deepcopy(basePdu) udh_part2 = copy.deepcopy(baseUdh) pdu_part3 = copy.deepcopy(basePdu) udh_part3 = copy.deepcopy(baseUdh) udh_part1.append(struct.pack('!B', 1)) # segment_seqnum pdu_part1.params['more_messages_to_send'] = MoreMessagesToSend.MORE_MESSAGES pdu_part1.params['short_message'] = ''.join( udh_part1) + '__1st_part_with_153_char________________________________________________________________________________________________________________________________.' udh_part2.append(struct.pack('!B', 2)) # segment_seqnum pdu_part2.params['more_messages_to_send'] = MoreMessagesToSend.MORE_MESSAGES pdu_part2.params['short_message'] = ''.join( udh_part2) + '__2nd_part_with_153_char________________________________________________________________________________________________________________________________.' udh_part3.append(struct.pack('!B', 3)) # segment_seqnum pdu_part3.params['more_messages_to_send'] = MoreMessagesToSend.NO_MORE_MESSAGES pdu_part3.params['short_message'] = ''.join(udh_part3) + '__3rd_part_end.' yield self.triggerDeliverSmFromSMSC([pdu_part1, pdu_part2, pdu_part3]) # Run tests # Destination connector must receive the message one time (no retries) self.assertEqual(self.AckServerResource.render_GET.call_count, 1) # Assert received args receivedHttpReq = self.AckServerResource.last_request.args self.assertEqual(len(receivedHttpReq), 8) self.assertEqual(receivedHttpReq['from'], [basePdu.params['source_addr']]) self.assertEqual(receivedHttpReq['to'], [basePdu.params['destination_addr']]) self.assertEqual(receivedHttpReq['content'], [ pdu_part1.params['short_message'][6:] + pdu_part2.params['short_message'][6:] + pdu_part3.params[ 'short_message'][6:]]) self.assertEqual(receivedHttpReq['binary'], [binascii.hexlify( pdu_part1.params['short_message'][6:] + pdu_part2.params['short_message'][6:] + pdu_part3.params[ 'short_message'][6:])]) self.assertEqual(receivedHttpReq['origin-connector'], [source_connector.cid]) # Disconnector from SMSC yield self.stopConnector(source_connector)
def setUp(self, interceptorpb_client=None): yield HappySMSCTestCase.setUp(self) self.encoder = pdu_encoding.PDUEncoder() # SMPPServerConfig init self.smpps_config = SMPPServerConfig() # Portal init _portal = portal.Portal(SmppsRealm(self.smpps_config.id, self.pbRoot_f)) _portal.registerChecker(RouterAuthChecker(self.pbRoot_f)) # Install mocks self.clientManager_f.perspective_submit_sm = mock.Mock( wraps=self.clientManager_f.perspective_submit_sm) # SMPPServerFactory init self.smpps_factory = LastProtoSMPPServerFactory( self.smpps_config, auth_portal=_portal, RouterPB=self.pbRoot_f, SMPPClientManagerPB=self.clientManager_f, interceptorpb_client=interceptorpb_client) self.smpps_port = reactor.listenTCP(self.smpps_config.port, self.smpps_factory) # Init protocol for testing self.smpps_proto = self.smpps_factory.buildProtocol(('127.0.0.1', 0)) self.smpps_tr = proto_helpers.StringTransport() self.smpps_proto.makeConnection(self.smpps_tr) # Add SMPPs factory to DLRThrower self.DLRThrower.addSmpps(self.smpps_factory) # Install mocks self.smpps_proto.sendPDU = mock.Mock(wraps=self.smpps_proto.sendPDU) # PDUs used for tests self.SubmitSmPDU = SubmitSM( source_addr='1234', destination_addr='4567', short_message='hello !', seqNum=1, ) self.DeliverSmPDU = DeliverSM( source_addr='4567', destination_addr='1234', short_message='any content', seqNum=1, ) self.DataSmPDU = DataSM( source_addr='4567', destination_addr='1234', message_payload='any content', seqNum=1, )
def test_unordered_long_content_delivery_HttpConnector(self): yield self.connect('127.0.0.1', self.pbPort) # Connect to SMSC source_connector = Connector(id_generator()) yield self.prepareRoutingsAndStartConnector(source_connector) # Send a deliver_sm from the SMSC basePdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='', sar_total_segments=3, sar_msg_ref_num=int(id_generator(size=2, chars=string.digits)), ) pdu_part1 = copy.deepcopy(basePdu) pdu_part2 = copy.deepcopy(basePdu) pdu_part3 = copy.deepcopy(basePdu) pdu_part1.params[ 'short_message'] = '__1st_part_with_153_char________________________________________________________________________________________________________________________________.' pdu_part1.params['sar_segment_seqnum'] = 1 pdu_part2.params[ 'short_message'] = '__2nd_part_with_153_char________________________________________________________________________________________________________________________________.' pdu_part2.params['sar_segment_seqnum'] = 2 pdu_part3.params['short_message'] = '__3rd_part_end.' pdu_part3.params['sar_segment_seqnum'] = 3 yield self.triggerDeliverSmFromSMSC([pdu_part1, pdu_part3, pdu_part2]) # Run tests # Destination connector must receive the message one time (no retries) self.assertEqual(self.AckServerResource.render_GET.call_count, 1) # Assert received args receivedHttpReq = self.AckServerResource.last_request.args self.assertEqual(len(receivedHttpReq), 8) self.assertEqual(receivedHttpReq['from'], [basePdu.params['source_addr']]) self.assertEqual(receivedHttpReq['to'], [basePdu.params['destination_addr']]) self.assertEqual(receivedHttpReq['content'], [ pdu_part1.params['short_message'] + pdu_part2.params['short_message'] + pdu_part3.params['short_message'] ]) self.assertEqual(receivedHttpReq['binary'], [ binascii.hexlify(pdu_part1.params['short_message'] + pdu_part2.params['short_message'] + pdu_part3.params['short_message']) ]) self.assertEqual(receivedHttpReq['origin-connector'], [source_connector.cid]) # Disconnector from SMSC yield self.stopConnector(source_connector)
def setUp(self): RouteTestCase.setUp(self) self.PDU_dst_1 = DeliverSM( source_addr='20203060', destination_addr='1', short_message='hello world', ) self.routable_connector1 = RoutableDeliverSm(self.PDU_dst_1, self.connector1) self.routable_connector2 = RoutableDeliverSm(self.PDU_dst_1, self.connector2)
def setUp(self): self.connector = SmppServerSystemIdConnector('jkl') self.script1 = MOInterceptorScript('abc') self.script2 = MOInterceptorScript('def') self.script3 = MOInterceptorScript('ghi') self.script4 = MOInterceptorScript('jkl') self.mt_filter1 = [SourceAddrFilter('^10\d+')] self.mt_filter2 = [DestinationAddrFilter('^90\d+')] self.transparent_filter = [TransparentFilter()] self.interceptor1 = StaticMOInterceptor(self.mt_filter1, self.script1) self.interceptor2 = StaticMOInterceptor(self.mt_filter2, self.script2) self.interceptor3 = StaticMOInterceptor(self.transparent_filter, self.script3) self.interceptor4 = DefaultInterceptor(self.script4) self.PDU_dst_1 = DeliverSM( source_addr='100', destination_addr='200', short_message='hello world', ) self.PDU_dst_2 = DeliverSM( source_addr='x', destination_addr='900', short_message='hello world', ) self.PDU_dst_3 = DeliverSM( source_addr='x', destination_addr='y', short_message='hello world', ) self.routable_matching_interceptor1 = RoutableDeliverSm( self.PDU_dst_1, self.connector) self.routable_matching_interceptor2 = RoutableDeliverSm( self.PDU_dst_2, self.connector) self.routable_notmatching_any = RoutableDeliverSm( self.PDU_dst_3, self.connector)
def setUp(self, authentication=False): # Initiating config objects without any filename # will lead to setting defaults and that's what we # need to run the tests self.InterceptorPBConfigInstance = InterceptorPBConfig() self.InterceptorPBConfigInstance.authentication = authentication # Launch the interceptor pb server pbRoot = InterceptorPB() pbRoot.setConfig(self.InterceptorPBConfigInstance) p = portal.Portal(JasminPBRealm(pbRoot)) if not authentication: p.registerChecker(AllowAnonymousAccess()) else: c = InMemoryUsernamePasswordDatabaseDontUse() c.addUser('test_user', md5('test_password').digest()) p.registerChecker(c) jPBPortalRoot = JasminPBPortalRoot(p) self.IPBServer = reactor.listenTCP(0, pb.PBServerFactory(jPBPortalRoot)) self.ipbPort = self.IPBServer.getHost().port # Test fixtures self.SubmitSMPDU = SubmitSM( source_addr='20203060', destination_addr='20203060', short_message='MT hello world', ) self.DeliverSMPDU = DeliverSM( source_addr='20203060', destination_addr='20203060', short_message='MO hello world', ) self.connector = Connector('abc') self.user = User(1, Group(100), 'username', 'password') # Routables fixtures self.routable_simple = SimpleRoutablePDU(self.connector, self.SubmitSMPDU, self.user, datetime.now()) # Scripts fixtures self.script_generic = InterceptorScript( 'somevar = "something in MOIS"') self.script_3_second = InterceptorScript('import time;time.sleep(3)') self.script_syntax_error = InterceptorScript('somevar = sssss') self.script_http_status = InterceptorScript('http_status = 404') self.script_smpp_status = InterceptorScript('smpp_status = 64')
def test_is_delivery_standard(self): pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='id:1891273321 sub:001 dlvrd:001 submit date:1305050826 done date:1305050826 stat:DELIVRD err:000 text:DLVRD TO MOBILE', ) isDlr = self.opFactory.isDeliveryReceipt(pdu) self.assertTrue(isDlr is not None) self.assertEquals(isDlr['id'], '1891273321') self.assertEquals(isDlr['sub'], '001') self.assertEquals(isDlr['dlvrd'], '001') self.assertEquals(isDlr['sdate'], '1305050826') self.assertEquals(isDlr['ddate'], '1305050826') self.assertEquals(isDlr['stat'], 'DELIVRD') self.assertEquals(isDlr['err'], '000') self.assertEquals(isDlr['text'], 'DLVRD TO MOBILE')
def test_is_delivery_jasmin_195(self): """Related to #195 Mandatory fields in short_message are parsed and optional fields are set to defaults when they dont exist in short_message""" pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='id:c87c2273-7edb-4bc7-8d3a-7f57f21b625e submit date:201506201641 done date:201506201641 stat:DELIVRD err:000', ) isDlr = self.opFactory.isDeliveryReceipt(pdu) self.assertTrue(isDlr is not None) self.assertEquals(isDlr['id'], 'c87c2273-7edb-4bc7-8d3a-7f57f21b625e') self.assertEquals(isDlr['sub'], 'ND') self.assertEquals(isDlr['dlvrd'], 'ND') self.assertEquals(isDlr['sdate'], '201506201641') self.assertEquals(isDlr['ddate'], '201506201641') self.assertEquals(isDlr['stat'], 'DELIVRD') self.assertEquals(isDlr['err'], '000') self.assertEquals(isDlr['text'], '')
def test_is_delivery_mmg_deliver_sm_224(self): """Related to #224, this is a Sicap's MMG deliver_sm receipt""" pdu = DeliverSM( source_addr='21698700177', destination_addr='JOOKIES', short_message='362d9701 2', message_state=MessageState.DELIVERED, receipted_message_id='362d9701', ) isDlr = self.opFactory.isDeliveryReceipt(pdu) self.assertTrue(isDlr is not None) self.assertEquals(isDlr['id'], '362d9701') self.assertEquals(isDlr['sub'], 'ND') self.assertEquals(isDlr['dlvrd'], 'ND') self.assertEquals(isDlr['sdate'], 'ND') self.assertEquals(isDlr['ddate'], 'ND') self.assertEquals(isDlr['stat'], 'DELIVRD') self.assertEquals(isDlr['err'], 'ND') self.assertEquals(isDlr['text'], '')
def test_is_delivery_jasmin_153(self): """Related to #153 Parsing jasmin's DLRs """ pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='id:4a38dc46-5125-4969-90be-72104c340d5c sub:001 dlvrd:001 submit date:150519232657 done date:150519232657 stat:DELIVRD err:000 text:-', ) isDlr = self.opFactory.isDeliveryReceipt(pdu) self.assertTrue(isDlr is not None) self.assertEquals(isDlr['id'], '4a38dc46-5125-4969-90be-72104c340d5c') self.assertEquals(isDlr['sub'], '001') self.assertEquals(isDlr['dlvrd'], '001') self.assertEquals(isDlr['sdate'], '150519232657') self.assertEquals(isDlr['ddate'], '150519232657') self.assertEquals(isDlr['stat'], 'DELIVRD') self.assertEquals(isDlr['err'], '000') self.assertEquals(isDlr['text'], '-')
def test_is_delivery_clickatell_70(self): """Related to #70 Parsing clickatell's DLRs """ pdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='id:a29f6845555647139e5c8f3b817f2c9a sub:001 dlvrd:001 submit date:141023215253 done date:141023215259 stat:DELIVRD err:000 text:HOLA', ) isDlr = self.opFactory.isDeliveryReceipt(pdu) self.assertTrue(isDlr is not None) self.assertEquals(isDlr['id'], 'a29f6845555647139e5c8f3b817f2c9a') self.assertEquals(isDlr['sub'], '001') self.assertEquals(isDlr['dlvrd'], '001') self.assertEquals(isDlr['sdate'], '141023215253') self.assertEquals(isDlr['ddate'], '141023215259') self.assertEquals(isDlr['stat'], 'DELIVRD') self.assertEquals(isDlr['err'], '000') self.assertEquals(isDlr['text'], 'HOLA')
def test_long_content_delivery_UDH_SmppsConnector(self): yield self.connect('127.0.0.1', self.pbPort) yield self.prepareRoutingsAndStartConnector() # Bind yield self.smppc_factory.connectAndBind() # Install mocks self.smppc_factory.lastProto.PDUDataRequestReceived = mock.Mock( wraps=self.smppc_factory.lastProto.PDUDataRequestReceived) # Build a UDH baseUdh = [] baseUdh.append(struct.pack('!B', 5)) # Length of User Data Header baseUdh.append( struct.pack('!B', 0) ) # Information Element Identifier, equal to 00 (Concatenated short messages, 8-bit reference number) baseUdh.append( struct.pack('!B', 3) ) # Length of the header, excluding the first two fields; equal to 03 baseUdh.append( struct.pack('!B', int(id_generator(size=2, chars=string.digits)))) # msg_ref_num baseUdh.append(struct.pack('!B', 3)) # total_segments # Send a deliver_sm from the SMSC basePdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='', esm_class=EsmClass(EsmClassMode.DEFAULT, EsmClassType.DEFAULT, [EsmClassGsmFeatures.UDHI_INDICATOR_SET]), ) pdu_part1 = copy.deepcopy(basePdu) udh_part1 = copy.deepcopy(baseUdh) pdu_part2 = copy.deepcopy(basePdu) udh_part2 = copy.deepcopy(baseUdh) pdu_part3 = copy.deepcopy(basePdu) udh_part3 = copy.deepcopy(baseUdh) udh_part1.append(struct.pack('!B', 1)) # segment_seqnum pdu_part1.params[ 'more_messages_to_send'] = MoreMessagesToSend.MORE_MESSAGES pdu_part1.params['short_message'] = ''.join( udh_part1 ) + '__1st_part_with_153_char________________________________________________________________________________________________________________________________.' udh_part2.append(struct.pack('!B', 2)) # segment_seqnum pdu_part2.params[ 'more_messages_to_send'] = MoreMessagesToSend.MORE_MESSAGES pdu_part2.params['short_message'] = ''.join( udh_part2 ) + '__2nd_part_with_153_char________________________________________________________________________________________________________________________________.' udh_part3.append(struct.pack('!B', 3)) # segment_seqnum pdu_part3.params[ 'more_messages_to_send'] = MoreMessagesToSend.NO_MORE_MESSAGES pdu_part3.params['short_message'] = ''.join( udh_part3) + '__3rd_part_end.' yield self.triggerDeliverSmFromSMSC([pdu_part1, pdu_part2, pdu_part3]) # Run tests self.assertEqual( self.smppc_factory.lastProto.PDUDataRequestReceived.call_count, 3) # First received pdu received_pdu_1 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 0][0][0] self.assertEqual(received_pdu_1.seqNum, 1) self.assertEqual(received_pdu_1.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_1.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_1.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_1.params['esm_class'], basePdu.params['esm_class']) self.assertEqual(received_pdu_1.params['short_message'][6:], pdu_part1.params['short_message'][6:]) # Second received pdu received_pdu_2 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 1][0][0] self.assertEqual(received_pdu_2.seqNum, 2) self.assertEqual(received_pdu_2.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_2.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_2.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_2.params['esm_class'], basePdu.params['esm_class']) self.assertEqual(received_pdu_2.params['short_message'][6:], pdu_part2.params['short_message'][6:]) # Third received pdu received_pdu_3 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 2][0][0] self.assertEqual(received_pdu_3.seqNum, 3) self.assertEqual(received_pdu_3.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_3.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_3.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_3.params['esm_class'], basePdu.params['esm_class']) self.assertEqual(received_pdu_3.params['short_message'][6:], pdu_part3.params['short_message'][6:]) # Unbind and disconnect yield self.smppc_factory.smpp.unbindAndDisconnect() yield self.stopSmppClientConnectors()
logger.addHandler(hdlr) logger.setLevel(logging.DEBUG) logger.debug("Received a routable from user %s", routable.user.uid) submit_sm = routable.pdu logger.debug("Got submit_sm: %s", submit_sm) deliver_sm = DeliverSM( submit_sm.seqNum, service_type=submit_sm.params['service_type'], source_addr_ton=submit_sm.params['source_addr_ton'], source_addr_npi=submit_sm.params['source_addr_npi'], source_addr=submit_sm.params['source_addr'], dest_addr_ton=submit_sm.params['dest_addr_ton'], dest_addr_npi=submit_sm.params['dest_addr_npi'], destination_addr=submit_sm.params['destination_addr'], esm_class=submit_sm.params['esm_class'], protocol_id=submit_sm.params['protocol_id'], priority_flag=submit_sm.params['priority_flag'], registered_delivery=submit_sm.params['registered_delivery'], replace_if_present_flag=submit_sm.params['replace_if_present_flag'], data_coding=submit_sm.params['data_coding'], short_message=submit_sm.params['short_message'], sm_default_msg_id=submit_sm.params['sm_default_msg_id']) logger.debug("Prepared a new deliver_sm: %s", deliver_sm) # Prepare for deliver_sm injection _routable = RoutableDeliverSm(deliver_sm, Connector(routable.user.uid)) content = DeliverSmContent(_routable, routable.user.uid, pickleProtocol=pickle.HIGHEST_PROTOCOL)
def test_long_content_delivery_SAR_SmppsConnector(self): yield self.connect('127.0.0.1', self.pbPort) yield self.prepareRoutingsAndStartConnector() # Bind yield self.smppc_factory.connectAndBind() # Install mocks self.smppc_factory.lastProto.PDUDataRequestReceived = mock.Mock( wraps=self.smppc_factory.lastProto.PDUDataRequestReceived) # Send a deliver_sm from the SMSC basePdu = DeliverSM( source_addr='1234', destination_addr='4567', short_message='', sar_total_segments=3, sar_msg_ref_num=int(id_generator(size=2, chars=string.digits)), ) pdu_part1 = copy.deepcopy(basePdu) pdu_part2 = copy.deepcopy(basePdu) pdu_part3 = copy.deepcopy(basePdu) pdu_part1.params[ 'short_message'] = '__1st_part_with_153_char________________________________________________________________________________________________________________________________.' pdu_part1.params['sar_segment_seqnum'] = 1 pdu_part2.params[ 'short_message'] = '__2nd_part_with_153_char________________________________________________________________________________________________________________________________.' pdu_part2.params['sar_segment_seqnum'] = 2 pdu_part3.params['short_message'] = '__3rd_part_end.' pdu_part3.params['sar_segment_seqnum'] = 3 yield self.triggerDeliverSmFromSMSC([pdu_part1, pdu_part2, pdu_part3]) # Run tests self.assertEqual( self.smppc_factory.lastProto.PDUDataRequestReceived.call_count, 3) # First received pdu received_pdu_1 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 0][0][0] self.assertEqual(received_pdu_1.seqNum, 1) self.assertEqual(received_pdu_1.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_1.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_1.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_1.params['short_message'], pdu_part1.params['short_message']) self.assertEqual(received_pdu_1.params['sar_segment_seqnum'], pdu_part1.params['sar_segment_seqnum']) # Second received pdu received_pdu_2 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 1][0][0] self.assertEqual(received_pdu_2.seqNum, 2) self.assertEqual(received_pdu_2.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_2.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_2.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_2.params['short_message'], pdu_part2.params['short_message']) self.assertEqual(received_pdu_2.params['sar_segment_seqnum'], pdu_part2.params['sar_segment_seqnum']) self.assertNotEqual(received_pdu_2.params['short_message'], received_pdu_1.params['short_message']) self.assertNotEqual(received_pdu_2.params['sar_segment_seqnum'], received_pdu_1.params['sar_segment_seqnum']) # Third received pdu received_pdu_3 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[ 2][0][0] self.assertEqual(received_pdu_3.seqNum, 3) self.assertEqual(received_pdu_3.id, pdu_types.CommandId.deliver_sm) self.assertEqual(received_pdu_3.params['source_addr'], basePdu.params['source_addr']) self.assertEqual(received_pdu_3.params['destination_addr'], basePdu.params['destination_addr']) self.assertEqual(received_pdu_3.params['short_message'], pdu_part3.params['short_message']) self.assertEqual(received_pdu_3.params['sar_segment_seqnum'], pdu_part3.params['sar_segment_seqnum']) self.assertNotEqual(received_pdu_3.params['short_message'], received_pdu_2.params['short_message']) self.assertNotEqual(received_pdu_3.params['sar_segment_seqnum'], received_pdu_2.params['sar_segment_seqnum']) # Unbind and disconnect yield self.smppc_factory.smpp.unbindAndDisconnect() yield self.stopSmppClientConnectors()
def getReceipt(self, dlr_pdu, msgid, source_addr, destination_addr, message_status, sub_date): "Will build a DataSm or a DeliverSm (depending on dlr_pdu) containing a receipt data" sm_message_stat = message_status # Prepare message_state if message_status[:5] == 'ESME_': if message_status == 'ESME_ROK': message_state = MessageState.ACCEPTED sm_message_stat = 'ACCEPTD' err = 0 else: message_state = MessageState.UNDELIVERABLE sm_message_stat = 'UNDELIV' err = 10 elif message_status == 'UNDELIV': message_state = MessageState.UNDELIVERABLE err = 10 elif message_status == 'REJECTD': message_state = MessageState.REJECTED err = 20 elif message_status == 'DELIVRD': err = 0 message_state = MessageState.DELIVERED elif message_status == 'EXPIRED': err = 30 message_state = MessageState.EXPIRED elif message_status == 'DELETED': err = 40 message_state = MessageState.DELETED elif message_status == 'ACCEPTD': err = 0 message_state = MessageState.ACCEPTED elif message_status == 'UNKNOWN': err = 50 message_state = MessageState.UNKNOWN else: raise UnknownMessageStatusError('Unknow message_status: %s' % message_status) # Build pdu if dlr_pdu == 'deliver_sm': short_message = r"id:%s submit date:%s done date:%s stat:%s err:%03d" % ( msgid, parser.parse(sub_date).strftime("%Y%m%d%H%M"), datetime.datetime.now().strftime("%Y%m%d%H%M"), sm_message_stat, err, ) # Build DeliverSM pdu pdu = DeliverSM( source_addr=destination_addr, destination_addr=source_addr, esm_class=EsmClass(EsmClassMode.DEFAULT, EsmClassType.SMSC_DELIVERY_RECEIPT), receipted_message_id=msgid, short_message=short_message, message_state=message_state, ) else: # Build DataSM pdu pdu = DataSM( source_addr=destination_addr, destination_addr=source_addr, esm_class=EsmClass(EsmClassMode.DEFAULT, EsmClassType.SMSC_DELIVERY_RECEIPT), receipted_message_id=msgid, message_state=message_state, ) return pdu