def setup_database_with_translations():
init_model(engine)
teardownDatabase()
metadata.create_all(engine)
# Creating members
member = Member()
member.member_name = compat.u('rms')
member.password = compat.u('freedom')
DBSession.add(member)
member = Member()
member.member_name = compat.u('linus')
member.password = compat.u('linux')
DBSession.add(member)
member = Member()
member.member_name = compat.u('sballmer')
member.password = compat.u('developers')
DBSession.add(member)
# Plus a couple of members without groups
member = Member()
member.member_name = compat.u('guido')
member.password = compat.u('phytonic')
DBSession.add(member)
member = Member()
member.member_name = compat.u('rasmus')
member.password = compat.u('php')
DBSession.add(member)
DBSession.commit()
def setup_database():
init_model(engine)
teardownDatabase()
metadata.create_all(engine)
# Creating users
user = User()
user.user_name = compat.u('rms')
user.password = compat.u('freedom')
DBSession.add(user)
user = User()
user.user_name = compat.u('linus')
user.password = compat.u('linux')
DBSession.add(user)
user = User()
user.user_name = compat.u('sballmer')
user.password = compat.u('developers')
DBSession.add(user)
# Plus a couple of users without groups
user = User()
user.user_name = compat.u('guido')
user.password = compat.u('phytonic')
DBSession.add(user)
user = User()
user.user_name = compat.u('rasmus')
user.password = compat.u('php')
DBSession.add(user)
DBSession.commit()
def setup_database():
init_model(engine)
teardownDatabase()
elixir.setup_all(True)
# Creating users
user = User()
user.user_name = compat.u('rms')
user.password = compat.u('freedom')
DBSession.add(user)
user = User()
user.user_name = compat.u('linus')
user.password = compat.u('linux')
DBSession.add(user)
user = User()
user.user_name = compat.u('sballmer')
user.password = compat.u('developers')
DBSession.add(user)
# Plus a couple of users without groups
user = User()
user.user_name = compat.u('guido')
user.password = compat.u('phytonic')
DBSession.add(user)
user = User()
user.user_name = compat.u('rasmus')
user.password = compat.u('php')
DBSession.add(user)
DBSession.commit()
def setup_database_with_translations():
init_model(engine)
teardownDatabase()
metadata.create_all(engine)
# Creating members
member = Member()
member.member_name = compat.u('rms')
member.password = compat.u('freedom')
DBSession.add(member)
member = Member()
member.member_name = compat.u('linus')
member.password = compat.u('linux')
DBSession.add(member)
member = Member()
member.member_name = compat.u('sballmer')
member.password = compat.u('developers')
DBSession.add(member)
# Plus a couple of members without groups
member = Member()
member.member_name = compat.u('guido')
member.password = compat.u('phytonic')
DBSession.add(member)
member = Member()
member.member_name = compat.u('rasmus')
member.password = compat.u('php')
DBSession.add(member)
DBSession.commit()
def test_dummy_validate(self):
self.plugin = SQLAlchemyAuthenticatorPlugin(sa_model.User,
sa_model.DBSession)
self.plugin.translations['dummy_validate_password'] = \
sa_model.dummy_validate
identity = {'login': compat.u('QWERTY'), 'password': compat.u('freedom')}
self.assertRaises(sa_model.DummyValidateException,
self.plugin.authenticate, None, identity)
def test_it(self):
self.plugin = SQLAlchemyAuthenticatorPlugin(sa_model.Member,
sa_model.DBSession)
# Updating the translations...
self.plugin.translations['user_name'] = 'member_name'
self.plugin.translations['validate_password'] = '******'
# Testing it...
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.assertEqual(compat.u('rms'), self.plugin.authenticate(None, identity))
def test_it(self):
self.plugin = SQLAlchemyAuthenticatorPlugin(sa_model.Member,
sa_model.DBSession)
# Updating the translations...
self.plugin.translations['user_name'] = 'member_name'
self.plugin.translations['validate_password'] = '******'
# Testing it...
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.assertEqual(compat.u('rms'),
self.plugin.authenticate(None, identity))
def test_dummy_validate(self):
self.plugin = SQLAlchemyAuthenticatorPlugin(sa_model.User,
sa_model.DBSession)
self.plugin.translations['dummy_validate_password'] = \
sa_model.dummy_validate
identity = {
'login': compat.u('QWERTY'),
'password': compat.u('freedom')
}
self.assertRaises(sa_model.DummyValidateException,
self.plugin.authenticate, None, identity)
def test_rollback(self):
"""The session must be rolled back before use."""
# Make the transaction invalid by attempting to add an existing user:
try:
user = elixir_model.User()
user.user_name = compat.u("rms")
user.password = "******"
elixir_model.DBSession.add(user)
elixir_model.DBSession.commit()
except IntegrityError:
pass
else:
self.fail("An IntegrityError must've been raised")
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.plugin.authenticate(None, identity)
def test_remember_max_age_unicode(self):
from repoze.who._compat import u
plugin = self._makeOne('secret')
environ = {'HTTP_HOST': 'example.com'}
tkt = self._makeTicket(userid='chris', userdata='')
result = plugin.remember(environ, {
'repoze.who.userid': 'chris',
'max_age': u('500')
})
name, value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(isinstance(value, str))
self.assertTrue(
value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt),
(value, tkt))
self.assertTrue('; Expires=' in value)
name, value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(
value.startswith(
'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500' %
tkt), value)
self.assertTrue('; Expires=' in value)
name, value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(
value.startswith(
'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' %
tkt), value)
self.assertTrue('; Expires=' in value)
def test_remember_max_age_unicode(self):
from repoze.who._compat import u
plugin = self._makeOne('secret')
environ = {'HTTP_HOST':'example.com'}
tkt = self._makeTicket(userid='chris', userdata='')
result = plugin.remember(environ, {'repoze.who.userid': 'chris',
'max_age': u('500')})
name, value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(isinstance(value, str))
self.assertTrue(
value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt),
(value, tkt))
self.assertTrue('; Expires=' in value)
name,value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(
value.startswith(
'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500'
% tkt), value)
self.assertTrue('; Expires=' in value)
name,value = result.pop(0)
self.assertEqual('Set-Cookie', name)
self.assertTrue(
value.startswith(
'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' % tkt),
value)
self.assertTrue('; Expires=' in value)
def test_rollback(self):
"""The session must be rolled back before use."""
# Make the transaction invalid by attempting to add an existing user:
try:
user = sa_model.User()
user.user_name = compat.u("rms")
user.password = "******"
sa_model.DBSession.add(user)
sa_model.DBSession.commit()
except IntegrityError:
pass
else:
self.fail("An IntegrityError must've been raised")
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.plugin.authenticate(None, identity)
def test_rollback(self):
"""The session must be rolled back before use."""
# Make the transaction invalid by attempting to add an existing user:
try:
user = sa_model.User()
user.user_name = compat.u("rms")
user.password = "******"
sa_model.DBSession.add(user)
sa_model.DBSession.commit()
except IntegrityError:
pass
else:
self.fail("An IntegrityError must've been raised")
identity = {'repoze.who.userid': compat.u("rms")}
self.plugin.add_metadata(None, identity)
def make_plugin(login_url, came_from_param=None, reason_param=None, reason_header=None):
if login_url in (u(""), b"", None):
raise ValueError("No 'login_url'")
if reason_header is not None and reason_param is None:
raise Exception("Can't set 'reason_header' without 'reason_param'.")
if reason_header is None and reason_param is not None:
reason_header = "X-Authorization-Failure-Reason"
return RedirectorPlugin(
login_url, came_from_param=came_from_param, reason_param=reason_param, reason_header=reason_header
)
def test_it(self):
user = sa_model.DBSession.query(sa_model.User).\
filter(sa_model.User.user_name==compat.u('rms')).one()
identity = {'repoze.who.userid': user.user_name}
expected_identity = {'repoze.who.userid': user.user_name, 'user': user}
self.plugin.add_metadata(None, identity)
self.assertEqual(identity.keys(), expected_identity.keys())
self.assertEqual(
expected_identity['repoze.who.userid'],
identity['repoze.who.userid'],
)
self.assertEqual(
expected_identity['user'].user_name,
identity['user'].user_name,
)
def test_it(self):
user = sa_model.DBSession.query(sa_model.User).\
filter(sa_model.User.user_name==compat.u('rms')).one()
identity = {'repoze.who.userid': user.user_name}
expected_identity = {
'repoze.who.userid': user.user_name,
'user': user}
self.plugin.add_metadata(None, identity)
self.assertEqual(identity.keys(), expected_identity.keys())
self.assertEqual(
expected_identity['repoze.who.userid'],
identity['repoze.who.userid'],
)
self.assertEqual(
expected_identity['user'].user_name,
identity['user'].user_name,
)
def make_plugin(
login_url,
came_from_param=None,
reason_param=None,
reason_header=None,
):
if login_url in (u(''), b'', None):
raise ValueError("No 'login_url'")
if reason_header is not None and reason_param is None:
raise Exception("Can't set 'reason_header' without 'reason_param'.")
if reason_header is None and reason_param is not None:
reason_header = 'X-Authorization-Failure-Reason'
return RedirectorPlugin(
login_url,
came_from_param=came_from_param,
reason_param=reason_param,
reason_header=reason_header,
)
def test_it(self):
self.plugin = SQLAlchemyUserMDPlugin(sa_model.Member,
sa_model.DBSession)
# Updating the translations...
self.plugin.translations['user_name'] = 'member_name'
# Testing it...
member = sa_model.DBSession.query(sa_model.Member).\
filter(sa_model.Member.member_name==compat.u('rms')).one()
identity = {'repoze.who.userid': member.member_name}
expected_identity = {
'repoze.who.userid': member.member_name,
'user': member}
self.plugin.add_metadata(None, identity)
self.assertEqual(expected_identity.keys(), identity.keys())
self.assertEqual(
expected_identity['repoze.who.userid'],
identity['repoze.who.userid'],
)
self.assertEqual(
expected_identity['user'].member_name,
identity['user'].member_name,
)
def test_it(self):
self.plugin = SQLAlchemyUserMDPlugin(sa_model.Member,
sa_model.DBSession)
# Updating the translations...
self.plugin.translations['user_name'] = 'member_name'
# Testing it...
member = sa_model.DBSession.query(sa_model.Member).\
filter(sa_model.Member.member_name==compat.u('rms')).one()
identity = {'repoze.who.userid': member.member_name}
expected_identity = {
'repoze.who.userid': member.member_name,
'user': member
}
self.plugin.add_metadata(None, identity)
self.assertEqual(expected_identity.keys(), identity.keys())
self.assertEqual(
expected_identity['repoze.who.userid'],
identity['repoze.who.userid'],
)
self.assertEqual(
expected_identity['user'].member_name,
identity['user'].member_name,
)
def test_non_existing_user(self):
self.assertFalse(self.plugin(compat.u("gustavo")))
def test_match(self):
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.assertEqual(compat.u('rms'),
self.plugin.authenticate(None, identity))
def test_existing_user(self):
self.assertTrue(self.plugin(compat.u("guido")))
def test_non_existing_user(self):
self.assertFalse(self.plugin(compat.u("gustavo")))
def test_no_match(self):
identity = {
'login': compat.u('gustavo'),
'password': compat.u('narea')
}
self.assertEqual(None, self.plugin.authenticate(None, identity))
def test_no_match(self):
identity = {'login': compat.u('gustavo'), 'password': compat.u('narea')}
self.assertEqual(None, self.plugin.authenticate(None, identity))
def test_match(self):
identity = {'login': compat.u('rms'), 'password': compat.u('freedom')}
self.assertEqual(compat.u('rms'), self.plugin.authenticate(None, identity))
def test_shaprefix_w_unicode_cleartext(self):
from repoze.who._compat import u
stored = '{SHA}' + self._get_sha_hex_digest()
compare = self._getFUT()
result = compare(u('password'), stored)
self.assertEqual(result, True)
def test_shaprefix_w_unicode_cleartext(self):
from repoze.who._compat import u
stored = '{SHA}' + self._get_sha_hex_digest()
compare = self._getFUT()
result = compare(u('password'), stored)
self.assertEqual(result, True)
def test_existing_user(self):
self.assertTrue(self.plugin(compat.u("guido")))
