def _user(self):
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'ptah@local', 'ptah@local')
uri = user.uri
Session.add(user)
Session.flush()
return user
def test_validate(self):
from ptah.crowd import validation
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
t = ptah.token.service.generate(validation.TOKEN_TYPE, user.uri)
request = DummyRequest()
self._setRequest(request)
try:
validation.validate(request)
except:
pass
self.assertIn(
"Can't validate email address.", request.session['msgservice'][0])
props = ptah.crowd.get_properties(user.uri)
props.validated = False
request.GET['token'] = t
request.session.clear()
try:
validation.validate(request)
except:
pass
self.assertIn(
"Account has been successfully validated.",
request.session['msgservice'][0])
props = ptah.crowd.get_properties(user.uri)
self.assertTrue(props.validated)
def test_login(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email',
password = '******')
uri = user.uri
Session.add(user)
Session.flush()
transaction.commit()
request = DummyRequest()
form = login.LoginForm(None, request)
form.update()
data, errors = form.extract()
self.assertEqual(len(errors), 2)
form.handleLogin()
self.assertIn('Please fix indicated errors.',
request.session['msgservice'][0])
request = DummyRequest(
POST={'login': '******', 'password': '******'})
form = login.LoginForm(None, request)
form.update()
data, errors = form.extract()
try:
form.handleLogin()
except Exception, res:
pass
def test_join_error(self):
from ptah.crowd.registration import Registration
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
uri = user.uri
Session.add(user)
Session.flush()
request = DummyRequest(
POST = {'name': 'Test user',
'login': '******',
'password': '******',
'confirm_password': '******'})
form = Registration(None, request)
form.update()
data, errors = form.extract()
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0].msg[0], 'Invalid email address')
form.register_handler()
self.assertIn('Please fix indicated errors.',
request.session['msgservice'][0])
request = DummyRequest(
POST = {'name': 'Test user',
'login': '******',
'password': '******',
'confirm_password': '******'})
form = Registration(None, request)
form.update()
data, errors = form.extract()
self.assertEqual(len(errors), 0)
def _make_user(self):
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
return user
def test_crowd_user_get(self):
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('user-name', 'user-login', 'user-email', 'passwd')
uri = user.uri
Session.add(user)
Session.flush()
self.assertEqual(CrowdUser.get(user.pid).uri, uri)
self.assertEqual(CrowdUser.get_byuri(user.uri).uri, uri)
self.assertEqual(CrowdUser.get_bylogin(user.login).uri, uri)
def test_get_bylogin(self):
from ptah.crowd.provider import CrowdProvider, CrowdUser, Session
provider = CrowdProvider()
self.assertIsNone(provider.get_principal_bylogin('test'))
user = CrowdUser('test', 'test', '*****@*****.**',
ptah.passwordTool.encode('12345'))
Session.add(user)
transaction.commit()
user = provider.get_principal_bylogin('test')
self.assertIsInstance(user, CrowdUser)
self.assertEqual(user.login, 'test')
def test_login_success(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
uri = user.uri
Session.add(user)
Session.flush()
transaction.commit()
request = DummyRequest()
ptah.authService.set_userid(uri)
res = login.LoginSuccess.__view_renderer__(None, request, '')
self.assertIn('You are now logged in', res)
def test_crowd_user_change_search(self):
from ptah.crowd.provider import Session, CrowdUser, search
user = CrowdUser('user-name', 'user-login', 'user-email', 'passwd')
uri = user.uri
Session.add(user)
Session.flush()
users = list(search('user'))
self.assertEqual(len(users), 1)
self.assertEqual(users[0].uri, uri)
users = list(search('email'))
self.assertEqual(len(users), 1)
self.assertEqual(users[0].uri, uri)
def test_logout(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
uri = user.uri
Session.add(user)
Session.flush()
transaction.commit()
request = DummyRequest()
ptah.authService.set_userid(uri)
try:
login.logout(request)
except Exception, res:
pass
def test_resetpassword_form_update(self):
from ptah.crowd.provider import CrowdUser, Session
from ptah.crowd.resetpassword import ResetPasswordForm
user = CrowdUser("name", "login", "email")
Session.add(user)
Session.flush()
passcode = ptah.passwordTool.generate_passcode(user)
request = DummyRequest(subpath=(passcode,))
form = ResetPasswordForm(None, request)
form.update()
self.assertEqual(form.title, user.name)
self.assertEqual(form.passcode, passcode)
def test_manage_module_get(self):
from ptah.crowd.module import CrowdModule, UserWrapper
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
uri = user.uri
Session.add(user)
Session.flush()
mod = CrowdModule(None, DummyRequest())
self.assertRaises(KeyError, mod.__getitem__, 'unkown')
wu = mod[str(user.pid)]
self.assertIsInstance(wu, UserWrapper)
self.assertEqual(wu.user.uri, uri)
def test_sharingform_unset(self):
from ptahcmsapp.sharing import SharingForm
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
container = Container()
container.__local_roles__ = {user.uri: [TestRole.id]}
form = SharingForm(container, DummyRequest(
session={'sharing-search-term': 'email'},
POST={'form.buttons.save': 'Save',
'userid-%s'%user.uri: 'on'}))
form.csrf = False
form.update()
self.assertNotIn(user.uri, container.__local_roles__)
def test_sharingform_unset(self):
from ptah.manage.apps import SharingForm
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
app = self._make_app()
app.app.__local_roles__ = {user.uri: [TestRole.id]}
form = SharingForm(app, DummyRequest(
session={'apps-sharing-term': 'email'},
POST={'form.buttons.save': 'Save',
'userid-%s'%user.uri: 'on'}))
form.csrf = False
form.update()
self.assertNotIn(user.uri, app.app.__local_roles__)
def test_login_suspended(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email',
password = '******')
uri = user.uri
Session.add(user)
ptah.crowd.get_properties(uri).suspended = True
transaction.commit()
request = DummyRequest(
POST={'login': '******', 'password': '******'})
form = login.LoginForm(None, request)
form.update()
try:
form.handleLogin()
except Exception, res:
pass
def test_suspended(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
uri = user.uri
props = ptah.crowd.get_properties(uri)
props.suspended = True
ptah.authService.set_userid(user.uri)
request = DummyRequest()
res = login.LoginSuspended.__view_renderer__(None, request, '')
self.assertIn('Your account is suspended', res)
def test_login_wrong_login(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email',
password = '******')
uri = user.uri
Session.add(user)
Session.flush()
transaction.commit()
request = DummyRequest(
POST={'login': '******', 'password': '******'})
form = login.LoginForm(None, request)
form.update()
form.handleLogin()
self.assertIn('You enter wrong login or password',
request.session['msgservice'][0])
def test_resetpassword_form_change(self):
from ptah.crowd.provider import CrowdUser, Session
from ptah.crowd.resetpassword import ResetPasswordForm
user = CrowdUser("name", "login", "email")
Session.add(user)
Session.flush()
passcode = ptah.passwordTool.generate_passcode(user)
request = DummyRequest(
subpath=(passcode,),
POST={"password": "******", "confirm_password": "******", "form.buttons.change": "Change"},
)
form = ResetPasswordForm(None, request)
try:
form.update()
except HTTPFound, res:
pass
def test_resetpassword_form_change_errors(self):
from ptah.crowd.provider import CrowdUser, Session
from ptah.crowd.resetpassword import ResetPasswordForm
user = CrowdUser("name", "login", "email")
Session.add(user)
Session.flush()
passcode = ptah.passwordTool.generate_passcode(user)
request = DummyRequest(
subpath=(passcode,),
POST={"password": "******", "confirm_password": "******", "form.buttons.change": "Change"},
)
form = ResetPasswordForm(None, request)
form.update()
msg = request.session["msgservice"][0]
self.assertIn("Please fix indicated errors.", msg)
def test_join(self):
from ptah.crowd.registration import Registration
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
uri = user.uri
Session.add(user)
Session.flush()
request = DummyRequest(
POST = {'name': 'Test user',
'login': '******',
'password': '******',
'confirm_password': '******'})
form = Registration(None, request)
form.update()
try:
form.register_handler()
except Exception, res:
pass
def test_login_unvalidated(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email',
password = '******')
uri = user.uri
Session.add(user)
ptah.crowd.get_properties(uri).validated = False
transaction.commit()
ptah.crowd.CONFIG['allow-unvalidated'] = False
request = DummyRequest(
POST={'login': '******', 'password': '******'})
form = login.LoginForm(None, request)
form.update()
form.handleLogin()
self.assertIn('Account is not validated.',
request.session['msgservice'][0])
def test_sharingform_update(self):
from ptahcmsapp.sharing import SharingForm
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
container = Container()
form = SharingForm(container, DummyRequest(
session={'sharing-search-term': 'email'}))
form.csrf = False
form.update()
self.assertEqual(len(form.users), 1)
self.assertEqual(form.users[0].uri, user.uri)
self.assertIs(form.local_roles, container.__local_roles__)
self.assertEqual(len(form.roles), 1)
self.assertIs(form.roles[0], TestRole)
self.assertEqual(form.get_principal(user.uri).uri, user.uri)
def test_sharingform_update(self):
from ptah.manage.apps import SharingForm
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
Session.flush()
app = self._make_app()
form = SharingForm(app, DummyRequest(
session={'apps-sharing-term': 'email'}))
form.csrf = False
form.update()
self.assertEqual(len(form.users), 1)
self.assertEqual(form.users[0].uri, user.uri)
self.assertIs(form.local_roles, app.app.__local_roles__)
self.assertEqual(len(form.roles), 1)
self.assertIs(form.roles[0], TestRole)
self.assertEqual(form.get_principal(user.uri).uri, user.uri)
def test_authenticate(self):
from ptah.crowd.provider import CrowdProvider, CrowdUser, Session
provider = CrowdProvider()
self.assertFalse(
provider.authenticate(
{'login': '******', 'password': '******'}))
user = CrowdUser('test', 'test', '*****@*****.**',
ptah.passwordTool.encode('12345'))
Session.add(user)
transaction.commit()
self.assertTrue(
provider.authenticate(
{'login': '******', 'password': '******'}))
self.assertFalse(
provider.authenticate(
{'login': '******', 'password': '******'}))
def test_login_came_from(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email',
password = '******')
uri = user.uri
Session.add(user)
Session.flush()
transaction.commit()
request = DummyRequest(
POST={'login': '******', 'password': '******'},
GET={'came_from': 'http://example.com/ptah-manage/'})
form = login.LoginForm(None, request)
form.update()
data, errors = form.extract()
try:
form.handleLogin()
except Exception, res:
pass
def test_resetpassword_template(self):
from ptah.crowd.provider import CrowdUser, Session
from ptah.crowd.resetpassword import ResetPasswordTemplate
user = CrowdUser("name", "login", "email")
Session.add(user)
Session.flush()
request = DummyRequest()
passcode = ptah.passwordTool.generate_passcode(user)
template = ResetPasswordTemplate(user, request)
template.passcode = passcode
template.update()
text = template.render()
self.assertIn(
"Password reseting process has been initiated. You must visit link below to complete password reseting:",
text,
)
self.assertIn("http://example.com/resetpassword.html/%s/" % passcode, text)
def test_check_login(self):
from ptah.crowd import login
from ptah.crowd.provider import CrowdUser, Session
user = CrowdUser('name', 'login', 'email')
Session.add(user)
transaction.commit()
request = DummyRequest()
self.assertRaises(
form.Invalid, ptah.crowd.checkLoginValidator, None, 'login')
class Field(object):
""" """
field = Field()
field.content = 'login'
ptah.crowd.checkLoginValidator(field, 'login')
field.content = 'other-login'
self.assertRaises(
form.Invalid, ptah.crowd.checkLoginValidator, field, 'login')
def test_resetpassword(self):
from ptah.crowd.provider import CrowdUser, Session
from ptah.crowd.resetpassword import ResetPassword
from ptah.crowd.resetpassword import ResetPasswordTemplate
user = CrowdUser("name", "login", "email")
Session.add(user)
Session.flush()
data = [1, None]
def send(self):
data[0] = 2
data[1] = self.passcode
ResetPasswordTemplate.send = send
request = DummyRequest(POST={"login": "******", "form.buttons.reset": "Reset"})
form = ResetPassword(None, request)
try:
form.update()
except HTTPFound, res:
pass
