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))