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
