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