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}