def test_login(self):
from ptahcrowd import login
from ptahcrowd.provider import CrowdUser
user = CrowdUser(name="name", login="******", email="email", password="******")
CrowdUser.__type__.add(user)
uri = user.__uri__
request = DummyRequest()
form = login.LoginForm(None, request)
form.update()
data, errors = form.extract()
self.assertEqual(len(errors), 2)
form.login_handler()
self.assertIn("Please fix indicated errors.", ptah.render_messages(request))
request = DummyRequest(POST={"login": "******", "password": "******"})
request.environ["HTTP_HOST"] = "example.com"
form = login.LoginForm(None, request)
form.update()
res = form.login_handler()
self.assertIsInstance(res, HTTPFound)
self.assertEqual(res.headers["location"], "http://example.com/login-success.html")
def test_edit_form(self):
from ptah.manage.settings import SettingsModule, EditForm
ptah.register_settings(
'test',
ptah.form.TextField('node1', default='test1'),
ptah.form.TextField('node2', default='test2'),
title = 'Test settings',
ttw = True,
ttw_skip_fields = ('node2',))
self.init_ptah()
mod = SettingsModule(None, self.request)
grp = mod['test']
settings = grp.group
form = EditForm(grp, self.request)
self.assertEqual(form.label, settings.__title__)
self.assertEqual(form.description, settings.__description__)
self.assertIs(form.form_content(), settings)
fields = form.fields
self.assertIn('node1', fields)
self.assertNotIn('node2', fields)
res = form.back_handler()
self.assertIsInstance(res, HTTPFound)
self.assertEqual(res.headers['location'], '..')
form.update()
form.modify_handler()
self.assertIn('Settings have been modified.',
ptah.render_messages(self.request))
def test_create_user(self):
from ptahcrowd.module import CrowdModule
from ptahcrowd.user import CreateUserForm
f = CreateUserForm(None, None)
request = DummyRequest(
POST = {'name': 'NKim',
'login': '******',
'password': '******',
'validated': 'false',
'suspended': 'true',
'form.buttons.create': 'Create'})
request.POST[CreateUserForm.csrfname] = \
request.session.get_csrf_token()
mod = CrowdModule(None, request)
view = CreateUserForm(mod, request)
res = view.update()
self.assertIsInstance(res, HTTPFound)
self.assertEqual(res.headers['location'], '.')
self.assertIn('User has been created.', ptah.render_messages(request))
transaction.commit()
user = ptah.auth_service.get_principal_bylogin('*****@*****.**')
self.assertEqual(user.name, 'NKim')
self.assertEqual(user.login, '*****@*****.**')
self.assertTrue(user.suspended)
self.assertFalse(user.validated)
def edit_category(context, request):
categoryform = form.Form(context,request)
categoryform.fields = models.Category.__type__.fieldset
def backAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
form.context.name = data['name']
form.message('Category has been updated.')
categoryform.label = u'Edit category'
categoryform.buttons.add_action('Update', action=updateAction)
categoryform.buttons.add_action('Back', action=backAction)
categoryform.content = {'name':context.name}
result = categoryform.update()
if isinstance(result, HTTPFound):
return result
rendered_form = categoryform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
api = TemplateAPI(request)
return {'api': api,
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def test_resetpassword(self):
from ptahcrowd.resetpassword import ResetPassword
from ptahcrowd.resetpassword import ResetPasswordTemplate
from ptahcrowd.provider import CrowdUser
user = CrowdUser(name="name", login="******", email="email")
CrowdUser.__type__.add(user)
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)
res = form.update()
msg = ptah.render_messages(request)
self.assertIn("We have started resetting your password.", msg)
self.assertIsInstance(res, HTTPFound)
self.assertEqual(res.headers["location"], "http://example.com")
self.assertEqual(data[0], 2)
principal = ptah.pwd_tool.get_principal(data[1])
self.assertEqual(principal.name, "name")
self.assertEqual(principal.login, "login")
del ResetPasswordTemplate.send
def test_resetpassword_required(self):
from ptahcrowd.resetpassword import ResetPassword
request = DummyRequest(POST={"form.buttons.reset": "Reset"})
form = ResetPassword(None, request)
form.update()
msg = ptah.render_messages(request)
self.assertIn("The system can't restore the password for this user.", msg)
def test_resetpassword_form_unknown_passcode(self):
from ptahcrowd.resetpassword import ResetPasswordForm
request = DummyRequest(subpath=("unknown",))
form = ResetPasswordForm(None, request)
res = form.update()
msg = ptah.render_messages(request)
self.assertIn("Passcode is invalid.", msg)
self.assertEqual(res.headers["location"], "http://example.com/resetpassword.html")
def test_sharingform_search_error(self):
from ptahcms.manage.apps import SharingForm
app = self._make_app()
form = SharingForm(
app, DummyRequest(POST={'form.buttons.search': 'Search'}))
form.csrf = False
form.update()
self.assertIn('Please specify search term',
ptah.render_messages(form.request))
def test_module_search_error(self):
from ptahcrowd.views import CrowdModuleView
mod = self._make_mod()
form = CrowdModuleView(mod, DummyRequest(
POST=MultiDict((('form.buttons.search', 'Search'),))))
form.csrf = False
form.update()
self.assertIn('Please specify search term',
ptah.render_messages(form.request))
def test_sharingform_search_error(self):
from ptahcms.manage.apps import SharingForm
app = self._make_app()
form = SharingForm(app, DummyRequest(
POST={'form.buttons.search': 'Search'}))
form.csrf = False
form.update()
self.assertIn('Please specify search term',
ptah.render_messages(form.request))
def test_validate(self):
from ptahcrowd import validation
from ptahcrowd.provider import CrowdUser
user = CrowdUser(name='name', login='******', email='email')
CrowdUser.__type__.add(user)
t = ptah.token.service.generate(validation.TOKEN_TYPE, user.__uri__)
res = validation.validate(self.request)
self.assertIsInstance(res, HTTPFound)
self.assertIn(
"Can't validate email address.", ptah.render_messages(self.request))
user.validated = False
self.request.GET['token'] = t
self.request.session.clear()
res = validation.validate(self.request)
self.assertIn("Account has been successfully validated.",
ptah.render_messages(self.request))
self.assertTrue(user.validated)
def test_modify_user_error(self):
from ptahcrowd.user import ModifyUserForm
user = self._user()
request = DummyRequest(
POST = {'form.buttons.modify': 'Modify'})
view = ModifyUserForm(user, request)
view.csrf = False
view.update()
self.assertIn(
'Please fix indicated errors.',
ptah.render_messages(request))
def add_post(context, request):
postform = form.Form(context,request)
postform.fields = models.Post.__type__.fieldset
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
now = datetime.utcnow()
user = ptah.auth_service.get_current_principal().name
post = models.Post(creator = user,
title = data['title'],
tags = data['tags'],
category = data['category'],
text = data['text'],
discussion = data['discussion'],
modified = now,
created = now)
ptah.get_session().add(post)
form.message('Post has been created.')
return HTTPFound(location='/')
postform.label = u'Add post'
postform.buttons.add_action('Add', action=updateAction)
postform.buttons.add_action('Cancel', action=cancelAction)
result = postform.update() # prepare form for rendering
if isinstance(result, HTTPFound):
return result
rendered_form = postform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
api = TemplateAPI(request)
return {'api': api,
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def test_login_wrong_login(self):
from ptahcrowd import login
from ptahcrowd.provider import CrowdUser
user = CrowdUser(name="name", login="******", email="email", password="******")
CrowdUser.__type__.add(user)
uri = user.__uri__
request = DummyRequest(POST={"login": "******", "password": "******"})
request.environ["HTTP_HOST"] = "example.com"
form = login.LoginForm(None, request)
form.update()
form.login_handler()
self.assertIn("You have entered the wrong login or password.", ptah.render_messages(request))
def edit_post(context, request):
postform = form.Form(context,request)
postform.fields = models.Post.__type__.fieldset
def backAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
user = ptah.auth_service.get_current_principal().name
form.context.creator = user
form.context.title = data['title']
form.context.tags = data['tags']
form.context.category = data['category']
form.context.text = data['text']
form.context.discussion = data['discussion']
form.context.modified = datetime.utcnow()
form.message('Post has been updated.')
postform.label = u'Edit Post'
postform.buttons.add_action('Update', action=updateAction)
postform.buttons.add_action('Back', action=backAction)
postform.content = {'title':context.title,
'tags':context.tags,
'category':context.category,
'text':context.text,
'discussion':context.discussion}
result = postform.update()
if isinstance(result, HTTPFound):
return result
rendered_form = postform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
api = TemplateAPI(request)
return {'api': api,
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def test_create_user_error(self):
from ptahcrowd.module import CrowdModule
from ptahcrowd.user import CreateUserForm
f = CreateUserForm(None, None)
request = DummyRequest(
POST = {'form.buttons.create': 'Create'})
request.POST[CreateUserForm.csrfname] = \
request.session.get_csrf_token()
mod = CrowdModule(None, request)
view = CreateUserForm(mod, request)
view.update()
self.assertIn(
'Please fix indicated errors.',
ptah.render_messages(request))
def edit_blog(context, request):
configform = form.Form(context,request)
configform.fields = models.Blog.__type__.fieldset
def backAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
form.context.name = data['name']
form.context.title = data['title']
form.context.tagline = data['tagline']
form.context.discussion = data['discussion']
form.context.disqus = data['disqus']
form.message('Blog has been updated.')
configform.label = u'Blog Configuration'
configform.buttons.add_action('Update', action=updateAction)
configform.buttons.add_action('Back', action=backAction)
configform.content = {'name':context.name,
'title':context.title,
'tagline':context.tagline,
'discussion':context.discussion,
'disqus':context.disqus}
result = configform.update()
if isinstance(result, HTTPFound):
return result
rendered_form = configform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
api = TemplateAPI(request)
return {'api': api,
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def test_resetpassword_form_change_errors(self):
from ptahcrowd.provider import CrowdUser
from ptahcrowd.resetpassword import ResetPasswordForm
user = CrowdUser(name="name", login="******", email="email")
CrowdUser.__type__.add(user)
passcode = ptah.pwd_tool.generate_passcode(user)
request = DummyRequest(
subpath=(passcode,),
POST={"password": "******", "confirm_password": "******", "form.buttons.change": "Change"},
)
request.environ["HTTP_HOST"] = "example.com"
form = ResetPasswordForm(None, request)
form.update()
msg = ptah.render_messages(request)
self.assertIn("Please fix indicated errors.", msg)
def test_module_remove(self):
from ptahcrowd.views import CrowdModuleView
mod = self._make_mod()
user = self._make_user()
user.suspended = False
uri = user.__uri__
form = CrowdModuleView(mod, DummyRequest(
POST=MultiDict((('uid', user.id),
('remove', 'remove')))))
form.update()
self.assertIn('The selected accounts have been removed.',
ptah.render_messages(form.request))
transaction.commit()
user = ptah.resolve(uri)
self.assertIsNone(user)
def test_login_unvalidated(self):
from ptahcrowd import login
from ptahcrowd.provider import CrowdUser
user = CrowdUser(name="name", login="******", email="email", password="******")
CrowdUser.__type__.add(user)
uri = user.__uri__
user.validated = False
cfg = ptah.get_settings(ptahcrowd.CFG_ID_CROWD)
cfg["allow-unvalidated"] = False
request = DummyRequest(POST={"login": "******", "password": "******"})
request.environ["HTTP_HOST"] = "example.com"
form = login.LoginForm(None, request)
form.update()
form.login_handler()
self.assertIn("Account is not validated.", ptah.render_messages(request))
def test_join_unvalidated(self):
import ptahcrowd
from ptahcrowd.provider import CrowdUser
from ptahcrowd.registration import Registration
user = CrowdUser(name='name', login='******', email='email')
ptah.get_session().add(user)
ptah.get_session().flush()
uri = user.__uri__
class Stub(object):
status = ''
def send(self, frm, to, msg):
Stub.status = 'Email has been sended'
MAIL = ptah.get_settings(ptah.CFG_ID_PTAH)
MAIL['Mailer'] = Stub()
CROWD = ptah.get_settings(ptahcrowd.CFG_ID_CROWD)
CROWD['allow-unvalidated'] = False
request = DummyRequest(
POST = {'name': 'Test user',
'login': '******',
'password': '******',
'confirm_password': '******'})
form = Registration(None, request)
form.update()
res = form.register_handler()
self.assertIsInstance(res, HTTPFound)
self.assertEqual(res.headers['location'], 'http://example.com')
user = ptah.auth_service.get_principal_bylogin('*****@*****.**')
self.assertIsInstance(user, CrowdUser)
self.assertEqual(user.name, 'Test user')
self.assertIn('Validation email has been sent.',
ptah.render_messages(request))
def add_object(context, request):
rackobform = form.Form(context, request)
rackobform.fields = models.RackObject.__type__.fieldset
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
obj = models.RackObject(title=data['title'],
label=data['label'],
objtype=data['objtype'])
ptah.get_session().add(obj)
form.message('RackObject has been created.')
return HTTPFound(location='/')
rackobform.label = u'Add object'
rackobform.buttons.add_action('Add', action=updateAction)
rackobform.buttons.add_action('Cancel', action=cancelAction)
result = rackobform.update() # prepare form for rendering
if isinstance(result, HTTPFound):
return result
rendered_form = rackobform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
return {
'objects': ptah.get_session().query(models.RackObject),
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)
}
def test_module_suspend(self):
from ptahcrowd.provider import CrowdUser
from ptahcrowd.views import CrowdModuleView
mod = self._make_mod()
user = self._make_user()
user.suspended = False
id = user.id
form = CrowdModuleView(mod, DummyRequest(
POST=MultiDict((('uid', id),
('suspend', 'suspend')))))
form.request.POST[form.csrfname] = form.request.session.get_csrf_token()
form.update()
self.assertIn('The selected accounts have been suspended.',
ptah.render_messages(form.request))
transaction.commit()
user = ptah.get_session().query(CrowdUser)\
.filter(CrowdUser.id==id).first()
self.assertTrue(user.suspended)
def test_resetpassword_form_change(self):
from ptahcrowd.provider import CrowdUser
from ptahcrowd.resetpassword import ResetPasswordForm
user = CrowdUser(name="name", login="******", email="email")
CrowdUser.__type__.add(user)
passcode = ptah.pwd_tool.generate_passcode(user)
request = DummyRequest(
subpath=(passcode,),
POST={"password": "******", "confirm_password": "******", "form.buttons.change": "Change"},
)
request.environ["HTTP_HOST"] = "example.com"
form = ResetPasswordForm(None, request)
res = form.update()
msg = ptah.render_messages(request)
self.assertIn("You have successfully changed your password.", msg)
self.assertEqual(res.headers["location"], "http://example.com")
self.assertTrue(ptah.pwd_tool.check(user.password, "123456"))
def add_category(context, request):
categoryform = form.Form(context,request)
categoryform.fields = models.Category.__type__.fieldset
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
category = models.Category(name = data['name'])
ptah.get_session().add(category)
form.message('Category has been created.')
return HTTPFound(location='/')
categoryform.label = u'Add category'
categoryform.buttons.add_action('Add', action=updateAction)
categoryform.buttons.add_action('Cancel', action=cancelAction)
result = categoryform.update() # prepare form for rendering
if isinstance(result, HTTPFound):
return result
rendered_form = categoryform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
api = TemplateAPI(request)
return {'api': api,
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def add_link(context, request):
linkform = form.Form(context,request)
linkform.fields = models.Link.__type__.fieldset
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
link = models.Link(title = data['title'],
href = data['href'],
color = data['color'])
ptah.get_session().add(link)
form.message('Link has been created.')
return HTTPFound(location='/')
linkform.label = u'Add link'
linkform.buttons.add_action('Add', action=updateAction)
linkform.buttons.add_action('Cancel', action=cancelAction)
result = linkform.update() # prepare form for rendering
if isinstance(result, HTTPFound):
return result
rendered_form = linkform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
return {'links': ptah.get_session().query(models.Link),
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def edit_link(context, request):
linkform = form.Form(context,request)
linkform.fields = models.Link.__type__.fieldset
def backAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
form.context.title = data['title']
form.context.href = data['href']
form.context.color = data['color']
form.message('Link has been updated.')
linkform.label = u'Edit link'
linkform.buttons.add_action('Update', action=updateAction)
linkform.buttons.add_action('Back', action=backAction)
linkform.content = {'title':context.title,
'href':context.href,
'color':context.color}
result = linkform.update() # prepare form for rendering
if isinstance(result, HTTPFound):
return result
rendered_form = linkform.render()
ptah.include(request, 'bootstrap')
rendered_includes = ptah.render_includes(request)
return {'links': ptah.get_session().query(models.Link),
'rendered_form': rendered_form,
'rendered_includes': rendered_includes,
'rendered_messages': ptah.render_messages(request)}
def test_join_error(self):
from ptahcrowd.provider import CrowdUser
from ptahcrowd.registration import Registration
user = CrowdUser(name='name', login='******', email='email')
ptah.get_session().add(user)
ptah.get_session().flush()
uri = user.__uri__
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.',
ptah.render_messages(request))
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 __call__(self):
request = self.request
self.rendered_includes = ptah.render_includes(request)
self.rendered_messages = ptah.render_messages(request)
return {}
def __call__(self):
return {'rendered_includes': ptah.render_includes(self.request),
'rendered_messages': ptah.render_messages(self.request)}
def contact_us(context, request):
contactform = form.Form(context, request)
contactform.fields = form.Fieldset(
form.TextField(
'fullname',
title = u'First & Last Name'),
form.TextField(
'phone',
title = u'Telephone number',
description=u'Please provide telephone number',
validator = Telephone()),
form.TextField(
'email',
title = u'Your email',
description = u'Please provide email address.',
validator = form.Email()),
form.TextAreaField(
'subject',
title = u'How can we help?',
missing = u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
)
# form actions
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
# form.context is ...
form.context.fullname = data['fullname']
form.context.phone = data['phone']
form.context.email = data['email']
form.context.subject = data['subject']
# You would add any logic/database updates/insert here.
# You would probably also redirect.
log.info('The form was updated successfully')
form.message('The form was updated successfully')
contactform.label = u'Contact us'
contactform.buttons.add_action('Update', action=updateAction)
contactform.buttons.add_action('Cancel', action=cancelAction)
# form default values
contactform.content = {}
# prepare form
result = contactform.update()
if isinstance(result, HTTPFound):
return result
# render form into HTML
rendered_form = contactform.render()
# query for links to populate links box
links = ptah.get_session().query(models.Link)
#include library dependencies
ptah.include(request, 'bootstrap')
# render all the included libraries into html
rendered_includes = ptah.render_includes(request)
# render messages
rendered_messages = ptah.render_messages(request)
return {'links': links,
'rendered_form': rendered_form,
'rendered_messages': rendered_messages,
'rendered_includes': rendered_includes}
