67 |
67 |
68 |
68 |
69 def test_list_arg(self): |
69 def test_list_arg(self): |
70 """tests the list_arg() function""" |
70 """tests the list_arg() function""" |
71 list_arg = self._cw.list_form_param |
71 list_arg = self._cw.list_form_param |
72 self.assertEquals(list_arg('arg3', {}), []) |
72 self.assertEqual(list_arg('arg3', {}), []) |
73 d = {'arg1' : "value1", |
73 d = {'arg1' : "value1", |
74 'arg2' : ('foo', INTERNAL_FIELD_VALUE,), |
74 'arg2' : ('foo', INTERNAL_FIELD_VALUE,), |
75 'arg3' : ['bar']} |
75 'arg3' : ['bar']} |
76 self.assertEquals(list_arg('arg1', d, True), ['value1']) |
76 self.assertEqual(list_arg('arg1', d, True), ['value1']) |
77 self.assertEquals(d, {'arg2' : ('foo', INTERNAL_FIELD_VALUE), 'arg3' : ['bar'],}) |
77 self.assertEqual(d, {'arg2' : ('foo', INTERNAL_FIELD_VALUE), 'arg3' : ['bar'],}) |
78 self.assertEquals(list_arg('arg2', d, True), ['foo']) |
78 self.assertEqual(list_arg('arg2', d, True), ['foo']) |
79 self.assertEquals({'arg3' : ['bar'],}, d) |
79 self.assertEqual({'arg3' : ['bar'],}, d) |
80 self.assertEquals(list_arg('arg3', d), ['bar',]) |
80 self.assertEqual(list_arg('arg3', d), ['bar',]) |
81 self.assertEquals({'arg3' : ['bar'],}, d) |
81 self.assertEqual({'arg3' : ['bar'],}, d) |
82 |
82 |
83 |
83 |
84 def test_from_controller(self): |
84 def test_from_controller(self): |
85 self._cw.vreg['controllers'] = {'view': 1, 'login': 1} |
85 self._cw.vreg['controllers'] = {'view': 1, 'login': 1} |
86 self.assertEquals(self._cw.from_controller(), 'view') |
86 self.assertEqual(self._cw.from_controller(), 'view') |
87 req = FakeRequest(url='project?vid=list') |
87 req = FakeRequest(url='project?vid=list') |
88 req.vreg['controllers'] = {'view': 1, 'login': 1} |
88 req.vreg['controllers'] = {'view': 1, 'login': 1} |
89 # this assertion is just to make sure that relative_path can be |
89 # this assertion is just to make sure that relative_path can be |
90 # correctly computed as it is used in from_controller() |
90 # correctly computed as it is used in from_controller() |
91 self.assertEquals(req.relative_path(False), 'project') |
91 self.assertEqual(req.relative_path(False), 'project') |
92 self.assertEquals(req.from_controller(), 'view') |
92 self.assertEqual(req.from_controller(), 'view') |
93 # test on a valid non-view controller |
93 # test on a valid non-view controller |
94 req = FakeRequest(url='login?x=1&y=2') |
94 req = FakeRequest(url='login?x=1&y=2') |
95 req.vreg['controllers'] = {'view': 1, 'login': 1} |
95 req.vreg['controllers'] = {'view': 1, 'login': 1} |
96 self.assertEquals(req.relative_path(False), 'login') |
96 self.assertEqual(req.relative_path(False), 'login') |
97 self.assertEquals(req.from_controller(), 'login') |
97 self.assertEqual(req.from_controller(), 'login') |
98 |
98 |
99 |
99 |
100 class UtilsTC(TestCase): |
100 class UtilsTC(TestCase): |
101 """test suite for misc application utilities""" |
101 """test suite for misc application utilities""" |
102 |
102 |
105 |
105 |
106 #def test_which_mapping(self): |
106 #def test_which_mapping(self): |
107 # """tests which mapping is used (application or core)""" |
107 # """tests which mapping is used (application or core)""" |
108 # init_mapping() |
108 # init_mapping() |
109 # from cubicweb.common import mapping |
109 # from cubicweb.common import mapping |
110 # self.assertEquals(mapping.MAPPING_USED, 'core') |
110 # self.assertEqual(mapping.MAPPING_USED, 'core') |
111 # sys.modules['mapping'] = FakeMapping() |
111 # sys.modules['mapping'] = FakeMapping() |
112 # init_mapping() |
112 # init_mapping() |
113 # self.assertEquals(mapping.MAPPING_USED, 'application') |
113 # self.assertEqual(mapping.MAPPING_USED, 'application') |
114 # del sys.modules['mapping'] |
114 # del sys.modules['mapping'] |
115 |
115 |
116 def test_execute_linkto(self): |
116 def test_execute_linkto(self): |
117 """tests the execute_linkto() function""" |
117 """tests the execute_linkto() function""" |
118 self.assertEquals(self.ctrl.execute_linkto(), None) |
118 self.assertEqual(self.ctrl.execute_linkto(), None) |
119 self.assertEquals(self.ctrl._cursor.executed, |
119 self.assertEqual(self.ctrl._cursor.executed, |
120 []) |
120 []) |
121 |
121 |
122 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:object', |
122 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:object', |
123 'eid': 8}) |
123 'eid': 8}) |
124 self.ctrl.execute_linkto() |
124 self.ctrl.execute_linkto() |
125 self.assertEquals(self.ctrl._cursor.executed, |
125 self.assertEqual(self.ctrl._cursor.executed, |
126 ['SET Y works_for X WHERE X eid 8, Y eid %s' % i |
126 ['SET Y works_for X WHERE X eid 8, Y eid %s' % i |
127 for i in (12, 13, 14)]) |
127 for i in (12, 13, 14)]) |
128 |
128 |
129 self.ctrl.new_cursor() |
129 self.ctrl.new_cursor() |
130 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:subject', |
130 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:subject', |
131 'eid': 8}) |
131 'eid': 8}) |
132 self.ctrl.execute_linkto() |
132 self.ctrl.execute_linkto() |
133 self.assertEquals(self.ctrl._cursor.executed, |
133 self.assertEqual(self.ctrl._cursor.executed, |
134 ['SET X works_for Y WHERE X eid 8, Y eid %s' % i |
134 ['SET X works_for Y WHERE X eid 8, Y eid %s' % i |
135 for i in (12, 13, 14)]) |
135 for i in (12, 13, 14)]) |
136 |
136 |
137 |
137 |
138 self.ctrl.new_cursor() |
138 self.ctrl.new_cursor() |
139 self.ctrl._cw.form = {'__linkto' : 'works_for:12_13_14:object'} |
139 self.ctrl._cw.form = {'__linkto' : 'works_for:12_13_14:object'} |
140 self.ctrl.execute_linkto(eid=8) |
140 self.ctrl.execute_linkto(eid=8) |
141 self.assertEquals(self.ctrl._cursor.executed, |
141 self.assertEqual(self.ctrl._cursor.executed, |
142 ['SET Y works_for X WHERE X eid 8, Y eid %s' % i |
142 ['SET Y works_for X WHERE X eid 8, Y eid %s' % i |
143 for i in (12, 13, 14)]) |
143 for i in (12, 13, 14)]) |
144 |
144 |
145 self.ctrl.new_cursor() |
145 self.ctrl.new_cursor() |
146 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:subject'}) |
146 self.ctrl.set_form({'__linkto' : 'works_for:12_13_14:subject'}) |
147 self.ctrl.execute_linkto(eid=8) |
147 self.ctrl.execute_linkto(eid=8) |
148 self.assertEquals(self.ctrl._cursor.executed, |
148 self.assertEqual(self.ctrl._cursor.executed, |
149 ['SET X works_for Y WHERE X eid 8, Y eid %s' % i |
149 ['SET X works_for Y WHERE X eid 8, Y eid %s' % i |
150 for i in (12, 13, 14)]) |
150 for i in (12, 13, 14)]) |
151 |
151 |
152 |
152 |
153 class ApplicationTC(CubicWebTC): |
153 class ApplicationTC(CubicWebTC): |
157 raise |
157 raise |
158 self.app.error_handler = raise_hdlr |
158 self.app.error_handler = raise_hdlr |
159 |
159 |
160 def test_cnx_user_groups_sync(self): |
160 def test_cnx_user_groups_sync(self): |
161 user = self.user() |
161 user = self.user() |
162 self.assertEquals(user.groups, set(('managers',))) |
162 self.assertEqual(user.groups, set(('managers',))) |
163 self.execute('SET X in_group G WHERE X eid %s, G name "guests"' % user.eid) |
163 self.execute('SET X in_group G WHERE X eid %s, G name "guests"' % user.eid) |
164 user = self.user() |
164 user = self.user() |
165 self.assertEquals(user.groups, set(('managers',))) |
165 self.assertEqual(user.groups, set(('managers',))) |
166 self.commit() |
166 self.commit() |
167 user = self.user() |
167 user = self.user() |
168 self.assertEquals(user.groups, set(('managers', 'guests'))) |
168 self.assertEqual(user.groups, set(('managers', 'guests'))) |
169 # cleanup |
169 # cleanup |
170 self.execute('DELETE X in_group G WHERE X eid %s, G name "guests"' % user.eid) |
170 self.execute('DELETE X in_group G WHERE X eid %s, G name "guests"' % user.eid) |
171 self.commit() |
171 self.commit() |
172 |
172 |
173 def test_nonregr_publish1(self): |
173 def test_nonregr_publish1(self): |
191 '__errorurl': 'view?vid=edition...' |
191 '__errorurl': 'view?vid=edition...' |
192 } |
192 } |
193 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
193 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
194 forminfo = req.session.data['view?vid=edition...'] |
194 forminfo = req.session.data['view?vid=edition...'] |
195 eidmap = forminfo['eidmap'] |
195 eidmap = forminfo['eidmap'] |
196 self.assertEquals(eidmap, {}) |
196 self.assertEqual(eidmap, {}) |
197 values = forminfo['values'] |
197 values = forminfo['values'] |
198 self.assertEquals(values['login-subject:'+eid], '') |
198 self.assertEqual(values['login-subject:'+eid], '') |
199 self.assertEquals(values['eid'], eid) |
199 self.assertEqual(values['eid'], eid) |
200 error = forminfo['error'] |
200 error = forminfo['error'] |
201 self.assertEquals(error.entity, user.eid) |
201 self.assertEqual(error.entity, user.eid) |
202 self.assertEquals(error.errors['login-subject'], 'required field') |
202 self.assertEqual(error.errors['login-subject'], 'required field') |
203 |
203 |
204 |
204 |
205 def test_validation_error_dont_loose_subentity_data_ctrl(self): |
205 def test_validation_error_dont_loose_subentity_data_ctrl(self): |
206 """test creation of two linked entities |
206 """test creation of two linked entities |
207 |
207 |
220 # necessary to get validation error handling |
220 # necessary to get validation error handling |
221 '__errorurl': 'view?vid=edition...', |
221 '__errorurl': 'view?vid=edition...', |
222 } |
222 } |
223 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
223 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
224 forminfo = req.session.data['view?vid=edition...'] |
224 forminfo = req.session.data['view?vid=edition...'] |
225 self.assertEquals(set(forminfo['eidmap']), set('XY')) |
225 self.assertEqual(set(forminfo['eidmap']), set('XY')) |
226 self.assertEquals(forminfo['eidmap']['X'], None) |
226 self.assertEqual(forminfo['eidmap']['X'], None) |
227 self.assertIsInstance(forminfo['eidmap']['Y'], int) |
227 self.assertIsInstance(forminfo['eidmap']['Y'], int) |
228 self.assertEquals(forminfo['error'].entity, 'X') |
228 self.assertEqual(forminfo['error'].entity, 'X') |
229 self.assertEquals(forminfo['error'].errors, |
229 self.assertEqual(forminfo['error'].errors, |
230 {'login-subject': 'required field'}) |
230 {'login-subject': 'required field'}) |
231 self.assertEquals(forminfo['values'], req.form) |
231 self.assertEqual(forminfo['values'], req.form) |
232 |
232 |
233 |
233 |
234 def test_validation_error_dont_loose_subentity_data_repo(self): |
234 def test_validation_error_dont_loose_subentity_data_repo(self): |
235 """test creation of two linked entities |
235 """test creation of two linked entities |
236 |
236 |
249 # necessary to get validation error handling |
249 # necessary to get validation error handling |
250 '__errorurl': 'view?vid=edition...', |
250 '__errorurl': 'view?vid=edition...', |
251 } |
251 } |
252 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
252 path, params = self.expect_redirect(lambda x: self.app_publish(x, 'edit'), req) |
253 forminfo = req.session.data['view?vid=edition...'] |
253 forminfo = req.session.data['view?vid=edition...'] |
254 self.assertEquals(set(forminfo['eidmap']), set('XY')) |
254 self.assertEqual(set(forminfo['eidmap']), set('XY')) |
255 self.assertIsInstance(forminfo['eidmap']['X'], int) |
255 self.assertIsInstance(forminfo['eidmap']['X'], int) |
256 self.assertIsInstance(forminfo['eidmap']['Y'], int) |
256 self.assertIsInstance(forminfo['eidmap']['Y'], int) |
257 self.assertEquals(forminfo['error'].entity, forminfo['eidmap']['X']) |
257 self.assertEqual(forminfo['error'].entity, forminfo['eidmap']['X']) |
258 self.assertEquals(forminfo['error'].errors, |
258 self.assertEqual(forminfo['error'].errors, |
259 {'login-subject': u'the value "admin" is already used, use another one'}) |
259 {'login-subject': u'the value "admin" is already used, use another one'}) |
260 self.assertEquals(forminfo['values'], req.form) |
260 self.assertEqual(forminfo['values'], req.form) |
261 |
261 |
262 |
262 |
263 def _test_cleaned(self, kwargs, injected, cleaned): |
263 def _test_cleaned(self, kwargs, injected, cleaned): |
264 req = self.request(**kwargs) |
264 req = self.request(**kwargs) |
265 page = self.app.publish('view', req) |
265 page = self.app.publish('view', req) |
280 # XXX work in all-in-one configuration but not in twisted for instance |
280 # XXX work in all-in-one configuration but not in twisted for instance |
281 # in which case we need a kindof repo -> http server notification |
281 # in which case we need a kindof repo -> http server notification |
282 # protocol |
282 # protocol |
283 vreg = self.app.vreg |
283 vreg = self.app.vreg |
284 # default value |
284 # default value |
285 self.assertEquals(vreg.property_value('ui.language'), 'en') |
285 self.assertEqual(vreg.property_value('ui.language'), 'en') |
286 self.execute('INSERT CWProperty X: X value "fr", X pkey "ui.language"') |
286 self.execute('INSERT CWProperty X: X value "fr", X pkey "ui.language"') |
287 self.assertEquals(vreg.property_value('ui.language'), 'en') |
287 self.assertEqual(vreg.property_value('ui.language'), 'en') |
288 self.commit() |
288 self.commit() |
289 self.assertEquals(vreg.property_value('ui.language'), 'fr') |
289 self.assertEqual(vreg.property_value('ui.language'), 'fr') |
290 self.execute('SET X value "de" WHERE X pkey "ui.language"') |
290 self.execute('SET X value "de" WHERE X pkey "ui.language"') |
291 self.assertEquals(vreg.property_value('ui.language'), 'fr') |
291 self.assertEqual(vreg.property_value('ui.language'), 'fr') |
292 self.commit() |
292 self.commit() |
293 self.assertEquals(vreg.property_value('ui.language'), 'de') |
293 self.assertEqual(vreg.property_value('ui.language'), 'de') |
294 self.execute('DELETE CWProperty X WHERE X pkey "ui.language"') |
294 self.execute('DELETE CWProperty X WHERE X pkey "ui.language"') |
295 self.assertEquals(vreg.property_value('ui.language'), 'de') |
295 self.assertEqual(vreg.property_value('ui.language'), 'de') |
296 self.commit() |
296 self.commit() |
297 self.assertEquals(vreg.property_value('ui.language'), 'en') |
297 self.assertEqual(vreg.property_value('ui.language'), 'en') |
298 |
298 |
299 def test_login_not_available_to_authenticated(self): |
299 def test_login_not_available_to_authenticated(self): |
300 req = self.request() |
300 req = self.request() |
301 ex = self.assertRaises(Unauthorized, self.app_publish, req, 'login') |
301 ex = self.assertRaises(Unauthorized, self.app_publish, req, 'login') |
302 self.assertEquals(str(ex), 'log out first') |
302 self.assertEqual(str(ex), 'log out first') |
303 |
303 |
304 def test_fb_login_concept(self): |
304 def test_fb_login_concept(self): |
305 """see data/views.py""" |
305 """see data/views.py""" |
306 self.set_option('auth-mode', 'cookie') |
306 self.set_option('auth-mode', 'cookie') |
307 self.set_option('anonymous-user', 'anon') |
307 self.set_option('anonymous-user', 'anon') |
309 req = self.request() |
309 req = self.request() |
310 origcnx = req.cnx |
310 origcnx = req.cnx |
311 req.form['__fblogin'] = u'turlututu' |
311 req.form['__fblogin'] = u'turlututu' |
312 page = self.app_publish(req) |
312 page = self.app_publish(req) |
313 self.failIf(req.cnx is origcnx) |
313 self.failIf(req.cnx is origcnx) |
314 self.assertEquals(req.user.login, 'turlututu') |
314 self.assertEqual(req.user.login, 'turlututu') |
315 self.failUnless('turlututu' in page, page) |
315 self.failUnless('turlututu' in page, page) |
316 |
316 |
317 # authentication tests #################################################### |
317 # authentication tests #################################################### |
318 |
318 |
319 def test_http_auth_no_anon(self): |
319 def test_http_auth_no_anon(self): |
320 req, origsession = self.init_authentication('http') |
320 req, origsession = self.init_authentication('http') |
321 self.assertAuthFailure(req) |
321 self.assertAuthFailure(req) |
322 self.assertRaises(AuthenticationError, self.app_publish, req, 'login') |
322 self.assertRaises(AuthenticationError, self.app_publish, req, 'login') |
323 self.assertEquals(req.cnx, None) |
323 self.assertEqual(req.cnx, None) |
324 authstr = base64.encodestring('%s:%s' % (origsession.login, origsession.authinfo['password'])) |
324 authstr = base64.encodestring('%s:%s' % (origsession.login, origsession.authinfo['password'])) |
325 req._headers['Authorization'] = 'basic %s' % authstr |
325 req._headers['Authorization'] = 'basic %s' % authstr |
326 self.assertAuthSuccess(req, origsession) |
326 self.assertAuthSuccess(req, origsession) |
327 self.assertEquals(req.session.authinfo, {'password': origsession.authinfo['password']}) |
327 self.assertEqual(req.session.authinfo, {'password': origsession.authinfo['password']}) |
328 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
328 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
329 self.assertEquals(len(self.open_sessions), 0) |
329 self.assertEqual(len(self.open_sessions), 0) |
330 |
330 |
331 def test_cookie_auth_no_anon(self): |
331 def test_cookie_auth_no_anon(self): |
332 req, origsession = self.init_authentication('cookie') |
332 req, origsession = self.init_authentication('cookie') |
333 self.assertAuthFailure(req) |
333 self.assertAuthFailure(req) |
334 form = self.app_publish(req, 'login') |
334 form = self.app_publish(req, 'login') |
335 self.failUnless('__login' in form) |
335 self.failUnless('__login' in form) |
336 self.failUnless('__password' in form) |
336 self.failUnless('__password' in form) |
337 self.assertEquals(req.cnx, None) |
337 self.assertEqual(req.cnx, None) |
338 req.form['__login'] = origsession.login |
338 req.form['__login'] = origsession.login |
339 req.form['__password'] = origsession.authinfo['password'] |
339 req.form['__password'] = origsession.authinfo['password'] |
340 self.assertAuthSuccess(req, origsession) |
340 self.assertAuthSuccess(req, origsession) |
341 self.assertEquals(req.session.authinfo, {'password': origsession.authinfo['password']}) |
341 self.assertEqual(req.session.authinfo, {'password': origsession.authinfo['password']}) |
342 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
342 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
343 self.assertEquals(len(self.open_sessions), 0) |
343 self.assertEqual(len(self.open_sessions), 0) |
344 |
344 |
345 def test_login_by_email(self): |
345 def test_login_by_email(self): |
346 login = self.request().user.login |
346 login = self.request().user.login |
347 address = login + u'@localhost' |
347 address = login + u'@localhost' |
348 self.execute('INSERT EmailAddress X: X address %(address)s, U primary_email X ' |
348 self.execute('INSERT EmailAddress X: X address %(address)s, U primary_email X ' |
357 origsession.login = address |
357 origsession.login = address |
358 self.set_option('allow-email-login', True) |
358 self.set_option('allow-email-login', True) |
359 req.form['__login'] = address |
359 req.form['__login'] = address |
360 req.form['__password'] = origsession.authinfo['password'] |
360 req.form['__password'] = origsession.authinfo['password'] |
361 self.assertAuthSuccess(req, origsession) |
361 self.assertAuthSuccess(req, origsession) |
362 self.assertEquals(req.session.authinfo, {'password': origsession.authinfo['password']}) |
362 self.assertEqual(req.session.authinfo, {'password': origsession.authinfo['password']}) |
363 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
363 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
364 self.assertEquals(len(self.open_sessions), 0) |
364 self.assertEqual(len(self.open_sessions), 0) |
365 |
365 |
366 def _reset_cookie(self, req): |
366 def _reset_cookie(self, req): |
367 # preparing the suite of the test |
367 # preparing the suite of the test |
368 # set session id in cookie |
368 # set session id in cookie |
369 cookie = Cookie.SimpleCookie() |
369 cookie = Cookie.SimpleCookie() |
374 req.session = req.cnx = None |
374 req.session = req.cnx = None |
375 |
375 |
376 def _test_auth_anon(self, req): |
376 def _test_auth_anon(self, req): |
377 self.app.connect(req) |
377 self.app.connect(req) |
378 asession = req.session |
378 asession = req.session |
379 self.assertEquals(len(self.open_sessions), 1) |
379 self.assertEqual(len(self.open_sessions), 1) |
380 self.assertEquals(asession.login, 'anon') |
380 self.assertEqual(asession.login, 'anon') |
381 self.assertEquals(asession.authinfo['password'], 'anon') |
381 self.assertEqual(asession.authinfo['password'], 'anon') |
382 self.failUnless(asession.anonymous_session) |
382 self.failUnless(asession.anonymous_session) |
383 self._reset_cookie(req) |
383 self._reset_cookie(req) |
384 |
384 |
385 def _test_anon_auth_fail(self, req): |
385 def _test_anon_auth_fail(self, req): |
386 self.assertEquals(len(self.open_sessions), 1) |
386 self.assertEqual(len(self.open_sessions), 1) |
387 self.app.connect(req) |
387 self.app.connect(req) |
388 self.assertEquals(req.message, 'authentication failure') |
388 self.assertEqual(req.message, 'authentication failure') |
389 self.assertEquals(req.session.anonymous_session, True) |
389 self.assertEqual(req.session.anonymous_session, True) |
390 self.assertEquals(len(self.open_sessions), 1) |
390 self.assertEqual(len(self.open_sessions), 1) |
391 self._reset_cookie(req) |
391 self._reset_cookie(req) |
392 |
392 |
393 def test_http_auth_anon_allowed(self): |
393 def test_http_auth_anon_allowed(self): |
394 req, origsession = self.init_authentication('http', 'anon') |
394 req, origsession = self.init_authentication('http', 'anon') |
395 self._test_auth_anon(req) |
395 self._test_auth_anon(req) |
397 req._headers['Authorization'] = 'basic %s' % authstr |
397 req._headers['Authorization'] = 'basic %s' % authstr |
398 self._test_anon_auth_fail(req) |
398 self._test_anon_auth_fail(req) |
399 authstr = base64.encodestring('%s:%s' % (origsession.login, origsession.authinfo['password'])) |
399 authstr = base64.encodestring('%s:%s' % (origsession.login, origsession.authinfo['password'])) |
400 req._headers['Authorization'] = 'basic %s' % authstr |
400 req._headers['Authorization'] = 'basic %s' % authstr |
401 self.assertAuthSuccess(req, origsession) |
401 self.assertAuthSuccess(req, origsession) |
402 self.assertEquals(req.session.authinfo, {'password': origsession.authinfo['password']}) |
402 self.assertEqual(req.session.authinfo, {'password': origsession.authinfo['password']}) |
403 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
403 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
404 self.assertEquals(len(self.open_sessions), 0) |
404 self.assertEqual(len(self.open_sessions), 0) |
405 |
405 |
406 def test_cookie_auth_anon_allowed(self): |
406 def test_cookie_auth_anon_allowed(self): |
407 req, origsession = self.init_authentication('cookie', 'anon') |
407 req, origsession = self.init_authentication('cookie', 'anon') |
408 self._test_auth_anon(req) |
408 self._test_auth_anon(req) |
409 req.form['__login'] = 'toto' |
409 req.form['__login'] = 'toto' |
410 req.form['__password'] = 'pouet' |
410 req.form['__password'] = 'pouet' |
411 self._test_anon_auth_fail(req) |
411 self._test_anon_auth_fail(req) |
412 req.form['__login'] = origsession.login |
412 req.form['__login'] = origsession.login |
413 req.form['__password'] = origsession.authinfo['password'] |
413 req.form['__password'] = origsession.authinfo['password'] |
414 self.assertAuthSuccess(req, origsession) |
414 self.assertAuthSuccess(req, origsession) |
415 self.assertEquals(req.session.authinfo, |
415 self.assertEqual(req.session.authinfo, |
416 {'password': origsession.authinfo['password']}) |
416 {'password': origsession.authinfo['password']}) |
417 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
417 self.assertRaises(LogOut, self.app_publish, req, 'logout') |
418 self.assertEquals(len(self.open_sessions), 0) |
418 self.assertEqual(len(self.open_sessions), 0) |
419 |
419 |
420 def test_non_regr_optional_first_var(self): |
420 def test_non_regr_optional_first_var(self): |
421 req = self.request() |
421 req = self.request() |
422 # expect a rset with None in [0][0] |
422 # expect a rset with None in [0][0] |
423 req.form['rql'] = 'rql:Any OV1, X WHERE X custom_workflow OV1?' |
423 req.form['rql'] = 'rql:Any OV1, X WHERE X custom_workflow OV1?' |