def test_rate_success(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate'
params = {
'to': '06155423',
'username': self.u1.username,
'password': self.u1_password
}
# We should receive an error since interceptorpb is not connected
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(url, params=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(_ic + 1, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec, self.stats_http.get('interceptor_error_count'))
def test_rate_success(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate?to=06155423&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Asserts
self.assertEqual(lastErrorStatus, None)
self.assertEqual(_ic + 1, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec, self.stats_http.get('interceptor_error_count'))
def setUp(self):
if hasattr(self, 'ipb_client'):
yield HappySMSCTestCase.setUp(self, interceptorpb_client = self.ipb_client)
else:
yield HappySMSCTestCase.setUp(self)
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
# Provision user, group, default mt route and
# default mt interceptor
self.g1 = Group(1)
yield self.group_add(self.g1)
self.c1 = SmppClientConnector(id_generator())
self.mt_interceptor = MTInterceptorScript(self.script)
self.u1_password = '******'
self.u1 = User(1, self.g1, 'username', self.u1_password)
self.u2_password = '******'
self.u2 = User(1, self.g1, 'username2', self.u2_password)
yield self.user_add(self.u1)
yield self.mtroute_add(DefaultRoute(self.c1), 0)
yield self.mtinterceptor_add(DefaultInterceptor(self.mt_interceptor), 0)
# Now we'll create the connector
yield self.SMPPClientManagerPBProxy.connect('127.0.0.1', self.CManagerPort)
c1Config = SMPPClientConfig(id=self.c1.cid, port = self.SMSCPort.getHost().port)
yield self.SMPPClientManagerPBProxy.add(c1Config)
# And start it !
yield self.SMPPClientManagerPBProxy.start(self.c1.cid)
# Get stats singletons
self.stats_http = HttpAPIStatsCollector().get()
def test_rate_HTTP_300_from_script(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_HTTP_300)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate?to=06155423&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, '300')
self.assertEqual(lastResponse,
'"Interception specific error code 300"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_send_with_tags(self):
"""Related to #455
Will send message through http api using tags and then assert for getting the tags into the short_message
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(
self.update_message_from_tags_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=temporary&username=%s&password=%s&tags=%s' % (
self.u1.username, self.u1_password, '123,456')
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, None)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
'[\'123\', \'456\']', self.SMSCPort.factory.lastClient.
submitRecords[0].params['short_message'])
def test_rate_ESME_RINVESMCLASS_from_script(self):
"Will ensure if script defines only smpp error it will implicitly cause a http 520 error"
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_ESME_RINVESMCLASS)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate?to=06155423&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception, e:
lastErrorStatus = e.status
lastResponse = e.response
def test_send_and_lock_param(self):
"""Related to #458
Will set and lock sm_default_msg_id inside interceptor and assert it were kept as set.
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.lock_param_script)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=temporary&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, None)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
10, self.SMSCPort.factory.lastClient.submitRecords[0].
params['sm_default_msg_id'])
def setUp(self):
if hasattr(self, 'ipb_client'):
yield SMPPClientTestCases.setUp(
self, interceptorpb_client=self.ipb_client)
else:
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()
# Launch the deliverSmThrower
self.deliverSmThrower = deliverSmThrower(
deliverSmThrowerConfigInstance)
# Add the broker to the deliverSmThrower
yield self.deliverSmThrower.addAmqpBroker(self.amqpBroker)
# Add SMPPs factory to DLRThrower
self.deliverSmThrower.addSmpps(self.smpps_factory)
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
# Provision mt interceptor
self.mo_interceptor = MOInterceptorScript(self.script)
yield self.mointerceptor_add(DefaultInterceptor(self.mo_interceptor),
0)
# Disconnect from RouterPB
self.disconnect()
def test_tagging(self):
"""Refs #495
Will tag message inside interceptor script and assert
routing based tagfilter were correctly done
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript("routable.addTag(10)")
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Change routing rules by shadowing (high order value) default route with a
# static route having a tagfilter
yield self.mtroute_flush()
yield self.mtroute_add(StaticMTRoute([TagFilter(10)], self.c1, 0.0),
1000)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=test&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception, e:
lastErrorStatus = e.status
lastResponse = e.response
def test_HTTP_300_from_script(self):
"Will ensure if script defines only http error it will implicitly cause a smpp ESME_RUNKNOWNERR error"
_ic = self.stats_smpps.get('interceptor_count')
_iec = self.stats_smpps.get('interceptor_error_count')
# Re-provision interceptor with script returning a HTTP 300
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
mt_interceptor = MTInterceptorScript(self.return_HTTP_300)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
# Bind
yield self.smppc_factory.connectAndBind()
# Install mocks
self.smpps_factory.lastProto.sendPDU = mock.Mock(
wraps=self.smpps_factory.lastProto.sendPDU)
# Send a SMS MT through smpps interface
yield self.smppc_factory.lastProto.sendDataRequest(self.SubmitSmPDU)
# Wait 3 seconds for submit_sm_resp
yield waitFor(3)
# Unbind & Disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
# Run tests on final destination smpp server (third party mocker)
self.assertEqual(0,
len(self.SMSCPort.factory.lastClient.submitRecords))
# Run tests on Jasmin's SMPPs
self.assertEqual(self.smpps_factory.lastProto.sendPDU.call_count, 2)
# smpps response was a submit_sm_resp with ESME_ROK
response_pdu = self.smpps_factory.lastProto.sendPDU.call_args_list[0][
0][0]
self.assertEqual(response_pdu.id, pdu_types.CommandId.submit_sm_resp)
self.assertEqual(response_pdu.seqNum, 2)
self.assertEqual(response_pdu.status,
pdu_types.CommandStatus.ESME_RUNKNOWNERR)
self.assertTrue('message_id' not in response_pdu.params)
self.assertEqual(_ic, self.stats_smpps.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_smpps.get('interceptor_error_count'))
def test_success(self):
_ic = self.stats_smpps.get('interceptor_count')
_iec = self.stats_smpps.get('interceptor_error_count')
# Re-provision interceptor with correct script
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
# Bind
yield self.smppc_factory.connectAndBind()
# Install mocks
self.smpps_factory.lastProto.sendPDU = mock.Mock(
wraps=self.smpps_factory.lastProto.sendPDU)
# Send a SMS MT through smpps interface
yield self.smppc_factory.lastProto.sendDataRequest(self.SubmitSmPDU)
# Wait 3 seconds for submit_sm_resp
yield waitFor(3)
# Unbind & Disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
# Run tests on final destination smpp server (third party mocker)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
# Run tests on Jasmin's SMPPs
self.assertEqual(self.smpps_factory.lastProto.sendPDU.call_count, 2)
# smpps response was a submit_sm_resp with ESME_ROK
response_pdu = self.smpps_factory.lastProto.sendPDU.call_args_list[0][
0][0]
self.assertEqual(response_pdu.id, pdu_types.CommandId.submit_sm_resp)
self.assertEqual(response_pdu.seqNum, 2)
self.assertEqual(response_pdu.status, pdu_types.CommandStatus.ESME_ROK)
self.assertNotEqual(None, response_pdu.params['message_id'])
# Message content has been updated
self.assertEqual(
'Intercepted message', self.SMSCPort.factory.lastClient.
submitRecords[0].params['short_message'])
self.assertEqual(_ic + 1, self.stats_smpps.get('interceptor_count'))
self.assertEqual(_iec, self.stats_smpps.get('interceptor_error_count'))
def test_success(self):
# Re-provision interceptor with correct script
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
mo_interceptor = MOInterceptorScript(self.update_message_sript)
yield self.mointerceptor_add(DefaultInterceptor(mo_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
_ic = self.stats_smppc.get('interceptor_count')
_iec = self.stats_smppc.get('interceptor_error_count')
# Bind
yield self.smppc_factory.connectAndBind()
# Install mocks
self.smppc_factory.lastProto.PDUDataRequestReceived = Mock(
wraps=self.smppc_factory.lastProto.PDUDataRequestReceived)
# Send a deliver_sm from the SMSC
yield self.triggerDeliverSmFromSMSC([self.DeliverSmPDU])
# Run tests on downstream smpp client
self.assertEqual(
self.smppc_factory.lastProto.PDUDataRequestReceived.call_count, 1)
received_pdu_1 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[
0][0][0]
self.assertEqual(received_pdu_1.id, pdu_types.CommandId.deliver_sm)
self.assertEqual(received_pdu_1.params['short_message'],
b'Intercepted message')
# Run tests on upstream smpp client
self.assertEqual(len(self.SMSCPort.factory.lastClient.pduRecords), 2)
sent_back_resp = self.SMSCPort.factory.lastClient.pduRecords[1]
self.assertEqual(sent_back_resp.id,
pdu_types.CommandId.deliver_sm_resp)
self.assertEqual(sent_back_resp.status,
pdu_types.CommandStatus.ESME_ROK)
self.assertEqual(_ic + 1, self.stats_smppc.get('interceptor_count'))
self.assertEqual(_iec, self.stats_smppc.get('interceptor_error_count'))
# Unbind and disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
def setUp(self):
if hasattr(self, 'ipb_client'):
yield SMPPClientTestCases.setUp(self, interceptorpb_client=self.ipb_client)
else:
yield SMPPClientTestCases.setUp(self)
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
# Provision mt interceptor
self.mt_interceptor = MTInterceptorScript(self.script)
yield self.mtinterceptor_add(DefaultInterceptor(self.mt_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Get stats singletons
self.stats_smpps = SMPPServerStatsCollector().get(cid=self.smpps_config.id)
def test_HTTP_300_from_script(self):
"Will ensure if script defines only http error it will implicitly cause a smpp ESME_RUNKNOWNERR error"
# Re-provision interceptor with script returning a HTTP 300
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
mo_interceptor = MOInterceptorScript(self.return_HTTP_300)
yield self.mointerceptor_add(DefaultInterceptor(mo_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
_ic = self.stats_smppc.get('interceptor_count')
_iec = self.stats_smppc.get('interceptor_error_count')
# Bind
yield self.smppc_factory.connectAndBind()
# Install mocks
self.smppc_factory.lastProto.PDUDataRequestReceived = Mock(
wraps=self.smppc_factory.lastProto.PDUDataRequestReceived)
# Send a deliver_sm from the SMSC
yield self.triggerDeliverSmFromSMSC([self.DeliverSmPDU])
# Run tests on downstream smpp client
self.assertEqual(
self.smppc_factory.lastProto.PDUDataRequestReceived.call_count, 0)
# Run tests on upstream smpp client
self.assertEqual(len(self.SMSCPort.factory.lastClient.pduRecords), 2)
sent_back_resp = self.SMSCPort.factory.lastClient.pduRecords[1]
self.assertEqual(sent_back_resp.id,
pdu_types.CommandId.deliver_sm_resp)
self.assertEqual(sent_back_resp.status,
pdu_types.CommandStatus.ESME_RUNKNOWNERR)
self.assertEqual(_ic, self.stats_smppc.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_smppc.get('interceptor_error_count'))
# Unbind and disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
def test_tagging(self):
"""Refs #495
Will tag message inside interceptor script and assert
routing based tagfilter were correctly done
"""
yield self.connect('127.0.0.1', self.pbPort)
mo_interceptor = MOInterceptorScript("routable.addTag(10)")
yield self.mointerceptor_add(DefaultInterceptor(mo_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
# Change routing rules by shadowing (high order value) default route with a
# static route having a tagfilter
c2_destination = SmppServerSystemIdConnector(
system_id=self.smppc_factory.config.username)
yield self.moroute_flush()
yield self.moroute_add(StaticMORoute([TagFilter(10)], c2_destination),
1000)
# Bind
yield self.smppc_factory.connectAndBind()
# Install mocks
self.smppc_factory.lastProto.PDUDataRequestReceived = Mock(
wraps=self.smppc_factory.lastProto.PDUDataRequestReceived)
# Send a deliver_sm from the SMSC
yield self.triggerDeliverSmFromSMSC([self.DeliverSmPDU])
# Run tests on downstream smpp client
self.assertEqual(
self.smppc_factory.lastProto.PDUDataRequestReceived.call_count, 1)
received_pdu_1 = self.smppc_factory.lastProto.PDUDataRequestReceived.call_args_list[
0][0][0]
self.assertEqual(received_pdu_1.id, pdu_types.CommandId.deliver_sm)
# Unbind and disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
def test_tagging(self):
"""Refs #495
Will tag message inside interceptor script and assert
routing based tagfilter were correctly done
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript("routable.addTag(10)")
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Change routing rules by shadowing (high order value) default route with a
# static route having a tagfilter
yield self.mtroute_flush()
yield self.mtroute_add(StaticMTRoute([TagFilter(10)], self.c1, 0.0),
1000)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'test',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
def test_tagging(self):
"""Refs #495
Will tag message inside interceptor script and assert
routing based tagfilter were correctly done
"""
# Re-provision interceptor with correct script
# Connect to RouterPB
yield self.connect('127.0.0.1', self.pbPort)
mt_interceptor = MTInterceptorScript("routable.addTag(10)")
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Disconnect from RouterPB
self.disconnect()
# Connect to InterceptorPB
yield self.ipb_connect()
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector()
# Change routing rules by shadowing (high order value) default route with a
# static route having a tagfilter
yield self.mtroute_flush()
yield self.mtroute_add(StaticMTRoute([TagFilter(10)], self.c1, 0.0),
1000)
# Bind
yield self.smppc_factory.connectAndBind()
# Send a SMS MT through smpps interface
yield self.smppc_factory.lastProto.sendDataRequest(self.SubmitSmPDU)
# Wait 3 seconds for submit_sm_resp
yield waitFor(3)
# Unbind & Disconnect
yield self.smppc_factory.smpp.unbindAndDisconnect()
yield self.stopSmppClientConnectors()
# Run tests on final destination smpp server (third party mocker)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
def test_send_success(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'test',
'username': self.u1.username,
'password': self.u1_password
}
# We should receive an error since interceptorpb is not connected
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
b'Intercepted message', self.SMSCPort.factory.lastClient.
submitRecords[0].params['short_message'])
self.assertEqual(_ic + 1, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec, self.stats_http.get('interceptor_error_count'))
def test_send_with_tags(self):
"""Related to #455
Will send message through http api using tags and then assert for getting the tags into the short_message
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(
self.update_message_from_tags_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'temporary',
'username': self.u1.username,
'password': self.u1_password,
'tags': '123,456'
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
b"['123', '456']", self.SMSCPort.factory.lastClient.
submitRecords[0].params['short_message'])
def test_send_ESME_RINVESMCLASS_from_script(self):
"Will ensure if script defines only smpp error it will implicitly cause a http 520 error"
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_ESME_RINVESMCLASS)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'test',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 520)
self.assertEqual(lastResponse,
'Error "Interception specific error code 520"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_send_any_exception_from_script(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.raise_any_exception)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'test',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 400)
self.assertEqual(
lastResponse,
'Error "Failed running interception script, check log for details"'
)
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_send_HTTP_300_from_script(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_HTTP_300)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=test&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception, e:
lastErrorStatus = e.status
lastResponse = e.response
def test_send_and_lock_param(self):
"""Related to #458
Will set and lock sm_default_msg_id inside interceptor and assert it were kept as set.
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.lock_param_script)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=temporary&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception, e:
lastErrorStatus = e.status
lastResponse = e.response
def test_send_with_tags(self):
"""Related to #455
Will send message through http api using tags and then assert for getting the tags into the short_message
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_from_tags_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=temporary&username=%s&password=%s&tags=%s' % (
self.u1.username, self.u1_password, '123,456')
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception, e:
lastErrorStatus = e.status
lastResponse = e.response
def test_send_and_lock_param(self):
"""Related to #458
Will set and lock sm_default_msg_id inside interceptor and assert it were kept as set.
"""
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.lock_param_script)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send'
params = {
'to': '06155423',
'content': 'temporary',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(url, data=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 200)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
10, self.SMSCPort.factory.lastClient.submitRecords[0].
params['sm_default_msg_id'])
def test_send_success(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.update_message_sript)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=test&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, None)
self.assertEqual(1,
len(self.SMSCPort.factory.lastClient.submitRecords))
self.assertEqual(
'Intercepted message', self.SMSCPort.factory.lastClient.
submitRecords[0].params['short_message'])
self.assertEqual(_ic + 1, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec, self.stats_http.get('interceptor_error_count'))
def test_send_any_exception_from_script(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.raise_any_exception)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=test&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, '400')
self.assertEqual(
lastResponse,
'Error "Failed running interception script, check log for details"'
)
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_send_ESME_RINVESMCLASS_from_script(self):
"Will ensure if script defines only smpp error it will implicitly cause a http 520 error"
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_ESME_RINVESMCLASS)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/send?to=06155423&content=test&username=%s&password=%s' % (
self.u1.username, self.u1_password)
# We should receive an error since interceptorpb is not connected
lastErrorStatus = None
lastResponse = None
try:
yield getPage(url)
except Exception as e:
lastErrorStatus = e.status
lastResponse = e.response
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, '520')
self.assertEqual(lastResponse,
'Error "Interception specific error code 520"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
def test_rate_HTTP_300_from_script(self):
_ic = self.stats_http.get('interceptor_count')
_iec = self.stats_http.get('interceptor_error_count')
# Re-provision interceptor with correct script
mt_interceptor = MTInterceptorScript(self.return_HTTP_300)
yield self.mtinterceptor_add(DefaultInterceptor(mt_interceptor), 0)
# Connect to InterceptorPB
yield self.ipb_connect()
# Send a SMS MT through http interface
url = 'http://127.0.0.1:1401/rate'
params = {
'to': '06155423',
'username': self.u1.username,
'password': self.u1_password
}
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.get(url, params=params)
lastErrorStatus = response.code
lastResponse = yield text_content(response)
# Wait some time for message delivery through smppc
yield waitFor(2)
# Asserts
self.assertEqual(lastErrorStatus, 300)
self.assertEqual(lastResponse,
'"Interception specific error code 300"')
self.assertEqual(_ic, self.stats_http.get('interceptor_count'))
self.assertEqual(_iec + 1,
self.stats_http.get('interceptor_error_count'))
