def test_add_mo_route(self):
yield self.connect('127.0.0.1', self.pbPort)
r = yield self.moroute_add(
DefaultRoute(HttpConnector(id_generator(), 'http://127.0.0.1')), 0)
self.assertTrue(r)
r = yield self.moroute_add(
DefaultRoute(SmppServerSystemIdConnector(id_generator())), 0)
self.assertTrue(r)
r = yield self.moroute_add(DefaultRoute(Connector(id_generator())), 0)
self.assertFalse(r)
r = yield self.moroute_add(
DefaultRoute(SmppClientConnector(id_generator())), 0)
self.assertFalse(r)
def test_rated_route_early_decrement_balance_percent_long_message(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', 10)
user.mt_credential.setQuota('early_decrement_balance_percent', 25)
route = DefaultRoute(self.c1, rate=2.0)
_QuotasTestCases = self
@defer.inlineCallbacks
def pre_submit_sm_resp(reqPDU):
"""
Will get the user balance before sending back a submit_sm_resp
"""
t = yield _QuotasTestCases.user_get_all()
remote_user = pickle.loads(t)[0]
# Before submit_sm_resp, user must be charged 25% of the route rate (x number of submit_sm parts)
self.assertEqual(remote_user.mt_credential.getQuota('balance'),
10 - ((2.0 * 25 / 100) * 3))
# Send default SMS
response_text, response_code = yield self.run_test(
user=user,
default_route=route,
side_effect=pre_submit_sm_resp,
content='X' * 400)
self.assertEqual(response_text[:7], 'Success')
self.assertEqual(response_code, 'Success')
# Assert balance after receiving submit_sm_resp
t = yield self.user_get_all()
remote_user = pickle.loads(t)[0]
# After submit_sm_resp, user must be charged 100% of the route rate (x number of submit_sm parts)
self.assertEqual(remote_user.mt_credential.getQuota('balance'),
10 - (2.0 * 3))
def prepareRoutingsAndStartConnector(self, connector):
self.AckServerResource.render_GET = mock.Mock(
wraps=self.AckServerResource.render_GET)
# Prepare for routing
connector.port = self.SMSCPort.getHost().port
c2_destination = HttpConnector(
id_generator(),
'http://127.0.0.1:%s/send' % self.AckServer.getHost().port)
# Set the route
yield self.moroute_add(DefaultRoute(c2_destination), 0)
# Now we'll create the connector 1 from which we'll receive DeliverSm PDUs before
# throwing to http
yield self.SMPPClientManagerPBProxy.connect('127.0.0.1',
self.CManagerPort)
c1Config = SMPPClientConfig(id=connector.cid, port=connector.port)
yield self.SMPPClientManagerPBProxy.add(c1Config)
# Start the connector
yield self.SMPPClientManagerPBProxy.start(connector.cid)
# Wait for 'BOUND_TRX' state
while True:
ssRet = yield self.SMPPClientManagerPBProxy.session_state(
connector.cid)
if ssRet == 'BOUND_TRX':
break
else:
time.sleep(0.2)
def test_delivery(self):
yield self.connect('127.0.0.1', self.pbPort)
g1 = Group(1)
yield self.group_add(g1)
c1 = SmppClientConnector(id_generator())
u1_password = '******'
u1 = User(1, g1, 'username', u1_password)
u2_password = '******'
u2 = User(1, g1, 'username2', u2_password)
yield self.user_add(u1)
yield self.mtroute_add(DefaultRoute(c1), 0)
# Send a SMS MT through http interface
url_ko = 'http://127.0.0.1:1401/send?to=98700177&content=test&username=%s&password=%s' % (
u2.username, u1_password)
url_ok = 'http://127.0.0.1:1401/send?to=98700177&content=test&username=%s&password=%s' % (
u1.username, u2_password)
# Incorrect username/password will lead to '403 Forbidden' error
lastErrorStatus = 200
try:
yield getPage(url_ko)
except Exception, e:
lastErrorStatus = e.status
def prepareRoutingsAndStartConnector(self,
bindOperation='transceiver',
route_rate=0.0,
user=None,
port=None):
# Routing stuff
g1 = Group(1)
yield self.group_add(g1)
self.c1 = SmppClientConnector(id_generator())
user_password = '******'
if user is None:
self.u1 = User(1, g1, 'username', user_password)
else:
self.u1 = user
yield self.user_add(self.u1)
yield self.mtroute_add(DefaultRoute(self.c1, route_rate), 0)
# Set port
if port is None:
port = self.SMSCPort.getHost().port
# Now we'll create the connecter
yield self.SMPPClientManagerPBProxy.connect('127.0.0.1',
self.CManagerPort)
c1Config = SMPPClientConfig(id=self.c1.cid,
port=port,
bindOperation=bindOperation)
yield self.SMPPClientManagerPBProxy.add(c1Config)
# Start the connector
yield self.SMPPClientManagerPBProxy.start(self.c1.cid)
# Wait for 'BOUND_TRX' state
while True:
ssRet = yield self.SMPPClientManagerPBProxy.session_state(
self.c1.cid)
if ssRet[:6] == 'BOUND_':
break
else:
time.sleep(0.2)
# Configuration
self.method = 'GET'
self.postdata = None
self.params = {
'to': '98700177',
'username': self.u1.username,
'password': user_password,
'content': 'test'
}
if hasattr(self, 'AckServer'):
# Send a SMS MT through http interface and set delivery receipt callback in url
self.dlr_url = 'http://127.0.0.1:%d/receipt' % (
self.AckServer.getHost().port)
self.AckServerResource.render_POST = mock.Mock(
wraps=self.AckServerResource.render_POST)
self.AckServerResource.render_GET = mock.Mock(
wraps=self.AckServerResource.render_GET)
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 prepareRoutingsAndStartConnector(self):
yield SubmitSmTestCaseTools.prepareRoutingsAndStartConnector(self)
# Add a MO Route to a SmppServerSystemIdConnector
c2_destination = SmppServerSystemIdConnector(system_id = self.smppc_factory.config.username)
# Set the route
yield self.moroute_add(DefaultRoute(c2_destination), 0)
def test_throughput_limit_rejection(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('http_throughput', 2)
route = DefaultRoute(self.c1, rate=0.0)
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, route)
# Set content
self.params['content'] = 'Any Content'
baseurl = 'http://127.0.0.1:%s/send?%s' % (
1401, urllib.urlencode(self.params))
# Send a bunch of MT messages
# We should receive a msg id for success and error when throughput is exceeded
start_time = datetime.now()
throughput_exceeded_errors = 0
request_counter = 0
for x in range(5000):
try:
response_text = yield getPage(baseurl,
method=self.method,
postdata=self.postdata)
response_code = 'Success'
except Exception, error:
response_text = error.response
response_code = str(error)
request_counter += 1
if response_code == '403 Forbidden' and response_text == 'Error "User throughput exceeded"':
throughput_exceeded_errors += 1
def test_rated_route_insufficient_submit_sm_count(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', None)
user.mt_credential.setQuota('submit_sm_count', 0)
route = DefaultRoute(self.c1, rate=1.2)
# Send default SMS
response_text, response_code = yield self.run_send_test(user=user, default_route=route)
self.assertEqual(response_text, 'Error "Cannot charge submit_sm, check RouterPB log file for details"')
self.assertEqual(response_code, '403 Forbidden')
def prepareRoutingsAndStartConnector(self):
yield SubmitSmTestCaseTools.prepareRoutingsAndStartConnector(self)
# Add a MO Route to a SmppServerSystemIdConnector
c2_destination = SmppServerSystemIdConnector(system_id=self.smppc_factory.config.username)
# Set the route
yield self.moroute_add(DefaultRoute(c2_destination), 0)
# Get stats singletons
self.stats_smppc = SMPPClientStatsCollector().get(self.c1.cid)
def prepareRoutingsAndStartConnector(self,
user=None,
default_route=None,
side_effect=None):
# Routing stuff
yield self.group_add(self.group1)
if user is None:
user = self.user1
yield self.user_add(user)
if default_route is None:
yield self.mtroute_add(DefaultRoute(self.c1), 0)
else:
yield self.mtroute_add(default_route, 0)
# Now we'll create the connecter
yield self.SMPPClientManagerPBProxy.connect('127.0.0.1',
self.CManagerPort)
c1Config = SMPPClientConfig(
id=self.c1.cid,
port=self.SMSCPort.getHost().port,
bindOperation='transceiver',
submit_sm_throughput=0,
log_level=logging.DEBUG,
)
yield self.SMPPClientManagerPBProxy.add(c1Config)
# Start the connector
yield self.SMPPClientManagerPBProxy.start(self.c1.cid)
# Wait for 'BOUND_TRX' state
while True:
ssRet = yield self.SMPPClientManagerPBProxy.session_state(
self.c1.cid)
if ssRet in ('BOUND_TRX', 'BOUND_TX', 'BOUND_RX'):
break
else:
yield waitFor(0.2)
# Install mock
# TODO: side effect causes the wrapped function to not be called and fails the tests
# the ability to use wrap and side effect was considered a bug
# that was fixed here: https://bugs.python.org/issue35330
self.SMSCPort.factory.lastClient.sendSubmitSmResponse = Mock(
wraps=self.SMSCPort.factory.lastClient.sendSubmitSmResponse)
# side_effect=side_effect)
# Configuration
self.method = 'POST'
self.postdata = None
self.params = {
'to': '06155423',
'username': user.username,
'password': '******',
'content': 'test'
}
def provision_user_connector(self, add_route=True):
# provision user
g1 = Group(1)
yield self.group_add(g1)
self.c1 = SmppClientConnector(id_generator())
u1_password = '******'
self.u1 = User(1, g1, 'username', u1_password)
yield self.user_add(self.u1)
# provision route
if add_route:
yield self.mtroute_add(DefaultRoute(self.c1), 0)
def setUp(self):
SMPPClientTestCases.setUp(self)
# Provision a user and default route into RouterPB
# Add throughput limit on user
self.foo = User('u1', Group('test'), 'username', 'password')
self.foo.mt_credential.setQuota('smpps_throughput', 2)
self.c1 = SmppClientConnector(id_generator())
self.defaultroute = DefaultRoute(self.c1)
self.provision_user_defaultroute(user=self.foo, defaultroute=self.defaultroute)
self.stats = SMPPServerStatsCollector().get(cid=self.smpps_config.id)
def test_rated_route_early_decrement_balance_percent_insufficient_balance(self):
'''Balance is greater than the early_decrement_balance_percent but lower than the final rate,
user must not be charged in this case, he have to get a balance covering the total rate'''
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', 1.0)
user.mt_credential.setQuota('early_decrement_balance_percent', 25)
route = DefaultRoute(self.c1, rate=2.0)
# Send default SMS
response_text, response_code = yield self.run_send_test(user=user, default_route=route)
self.assertEqual(response_text, 'Error "Cannot charge submit_sm, check RouterPB log file for details"')
self.assertEqual(response_code, '403 Forbidden')
def prepareRoutingsAndStartConnector(self,
user=None,
default_route=None,
side_effect=None):
# Routing stuff
yield self.group_add(self.group1)
if user is None:
user = self.user1
yield self.user_add(user)
if default_route is None:
yield self.mtroute_add(DefaultRoute(self.c1), 0)
else:
yield self.mtroute_add(default_route, 0)
# Now we'll create the connecter
yield self.SMPPClientManagerPBProxy.connect('127.0.0.1',
self.CManagerPort)
c1Config = SMPPClientConfig(
id=self.c1.cid,
port=self.SMSCPort.getHost().port,
bindOperation='transceiver',
submit_sm_throughput=0,
)
yield self.SMPPClientManagerPBProxy.add(c1Config)
# Start the connector
yield self.SMPPClientManagerPBProxy.start(self.c1.cid)
# Wait for 'BOUND_TRX' state
while True:
ssRet = yield self.SMPPClientManagerPBProxy.session_state(
self.c1.cid)
if ssRet[:6] == 'BOUND_':
break
else:
yield waitFor(0.2)
# Install mock
self.SMSCPort.factory.lastClient.sendSubmitSmResponse = mock.Mock(
wraps=self.SMSCPort.factory.lastClient.sendSubmitSmResponse,
side_effect=side_effect)
# Configuration
self.method = 'GET'
self.postdata = None
self.params = {
'to': '06155423',
'username': user.username,
'password': '******',
'content': 'test'
}
def test_rated_route_insufficient_balance_long_message(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', 5.9)
user.mt_credential.setQuota('submit_sm_count', None)
route = DefaultRoute(self.c1, rate=2.0)
# Send default SMS
response_text, response_code = yield self.run_send_test(
user=user, default_route=route, content='X' * 400)
self.assertEqual(
response_text,
'Error "Cannot charge submit_sm, check RouterPB log file for details"'
)
self.assertEqual(response_code, 403)
def test_add_list_and_remove_mo_route_smpps(self):
yield self.connect('127.0.0.1', self.pbPort)
yield self.moroute_add(
DefaultRoute(SmppServerSystemIdConnector(id_generator())), 0)
listRet1 = yield self.moroute_get_all()
listRet1 = pickle.loads(listRet1)
yield self.mtroute_remove(0)
listRet2 = yield self.mtroute_get_all()
listRet2 = pickle.loads(listRet2)
self.assertEqual(1, len(listRet1))
self.assertEqual(0, len(listRet2))
def test_add_list_and_remove_mo_route_http(self):
yield self.connect('127.0.0.1', self.pbPort)
yield self.moroute_add(
DefaultRoute(HttpConnector(id_generator(), 'http://127.0.0.1')), 0)
listRet1 = yield self.moroute_get_all()
listRet1 = pickle.loads(listRet1)
yield self.mtroute_remove(0)
listRet2 = yield self.mtroute_get_all()
listRet2 = pickle.loads(listRet2)
self.assertEqual(1, len(listRet1))
self.assertEqual(0, len(listRet2))
def test_throughput_limit_rejection(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('http_throughput', 2)
route = DefaultRoute(self.c1, rate=0.0)
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, route)
# Set content
self.params['content'] = 'Any Content'
baseurl = 'http://127.0.0.1:%s/send?%s' % (
1401, urllib.urlencode(self.params))
# Send a bunch of MT messages
# We should receive a msg id for success and error when throughput is exceeded
start_time = datetime.now()
throughput_exceeded_errors = 0
request_counter = 0
for x in range(5000):
try:
response_text = yield getPage(baseurl,
method=self.method,
postdata=self.postdata)
response_code = 'Success'
except Exception as error:
response_text = error.response
response_code = str(error)
request_counter += 1
if response_code == '403 Forbidden' and response_text == 'Error "User throughput exceeded"':
throughput_exceeded_errors += 1
end_time = datetime.now()
# Wait 2 seconds before stopping SmppClientConnectors
yield waitFor(2)
yield self.stopSmppClientConnectors()
# Asserts (tolerance of -/+ 3 messages)
throughput = 1 / float(user.mt_credential.getQuota('http_throughput'))
dt = end_time - start_time
max_unsuccessfull_requests = request_counter - (dt.seconds /
throughput)
unsuccessfull_requests = throughput_exceeded_errors
self.assertGreaterEqual(unsuccessfull_requests,
max_unsuccessfull_requests - 3)
self.assertLessEqual(unsuccessfull_requests,
max_unsuccessfull_requests + 3)
def test_rated_route_unlimited_quotas(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', None)
user.mt_credential.setQuota('submit_sm_count', None)
route = DefaultRoute(self.c1, rate=1.2)
# Send default SMS
response_text, response_code = yield self.run_send_test(user=user, default_route=route)
self.assertEqual(response_text[:7], 'Success')
self.assertEqual(response_code, 'Success')
# Assert quotas after SMS is sent
t = yield self.user_get_all()
remote_user = pickle.loads(t)[0]
self.assertEqual(remote_user.mt_credential.getQuota('balance'), None)
self.assertEqual(remote_user.mt_credential.getQuota('submit_sm_count'), None)
def setUp(self):
# Initiating config objects without any filename
# will lead to setting defaults and that's what we
# need to run the tests
self.routerpb_config = RouterPBConfig()
# Instanciate RouterPB but will not launch a server
# we only need the instance to access its .users attribute
# for authentication
self.routerpb_factory = RouterPB(self.routerpb_config, persistenceTimer=False)
# Provision a user and default route into RouterPB
self.foo = User('u1', Group('test'), 'username', 'password')
self.c1 = SmppClientConnector(id_generator())
self.defaultroute = DefaultRoute(self.c1)
self.provision_user_defaultroute(user=self.foo, defaultroute=self.defaultroute)
def test_rated_route_long_message(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('balance', 10.0)
user.mt_credential.setQuota('submit_sm_count', 10)
route = DefaultRoute(self.c1, rate=1.2)
# Send long SMS
response_text, response_code = yield self.run_send_test(user=user, default_route=route,
content='X' * 400)
self.assertEqual(response_text[:7], 'Success')
self.assertEqual(response_code, 'Success')
# Assert quotas after long SMS is sent
t = yield self.user_get_all()
remote_user = pickle.loads(t)[0]
self.assertEqual(remote_user.mt_credential.getQuota('balance'), 6.4)
self.assertEqual(remote_user.mt_credential.getQuota('submit_sm_count'), 7)
def runScenario():
try:
## First part, SMPP Client connector management
###############################################
# Connect to SMPP Client management PB proxy
proxy_smpp = SMPPClientManagerPBProxy()
yield proxy_smpp.connect('127.0.0.1', 8989, 'cmadmin', 'cmpwd')
# Provision SMPPClientManagerPBProxy with a connector and start it
connector1 = {
'id': 'abc',
'username': '******',
'reconnectOnConnectionFailure': True
}
config1 = SMPPClientConfig(**connector1)
yield proxy_smpp.add(config1)
yield proxy_smpp.start('abc')
## Second part, User and Routing management
###########################################
# Connect to Router PB proxy
proxy_router = RouterPBProxy()
yield proxy_router.connect('127.0.0.1', 8988, 'radmin', 'rpwd')
# Provision RouterPBProxy with MT routes
yield proxy_router.mtroute_add(
DefaultRoute(SmppClientConnector('abc')), 0)
routes = yield proxy_router.mtroute_get_all()
print("Configured routes: \n\t%s" % pickle.loads(routes))
# Provisiong router with users
g1 = Group(1)
u1 = User(uid=1, group=g1, username='******', password='******')
yield proxy_router.group_add(g1)
yield proxy_router.user_add(u1)
users = yield proxy_router.user_get_all()
print("Users: \n\t%s" % pickle.loads(users))
## Last, tear down
##################
# Stop connector
yield proxy_smpp.stop('abc')
except Exception as e:
print("ERROR RUNNING SCENARIO: %s" % str(e))
finally:
reactor.stop()
def test_add_list_and_remove_mt_route(self):
yield self.connect('127.0.0.1', self.pbPort)
yield self.mtroute_add(
StaticMTRoute([GroupFilter(Group(1))],
SmppClientConnector(id_generator()), 0.0), 2)
yield self.mtroute_add(
DefaultRoute(SmppClientConnector(id_generator())), 0)
listRet1 = yield self.mtroute_get_all()
listRet1 = pickle.loads(listRet1)
yield self.mtroute_remove(2)
listRet2 = yield self.mtroute_get_all()
listRet2 = pickle.loads(listRet2)
self.assertEqual(2, len(listRet1))
self.assertEqual(1, len(listRet2))
def test_throughput_limit_rejection(self):
user = copy.copy(self.user1)
user.mt_credential.setQuota('http_throughput', 2)
route = DefaultRoute(self.c1, rate=0.0)
yield self.connect('127.0.0.1', self.pbPort)
yield self.prepareRoutingsAndStartConnector(user, route)
# Set content
self.params['content'] = 'Any Content'
baseurl = 'http://127.0.0.1:1401/send'
# Send a bunch of MT messages
# We should receive a msg id for success and error when throughput is exceeded
start_time = datetime.now()
throughput_exceeded_errors = 0
request_counter = 0
for x in range(5000):
agent = Agent(reactor)
client = HTTPClient(agent)
response = yield client.post(baseurl, data=self.params)
response_text = yield text_content(response)
response_code = response.code
request_counter += 1
if response_code == 403 and response_text == 'Error "User throughput exceeded"':
throughput_exceeded_errors += 1
end_time = datetime.now()
# Wait 2 seconds before stopping SmppClientConnectors
yield waitFor(2)
yield self.stopSmppClientConnectors()
# Asserts (tolerance of -/+ 3 messages)
throughput = 1 / float(user.mt_credential.getQuota('http_throughput'))
dt = end_time - start_time
max_unsuccessfull_requests = request_counter - (dt.seconds /
throughput)
unsuccessfull_requests = throughput_exceeded_errors
self.assertGreaterEqual(unsuccessfull_requests,
max_unsuccessfull_requests - 3)
self.assertLessEqual(unsuccessfull_requests,
max_unsuccessfull_requests + 3)
def setUp(self):
# Instanciate a RouterPB (a requirement for HTTPApi)
RouterPBConfigInstance = RouterPBConfig()
self.RouterPB_f = RouterPB()
self.RouterPB_f.setConfig(RouterPBConfigInstance)
# Provision Router with User and Route
self.u1 = User(1, Group(1), 'fourat', 'correct')
self.RouterPB_f.users.append(self.u1)
self.RouterPB_f.mt_routing_table.add(DefaultRoute(SmppClientConnector('abc')), 0)
# Instanciate a SMPPClientManagerPB (a requirement for HTTPApi)
SMPPClientPBConfigInstance = SMPPClientPBConfig()
SMPPClientPBConfigInstance.authentication = False
clientManager_f = SMPPClientManagerPB()
clientManager_f.setConfig(SMPPClientPBConfigInstance)
httpApiConfigInstance = HTTPApiConfig()
self.web = DummySite(HTTPApi(self.RouterPB_f, clientManager_f, httpApiConfigInstance))
def test_persitance_flag(self):
yield self.connect('127.0.0.1', self.pbPort)
# Initially, all config is already persisted
isPersisted = yield self.is_persisted()
self.assertTrue(isPersisted)
# Make config modifications and assert is_persisted()
g1 = Group(1)
yield self.group_add(g1)
# Config is not persisted, waiting for persistance
isPersisted = yield self.is_persisted()
self.assertFalse(isPersisted)
u1 = User(1, g1, 'username', 'password')
yield self.user_add(u1)
# Config is not persisted, waiting for persistance
isPersisted = yield self.is_persisted()
self.assertFalse(isPersisted)
u2 = User(2, g1, 'username2', 'password')
yield self.user_add(u2)
# Persist
yield self.persist()
# Config is now persisted
isPersisted = yield self.is_persisted()
self.assertTrue(isPersisted)
# Add mo route
yield self.moroute_add(
DefaultRoute(HttpConnector(id_generator(),
'http://127.0.0.1/any')), 0)
# Config is not persisted, waiting for persistance
isPersisted = yield self.is_persisted()
self.assertFalse(isPersisted)
# Add mt route
yield self.mtroute_add(
DefaultRoute(SmppClientConnector(id_generator())), 0)
# Persist
yield self.persist()
# Config is now persisted
isPersisted = yield self.is_persisted()
self.assertTrue(isPersisted)
# Remove all users
yield self.user_remove_all()
# Remove all group
yield self.group_remove_all()
# Remove all mo routes
yield self.moroute_flush()
# Remove all mt routes
yield self.mtroute_flush()
# Config is not persisted, waiting for persistance
isPersisted = yield self.is_persisted()
self.assertFalse(isPersisted)
# Load
yield self.load()
# Config is now persisted
isPersisted = yield self.is_persisted()
self.assertTrue(isPersisted)
def test_add_all_persist_and_load_default(self):
yield self.connect('127.0.0.1', self.pbPort)
# Add users and groups
g1 = Group(1)
yield self.group_add(g1)
u1 = User(1, g1, 'username', 'password')
yield self.user_add(u1)
u2 = User(2, g1, 'username2', 'password')
yield self.user_add(u2)
# Add mo route
yield self.moroute_add(
DefaultRoute(HttpConnector(id_generator(),
'http://127.0.0.1/any')), 0)
# Add mt route
yield self.mtroute_add(
DefaultRoute(SmppClientConnector(id_generator())), 0)
# List users
c = yield self.user_get_all()
c = pickle.loads(c)
self.assertEqual(2, len(c))
# List groups
c = yield self.group_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))
# List mo routes
c = yield self.moroute_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))
# List mt routes
c = yield self.mtroute_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))
# Persist
yield self.persist()
# Remove all users
yield self.user_remove_all()
# Remove all group
yield self.group_remove_all()
# Remove all mo routes
yield self.moroute_flush()
# Remove all mt routes
yield self.mtroute_flush()
# List and assert
c = yield self.user_get_all()
c = pickle.loads(c)
self.assertEqual(0, len(c))
# List groups
c = yield self.group_get_all()
c = pickle.loads(c)
self.assertEqual(0, len(c))
# List mo routes
c = yield self.moroute_get_all()
c = pickle.loads(c)
self.assertEqual(0, len(c))
# List mt routes
c = yield self.mtroute_get_all()
c = pickle.loads(c)
self.assertEqual(0, len(c))
# Load
yield self.load()
# List users
c = yield self.user_get_all()
c = pickle.loads(c)
self.assertEqual(2, len(c))
# List groups
c = yield self.group_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))
# List mo routes
c = yield self.moroute_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))
# List mt routes
c = yield self.mtroute_get_all()
c = pickle.loads(c)
self.assertEqual(1, len(c))