Mercurial Mercurial > pub > hg > cubicweb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
web/test/unittest_application.py
changeset 3657 706d7bf0ae3d
parent 3524 a3431f4e2f40
child 3890 d7a270f50f54
equal deleted inserted replaced
3656:9ba2e3253a88 3657:706d7bf0ae3d 
   142         super(ApplicationTC, self).setUp()
 
   142         super(ApplicationTC, self).setUp()
 
   143         def raise_hdlr(*args, **kwargs):
 
   143         def raise_hdlr(*args, **kwargs):
 
   144             raise
 
   144             raise
 
   145         self.app.error_handler = raise_hdlr
 
   145         self.app.error_handler = raise_hdlr
 
   146 
   146 
   147     def publish(self, req, path='view'):
 
       
   148         return self.app.publish(path, req)
 
       
   149 
       
   150     def expect_redirect(self, callback, req):
 
       
   151         try:
 
       
   152             res = callback(req)
 
       
   153             print res
 
       
   154         except Redirect, ex:
 
       
   155             try:
 
       
   156                 path, params = ex.location.split('?', 1)
 
       
   157             except ValueError:
 
       
   158                 path = ex.location
 
       
   159                 params = {}
 
       
   160             else:
 
       
   161                 cleanup = lambda p: (p[0], unquote(p[1]))
 
       
   162                 params = dict(cleanup(p.split('=', 1)) for p in params.split('&') if p)
 
       
   163             path = path[len(req.base_url()):]
 
       
   164             return path, params
 
       
   165         else:
 
       
   166             self.fail('expected a Redirect exception')
 
       
   167 
       
   168     def expect_redirect_publish(self, req, path='view'):
 
       
   169         return self.expect_redirect(lambda x: self.publish(x, path), req)
 
       
   170 
       
   171     def test_cnx_user_groups_sync(self):
 
   147     def test_cnx_user_groups_sync(self):
 
   172         user = self.user()
 
   148         user = self.user()
 
   173         self.assertEquals(user.groups, set(('managers',)))
 
   149         self.assertEquals(user.groups, set(('managers',)))
 
   174         self.execute('SET X in_group G WHERE X eid %s, G name "guests"' % user.eid)
 
   150         self.execute('SET X in_group G WHERE X eid %s, G name "guests"' % user.eid)
 
   175         user = self.user()
 
   151         user = self.user()
 
   199             'login:'+`user.eid`:     '', # ERROR: no login specified
 
   175             'login:'+`user.eid`:     '', # ERROR: no login specified
 
   200             'edits-login:'+`user.eid`: unicode(user.login),
 
   176             'edits-login:'+`user.eid`: unicode(user.login),
 
   201              # just a sample, missing some necessary information for real life
 
   177              # just a sample, missing some necessary information for real life
 
   202             '__errorurl': 'view?vid=edition...'
 
   178             '__errorurl': 'view?vid=edition...'
 
   203             }
 
   179             }
 
   204         path, params = self.expect_redirect_publish(req, 'edit')
 
   180         path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req)
 
   205         forminfo = req.get_session_data('view?vid=edition...')
 
   181         forminfo = req.get_session_data('view?vid=edition...')
 
   206         eidmap = forminfo['eidmap']
 
   182         eidmap = forminfo['eidmap']
 
   207         self.assertEquals(eidmap, {})
 
   183         self.assertEquals(eidmap, {})
 
   208         values = forminfo['values']
 
   184         values = forminfo['values']
 
   209         self.assertEquals(values['login:'+`user.eid`], '')
 
   185         self.assertEquals(values['login:'+`user.eid`], '')
 
   232                 '__errorurl': 'view?vid=edition...',
 
   208                 '__errorurl': 'view?vid=edition...',
 
   233                 }
 
   209                 }
 
   234         req.form = form
 
   210         req.form = form
 
   235         # monkey patch edited_eid to ensure both entities are edited, not only X
 
   211         # monkey patch edited_eid to ensure both entities are edited, not only X
 
   236         req.edited_eids = lambda : ('Y', 'X')
 
   212         req.edited_eids = lambda : ('Y', 'X')
 
   237         path, params = self.expect_redirect_publish(req, 'edit')
 
   213         path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req)
 
   238         forminfo = req.get_session_data('view?vid=edition...')
 
   214         forminfo = req.get_session_data('view?vid=edition...')
 
   239         self.assertUnorderedIterableEquals(forminfo['eidmap'].keys(), ['X', 'Y'])
 
   215         self.assertUnorderedIterableEquals(forminfo['eidmap'].keys(), ['X', 'Y'])
 
   240         self.assertEquals(forminfo['errors'].entity, forminfo['eidmap']['X'])
 
   216         self.assertEquals(forminfo['errors'].entity, forminfo['eidmap']['X'])
 
   241         self.assertEquals(forminfo['errors'].errors, {'login': 'required attribute',
 
   217         self.assertEquals(forminfo['errors'].errors, {'login': 'required attribute',
 
   242                                                       'upassword': 'required attribute'})
 
   218                                                       'upassword': 'required attribute'})
 
   284         self.set_option('anonymous-user', 'anon')
 
   260         self.set_option('anonymous-user', 'anon')
 
   285         self.login('anon')
 
   261         self.login('anon')
 
   286         req = self.request()
 
   262         req = self.request()
 
   287         origcnx = req.cnx
 
   263         origcnx = req.cnx
 
   288         req.form['__fblogin'] = u'turlututu'
 
   264         req.form['__fblogin'] = u'turlututu'
 
   289         page = self.publish(req)
 
   265         page = self.app_publish(req)
 
   290         self.failIf(req.cnx is origcnx)
 
   266         self.failIf(req.cnx is origcnx)
 
   291         self.assertEquals(req.user.login, 'turlututu')
 
   267         self.assertEquals(req.user.login, 'turlututu')
 
   292         self.failUnless('turlututu' in page, page)
 
   268         self.failUnless('turlututu' in page, page)
 
   293 
   269 
   294     # authentication tests ####################################################
 
   270     # authentication tests ####################################################
 
   295 
   271 
   296     def _init_auth(self, authmode, anonuser=None):
 
   272     def test_http_auth_no_anon(self):
 
   297         self.set_option('auth-mode', authmode)
 
   273         req, origcnx = self.init_authentication('http')
 
   298         self.set_option('anonymous-user', anonuser)
 
   274         self.assertAuthFailure(req)
 
   299         req = self.request()
 
   275         self.assertRaises(ExplicitLogin, self.app_publish, req, 'login')
 
   300         origcnx = req.cnx
 
       
   301         req.cnx = None
 
       
   302         sh = self.app.session_handler
 
       
   303         # not properly cleaned between tests
 
       
   304         self.open_sessions = sh.session_manager._sessions = {}
 
       
   305         return req, origcnx
 
       
   306 
       
   307     def _test_auth_succeed(self, req, origcnx):
 
       
   308         sh = self.app.session_handler
 
       
   309         path, params = self.expect_redirect(lambda x: self.app.connect(x), req)
 
       
   310         cnx = req.cnx
 
       
   311         self.assertEquals(len(self.open_sessions), 1, self.open_sessions)
 
       
   312         self.assertEquals(cnx.login, origcnx.login)
 
       
   313         self.assertEquals(cnx.password, origcnx.password)
 
       
   314         self.assertEquals(cnx.anonymous_connection, False)
 
       
   315         self.assertEquals(path, 'view')
 
       
   316         self.assertEquals(params, {'__message': 'welcome %s !' % cnx.user().login})
 
       
   317 
       
   318     def _test_auth_fail(self, req):
 
       
   319         self.assertRaises(AuthenticationError, self.app.connect, req)
 
       
   320         self.assertEquals(req.cnx, None)
 
   276         self.assertEquals(req.cnx, None)
 
   321         self.assertEquals(len(self.open_sessions), 0)
 
   277         authstr = base64.encodestring('%s:%s' % (origcnx.login, origcnx.authinfo['password']))
 
   322         clear_cache(req, 'get_authorization')
 
       
   323 
       
   324     def test_http_auth_no_anon(self):
 
       
   325         req, origcnx = self._init_auth('http')
 
       
   326         self._test_auth_fail(req)
 
       
   327         self.assertRaises(ExplicitLogin, self.publish, req, 'login')
 
       
   328         self.assertEquals(req.cnx, None)
 
       
   329         authstr = base64.encodestring('%s:%s' % (origcnx.login, origcnx.password))
 
       
   330         req._headers['Authorization'] = 'basic %s' % authstr
 
   278         req._headers['Authorization'] = 'basic %s' % authstr
 
   331         self._test_auth_succeed(req, origcnx)
 
   279         self.assertAuthSuccess(req, origcnx)
 
   332         self.assertRaises(AuthenticationError, self.publish, req, 'logout')
 
   280         self.assertEquals(req.cnx.authinfo, {'password': origcnx.authinfo['password']})
 
       
   281         self.assertRaises(AuthenticationError, self.app_publish, req, 'logout')
 
   333         self.assertEquals(len(self.open_sessions), 0)
 
   282         self.assertEquals(len(self.open_sessions), 0)
 
   334 
   283 
   335     def test_cookie_auth_no_anon(self):
 
   284     def test_cookie_auth_no_anon(self):
 
   336         req, origcnx = self._init_auth('cookie')
 
   285         req, origcnx = self.init_authentication('cookie')
 
   337         self._test_auth_fail(req)
 
   286         self.assertAuthFailure(req)
 
   338         form = self.publish(req, 'login')
 
   287         form = self.app_publish(req, 'login')
 
   339         self.failUnless('__login' in form)
 
   288         self.failUnless('__login' in form)
 
   340         self.failUnless('__password' in form)
 
   289         self.failUnless('__password' in form)
 
   341         self.assertEquals(req.cnx, None)
 
   290         self.assertEquals(req.cnx, None)
 
   342         req.form['__login'] = origcnx.login
 
   291         req.form['__login'] = origcnx.login
 
   343         req.form['__password'] = origcnx.password
 
   292         req.form['__password'] = origcnx.authinfo['password']
 
   344         self._test_auth_succeed(req, origcnx)
 
   293         self.assertAuthSuccess(req, origcnx)
 
   345         self.assertRaises(AuthenticationError, self.publish, req, 'logout')
 
   294         self.assertEquals(req.cnx.authinfo, {'password': origcnx.authinfo['password']})
 
       
   295         self.assertRaises(AuthenticationError, self.app_publish, req, 'logout')
 
   346         self.assertEquals(len(self.open_sessions), 0)
 
   296         self.assertEquals(len(self.open_sessions), 0)
 
   347 
   297 
   348     def test_login_by_email(self):
 
   298     def test_login_by_email(self):
 
   349         login = self.request().user.login
 
   299         login = self.request().user.login
 
   350         address = login + u'@localhost'
 
   300         address = login + u'@localhost'
 
   351         self.execute('INSERT EmailAddress X: X address %(address)s, U primary_email X '
 
   301         self.execute('INSERT EmailAddress X: X address %(address)s, U primary_email X '
 
   352                      'WHERE U login %(login)s', {'address': address, 'login': login})
 
   302                      'WHERE U login %(login)s', {'address': address, 'login': login})
 
   353         self.commit()
 
   303         self.commit()
 
   354         # option allow-email-login not set
 
   304         # option allow-email-login not set
 
   355         req, origcnx = self._init_auth('cookie')
 
   305         req, origcnx = self.init_authentication('cookie')
 
   356         req.form['__login'] = address
 
   306         req.form['__login'] = address
 
   357         req.form['__password'] = origcnx.password
 
   307         req.form['__password'] = origcnx.authinfo['password']
 
   358         self._test_auth_fail(req)
 
   308         self.assertAuthFailure(req)
 
   359         # option allow-email-login set
 
   309         # option allow-email-login set
 
   360         origcnx.login = address
 
   310         origcnx.login = address
 
   361         self.set_option('allow-email-login', True)
 
   311         self.set_option('allow-email-login', True)
 
   362         req.form['__login'] = address
 
   312         req.form['__login'] = address
 
   363         req.form['__password'] = origcnx.password
 
   313         req.form['__password'] = origcnx.authinfo['password']
 
   364         self._test_auth_succeed(req, origcnx)
 
   314         self.assertAuthSuccess(req, origcnx)
 
   365         self.assertRaises(AuthenticationError, self.publish, req, 'logout')
 
   315         self.assertEquals(req.cnx.authinfo, {'password': origcnx.authinfo['password']})
 
   366         self.assertEquals(len(self.open_sessions), 0)
 
   316         self.assertRaises(AuthenticationError, self.app_publish, req, 'logout')
 
   367 
   317         self.assertEquals(len(self.open_sessions), 0)
 
   368     def _test_auth_anon(self, req):
 
       
   369         self.app.connect(req)
 
       
   370         acnx = req.cnx
 
       
   371         self.assertEquals(len(self.open_sessions), 1)
 
       
   372         self.assertEquals(acnx.login, 'anon')
 
       
   373         self.assertEquals(acnx.password, 'anon')
 
       
   374         self.failUnless(acnx.anonymous_connection)
 
       
   375         self._reset_cookie(req)
 
       
   376 
   318 
   377     def _reset_cookie(self, req):
 
   319     def _reset_cookie(self, req):
 
   378         # preparing the suite of the test
 
   320         # preparing the suite of the test
 
   379         # set session id in cookie
 
   321         # set session id in cookie
 
   380         cookie = Cookie.SimpleCookie()
 
   322         cookie = Cookie.SimpleCookie()
 
   382         req._headers['Cookie'] = cookie['__session'].OutputString()
 
   324         req._headers['Cookie'] = cookie['__session'].OutputString()
 
   383         clear_cache(req, 'get_authorization')
 
   325         clear_cache(req, 'get_authorization')
 
   384         # reset cnx as if it was a new incoming request
 
   326         # reset cnx as if it was a new incoming request
 
   385         req.cnx = None
 
   327         req.cnx = None
 
   386 
   328 
       
   329     def _test_auth_anon(self, req):
 
       
   330         self.app.connect(req)
 
       
   331         acnx = req.cnx
 
       
   332         self.assertEquals(len(self.open_sessions), 1)
 
       
   333         self.assertEquals(acnx.login, 'anon')
 
       
   334         self.assertEquals(acnx.authinfo['password'], 'anon')
 
       
   335         self.failUnless(acnx.anonymous_connection)
 
       
   336         self._reset_cookie(req)
 
       
   337 
   387     def _test_anon_auth_fail(self, req):
 
   338     def _test_anon_auth_fail(self, req):
 
   388         self.assertEquals(len(self.open_sessions), 1)
 
   339         self.assertEquals(len(self.open_sessions), 1)
 
   389         self.app.connect(req)
 
   340         self.app.connect(req)
 
   390         self.assertEquals(req.message, 'authentication failure')
 
   341         self.assertEquals(req.message, 'authentication failure')
 
   391         self.assertEquals(req.cnx.anonymous_connection, True)
 
   342         self.assertEquals(req.cnx.anonymous_connection, True)
 
   392         self.assertEquals(len(self.open_sessions), 1)
 
   343         self.assertEquals(len(self.open_sessions), 1)
 
   393         self._reset_cookie(req)
 
   344         self._reset_cookie(req)
 
   394 
   345 
   395     def test_http_auth_anon_allowed(self):
 
   346     def test_http_auth_anon_allowed(self):
 
   396         req, origcnx = self._init_auth('http', 'anon')
 
   347         req, origcnx = self.init_authentication('http', 'anon')
 
   397         self._test_auth_anon(req)
 
   348         self._test_auth_anon(req)
 
   398         authstr = base64.encodestring('toto:pouet')
 
   349         authstr = base64.encodestring('toto:pouet')
 
   399         req._headers['Authorization'] = 'basic %s' % authstr
 
   350         req._headers['Authorization'] = 'basic %s' % authstr
 
   400         self._test_anon_auth_fail(req)
 
   351         self._test_anon_auth_fail(req)
 
   401         authstr = base64.encodestring('%s:%s' % (origcnx.login, origcnx.password))
 
   352         authstr = base64.encodestring('%s:%s' % (origcnx.login, origcnx.authinfo['password']))
 
   402         req._headers['Authorization'] = 'basic %s' % authstr
 
   353         req._headers['Authorization'] = 'basic %s' % authstr
 
   403         self._test_auth_succeed(req, origcnx)
 
   354         self.assertAuthSuccess(req, origcnx)
 
   404         self.assertRaises(AuthenticationError, self.publish, req, 'logout')
 
   355         self.assertEquals(req.cnx.authinfo, {'password': origcnx.authinfo['password']})
 
       
   356         self.assertRaises(AuthenticationError, self.app_publish, req, 'logout')
 
   405         self.assertEquals(len(self.open_sessions), 0)
 
   357         self.assertEquals(len(self.open_sessions), 0)
 
   406 
   358 
   407     def test_cookie_auth_anon_allowed(self):
 
   359     def test_cookie_auth_anon_allowed(self):
 
   408         req, origcnx = self._init_auth('cookie', 'anon')
 
   360         req, origcnx = self.init_authentication('cookie', 'anon')
 
   409         self._test_auth_anon(req)
 
   361         self._test_auth_anon(req)
 
   410         req.form['__login'] = 'toto'
 
   362         req.form['__login'] = 'toto'
 
   411         req.form['__password'] = 'pouet'
 
   363         req.form['__password'] = 'pouet'
 
   412         self._test_anon_auth_fail(req)
 
   364         self._test_anon_auth_fail(req)
 
   413         req.form['__login'] = origcnx.login
 
   365         req.form['__login'] = origcnx.login
 
   414         req.form['__password'] = origcnx.password
 
   366         req.form['__password'] = origcnx.authinfo['password']
 
   415         self._test_auth_succeed(req, origcnx)
 
   367         self.assertAuthSuccess(req, origcnx)
 
   416         self.assertRaises(AuthenticationError, self.publish, req, 'logout')
 
   368         self.assertEquals(req.cnx.authinfo, {'password': origcnx.authinfo['password']})
 
       
   369         self.assertRaises(AuthenticationError, self.app_publish, req, 'logout')
 
   417         self.assertEquals(len(self.open_sessions), 0)
 
   370         self.assertEquals(len(self.open_sessions), 0)
 
   418 
   371 
   419     def test_non_regr_optional_first_var(self):
 
   372     def test_non_regr_optional_first_var(self):
 
   420         req = self.request()
 
   373         req = self.request()
 
   421         # expect a rset with None in [0][0]
 
   374         # expect a rset with None in [0][0]
 
   422         req.form['rql'] = 'rql:Any OV1, X WHERE X custom_workflow OV1?'
 
   375         req.form['rql'] = 'rql:Any OV1, X WHERE X custom_workflow OV1?'
 
   423         self.publish(req)
 
   376         self.app_publish(req)
 
   424         print 'yuea'
 
       
   425 
   377 
   426 if __name__ == '__main__':
 
   378 if __name__ == '__main__':
 
   427     unittest_main()
 
   379     unittest_main()
cubicweb