def test_password_min_length(self):
testkey = 'min_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_disallowed(self):
testkey = 'disallowed'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: '$+]'})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'complex' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_length(self):
testkey = 'min_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_non_alpha(self):
testkey = 'min_non_alpha'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 4})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['numeric', 'special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_disallowed(self):
testkey = 'disallowed'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: '$+]'})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'complex' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_non_alpha(self):
testkey = 'min_non_alpha'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 4})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['numeric', 'special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def setUp(self):
# self.settings = DEFAULT_PASSWORD_SETTINGS.copy()
self.validator = PasswordValidator()
self.passwords = {
'alpha_lower': ['abcdef', [6, 0, 0, 0, 0]],
'alpha_upper': ['ABCDEF', [0, 6, 0, 0, 0]],
'alpha_mixed': ['abcDEF', [3, 3, 0, 0, 0]],
'numeric': ['123456', [0, 0, 6, 0, 6]],
'alphanumeric_lower': ['123abc', [3, 0, 3, 0, 3]],
'alphanumeric_upper': ['123ABC', [0, 3, 3, 0, 3]],
'alphanumeric_mixed': ['12aAbB', [2, 2, 2, 0, 2]],
'special': ['!#@{%^', [0, 0, 0, 6, 6]],
'complex': ['yRo8$D', [2, 2, 1, 1, 2]],
'long_complex': ['nYfJ6UUt$8y4j+]W', [5, 5, 3, 3, 6]]
}
def test_set_string_val(self):
key = 'disallowed'
expected, expected_type = self.use_settings[key]
self.config.add_settings(dict(PASSWORD_CONFIG.items(key)))
validator = PasswordValidator(self.config.registry.settings)
actual = validator.settings[key]
self.assertEqual(expected, actual)
self.assertTrue(isinstance(actual, expected_type))
def test_set_all_vals(self):
confkey = 'multiple'
self.config.add_settings(dict(PASSWORD_CONFIG.items(confkey)))
for key in PasswordValidator.default_settings.keys():
expected, expected_type = self.use_settings[key]
validator = PasswordValidator(self.config.registry.settings)
actual = validator.settings[key]
self.assertEqual(expected, actual)
self.assertTrue(isinstance(actual, expected_type))
def test_password_multiple_errors(self):
keys = ['min_lower', 'min_upper', 'min_numeric', 'min_special']
keys = map(lambda x: '.'.join([PASSWORD_SETTINGS_PREFIX, x]), keys)
expected_error_keys = ['min_numeric', 'min_special', 'min_length']
settings = dict([(key, 2) for key in keys])
settings['.'.join([PASSWORD_SETTINGS_PREFIX, 'min_length'])] = 8
validator = PasswordValidator(settings)
for pwkey in ['complex', 'long_complex']:
password = self.passwords[pwkey][0]
result = validator(password)
if 'long' in pwkey:
self.assertEqual(result, None)
else:
msg = "%s passed but should not have"
self.assertTrue(result is not None, msg % pwkey)
for errkey in expected_error_keys:
errmsg = validator._get_error_message(errkey)
self.assertTrue(errmsg in result, 'missing "%s"' % errmsg)
def test_password_multiple_errors(self):
keys = ['min_lower', 'min_upper', 'min_numeric', 'min_special']
keys = map(lambda x: '.'.join([PASSWORD_SETTINGS_PREFIX, x]), keys)
expected_error_keys = ['min_numeric', 'min_special', 'min_length']
settings = dict([(key, 2) for key in keys])
settings['.'.join([PASSWORD_SETTINGS_PREFIX, 'min_length'])] = 8
validator = PasswordValidator(settings)
for pwkey in ['complex', 'long_complex']:
password = self.passwords[pwkey][0]
result = validator(password)
if 'long' in pwkey:
self.assertEqual(result, None)
else:
msg = "%s passed but should not have"
self.assertTrue(result is not None, msg % pwkey)
for errkey in expected_error_keys:
errmsg = validator._get_error_message(errkey)
self.assertTrue(errmsg in result, 'missing "%s"' % errmsg)
def test_set_nonevals(self):
"""what happens when the value in .ini is nothing
"""
confkey = 'nonevals'
self.config.add_settings(dict(PASSWORD_CONFIG.items(confkey)))
defaults = PasswordValidator.default_settings
for key in defaults.keys():
expected = defaults[key]
validator = PasswordValidator(self.config.registry.settings)
actual = validator.settings[key]
self.assertEqual(expected, actual, 'bad value for %s' % key)
def test_set_integer_vals(self):
for key in [
'min_length', 'max_length', 'min_lower', 'min_upper',
'min_numeric', 'min_special', 'min_non_alpha'
]:
expected, expected_type = self.use_settings[key]
self.config.add_settings(dict(PASSWORD_CONFIG.items(key)))
validator = PasswordValidator(self.config.registry.settings)
actual = validator.settings[key]
self.assertEqual(expected, actual)
self.assertTrue(isinstance(actual, expected_type))
def setUp(self):
# self.settings = DEFAULT_PASSWORD_SETTINGS.copy()
self.validator = PasswordValidator()
self.passwords = {
'alpha_lower': ['abcdef', [6, 0, 0, 0, 0]],
'alpha_upper': ['ABCDEF', [0, 6, 0, 0, 0]],
'alpha_mixed': ['abcDEF', [3, 3, 0, 0, 0]],
'numeric': ['123456', [0, 0, 6, 0, 6]],
'alphanumeric_lower': ['123abc', [3, 0, 3, 0, 3]],
'alphanumeric_upper': ['123ABC', [0, 3, 3, 0, 3]],
'alphanumeric_mixed': ['12aAbB', [2, 2, 2, 0, 2]],
'special': ['!#@{%^', [0, 0, 0, 6, 6]],
'complex': ['yRo8$D', [2, 2, 1, 1, 2]],
'long_complex': ['nYfJ6UUt$8y4j+]W', [5, 5, 3, 3, 6]]
}
class PasswordToolsTests(TestCase):
def setUp(self):
# self.settings = DEFAULT_PASSWORD_SETTINGS.copy()
self.validator = PasswordValidator()
self.passwords = {
'alpha_lower': ['abcdef', [6, 0, 0, 0, 0]],
'alpha_upper': ['ABCDEF', [0, 6, 0, 0, 0]],
'alpha_mixed': ['abcDEF', [3, 3, 0, 0, 0]],
'numeric': ['123456', [0, 0, 6, 0, 6]],
'alphanumeric_lower': ['123abc', [3, 0, 3, 0, 3]],
'alphanumeric_upper': ['123ABC', [0, 3, 3, 0, 3]],
'alphanumeric_mixed': ['12aAbB', [2, 2, 2, 0, 2]],
'special': ['!#@{%^', [0, 0, 0, 6, 6]],
'complex': ['yRo8$D', [2, 2, 1, 1, 2]],
'long_complex': ['nYfJ6UUt$8y4j+]W', [5, 5, 3, 3, 6]]
}
def decompose_charcounts(self, password):
"""return counts for character types in uniform order
will always return the count as lower, upper, numeric, special
"""
out = []
counts = self.validator._get_chartype_counts(password)
for key in [
'min_lower', 'min_upper', 'min_numeric', 'min_special',
'min_non_alpha'
]:
out.append(counts[key])
return out
def test_get_chartype_counts(self):
"""characters in a password can be correctly categorized"""
for key, val in self.passwords.items():
password, expected = val
actual = self.decompose_charcounts(password)
err_msg = "char count for %s incorrect: expected %s but got %s"
self.assertEqual(expected, actual,
err_msg % (key, expected, actual))
def test_disallowed_reg(self):
"""a constructed regular expression correctly finds matches
"""
for disallowed, keymatch in [('abcABC', 'alpha'), ('123', 'numeric'),
('$+]', 'complex')]:
regex = self.validator._make_disallowed_regex(disallowed)
for key, val in self.passwords.items():
password = val[0]
found = bool(len(regex.findall(password)))
if keymatch in key:
self.assertTrue(found)
else:
self.assertFalse(found)
def test_password_okay_permissive(self):
"""default settings allow any password to pass"""
for key, val in self.passwords.items():
password = val[0]
self.assertEqual(self.validator(password), None)
def test_password_min_length(self):
testkey = 'min_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_max_length(self):
testkey = 'max_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_lower(self):
testkey = 'min_lower'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 5})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'alpha_lower' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_upper(self):
testkey = 'min_upper'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 5})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'alpha_upper' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_numeric(self):
testkey = 'min_numeric'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 2})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'numeric' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_special(self):
testkey = 'min_special'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 3})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_non_alpha(self):
testkey = 'min_non_alpha'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 4})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['numeric', 'special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_disallowed(self):
testkey = 'disallowed'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: '$+]'})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'complex' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_multiple_errors(self):
keys = ['min_lower', 'min_upper', 'min_numeric', 'min_special']
keys = map(lambda x: '.'.join([PASSWORD_SETTINGS_PREFIX, x]), keys)
expected_error_keys = ['min_numeric', 'min_special', 'min_length']
settings = dict([(key, 2) for key in keys])
settings['.'.join([PASSWORD_SETTINGS_PREFIX, 'min_length'])] = 8
validator = PasswordValidator(settings)
for pwkey in ['complex', 'long_complex']:
password = self.passwords[pwkey][0]
result = validator(password)
if 'long' in pwkey:
self.assertEqual(result, None)
else:
msg = "%s passed but should not have"
self.assertTrue(result is not None, msg % pwkey)
for errkey in expected_error_keys:
errmsg = validator._get_error_message(errkey)
self.assertTrue(errmsg in result, 'missing "%s"' % errmsg)
class PasswordToolsTests(TestCase):
def setUp(self):
# self.settings = DEFAULT_PASSWORD_SETTINGS.copy()
self.validator = PasswordValidator()
self.passwords = {
'alpha_lower': ['abcdef', [6, 0, 0, 0, 0]],
'alpha_upper': ['ABCDEF', [0, 6, 0, 0, 0]],
'alpha_mixed': ['abcDEF', [3, 3, 0, 0, 0]],
'numeric': ['123456', [0, 0, 6, 0, 6]],
'alphanumeric_lower': ['123abc', [3, 0, 3, 0, 3]],
'alphanumeric_upper': ['123ABC', [0, 3, 3, 0, 3]],
'alphanumeric_mixed': ['12aAbB', [2, 2, 2, 0, 2]],
'special': ['!#@{%^', [0, 0, 0, 6, 6]],
'complex': ['yRo8$D', [2, 2, 1, 1, 2]],
'long_complex': ['nYfJ6UUt$8y4j+]W', [5, 5, 3, 3, 6]]
}
def decompose_charcounts(self, password):
"""return counts for character types in uniform order
will always return the count as lower, upper, numeric, special
"""
out = []
counts = self.validator._get_chartype_counts(password)
for key in ['min_lower', 'min_upper', 'min_numeric', 'min_special',
'min_non_alpha']:
out.append(counts[key])
return out
def test_get_chartype_counts(self):
"""characters in a password can be correctly categorized"""
for key, val in self.passwords.items():
password, expected = val
actual = self.decompose_charcounts(password)
err_msg = "char count for %s incorrect: expected %s but got %s"
self.assertEqual(expected, actual,
err_msg % (key, expected, actual))
def test_disallowed_reg(self):
"""a constructed regular expression correctly finds matches
"""
for disallowed, keymatch in [('abcABC', 'alpha'),
('123', 'numeric'),
('$+]', 'complex')]:
regex = self.validator._make_disallowed_regex(disallowed)
for key, val in self.passwords.items():
password = val[0]
found = bool(len(regex.findall(password)))
if keymatch in key:
self.assertTrue(found)
else:
self.assertFalse(found)
def test_password_okay_permissive(self):
"""default settings allow any password to pass"""
for key, val in self.passwords.items():
password = val[0]
self.assertEqual(self.validator(password), None)
def test_password_min_length(self):
testkey = 'min_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_max_length(self):
testkey = 'max_length'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 7})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'long' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_lower(self):
testkey = 'min_lower'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 5})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'alpha_lower' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_upper(self):
testkey = 'min_upper'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 5})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'alpha_upper' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_numeric(self):
testkey = 'min_numeric'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 2})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'numeric' in key or 'long_complex' in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_special(self):
testkey = 'min_special'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 3})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_min_non_alpha(self):
testkey = 'min_non_alpha'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: 4})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if key in ['numeric', 'special', 'long_complex']:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_disallowed(self):
testkey = 'disallowed'
key = '.'.join([PASSWORD_SETTINGS_PREFIX, testkey])
validator = PasswordValidator({key: '$+]'})
expected_error = validator._get_error_message(testkey)
for key, val in self.passwords.items():
password = val[0]
result = validator(password)
if 'complex' not in key:
self.assertEqual(result, None)
else:
self.assertTrue(result is not None)
self.assertEqual(result, expected_error)
def test_password_multiple_errors(self):
keys = ['min_lower', 'min_upper', 'min_numeric', 'min_special']
keys = map(lambda x: '.'.join([PASSWORD_SETTINGS_PREFIX, x]), keys)
expected_error_keys = ['min_numeric', 'min_special', 'min_length']
settings = dict([(key, 2) for key in keys])
settings['.'.join([PASSWORD_SETTINGS_PREFIX, 'min_length'])] = 8
validator = PasswordValidator(settings)
for pwkey in ['complex', 'long_complex']:
password = self.passwords[pwkey][0]
result = validator(password)
if 'long' in pwkey:
self.assertEqual(result, None)
else:
msg = "%s passed but should not have"
self.assertTrue(result is not None, msg % pwkey)
for errkey in expected_error_keys:
errmsg = validator._get_error_message(errkey)
self.assertTrue(errmsg in result, 'missing "%s"' % errmsg)