def setUp(self): TestController.setUp(self) parameters = { 'EmailProvider': 'linotp.lib.emailprovider.SMTPEmailProvider', 'EmailProviderConfig': '{ "SMTP_SERVER": "mail.example.com",\ "SMTP_USER": "******",\ "SMTP_PASSWORD": "******" }', 'EmailChallengeValidityTime': self.challenge_validity, 'EmailBlockingTimeout': 0 } response = self.app.get(url(controller='system', action='setConfig'), params=parameters) assert '"status": true' in response # Enroll token parameters = { 'type': 'email', 'serial': self.token_serial, 'description': "E-mail token enrolled in functional tests", 'email_address': self.default_email_address } response = self.app.get(url(controller='admin', action='init'), params=parameters) assert '"value": true' in response parameters = {"serial": self.token_serial, "user": "******", "pin": self.pin} response = self.app.get(url(controller='admin', action='assign'), params=parameters) assert '"value": true' in response # Patch (replace) smtplib.SMTP class to prevent e-mails from being sent out self.patch_smtp = patch('smtplib.SMTP', spec=smtplib.SMTP) mock_smtp_class = self.patch_smtp.start() self.mock_smtp_instance = mock_smtp_class.return_value self.mock_smtp_instance.sendmail.return_value = []
def setUp(self): TestController.setUp(self) self.create_common_resolvers() self.create_common_realms() self.token_for_deletion = set() self.policies_for_deletion = set() return
def tearDown(self): ''' make the dishes''' self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self) return
def setUp(self): self.serial = '' self.counter = 0 self.origin = 'https://u2f-fakeurl.com' TestController.setUp(self) self.__createResolvers__() self.__createRealms__()
def _enroll_token_set_pin(self): """ Enroll token and set PIN 'mypin' :return: Dictionary with token information """ token = { "key": "3132333435363738393031323334353637383930", "type": "hmac", "serial": None, "otplen": 6, "otps": deque( ["755224", "287082", "359152", "969429", "338314", "254676", "287922", "162583", "399871", "520489"] ), } # enroll token params = {"otpkey": token["key"], "type": token["type"], "otplen": token["otplen"]} response = self.make_admin_request("init", params=params) content = TestController.get_json_body(response) self.assertTrue(content["result"]["status"]) self.assertTrue(content["result"]["value"]) token["serial"] = content["detail"]["serial"] self.token_for_deletion.add(token["serial"]) # set PIN params = {"serial": token["serial"], "pin": "mypin"} response = self.make_admin_request("set", params=params) content = TestController.get_json_body(response) self.assertTrue(content["result"]["status"]) self.assertTrue(content["result"]["value"]) return token
def tearDown(self): ''' make the dishes''' self.remove_tokens() self.__deleteAllRealms__() self.__deleteAllResolvers__() TestController.tearDown(self) return
def setUp(self): ''' setup the Test Controller''' TestController.setUp(self) self.set_config_selftest() self.__createResolvers__() self.__createRealms__() self.serials = []
def setUp(self): TestController.setUp(self) self.create_common_resolvers() self._setup_realms() self.token_for_deletion = set() self.policies_for_deletion = set() self.token = self._enroll_token_set_pin()
def setUp(self): ''' Overwrite the deleting of the realms! If the realms are deleted also the table TokenRealm gets deleted and we loose the information how many tokens are within a realm! ''' TestController.setUp(self) self.set_config_selftest() if nose_config and 'paster' in nose_config: self.paster_port = nose_config['paster']['port'] else: self.paster_port = DEFAULT_NOSE_CONFIG['paster']['port'] self.remote_url = 'http://127.0.0.1:%s' % self.paster_port ''' Init the tests.... ''' self.delete_all_policies() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() self.create_common_resolvers() self.create_realms() return
def setUp(self): ''' setup the Test Controller''' TestController.setUp(self) self.set_config_selftest() self.create_common_resolvers() self.create_common_realms() self.serials = []
def tearDown(self): if self.serial: parameters = {"serial": self.serial} response = self.app.get(url(controller="admin", action="remove"), params=parameters) self.assertTrue( '"value": 1' in response, "Failed removing yubikey %s. Response: %s" % (self.serial, response) ) TestController.tearDown(self)
def setUp(self): ''' This sets up all the resolvers and realms ''' TestController.setUp(self) self.removeTokens() self.initToken() self.initProvider()
def setUp(self): self.delete_all_realms() self.delete_all_policies() self.delete_all_resolvers() self.dropTable() TestController.setUp(self)
def setUp(self): ''' This sets up all the resolvers and realms ''' TestController.setUp(self) self.create_common_resolvers() self.create_common_realms()
def setUp(self): self.serial = '' self.counter = 0 self.origin = 'https://u2f-fakeurl.com' TestController.setUp(self) self.create_common_resolvers() self.create_common_realms() self.serials = set()
def setUp(self): """ This sets up all the resolvers and realms """ TestController.setUp(self) self.curTime = datetime.datetime(2012, 5, 16, 9, 0, 52, 227413) self.TOTPcurTime = datetime.datetime.fromtimestamp(1337292860.585256) self.initToken()
def tearDown(self): self.delete_all_token() self.delete_all_policies() self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self) global Rad_Serv Rad_Serv = None
def setUp(self): TestController.setUp(self) self.delete_all_policies() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() self.create_common_resolvers() self.create_common_realms()
def setUp(self): TestController.setUp(self) self.create_common_resolvers() self.create_common_realms() self.serials = [] self.fixture_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'fixtures', )
def setup_class(cls): if nose_config and 'radius' in nose_config: cls.radius_authport = nose_config['radius']['authport'] cls.radius_acctport = nose_config['radius']['acctport'] if nose_config and 'paster' in nose_config: cls.paster_port = nose_config['paster']['port'] TestController.setup_class()
def tearDown(self): self.delete_all_policies() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self)
def setUp(self): TestController.setUp(self) # self.appconf = self.app.app.app.apps[1].application.app.application.app.app.app.config self.sqlconnect = self.appconf.get("sqlalchemy.url") sqlData = SQLData(connect=self.sqlconnect) log.debug(sqlData) return
def tearDown(self): self.delete_all_policies() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self) global REQUEST_BODY REQUEST_BODY = ''
def tearDown(self): # Delete policies for policy in self.policies_for_deletion: self.delete_policy(policy) # Delete token for token in self.token_for_deletion: self.delete_token(token) self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self)
def test_duplicate_otp(self): """ If the OTP value matches for several token autoassignment fails """ token_list = deepcopy(self.token_list[0:1]) # Enroll new token with duplicate first OTP token = { "key": "0f51c51a55a3c2736ecd0c022913d541b25734b5", "type": "hmac", "serial": None, "otplen": 6, "otps": ["755224", "657344", "672823"], } params = {"otpkey": token["key"], "type": token["type"], "otplen": token["otplen"]} response = self.make_admin_request("init", params=params) content = TestController.get_json_body(response) self.assertTrue(content["result"]["status"]) self.assertTrue(content["result"]["value"]) token["serial"] = content["detail"]["serial"] self.token_for_deletion.add(token["serial"]) token_list.append(token) # (user, password) pairs from myDefRealm users = [(u"molière", u"molière"), (u"shakespeare", u"shakespeare1")] self._create_autoassignment_policy("my_autoassign_policy", "mydefrealm") self._set_token_realm(token_list, "mydefrealm") # autoassign token_list[0] to users[0] -> should fail because the OTP # value is valid for several token and therefore it can't be # determined which one to use user_name, user_pwd = users[0] token = token_list[0] self._validate(user_name, user_pwd + token["otps"][0], expected="value-false") # This only happens if several unassigned token have a common OTP # value. To verify this we assign one of the token, then the other # one can be assigned with autoassigment. # Assign token_list[0] to users[0] user_name, user_pwd = users[0] token = token_list[0] params = {"user": user_name.encode("utf-8"), "serial": token["serial"]} response = self.make_admin_request("assign", params=params) content = TestController.get_json_body(response) self.assertTrue(content["result"]["status"]) self.assertEqual(1, content["result"]["value"]) # No PIN was set self._validate(user_name, token["otps"][0]) # autoassign token_list[1] to users[1] user_name, user_pwd = users[1] token = token_list[1] self._validate(user_name, user_pwd + token["otps"][0])
def setUp(self): TestController.setUp(self) self.set_config_selftest() self.__createResolvers__() self.__createRealms__() if nose_config and 'radius' in nose_config: self.radius_authport = nose_config['radius']['authport'] self.radius_acctport = nose_config['radius']['acctport'] else: self.radius_authport = DEFAULT_NOSE_CONFIG['radius']['authport'] self.radius_acctport = DEFAULT_NOSE_CONFIG['radius']['acctport']
def setUp(self): ''' This sets up all the resolvers and realms ''' TestController.setUp(self) self.set_config_selftest() self.create_common_resolvers() self.create_common_realms() self.curTime = datetime.datetime(2012, 5, 16, 9, 0, 52, 227413) self.TOTPcurTime = datetime.datetime.fromtimestamp(1337292860.585256) self.initToken()
def setUp(self): TestController.setUp(self) self.create_common_resolvers() self.create_common_realms() self.token_for_deletion = set() self.policies_for_deletion = set() self.skip_selfservice_auth = False if self.env['pylons'] <= LooseVersion('0.10'): self.skip_selfservice_auth = True return
def setUp(self): self.tokens = {} params = {'splitAtSign': True} response = self.make_system_request('setConfig', params=params) assert 'false' not in response.body TestController.setUp(self) self.set_config_selftest() self.create_common_resolvers() self.create_common_realms()
def setUp(self): TestController.setUp(self) # clean setup self.delete_all_policies() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() # create the common resolvers and realm self.create_common_resolvers() self.create_common_realms() self.create_extra_resolver()
def tearDown(self): self.delete_license() self.delete_all_token() self.delete_all_realms() self.delete_all_resolvers() # remove the license, if installed self.make_system_request("delConfig", params={"key": "license"}) return TestController.tearDown(self)
def _set_pin(self, serial, pin): """ Set the token PIN 'pin' for the token identified by 'serial' """ params = { 'serial': serial, 'pin': pin, } response = self.make_admin_request('set', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertTrue(content['result']['value']) return
def setUp(self): TestController.setUp(self) self.create_common_resolvers() self.create_common_realms() params = { "EmailProvider": "linotp.provider.emailprovider.SMTPEmailProvider", "EmailProviderConfig": '{ "SMTP_SERVER": "mail.example.com",\ "SMTP_USER": "******",\ "SMTP_PASSWORD": "******" }', "EmailChallengeValidityTime": self.challenge_validity, "EmailBlockingTimeout": 0, } response = self.make_system_request("setConfig", params) assert '"status": true' in response # Enroll token params = { "type": "email", "serial": self.token_serial, "description": "E-mail token enrolled in functional tests", "email_address": self.default_email_address, } response = self.make_admin_request("init", params) assert '"value": true' in response params = { "serial": self.token_serial, "user": "******", "pin": self.pin, } response = self.make_admin_request("assign", params) assert '"value": true' in response # Patch (replace) smtplib.SMTP class to prevent e-mails from being sent # out self.patch_smtp = patch("smtplib.SMTP", spec=smtplib.SMTP) mock_smtp_class = self.patch_smtp.start() self.mock_smtp_instance = mock_smtp_class.return_value self.mock_smtp_instance.sendmail.return_value = []
def test_autoassign_mixed_token(self): """ Autoassignment with 4 HMAC and 1 Yubikey token to 5 different users 5 Token (4 HMAC + 1 Yubikey) are enrolled and put together in the same token realm. An autoenrollment policy for that realm is created. 5 different users from that realm autoassign themselves one token each by authenticating with their user-store password and an OTP value corresponding to that token. """ token_list = deepcopy(self.token_list) self._create_autoassignment_policy('my_autoassign_policy', 'mydefrealm') self._set_token_realm(token_list, 'mydefrealm') # 5 (user, password) pairs from myDefRealm users = [ (u'molière', u'molière'), (u'shakespeare', u'shakespeare1'), (u'lorca', u'lorca1'), (u'aἰσχύλος', u'Πέρσαι'), (u'beckett', u'beckett1'), ] # autoassign token to users for i in range(5): user_name, user_pwd = users[i] token = token_list[i] self._validate( user_name, user_pwd + token['otps'][0], ) for i in range(5): # Assert the token was assigned to the correct user user_name, user_pwd = users[i] token = token_list[i] response = self.make_admin_request('getTokenOwner', {'serial': token['serial']}) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertEqual(user_name, content['result']['value']['username']) # Validate the remaining OTP values for j in range(1, 3): self._validate( user_name, user_pwd + token['otps'][j], )
def setUp(self): TestController.setUp(self) self.__createResolvers__() self.__createRealms__() params = { 'EmailProvider': 'linotp.lib.emailprovider.SMTPEmailProvider', 'EmailProviderConfig': '{ "SMTP_SERVER": "mail.example.com",\ "SMTP_USER": "******",\ "SMTP_PASSWORD": "******" }', 'EmailChallengeValidityTime': self.challenge_validity, 'EmailBlockingTimeout': 0, } response = self.make_system_request('setConfig', params) assert '"status": true' in response # Enroll token params = { 'type': 'email', 'serial': self.token_serial, 'description': "E-mail token enrolled in functional tests", 'email_address': self.default_email_address, } response = self.make_admin_request('init', params) assert '"value": true' in response params = { "serial": self.token_serial, "user": "******", "pin": self.pin, } response = self.make_admin_request('assign', params) assert '"value": true' in response # Patch (replace) smtplib.SMTP class to prevent e-mails from being sent out self.patch_smtp = patch('smtplib.SMTP', spec=smtplib.SMTP) mock_smtp_class = self.patch_smtp.start() self.mock_smtp_instance = mock_smtp_class.return_value self.mock_smtp_instance.sendmail.return_value = []
def tearDown(self): self.delete_all_realms() self.delete_all_resolvers() params = { "user_lookup_cache.enabled": False, "resolver_lookup_cache.enabled": False, } response = self.make_system_request('setConfig', params) self.assertTrue('"status": true' in response.body, response) return TestController.tearDown(self)
def _set_token_realm(self, token_list, realm_name): """ Set the token realm 'realm_name' for all token in 'token_list'. """ for token in token_list: self.assertIsNotNone(token['serial']) params = { 'serial': token['serial'], 'realms': realm_name } response = self.make_admin_request('tokenrealm', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertEqual(1, content['result']['value'])
def _set_token_realm(self, serial, realm): """ Set the token realm 'realm' for the token identified by 'serial' """ assert serial and realm, "Both 'serial' and 'realm' required" params = { 'serial': serial, 'realms': realm, } response = self.make_admin_request('tokenrealm', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertEqual(1, content['result']['value']) return
def _setup_realms(self): """ Setup 2 realms 'realm_default' and 'realm_no_default' with resolver myDefRes. """ for realm in ('realm_default', 'realm_no_default'): response = self.create_realm( realm=realm, resolvers=self.resolvers['myDefRes'], ) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertTrue(content['result']['value']) # Assert 'realm_default' is default response = self.make_system_request('getRealms', {}) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) realms = content['result']['value'] self.assertEqual(len(realms), 2) self.assertIn('realm_default', realms) self.assertIn('default', realms['realm_default']) self.assertTrue(realms['realm_default']['default'])
def _set_pin_in_selfservice(self, user, pwd, serial, pin): """ Log into selfservice and set PIN :param user: username or username@realm :param pwd: User password :param serial: Token serial :param pin: The PIN to be set """ params = { 'login': user.encode('utf-8'), 'password': pwd.encode('utf-8'), 'defaultRealm': 'myDefRealm', 'realm': '', 'realmbox': False, } response = self.make_request('account', 'dologin', params=params) err_msg = "Unexpected response %r" % response self.assertEqual(302, response.status_int, err_msg) self.assertEqual('/', response.headers['location']) self.assertRegexpMatches( response.headers['Set-Cookie'], r"^linotp_selfservice=.*", err_msg, ) session = self.app.cookies['linotp_selfservice'] session = session.strip('"') self.assertGreater(len(session), 0, err_msg) params = { 'serial': serial, 'session': session, 'userpin': pin, } cookies = { 'linotp_selfservice': '"%s"' % session, } response = self.make_request( 'userservice', 'setpin', params=params, cookies=cookies, ) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) expected = {"set userpin": 1} self.assertDictEqual(expected, content['result']['value']) return
def _assign(self, serial, user): """ Assign token defined by 'serial' to 'user' :param serial: Token serial number :param user: User (e.g. username@realm) :return: None """ params = { 'serial': serial, 'user': user.encode('utf-8'), } response = self.make_admin_request('assign', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertTrue(content['result']['value'])
def _validate(self, user_or_serial, pwd, expected='success', err_msg=None, action='check'): """ Makes a validate/check request and verifies the response is as 'expected' :param user_or_serial: Username or username@realm or token serial number :param pwd: Password (e.g. PIN+OTP) :param expected: One of 'success', 'value-false', 'status-false' or 'both-false' :param err_msg: An error message to display if assert fails :param action: The validate action (typically check or check_s) :return: The content (JSON object) """ params = {'pass': pwd.encode('utf-8')} if action == 'check': params['user'] = user_or_serial.encode('utf-8') elif action == 'check_s': params['serial'] = user_or_serial else: self.fail("Action %s not implemented" % action) response = self.make_validate_request(action, params=params) content = TestController.get_json_body(response) if not err_msg: err_msg = "validate/%s failed for %r. Response: %r" % ( action, user_or_serial, content, ) if expected == 'success': self.assertTrue(content['result']['status'], err_msg) self.assertTrue(content['result']['value'], err_msg) elif expected == 'value-false': self.assertTrue(content['result']['status'], err_msg) self.assertFalse(content['result']['value'], err_msg) elif expected == 'status-false': self.assertFalse(content['result']['status'], err_msg) self.assertTrue(content['result']['value'], err_msg) elif expected == 'both-false': self.assertFalse(content['result']['status'], err_msg) self.assertFalse(content['result']['value'], err_msg) else: self.fail("Unknown 'expected' %s" % expected) return content
def _enroll_token(self, token_list): """ Enroll all token in token_list. Update the list with the serial number returned by LinOTP. Adds the token to self.token_for deletion so it is cleaned up on tearDown. """ for token in token_list: params = { "otpkey": token['key'], "type": token['type'], "otplen": token['otplen'], } response = self.make_admin_request('init', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertTrue(content['result']['value']) token['serial'] = content['detail']['serial'] self.token_for_deletion.add(token['serial'])
def test_lostToken_policy_hierarchy_1(self): """ The losttoken policy for specific user is prefered over the wildcard policy two policies are definded, one for specific user, one for wildcard user """ serial = '0001' policy_special = { 'name': 'losttoken_valid_hans', 'scope': 'enrollment', 'action': 'lostTokenValid=8', 'realm': '*', 'user': '******', 'time': '', 'client': '', } policy_wildcard = { 'name': 'losttoken_valid_all', 'scope': 'enrollment', 'action': 'lostTokenValid=5', 'realm': '*', 'user': '******', 'time': '', 'client': '', } token = {'serial': serial} self._create_token(serial=serial, user='******') self.create_policy(params=policy_special) self.create_policy(params=policy_wildcard) today = datetime.now() validity_special = (today + timedelta(days=8)).strftime("%d/%m/%y 23:59") losetoken = self.make_authenticated_request(controller='admin', action='losttoken', params=token) resp = TestController.get_json_body(losetoken) values = resp.get('result').get('value') self.assertEqual(values.get('end_date'), validity_special, resp)
def test_with_ignore_autoassignment_pin(self): """ Test PIN is empty when ignore_autoassignment_pin policy is set """ token_list = deepcopy(self.token_list[0:1]) self._create_autoassignment_policy('my_autoassign_policy', 'mydefrealm') self._set_token_realm(token_list, 'mydefrealm') # (user, password) pairs from myDefRealm users = [ (u'molière', u'molière'), ] self._create_ignore_autoassignment_pin_policy('mydefrealm') # autoassign token to users user_name, user_pwd = users[0] token = token_list[0] self._validate( user_name, user_pwd + token['otps'][0], ) # Assert the token was assigned to the correct user response = self.make_admin_request('getTokenOwner', {'serial': token['serial']}) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertEqual(user_name, content['result']['value']['username']) # Validate the remaining OTP values (note PIN is empty) for j in range(1, 3): self._validate( user_name, token['otps'][j], )
def _validate_base(self, params, action='check', expected='success', err_msg=None): """ Base method for /validate/<action> requests Don't call this method directly but use _validate() or _validate_check_s() instead. :param params: Request parameters :param expected: One of 'success', 'value-false', 'status-false' or 'both-false' :param err_msg: An error message to display if assert fails :return: The content (JSON object) """ response = self.make_validate_request(action, params=params) content = TestController.get_json_body(response) if not err_msg: err_msg = "validate/%s failed for %r. Response: %r" % ( action, params, content) if expected == 'success': self.assertTrue(content['result']['status'], err_msg) self.assertTrue(content['result']['value'], err_msg) elif expected == 'value-false': self.assertTrue(content['result']['status'], err_msg) self.assertFalse(content['result']['value'], err_msg) elif expected == 'status-false': self.assertFalse(content['result']['status'], err_msg) self.assertTrue(content['result']['value'], err_msg) elif expected == 'both-false': self.assertFalse(content['result']['status'], err_msg) self.assertFalse(content['result']['value'], err_msg) else: self.fail("Unknown 'expected' %s" % expected) return content
def _set_pin_in_selfservice(self, user, pwd, serial, pin): """ Log into selfservice and set PIN :param user: username or username@realm :param pwd: User password :param serial: Token serial :param pin: The PIN to be set """ params = { 'serial': serial, 'userpin': pin, } login = user.encode('utf-8') password = pwd.encode('utf-8') response = self.make_userservice_request('setpin', params, auth_user=(login, password)) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) expected = {"set userpin": 1} self.assertDictEqual(expected, content['result']['value']) return
def _enroll_token(self, token, user=None): """ Enroll token for 'user'. :param token: A dictionary with token information. This dictionary is augmented with 'serial' after enrolling the token. :param user: The name of the user to assign the token to. If None then the token is not assigned. """ # enroll token params = { "otpkey": token['key'], "type": token['type'], "otplen": token['otplen'], } if user: params['user'] = user.encode('utf-8') response = self.make_admin_request('init', params=params) content = TestController.get_json_body(response) self.assertTrue(content['result']['status']) self.assertTrue(content['result']['value']) token['serial'] = content['detail']['serial'] self.token_for_deletion.add(token['serial']) return
def tearDown(self): self.patch_smtp.stop() self.__deleteAllRealms__() self.__deleteAllResolvers__() TestController.tearDown(self)
def tearDown(self): for serial in self.serials: self.removeTokenBySerial(serial) self.__deleteAllRealms__() self.__deleteAllResolvers__() TestController.tearDown(self)
def tearDown(self): self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self)
def tearDown(self): TestController.tearDown(self) self.patch_smtp.stop()
def tearDown(self): TestController.tearDown(self)
def tearDown(self): for serial in self.serials: self.delete_token(serial) self.delete_all_realms() self.delete_all_resolvers() TestController.tearDown(self)
def tearDown(self): self.__deleteAllRealms__() self.__deleteAllResolvers__() TestController.tearDown(self)
def setUp(self): TestController.setUp(self) self.set_config_selftest() self.__createResolvers__() self.__createRealms__()
def tearDown(self): self.patch_smtp.stop() self.delete_all_realms() self.delete_all_resolvers() self.delete_all_token() TestController.tearDown(self)
def setUp(self): TestController.setUp(self) self.set_config_selftest() self.create_common_resolvers() self.create_common_realms()
def setUp(self): ''' setup the Test Controller''' TestController.setUp(self) self.create_common_resolvers() self.create_common_realms()
def setUp(self): TestController.setUp(self) self.set_config_selftest() self.initToken()