def setUp(self, authentication=False):
"This will launch InterceptorPB and provide a client connected to it."
# Launch a client in a disconnected state
# it will be connected on demand through the self.ipb_connect() method
self.ipb_client = InterceptorPBProxy()
yield ProvisionWithoutInterceptorPB.setUp(self)
# Initiating config objects without any filename
# will lead to setting defaults and that's what we
# need to run the tests
InterceptorPBConfigInstance = InterceptorPBConfig()
# Launch the interceptor server
pbInterceptor_factory = InterceptorPB(InterceptorPBConfigInstance)
# Configure portal
p = portal.Portal(JasminPBRealm(pbInterceptor_factory))
if not authentication:
p.registerChecker(AllowAnonymousAccess())
else:
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser('test_user',
md5('test_password'.encode('ascii')).digest())
p.registerChecker(c)
jPBPortalRoot = JasminPBPortalRoot(p)
self.pbInterceptor_server = reactor.listenTCP(
0, pb.PBServerFactory(jPBPortalRoot))
self.pbInterceptor_port = self.pbInterceptor_server.getHost().port
def startRouterPBService(self):
"Start Router PB server"
RouterPBConfigInstance = RouterPBConfig(self.options['config'])
self.components['router-pb-factory'] = RouterPB()
self.components['router-pb-factory'].setConfig(RouterPBConfigInstance)
# Set authentication portal
p = portal.Portal(JasminPBRealm(self.components['router-pb-factory']))
if RouterPBConfigInstance.authentication:
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser(RouterPBConfigInstance.admin_username,
RouterPBConfigInstance.admin_password)
p.registerChecker(c)
else:
p.registerChecker(AllowAnonymousAccess())
jPBPortalRoot = JasminPBPortalRoot(p)
# Add service
self.components['router-pb-server'] = reactor.listenTCP(
RouterPBConfigInstance.port,
pb.PBServerFactory(jPBPortalRoot),
interface=RouterPBConfigInstance.bind)
# AMQP Broker is used to listen to deliver_sm/dlr queues
return self.components['router-pb-factory'].addAmqpBroker(
self.components['amqp-broker-factory'])
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.RouterPBConfigInstance = RouterPBConfig()
# Launch the router server
self.pbRoot_f = RouterPB()
# Mock callbacks
# will be used for assertions
self.pbRoot_f.bill_request_submit_sm_resp_callback = mock.Mock(
wraps=self.pbRoot_f.bill_request_submit_sm_resp_callback)
self.pbRoot_f.deliver_sm_callback = mock.Mock(
wraps=self.pbRoot_f.deliver_sm_callback)
self.pbRoot_f.setConfig(self.RouterPBConfigInstance)
p = portal.Portal(JasminPBRealm(self.pbRoot_f))
if not authentication:
p.registerChecker(AllowAnonymousAccess())
else:
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser('test_user', md5('test_password').digest())
p.registerChecker(c)
jPBPortalRoot = JasminPBPortalRoot(p)
self.PBServer = reactor.listenTCP(0, pb.PBServerFactory(jPBPortalRoot))
self.pbPort = self.PBServer.getHost().port
def setUp(self):
yield SMPPClientTestCases.setUp(self)
# Init SMPPServerPB
SMPPServerPBConfigInstance = SMPPServerPBConfig()
SMPPServerPBInstance = SMPPServerPB(SMPPServerPBConfigInstance)
SMPPServerPBInstance.addSmpps(self.smpps_factory)
p = portal.Portal(JasminPBRealm(SMPPServerPBInstance))
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser('smppsadmin', md5('smppspwd'.encode('ascii')).digest())
p.registerChecker(c)
jPBPortalRoot = JasminPBPortalRoot(p)
self.SMPPServerPBInstanceServer = reactor.listenTCP(SMPPServerPBConfigInstance.port,
pb.PBServerFactory(jPBPortalRoot))
# Init SMPPServerPBClient and connect it to SMPPServerPB
SMPPServerPBClientConfigInstance = SMPPServerPBClientConfig()
self.SMPPServerPBProxyInstance = SMPPServerPBProxy()
yield self.SMPPServerPBProxyInstance.connect(
SMPPServerPBClientConfigInstance.host,
SMPPServerPBClientConfigInstance.port,
SMPPServerPBClientConfigInstance.username,
SMPPServerPBClientConfigInstance.password,
retry=False)
# Lower the timeout config to pass the timeout tests quickly
self.DLRThrower.config.timeout = 2
self.DLRThrower.config.retry_delay = 1
self.DLRThrower.config.max_retries = 2
# Most important thing:
# Swap default direct smpps access to perspectivebroker smpps access:
self.DLRThrower.addSmpps(self.SMPPServerPBProxyInstance)
def startInterceptorPBService(self):
"Start Interceptor PB server"
InterceptorPBConfigInstance = InterceptorPBConfig(
self.options['config'])
self.components['interceptor-pb-factory'] = InterceptorPB()
self.components['interceptor-pb-factory'].setConfig(
InterceptorPBConfigInstance)
# Set authentication portal
p = portal.Portal(
JasminPBRealm(self.components['interceptor-pb-factory']))
if InterceptorPBConfigInstance.authentication:
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser(InterceptorPBConfigInstance.admin_username,
InterceptorPBConfigInstance.admin_password)
p.registerChecker(c)
else:
p.registerChecker(AllowAnonymousAccess())
jPBPortalRoot = JasminPBPortalRoot(p)
# Add service
self.components['interceptor-pb-server'] = reactor.listenTCP(
InterceptorPBConfigInstance.port,
pb.PBServerFactory(jPBPortalRoot),
interface=InterceptorPBConfigInstance.bind)
def startSMPPClientManagerPBService(self):
"Start SMPP Client Manager PB server"
SMPPClientPBConfigInstance = SMPPClientPBConfig(self.options['config'])
self.components['smppcm-pb-factory'] = SMPPClientManagerPB()
self.components['smppcm-pb-factory'].setConfig(
SMPPClientPBConfigInstance)
# Set authentication portal
p = portal.Portal(JasminPBRealm(self.components['smppcm-pb-factory']))
if SMPPClientPBConfigInstance.authentication:
c = InMemoryUsernamePasswordDatabaseDontUse()
c.addUser(SMPPClientPBConfigInstance.admin_username,
SMPPClientPBConfigInstance.admin_password)
p.registerChecker(c)
else:
p.registerChecker(AllowAnonymousAccess())
jPBPortalRoot = JasminPBPortalRoot(p)
# Add service
self.components['smppcm-pb-server'] = reactor.listenTCP(
SMPPClientPBConfigInstance.port,
pb.PBServerFactory(jPBPortalRoot),
interface=SMPPClientPBConfigInstance.bind)
# AMQP Broker is used to listen to submit_sm queues and publish to deliver_sm/dlr queues
self.components['smppcm-pb-factory'].addAmqpBroker(
self.components['amqp-broker-factory'])
self.components['smppcm-pb-factory'].addRedisClient(
self.components['rc'])
def setUp(self):
HttpServerTestCase.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
# Launch AMQP Broker
self.amqpBroker = AmqpFactory(AMQPServiceConfigInstance)
self.amqpBroker.preConnect()
self.amqpClient = reactor.connectTCP(AMQPServiceConfigInstance.host,
AMQPServiceConfigInstance.port,
self.amqpBroker)
# Wait for AMQP Broker connection to get ready
yield self.amqpBroker.getChannelReadyDeferred()
# Add the broker to the RouterPB
yield self.pbRoot_f.addAmqpBroker(self.amqpBroker)
# Setup smpp client manager pb
yield self.clientManager_f.addAmqpBroker(self.amqpBroker)
p = portal.Portal(JasminPBRealm(self.clientManager_f))
p.registerChecker(AllowAnonymousAccess())
jPBPortalRoot = JasminPBPortalRoot(p)
self.CManagerServer = reactor.listenTCP(
0, pb.PBServerFactory(jPBPortalRoot))
self.CManagerPort = self.CManagerServer.getHost().port
# Start DLRThrower
DLRThrowerConfigInstance = DLRThrowerConfig()
self.DLRThrower = DLRThrower()
self.DLRThrower.setConfig(DLRThrowerConfigInstance)
yield self.DLRThrower.addAmqpBroker(self.amqpBroker)
# Connect to redis server
RedisForJasminConfigInstance = RedisForJasminConfig()
self.redisClient = yield ConnectionWithConfiguration(
RedisForJasminConfigInstance)
# Authenticate and select db
if RedisForJasminConfigInstance.password is not None:
yield self.redisClient.auth(RedisForJasminConfigInstance.password)
yield self.redisClient.select(RedisForJasminConfigInstance.dbid)
# Connect CM with RC:
self.clientManager_f.addRedisClient(self.redisClient)
# Set a smpp client manager proxy instance
self.SMPPClientManagerPBProxy = SMPPClientManagerPBProxy()
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.SMPPClientPBConfigInstance = SMPPClientPBConfig()
self.SMPPClientPBConfigInstance.authentication = authentication
AMQPServiceConfigInstance = AmqpConfig()
AMQPServiceConfigInstance.reconnectOnConnectionLoss = False
# Launch AMQP Broker
self.amqpBroker = AmqpFactory(AMQPServiceConfigInstance)
self.amqpBroker.preConnect()
self.amqpClient = reactor.connectTCP(AMQPServiceConfigInstance.host,
AMQPServiceConfigInstance.port,
self.amqpBroker)
# Wait for AMQP Broker connection to get ready
yield self.amqpBroker.getChannelReadyDeferred()
# Launch the client manager server
pbRoot = SMPPClientManagerPB()
pbRoot.setConfig(self.SMPPClientPBConfigInstance)
yield pbRoot.addAmqpBroker(self.amqpBroker)
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.PBServer = reactor.listenTCP(0, pb.PBServerFactory(jPBPortalRoot))
self.pbPort = self.PBServer.getHost().port
# Launch the router server
self.RouterPBInstance = RouterPB()
self.RouterPBInstance.setConfig(RouterPBConfig())
pbRoot.addRouterPB(self.RouterPBInstance)
# Default SMPPClientConfig
defaultSMPPClientId = '001-testconnector'
self.defaultConfig = SMPPClientConfig(
id=defaultSMPPClientId,
username='******',
reconnectOnConnectionFailure=True,
port=9002,
)
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 setUp(self, authentication=False):
SMPPServerTestCases.setUp(self)
# Initiating config objects without any filename
self.SMPPServerPBConfigInstance = SMPPServerPBConfig()
self.SMPPServerPBConfigInstance.authentication = authentication
# Launch the SMPPServerPB
pbRoot = SMPPServerPB(self.SMPPServerPBConfigInstance)
pbRoot.addSmpps(self.smpps_factory)
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.PBServer = reactor.listenTCP(0, pb.PBServerFactory(jPBPortalRoot))
self.pbPort = self.PBServer.getHost().port