def test_submit_sm_resp_explicit(self):
"""
FakeSMSC can respond to a SubmitSM PDU that is explicitly passed in.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
# No params.
submit_sm_resp_d = fake_smsc.submit_sm_resp(SubmitSM(123).obj)
self.assertNoResult(submit_sm_resp_d)
client.handle_pdu_d.callback(None)
self.successResultOf(submit_sm_resp_d)
resp = SubmitSMResp(123, message_id="id123", command_status="ESME_ROK")
self.assertEqual(client.pdus_handled, [resp.obj])
client.pdus_handled[:] = []
# Explicit message_id.
submit_sm_resp_d = fake_smsc.submit_sm_resp(SubmitSM(124).obj,
message_id="foo")
yield client.write(SubmitSM(124).get_bin())
self.assertNoResult(submit_sm_resp_d)
client.handle_pdu_d.callback(None)
self.successResultOf(submit_sm_resp_d)
resp = SubmitSMResp(124, message_id="foo", command_status="ESME_ROK")
self.assertEqual(client.pdus_handled, [resp.obj])
def test_mt_sms_queue_full(self):
smpp_helper = yield self.get_smpp_helper()
transport_config = smpp_helper.transport.get_static_config()
msg = self.tx_helper.make_outbound('hello world')
yield self.tx_helper.dispatch_outbound(msg)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm_pdu),
message_id='foo',
command_status='ESME_RMSGQFUL'))
self.clock.advance(transport_config.throttle_delay)
[submit_sm_pdu_retry] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm_pdu_retry),
message_id='bar',
command_status='ESME_ROK'))
self.assertTrue(seq_no(submit_sm_pdu_retry) > seq_no(submit_sm_pdu))
self.assertEqual(short_message(submit_sm_pdu), 'hello world')
self.assertEqual(short_message(submit_sm_pdu_retry), 'hello world')
[event] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(event['event_type'], 'ack')
self.assertEqual(event['user_message_id'], msg['message_id'])
def test_on_submit_sm_resp(self):
calls = []
self.patch(EsmeTransceiver, 'on_submit_sm_resp',
lambda p, *a: calls.append(a))
transport, protocol = yield self.setup_bind()
pdu = SubmitSMResp(sequence_number=0, message_id='foo')
protocol.dataReceived(pdu.get_bin())
self.assertEqual(calls, [(0, 'foo', 'ESME_ROK')])
def test_mt_sms_throttle_while_throttled(self):
smpp_helper = yield self.get_smpp_helper()
transport_config = smpp_helper.transport.get_static_config()
msg1 = self.tx_helper.make_outbound('hello world 1')
msg2 = self.tx_helper.make_outbound('hello world 2')
yield self.tx_helper.dispatch_outbound(msg1)
yield self.tx_helper.dispatch_outbound(msg2)
[ssm_pdu1, ssm_pdu2] = yield smpp_helper.wait_for_pdus(2)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(ssm_pdu1),
message_id='foo1',
command_status='ESME_RTHROTTLED'))
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(ssm_pdu2),
message_id='foo2',
command_status='ESME_RTHROTTLED'))
# Advance clock, still throttled.
self.clock.advance(transport_config.throttle_delay)
[ssm_pdu1_retry1] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(ssm_pdu1_retry1),
message_id='bar1',
command_status='ESME_RTHROTTLED'))
# Advance clock, message no longer throttled.
self.clock.advance(transport_config.throttle_delay)
[ssm_pdu2_retry1] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(ssm_pdu2_retry1),
message_id='bar2',
command_status='ESME_ROK'))
# Prod clock, message no longer throttled.
self.clock.advance(0)
[ssm_pdu1_retry2] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(ssm_pdu1_retry2),
message_id='baz1',
command_status='ESME_ROK'))
self.assertEqual(short_message(ssm_pdu1), 'hello world 1')
self.assertEqual(short_message(ssm_pdu2), 'hello world 2')
self.assertEqual(short_message(ssm_pdu1_retry1), 'hello world 1')
self.assertEqual(short_message(ssm_pdu2_retry1), 'hello world 2')
self.assertEqual(short_message(ssm_pdu1_retry2), 'hello world 1')
[event2, event1] = yield self.tx_helper.wait_for_dispatched_events(2)
self.assertEqual(event1['event_type'], 'ack')
self.assertEqual(event1['user_message_id'], msg1['message_id'])
self.assertEqual(event2['event_type'], 'ack')
self.assertEqual(event2['user_message_id'], msg2['message_id'])
def test_failed_submit(self):
message = yield self.tx_helper.make_dispatch_outbound(
"message", message_id='446')
response = SubmitSMResp(
1, "3rd_party_id_3", command_status="ESME_RSUBMITFAIL")
yield self.esme.handle_data(response.get_bin())
self.assert_sent_contents(["message"])
# There should be a nack
[nack] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(nack['user_message_id'], message['message_id'])
self.assertEqual(nack['nack_reason'], 'ESME_RSUBMITFAIL')
[failure] = yield self.tx_helper.get_dispatched_failures()
self.assertEqual(failure['reason'], 'ESME_RSUBMITFAIL')
def _submit_sm_resp(self, submit_sm_pdu, message_id, **kw):
self.assert_command_id(submit_sm_pdu, 'submit_sm')
sequence_number = seq_no(submit_sm_pdu)
if message_id is None:
message_id = "id%s" % (sequence_number, )
# We use handle_pdu here to avoid complications with all the async.
return self.handle_pdu(SubmitSMResp(sequence_number, message_id, **kw))
def test_failed_submit(self):
message = yield self.tx_helper.make_dispatch_outbound("message",
message_id='446')
response = SubmitSMResp(1,
"3rd_party_id_3",
command_status="ESME_RSUBMITFAIL")
yield self.esme.handle_data(response.get_bin())
self.assert_sent_contents(["message"])
# There should be a nack
[nack] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(nack['user_message_id'], message['message_id'])
self.assertEqual(nack['nack_reason'], 'ESME_RSUBMITFAIL')
[failure] = yield self.tx_helper.get_dispatched_failures()
self.assertEqual(failure['reason'], 'ESME_RSUBMITFAIL')
def test_on_submit_sm_resp(self):
protocol = yield self.get_protocol()
yield self.fake_smsc.bind()
calls = []
protocol.on_submit_sm_resp = lambda *a: calls.append(a)
yield self.fake_smsc.send_pdu(SubmitSMResp(0, message_id='foo'))
self.assertEqual(calls, [(0, 'foo', 'ESME_ROK')])
def handle_submit_sm(self, pdu):
if pdu['header']['command_status'] == 'ESME_ROK':
sequence_number = pdu['header']['sequence_number']
message_id = str(uuid.uuid4())
command_status = self.command_status(pdu)
pdu_resp = SubmitSMResp(
sequence_number, message_id, command_status)
self.send_pdu(pdu_resp)
reactor.callLater(0, self.delivery_report, message_id)
def test_out_of_order_responses(self):
# Sequence numbers are hardcoded, assuming we start fresh from 0.
yield self.tx_helper.make_dispatch_outbound("msg 1", message_id='444')
response1 = SubmitSMResp(1, "3rd_party_id_1")
yield self.tx_helper.make_dispatch_outbound("msg 2", message_id='445')
response2 = SubmitSMResp(2, "3rd_party_id_2")
self.assert_sent_contents(["msg 1", "msg 2"])
# respond out of order - just to keep things interesting
yield self.esme.handle_data(response2.get_bin())
yield self.esme.handle_data(response1.get_bin())
[ack1, ack2] = self.tx_helper.get_dispatched_events()
self.assertEqual(ack1['user_message_id'], '445')
self.assertEqual(ack1['sent_message_id'], '3rd_party_id_2')
self.assertEqual(ack2['user_message_id'], '444')
self.assertEqual(ack2['sent_message_id'], '3rd_party_id_1')
def test_mt_sms_multipart_ack(self):
smpp_helper = yield self.get_smpp_helper(
config={
'submit_short_message_processor_config': {
'send_multipart_udh': True,
}
})
content = '1' * 161
msg = self.tx_helper.make_outbound(content)
yield self.tx_helper.dispatch_outbound(msg)
[submit_sm1, submit_sm2] = yield smpp_helper.wait_for_pdus(2)
smpp_helper.send_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm1), message_id='foo'))
smpp_helper.send_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm2), message_id='bar'))
[event] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(event['event_type'], 'ack')
self.assertEqual(event['user_message_id'], msg['message_id'])
self.assertEqual(event['sent_message_id'], 'bar,foo')
def test_out_of_order_responses(self):
smpp_helper = yield self.get_smpp_helper()
yield self.tx_helper.make_dispatch_outbound("msg 1", message_id='444')
[submit_sm1] = yield smpp_helper.wait_for_pdus(1)
response1 = SubmitSMResp(seq_no(submit_sm1), "3rd_party_id_1")
yield self.tx_helper.make_dispatch_outbound("msg 2", message_id='445')
[submit_sm2] = yield smpp_helper.wait_for_pdus(1)
response2 = SubmitSMResp(seq_no(submit_sm2), "3rd_party_id_2")
# respond out of order - just to keep things interesting
yield smpp_helper.handle_pdu(response2)
yield smpp_helper.handle_pdu(response1)
[ack1, ack2] = yield self.tx_helper.wait_for_dispatched_events(2)
self.assertEqual(ack1['user_message_id'], '445')
self.assertEqual(ack1['sent_message_id'], '3rd_party_id_2')
self.assertEqual(ack2['user_message_id'], '444')
self.assertEqual(ack2['sent_message_id'], '3rd_party_id_1')
def test_mt_sms_ack(self):
smpp_helper = yield self.get_smpp_helper()
msg = self.tx_helper.make_outbound('hello world')
yield self.tx_helper.dispatch_outbound(msg)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
smpp_helper.send_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm_pdu),
message_id='foo'))
[event] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(event['event_type'], 'ack')
self.assertEqual(event['user_message_id'], msg['message_id'])
self.assertEqual(event['sent_message_id'], 'foo')
def test_throttled_submit_ESME_RMSGQFUL(self):
clock = Clock()
self.transport.callLater = clock.callLater
def assert_throttled_status(throttled, messages, acks):
self.assertEqual(self.transport.throttled, throttled)
self.assert_sent_contents(messages)
self.assertEqual(acks,
[(m['user_message_id'], m['sent_message_id'])
for m in self.tx_helper.get_dispatched_events()])
self.assertEqual([], self.tx_helper.get_dispatched_failures())
assert_throttled_status(False, [], [])
yield self.tx_helper.make_dispatch_outbound("Heimlich",
message_id="447")
response = SubmitSMResp(1,
"3rd_party_id_4",
command_status="ESME_RMSGQFUL")
yield self.esme.handle_data(response.get_bin())
assert_throttled_status(True, ["Heimlich"], [])
# Still waiting to resend
clock.advance(0.05)
yield self.transport.redis.exists('wait for redis')
assert_throttled_status(True, ["Heimlich"], [])
# Don't wait for this, because it won't be processed until later.
self.tx_helper.make_dispatch_outbound("Other", message_id="448")
assert_throttled_status(True, ["Heimlich"], [])
# Resent
clock.advance(0.05)
yield self.transport.redis.exists('wait for redis')
assert_throttled_status(True, ["Heimlich", "Heimlich"], [])
# And acknowledged by the other side
yield self.esme.handle_data(SubmitSMResp(2, "3rd_party_5").get_bin())
yield self.tx_helper.kick_delivery()
yield self.esme.handle_data(SubmitSMResp(3, "3rd_party_6").get_bin())
assert_throttled_status(False, ["Heimlich", "Heimlich", "Other"],
[('447', '3rd_party_5'),
('448', '3rd_party_6')])
def test_throttled_submit_ESME_RMSGQFUL(self):
clock = Clock()
self.transport.callLater = clock.callLater
def assert_throttled_status(throttled, messages, acks):
self.assertEqual(self.transport.throttled, throttled)
self.assert_sent_contents(messages)
self.assertEqual(acks, [
(m['user_message_id'], m['sent_message_id'])
for m in self.tx_helper.get_dispatched_events()])
self.assertEqual([], self.tx_helper.get_dispatched_failures())
assert_throttled_status(False, [], [])
yield self.tx_helper.make_dispatch_outbound(
"Heimlich", message_id="447")
response = SubmitSMResp(1, "3rd_party_id_4",
command_status="ESME_RMSGQFUL")
yield self.esme.handle_data(response.get_bin())
assert_throttled_status(True, ["Heimlich"], [])
# Still waiting to resend
clock.advance(0.05)
yield self.transport.redis.exists('wait for redis')
assert_throttled_status(True, ["Heimlich"], [])
# Don't wait for this, because it won't be processed until later.
self.tx_helper.make_dispatch_outbound("Other", message_id="448")
assert_throttled_status(True, ["Heimlich"], [])
# Resent
clock.advance(0.05)
yield self.transport.redis.exists('wait for redis')
assert_throttled_status(True, ["Heimlich", "Heimlich"], [])
# And acknowledged by the other side
yield self.esme.handle_data(SubmitSMResp(2, "3rd_party_5").get_bin())
yield self.tx_helper.kick_delivery()
yield self.esme.handle_data(SubmitSMResp(3, "3rd_party_6").get_bin())
assert_throttled_status(
False, ["Heimlich", "Heimlich", "Other"],
[('447', '3rd_party_5'), ('448', '3rd_party_6')])
def test_message_clearing(self):
smpp_helper = yield self.get_smpp_helper()
transport = smpp_helper.transport
message_stash = transport.message_stash
msg = self.tx_helper.make_outbound('hello world')
yield message_stash.set_sequence_number_message_id(
3, msg['message_id'])
yield message_stash.cache_message(msg)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=3,
message_id='foo',
command_status='ESME_ROK'))
self.assertEqual(
None, (yield message_stash.get_cached_message(msg['message_id'])))
def test_mt_sms_throttled(self):
smpp_helper = yield self.get_smpp_helper()
transport_config = smpp_helper.transport.get_static_config()
msg = self.tx_helper.make_outbound('hello world')
yield self.tx_helper.dispatch_outbound(msg)
[submit_sm_pdu] = yield smpp_helper.wait_for_pdus(1)
with LogCatcher(message="Throttling outbound messages.") as lc:
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm_pdu),
message_id='foo',
command_status='ESME_RTHROTTLED'))
[logmsg] = lc.logs
self.assertEqual(logmsg['logLevel'], logging.WARNING)
self.clock.advance(transport_config.throttle_delay)
[submit_sm_pdu_retry] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm_pdu_retry),
message_id='bar',
command_status='ESME_ROK'))
self.assertTrue(seq_no(submit_sm_pdu_retry) > seq_no(submit_sm_pdu))
self.assertEqual(short_message(submit_sm_pdu), 'hello world')
self.assertEqual(short_message(submit_sm_pdu_retry), 'hello world')
[event] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(event['event_type'], 'ack')
self.assertEqual(event['user_message_id'], msg['message_id'])
# We're still throttled until our next attempt to unthrottle finds no
# messages to retry.
with LogCatcher(message="No longer throttling outbound") as lc:
self.clock.advance(transport_config.throttle_delay)
[logmsg] = lc.logs
self.assertEqual(logmsg['logLevel'], logging.WARNING)
def test_mt_sms_failure(self):
smpp_helper = yield self.get_smpp_helper()
message = yield self.tx_helper.make_dispatch_outbound("message",
message_id='446')
[submit_sm] = yield smpp_helper.wait_for_pdus(1)
response = SubmitSMResp(seq_no(submit_sm),
"3rd_party_id_3",
command_status="ESME_RSUBMITFAIL")
# A failure PDU might not have a body.
response.obj.pop('body')
smpp_helper.send_pdu(response)
# There should be a nack
[nack] = yield self.tx_helper.wait_for_dispatched_events(1)
[failure] = yield self.tx_helper.get_dispatched_failures()
self.assertEqual(failure['reason'], 'ESME_RSUBMITFAIL')
self.assertEqual(failure['message'], message.payload)
def test_mt_sms_seq_num_lookup_failure(self):
smpp_helper = yield self.get_smpp_helper()
lc = LogCatcher(message="Failed to retrieve message id")
with lc:
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=0xbad, message_id='bad'))
# Make sure we didn't store 'None' in redis.
message_stash = smpp_helper.transport.message_stash
message_id = yield message_stash.get_internal_message_id('bad')
self.assertEqual(message_id, None)
# check that failure to send ack/nack was logged
[warning] = lc.logs
expected_msg = (
"Failed to retrieve message id for deliver_sm_resp. ack/nack"
" from %s discarded.") % (self.tx_helper.transport_name, )
self.assertEqual(warning['message'], (expected_msg, ))
def test_link_remote_message_id(self):
smpp_helper = yield self.get_smpp_helper()
transport = smpp_helper.transport
config = transport.get_static_config()
msg = self.tx_helper.make_outbound('hello world')
yield self.tx_helper.dispatch_outbound(msg)
[pdu] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(pdu),
message_id='foo',
command_status='ESME_ROK'))
self.assertEqual(
msg['message_id'],
(yield transport.message_stash.get_internal_message_id('foo')))
ttl = yield transport.redis.ttl(remote_message_key('foo'))
self.assertTrue(0 < ttl <= config.third_party_id_expiry)
def test_mt_sms_failure_with_no_reason(self):
smpp_helper = yield self.get_smpp_helper()
message = yield self.tx_helper.make_dispatch_outbound("message",
message_id='446')
[submit_sm] = yield smpp_helper.wait_for_pdus(1)
yield smpp_helper.handle_pdu(
SubmitSMResp(sequence_number=seq_no(submit_sm),
message_id='foo',
command_status=None))
# There should be a nack
[nack] = yield self.tx_helper.wait_for_dispatched_events(1)
self.assertEqual(nack['user_message_id'], message['message_id'])
self.assertEqual(nack['nack_reason'], 'Unspecified')
[failure] = yield self.tx_helper.get_dispatched_failures()
self.assertEqual(failure['reason'], 'Unspecified')
def test_out_of_order_responses(self):
# Sequence numbers are hardcoded, assuming we start fresh from 0.
yield self.tx_helper.make_dispatch_outbound("msg 1", message_id='444')
response1 = SubmitSMResp(1, "3rd_party_id_1")
yield self.tx_helper.make_dispatch_outbound("msg 2", message_id='445')
response2 = SubmitSMResp(2, "3rd_party_id_2")
self.assert_sent_contents(["msg 1", "msg 2"])
# respond out of order - just to keep things interesting
yield self.esme.handle_data(response2.get_bin())
yield self.esme.handle_data(response1.get_bin())
[ack1, ack2] = self.tx_helper.get_dispatched_events()
self.assertEqual(ack1['user_message_id'], '445')
self.assertEqual(ack1['sent_message_id'], '3rd_party_id_2')
self.assertEqual(ack2['user_message_id'], '444')
self.assertEqual(ack2['sent_message_id'], '3rd_party_id_1')
def test_match_resp(self):
message1 = self.mkmsg_out(
message_id='444',
content="hello world",
to_addr="1111111111")
sequence_num1 = self.esme.get_seq()
response1 = SubmitSMResp(sequence_num1, "3rd_party_id_1")
yield self.transport._process_message(message1)
message2 = self.mkmsg_out(
message_id='445',
content="hello world",
to_addr="1111111111")
sequence_num2 = self.esme.get_seq()
response2 = SubmitSMResp(sequence_num2, "3rd_party_id_2")
yield self.transport._process_message(message2)
# respond out of order - just to keep things interesting
self.esme.handle_data(response2.get_bin())
self.esme.handle_data(response1.get_bin())
self.assertEqual([
self.mkmsg_ack('445', '3rd_party_id_2'),
self.mkmsg_ack('444', '3rd_party_id_1'),
], self.get_dispatched_events())
message3 = self.mkmsg_out(
message_id='446',
content="hello world",
to_addr="1111111111")
sequence_num3 = self.esme.get_seq()
response3 = SubmitSMResp(sequence_num3, "3rd_party_id_3",
command_status="ESME_RSUBMITFAIL")
self.transport._process_message(message3)
self.esme.handle_data(response3.get_bin())
# There should be no ack
self.assertEqual([], self.get_dispatched_events()[2:])
comparison = self.mkmsg_fail(message3.payload, 'ESME_RSUBMITFAIL')
actual = self.get_dispatched_failures()[0]
self.assertEqual(actual, comparison)
message4 = self.mkmsg_out(
message_id=447,
content="hello world",
to_addr="1111111111")
sequence_num4 = self.esme.get_seq()
response4 = SubmitSMResp(sequence_num4, "3rd_party_id_4",
command_status="ESME_RTHROTTLED")
self.transport._process_message(message4)
self.esme.handle_data(response4.get_bin())
# There should be no ack
self.assertEqual([], self.get_dispatched_events()[3:])
comparison = self.mkmsg_fail(message4.payload, 'ESME_RTHROTTLED')
actual = self.get_dispatched_failures()[1]
self.assertEqual(actual, comparison)
def test_match_resp(self):
message1 = self.mkmsg_out(
message_id='444',
content="hello world",
to_addr="1111111111")
sequence_num1 = self.esme.getSeq()
response1 = SubmitSMResp(sequence_num1, "3rd_party_id_1")
yield self.transport._process_message(message1)
message2 = self.mkmsg_out(
message_id='445',
content="hello world",
to_addr="1111111111")
sequence_num2 = self.esme.getSeq()
response2 = SubmitSMResp(sequence_num2, "3rd_party_id_2")
yield self.transport._process_message(message2)
# respond out of order - just to keep things interesting
self.esme.handleData(response2.get_bin())
self.esme.handleData(response1.get_bin())
self.assertEqual([
self.mkmsg_ack('445', '3rd_party_id_2'),
self.mkmsg_ack('444', '3rd_party_id_1'),
], self.get_dispatched_events())
message3 = self.mkmsg_out(
message_id=446,
content="hello world",
to_addr="1111111111")
sequence_num3 = self.esme.getSeq()
response3 = SubmitSMResp(sequence_num3, "3rd_party_id_3",
command_status="ESME_RSUBMITFAIL")
self.transport._process_message(message3)
self.esme.handleData(response3.get_bin())
self.assertEqual([self.mkmsg_ack('446', '3rd_party_id_3')],
self.get_dispatched_events()[2:])
self.assertEqual([self.mkmsg_fail({'id': '446'}, 'ESME_RSUBMITFAIL')],
self.get_dispatched_failures())
message4 = self.mkmsg_out(
message_id=447,
content="hello world",
to_addr="1111111111")
sequence_num4 = self.esme.getSeq()
response4 = SubmitSMResp(sequence_num4, "3rd_party_id_4",
command_status="ESME_RTHROTTLED")
self.transport._process_message(message4)
self.esme.handleData(response4.get_bin())
self.assertEqual([self.mkmsg_ack('447', '3rd_party_id_4')],
self.get_dispatched_events()[3:])
self.assertTrue(self.transport.throttle_invoked_via_pdu)
fail_msg = self.mkmsg_out(
message_id=555,
content="hello world",
to_addr="1111111111")
self.transport.send_failure(fail_msg, Exception("Foo"), "testing")
self.assertEqual([self.mkmsg_fail(fail_msg.payload, "testing")],
self.get_dispatched_failures()[1:])
# Some error codes would occur on bind attempts
bind_dispatch_methods = {
"ESME_ROK": self.transport.ok,
"ESME_RINVBNDSTS": self.transport.conn_tempfault,
"ESME_RALYBND": self.transport.conn_tempfault,
"ESME_RSYSERR": self.transport.conn_permfault,
"ESME_RBINDFAIL": self.transport.conn_permfault,
"ESME_RINVPASWD": self.transport.conn_permfault,
"ESME_RINVSYSID": self.transport.conn_permfault,
"ESME_RINVSERTYP": self.transport.conn_permfault,
}
# Some error codes would occur post bind i.e. on submission attempts
submit_dispatch_methods = {
"ESME_RINVMSGLEN": self.transport.mess_permfault,
"ESME_RINVCMDLEN": self.transport.mess_permfault,
"ESME_RINVCMDID": self.transport.mess_permfault,
"ESME_RINVPRTFLG": self.transport.mess_permfault,
"ESME_RINVREGDLVFLG": self.transport.mess_permfault,
"ESME_RINVSRCADR": self.transport.mess_permfault,
"ESME_RINVDSTADR": self.transport.mess_permfault,
"ESME_RINVMSGID": self.transport.mess_permfault,
"ESME_RCANCELFAIL": self.transport.mess_permfault,
"ESME_RREPLACEFAIL": self.transport.mess_permfault,
"ESME_RMSGQFUL": self.transport.conn_throttle,
"ESME_RINVNUMDESTS": self.transport.mess_permfault,
"ESME_RINVDLNAME": self.transport.mess_permfault,
"ESME_RINVDESTFLAG": self.transport.mess_permfault,
"ESME_RINVSUBREP": self.transport.mess_permfault,
"ESME_RINVESMCLASS": self.transport.mess_permfault,
"ESME_RCNTSUBDL": self.transport.mess_permfault,
"ESME_RSUBMITFAIL": self.transport.mess_tempfault,
"ESME_RINVSRCTON": self.transport.mess_permfault,
"ESME_RINVSRCNPI": self.transport.mess_permfault,
"ESME_RINVDSTTON": self.transport.mess_permfault,
"ESME_RINVDSTNPI": self.transport.mess_permfault,
"ESME_RINVSYSTYP": self.transport.conn_permfault,
"ESME_RINVREPFLAG": self.transport.mess_permfault,
"ESME_RINVNUMMSGS": self.transport.mess_tempfault,
"ESME_RTHROTTLED": self.transport.conn_throttle,
"ESME_RINVSCHED": self.transport.mess_permfault,
"ESME_RINVEXPIRY": self.transport.mess_permfault,
"ESME_RINVDFTMSGID": self.transport.mess_permfault,
"ESME_RX_T_APPN": self.transport.mess_tempfault,
"ESME_RX_P_APPN": self.transport.mess_permfault,
"ESME_RX_R_APPN": self.transport.mess_permfault,
"ESME_RQUERYFAIL": self.transport.mess_permfault,
"ESME_RINVOPTPARSTREAM": self.transport.mess_permfault,
"ESME_ROPTPARNOTALLWD": self.transport.mess_permfault,
"ESME_RINVPARLEN": self.transport.mess_permfault,
"ESME_RMISSINGOPTPARAM": self.transport.mess_permfault,
"ESME_RINVOPTPARAMVAL": self.transport.mess_permfault,
"ESME_RDELIVERYFAILURE": self.transport.mess_tempfault,
"ESME_RUNKNOWNERR": self.transport.mess_tempfault,
}
# Also have unknown error codes
newfangled_fake_error = {
"ESME_NEWFNGLEDFAKERR": self.esme.dummy_unknown,
}
for code, method in bind_dispatch_methods.items():
response = BindTransceiverResp(1, code)
# check the dispatcher returns the correct transport method
self.assertEquals(method,
self.esme.command_status_dispatch(response.get_obj()))
for code, method in submit_dispatch_methods.items():
response = SubmitSMResp(1, "2", code)
# check the dispatcher returns the correct transport method
self.assertEquals(method,
self.esme.command_status_dispatch(response.get_obj()))
for code, method in newfangled_fake_error.items():
response = SubmitSMResp(1, "2", code)
# check the dispatcher returns the correct transport method
self.assertEquals(method,
self.esme.command_status_dispatch(response.get_obj()))
