branch | tls-sprint |
changeset 1426 | 379261551578 |
parent 1398 | 5fe84a5f7035 |
child 1654 | 57b9fd2462b8 |
1425:3ad7cfca481e | 1426:379261551578 |
---|---|
9 |
9 |
10 from cubicweb.common import ValidationError |
10 from cubicweb.common import ValidationError |
11 from cubicweb.common.uilib import rql_for_eid |
11 from cubicweb.common.uilib import rql_for_eid |
12 |
12 |
13 from cubicweb.web import INTERNAL_FIELD_VALUE, Redirect, RequestError |
13 from cubicweb.web import INTERNAL_FIELD_VALUE, Redirect, RequestError |
14 from cubicweb.web.views.basecontrollers import xmlize |
14 from cubicweb.web.views.basecontrollers import xhtml_wrap |
15 |
15 |
16 from cubicweb.entities.authobjs import CWUser |
16 from cubicweb.entities.authobjs import CWUser |
17 |
17 |
18 |
18 |
19 class EditControllerTC(ControllerTC): |
19 class EditControllerTC(ControllerTC): |
20 def setUp(self): |
20 def setUp(self): |
21 ControllerTC.setUp(self) |
21 ControllerTC.setUp(self) |
22 self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read')) |
22 self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read')) |
23 |
23 |
24 def tearDown(self): |
24 def tearDown(self): |
25 ControllerTC.tearDown(self) |
25 ControllerTC.tearDown(self) |
26 self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read')) |
26 self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read')) |
27 |
27 |
28 def test_noparam_edit(self): |
28 def test_noparam_edit(self): |
29 """check behaviour of this controller without any form parameter |
29 """check behaviour of this controller without any form parameter |
30 """ |
30 """ |
31 |
31 |
32 self.req.form = {} |
32 self.req.form = {} |
33 self.assertRaises(ValidationError, self.publish, self.req) |
33 self.assertRaises(ValidationError, self.publish, self.req) |
34 |
34 |
35 def test_validation_unique(self): |
35 def test_validation_unique(self): |
36 """test creation of two linked entities |
36 """test creation of two linked entities |
37 """ |
37 """ |
38 user = self.user() |
38 user = self.user() |
39 self.req.form = {'eid': 'X', '__type:X': 'CWUser', |
39 self.req.form = {'eid': 'X', '__type:X': 'CWUser', |
40 'login:X': u'admin', 'edits-login:X': u'', |
40 'login:X': u'admin', 'edits-login:X': u'', |
41 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
41 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
42 } |
42 } |
43 self.assertRaises(ValidationError, self.publish, self.req) |
43 self.assertRaises(ValidationError, self.publish, self.req) |
44 |
44 |
45 |
45 |
46 def test_user_editing_itself(self): |
46 def test_user_editing_itself(self): |
115 self.assertEquals(e.firstname, u'Th\xe9nault') |
115 self.assertEquals(e.firstname, u'Th\xe9nault') |
116 self.assertEquals(e.surname, u'Sylvain') |
116 self.assertEquals(e.surname, u'Sylvain') |
117 self.assertEquals([g.eid for g in e.in_group], groupeids) |
117 self.assertEquals([g.eid for g in e.in_group], groupeids) |
118 stateeids = [eid for eid, in self.execute('State S WHERE S name "activated"')] |
118 stateeids = [eid for eid, in self.execute('State S WHERE S name "activated"')] |
119 self.assertEquals([s.eid for s in e.in_state], stateeids) |
119 self.assertEquals([s.eid for s in e.in_state], stateeids) |
120 |
120 |
121 |
121 |
122 def test_create_multiple_linked(self): |
122 def test_create_multiple_linked(self): |
123 gueid = self.execute('CWGroup G WHERE G name "users"')[0][0] |
123 gueid = self.execute('CWGroup G WHERE G name "users"')[0][0] |
124 self.req.form = {'eid': ['X', 'Y'], |
124 self.req.form = {'eid': ['X', 'Y'], |
125 |
125 |
126 '__type:X': 'CWUser', |
126 '__type:X': 'CWUser', |
127 '__maineid' : 'X', |
127 '__maineid' : 'X', |
128 'login:X': u'adim', 'edits-login:X': u'', |
128 'login:X': u'adim', 'edits-login:X': u'', |
129 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
129 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
130 'surname:X': u'Di Mascio', 'edits-surname:X': '', |
130 'surname:X': u'Di Mascio', 'edits-surname:X': '', |
131 |
131 |
132 'in_group:X': `gueid`, 'edits-in_group:X': INTERNAL_FIELD_VALUE, |
132 'in_group:X': `gueid`, 'edits-in_group:X': INTERNAL_FIELD_VALUE, |
133 |
133 |
134 '__type:Y': 'EmailAddress', |
134 '__type:Y': 'EmailAddress', |
135 'address:Y': u'dima@logilab.fr', 'edits-address:Y': '', |
135 'address:Y': u'dima@logilab.fr', 'edits-address:Y': '', |
136 'use_email:X': 'Y', 'edits-use_email:X': INTERNAL_FIELD_VALUE, |
136 'use_email:X': 'Y', 'edits-use_email:X': INTERNAL_FIELD_VALUE, |
137 } |
137 } |
138 path, params = self.expect_redirect_publish() |
138 path, params = self.expect_redirect_publish() |
139 # should be redirected on the created person |
139 # should be redirected on the created person |
140 self.assertEquals(path, 'euser/adim') |
140 self.assertEquals(path, 'euser/adim') |
141 e = self.execute('Any P WHERE P surname "Di Mascio"').get_entity(0, 0) |
141 e = self.execute('Any P WHERE P surname "Di Mascio"').get_entity(0, 0) |
142 self.assertEquals(e.surname, 'Di Mascio') |
142 self.assertEquals(e.surname, 'Di Mascio') |
143 email = e.use_email[0] |
143 email = e.use_email[0] |
144 self.assertEquals(email.address, 'dima@logilab.fr') |
144 self.assertEquals(email.address, 'dima@logilab.fr') |
145 |
145 |
146 def test_edit_multiple_linked(self): |
146 def test_edit_multiple_linked(self): |
147 peid = self.create_user('adim').eid |
147 peid = self.create_user('adim').eid |
148 self.req.form = {'eid': [`peid`, 'Y'], |
148 self.req.form = {'eid': [`peid`, 'Y'], |
149 '__type:%s'%peid: 'CWUser', |
149 '__type:%s'%peid: 'CWUser', |
150 'surname:%s'%peid: u'Di Masci', 'edits-surname:%s'%peid: '', |
150 'surname:%s'%peid: u'Di Masci', 'edits-surname:%s'%peid: '', |
151 |
151 |
152 '__type:Y': 'EmailAddress', |
152 '__type:Y': 'EmailAddress', |
153 'address:Y': u'dima@logilab.fr', 'edits-address:Y': '', |
153 'address:Y': u'dima@logilab.fr', 'edits-address:Y': '', |
154 'use_email:%s'%peid: 'Y', 'edits-use_email:%s'%peid: INTERNAL_FIELD_VALUE, |
154 'use_email:%s'%peid: 'Y', 'edits-use_email:%s'%peid: INTERNAL_FIELD_VALUE, |
155 |
155 |
156 '__redirectrql': 'Any X WHERE X eid %s'%peid, |
156 '__redirectrql': 'Any X WHERE X eid %s'%peid, |
157 } |
157 } |
158 path, params = self.expect_redirect_publish() |
158 path, params = self.expect_redirect_publish() |
159 # should be redirected on the created person |
159 # should be redirected on the created person |
160 eid = params['rql'].split()[-1] |
160 eid = params['rql'].split()[-1] |
161 e = self.execute('Any X WHERE X eid %(x)s', {'x': eid}, 'x').get_entity(0, 0) |
161 e = self.execute('Any X WHERE X eid %(x)s', {'x': eid}, 'x').get_entity(0, 0) |
162 self.assertEquals(e.surname, 'Di Masci') |
162 self.assertEquals(e.surname, 'Di Masci') |
163 email = e.use_email[0] |
163 email = e.use_email[0] |
164 self.assertEquals(email.address, 'dima@logilab.fr') |
164 self.assertEquals(email.address, 'dima@logilab.fr') |
165 |
165 |
166 emaileid = email.eid |
166 emaileid = email.eid |
167 self.req.form = {'eid': [`peid`, `emaileid`], |
167 self.req.form = {'eid': [`peid`, `emaileid`], |
168 '__type:%s'%peid: 'CWUser', |
168 '__type:%s'%peid: 'CWUser', |
169 'surname:%s'%peid: u'Di Masci', 'edits-surname:%s'%peid: 'Di Masci', |
169 'surname:%s'%peid: u'Di Masci', 'edits-surname:%s'%peid: 'Di Masci', |
170 '__type:%s'%emaileid: 'EmailAddress', |
170 '__type:%s'%emaileid: 'EmailAddress', |
171 'address:%s'%emaileid: u'adim@logilab.fr', 'edits-address:%s'%emaileid: 'dima@logilab.fr', |
171 'address:%s'%emaileid: u'adim@logilab.fr', 'edits-address:%s'%emaileid: 'dima@logilab.fr', |
172 'use_email:%s'%peid: `emaileid`, 'edits-use_email:%s'%peid: `emaileid`, |
172 'use_email:%s'%peid: `emaileid`, 'edits-use_email:%s'%peid: `emaileid`, |
173 '__redirectrql': 'Any X WHERE X eid %s'%peid, |
173 '__redirectrql': 'Any X WHERE X eid %s'%peid, |
174 } |
174 } |
175 path, params = self.expect_redirect_publish() |
175 path, params = self.expect_redirect_publish() |
176 # should be redirected on the created person |
176 # should be redirected on the created person |
177 eid = params['rql'].split()[-1] |
177 eid = params['rql'].split()[-1] |
178 e = self.execute('Any X WHERE X eid %(x)s', {'x': eid}, 'x').get_entity(0, 0) |
178 e = self.execute('Any X WHERE X eid %(x)s', {'x': eid}, 'x').get_entity(0, 0) |
179 self.assertEquals(e.surname, 'Di Masci') |
179 self.assertEquals(e.surname, 'Di Masci') |
180 email = e.use_email[0] |
180 email = e.use_email[0] |
181 self.assertEquals(email.address, 'adim@logilab.fr') |
181 self.assertEquals(email.address, 'adim@logilab.fr') |
182 |
182 |
183 |
183 |
184 def test_password_confirm(self): |
184 def test_password_confirm(self): |
185 """test creation of two linked entities |
185 """test creation of two linked entities |
186 """ |
186 """ |
187 user = self.user() |
187 user = self.user() |
188 self.req.form = {'__cloned_eid:X': user.eid, |
188 self.req.form = {'__cloned_eid:X': user.eid, |
189 'eid': 'X', '__type:X': 'CWUser', |
189 'eid': 'X', '__type:X': 'CWUser', |
190 'login:X': u'toto', 'edits-login:X': u'', |
190 'login:X': u'toto', 'edits-login:X': u'', |
191 'upassword:X': u'toto', 'edits-upassword:X': u'', |
191 'upassword:X': u'toto', 'edits-upassword:X': u'', |
192 } |
192 } |
193 self.assertRaises(ValidationError, self.publish, self.req) |
193 self.assertRaises(ValidationError, self.publish, self.req) |
194 self.req.form = {'__cloned_eid:X': user.eid, |
194 self.req.form = {'__cloned_eid:X': user.eid, |
195 'eid': 'X', '__type:X': 'CWUser', |
195 'eid': 'X', '__type:X': 'CWUser', |
196 'login:X': u'toto', 'edits-login:X': u'', |
196 'login:X': u'toto', 'edits-login:X': u'', |
197 'upassword:X': u'toto', 'upassword-confirm:X': u'tutu', 'edits-upassword:X': u'', |
197 'upassword:X': u'toto', 'upassword-confirm:X': u'tutu', 'edits-upassword:X': u'', |
198 } |
198 } |
199 self.assertRaises(ValidationError, self.publish, self.req) |
199 self.assertRaises(ValidationError, self.publish, self.req) |
200 |
200 |
201 |
201 |
202 def test_interval_bound_constraint_success(self): |
202 def test_interval_bound_constraint_success(self): |
218 '__type:X': 'Salesterm', |
218 '__type:X': 'Salesterm', |
219 'amount:X': u'10', 'edits-amount:X': '', |
219 'amount:X': u'10', 'edits-amount:X': '', |
220 'described_by_test:X': str(feid), 'edits-described_by_test:X': INTERNAL_FIELD_VALUE, |
220 'described_by_test:X': str(feid), 'edits-described_by_test:X': INTERNAL_FIELD_VALUE, |
221 } |
221 } |
222 self.expect_redirect_publish() |
222 self.expect_redirect_publish() |
223 # should be redirected on the created |
223 # should be redirected on the created |
224 #eid = params['rql'].split()[-1] |
224 #eid = params['rql'].split()[-1] |
225 e = self.execute('Salesterm X').get_entity(0, 0) |
225 e = self.execute('Salesterm X').get_entity(0, 0) |
226 self.assertEquals(e.amount, 10) |
226 self.assertEquals(e.amount, 10) |
227 |
227 |
228 def test_req_pending_insert(self): |
228 def test_req_pending_insert(self): |
271 path, params = self.expect_redirect_publish() |
271 path, params = self.expect_redirect_publish() |
272 rset = self.execute('Any L WHERE X eid %(x)s, X login L', {'x': user.eid}, 'x') |
272 rset = self.execute('Any L WHERE X eid %(x)s, X login L', {'x': user.eid}, 'x') |
273 self.assertEquals(rset[0][0], 'FOO') |
273 self.assertEquals(rset[0][0], 'FOO') |
274 finally: |
274 finally: |
275 del CWUser.custom_login_edit |
275 del CWUser.custom_login_edit |
276 |
276 |
277 def test_redirect_apply_button(self): |
277 def test_redirect_apply_button(self): |
278 redirectrql = rql_for_eid(4012) # whatever |
278 redirectrql = rql_for_eid(4012) # whatever |
279 self.req.form = { |
279 self.req.form = { |
280 'eid': 'A', '__type:A': 'BlogEntry', |
280 'eid': 'A', '__type:A': 'BlogEntry', |
281 '__maineid' : 'A', |
281 '__maineid' : 'A', |
352 'eid': `eeetypeeid`, |
352 'eid': `eeetypeeid`, |
353 '__type:'+`eeetypeeid`: 'CWEType', |
353 '__type:'+`eeetypeeid`: 'CWEType', |
354 'name:'+`eeetypeeid`: u'CWGroup', |
354 'name:'+`eeetypeeid`: u'CWGroup', |
355 'final:'+`eeetypeeid`: False, |
355 'final:'+`eeetypeeid`: False, |
356 'meta:'+`eeetypeeid`: True, |
356 'meta:'+`eeetypeeid`: True, |
357 'description:'+`eeetypeeid`: u'users group', |
357 'description:'+`eeetypeeid`: u'users group', |
358 'read_permission:'+`eeetypeeid`: groups, |
358 'read_permission:'+`eeetypeeid`: groups, |
359 # |
359 # |
360 'edits-name:'+`eeetypeeid`: u'CWGroup', |
360 'edits-name:'+`eeetypeeid`: u'CWGroup', |
361 'edits-final:'+`eeetypeeid`: False, |
361 'edits-final:'+`eeetypeeid`: False, |
362 'edits-meta:'+`eeetypeeid`: True, |
362 'edits-meta:'+`eeetypeeid`: True, |
363 'edits-description:'+`eeetypeeid`: u'users group', |
363 'edits-description:'+`eeetypeeid`: u'users group', |
364 'edits-read_permission:'+`eeetypeeid`: basegroups, |
364 'edits-read_permission:'+`eeetypeeid`: basegroups, |
365 } |
365 } |
366 try: |
366 try: |
367 path, params = self.expect_redirect_publish() |
367 path, params = self.expect_redirect_publish() |
368 e = self.execute('Any X WHERE X eid %(x)s', {'x': eeetypeeid}, 'x').get_entity(0, 0) |
368 e = self.execute('Any X WHERE X eid %(x)s', {'x': eeetypeeid}, 'x').get_entity(0, 0) |
370 self.assertEquals([g.eid for g in e.read_permission], groupeids) |
370 self.assertEquals([g.eid for g in e.read_permission], groupeids) |
371 finally: |
371 finally: |
372 # restore |
372 # restore |
373 self.execute('SET X read_permission Y WHERE X name "CWGroup", Y eid IN (%s), NOT X read_permission Y' % (','.join(basegroups))) |
373 self.execute('SET X read_permission Y WHERE X name "CWGroup", Y eid IN (%s), NOT X read_permission Y' % (','.join(basegroups))) |
374 self.commit() |
374 self.commit() |
375 |
375 |
376 def test_nonregr_eetype_etype_editing(self): |
376 def test_nonregr_eetype_etype_editing(self): |
377 """non-regression test checking that a manager user can edit a CWEType entity (CWEType) |
377 """non-regression test checking that a manager user can edit a CWEType entity (CWEType) |
378 """ |
378 """ |
379 groupeids = sorted(eid for eid, in self.execute('CWGroup G WHERE G name in ("managers", "users")')) |
379 groupeids = sorted(eid for eid, in self.execute('CWGroup G WHERE G name in ("managers", "users")')) |
380 groups = [str(eid) for eid in groupeids] |
380 groups = [str(eid) for eid in groupeids] |
384 'eid': `eeetypeeid`, |
384 'eid': `eeetypeeid`, |
385 '__type:'+`eeetypeeid`: 'CWEType', |
385 '__type:'+`eeetypeeid`: 'CWEType', |
386 'name:'+`eeetypeeid`: u'CWEType', |
386 'name:'+`eeetypeeid`: u'CWEType', |
387 'final:'+`eeetypeeid`: False, |
387 'final:'+`eeetypeeid`: False, |
388 'meta:'+`eeetypeeid`: True, |
388 'meta:'+`eeetypeeid`: True, |
389 'description:'+`eeetypeeid`: u'users group', |
389 'description:'+`eeetypeeid`: u'users group', |
390 'read_permission:'+`eeetypeeid`: groups, |
390 'read_permission:'+`eeetypeeid`: groups, |
391 |
391 |
392 'edits-name:'+`eeetypeeid`: u'CWEType', |
392 'edits-name:'+`eeetypeeid`: u'CWEType', |
393 'edits-final:'+`eeetypeeid`: False, |
393 'edits-final:'+`eeetypeeid`: False, |
394 'edits-meta:'+`eeetypeeid`: True, |
394 'edits-meta:'+`eeetypeeid`: True, |
395 'edits-description:'+`eeetypeeid`: u'users group', |
395 'edits-description:'+`eeetypeeid`: u'users group', |
396 'edits-read_permission:'+`eeetypeeid`: basegroups, |
396 'edits-read_permission:'+`eeetypeeid`: basegroups, |
397 } |
397 } |
398 try: |
398 try: |
399 path, params = self.expect_redirect_publish() |
399 path, params = self.expect_redirect_publish() |
400 e = self.execute('Any X WHERE X eid %(x)s', {'x': eeetypeeid}, 'x').get_entity(0, 0) |
400 e = self.execute('Any X WHERE X eid %(x)s', {'x': eeetypeeid}, 'x').get_entity(0, 0) |
402 self.assertEquals(sorted(g.eid for g in e.read_permission), groupeids) |
402 self.assertEquals(sorted(g.eid for g in e.read_permission), groupeids) |
403 finally: |
403 finally: |
404 # restore |
404 # restore |
405 self.execute('SET X read_permission Y WHERE X name "CWEType", Y eid IN (%s), NOT X read_permission Y' % (','.join(basegroups))) |
405 self.execute('SET X read_permission Y WHERE X name "CWEType", Y eid IN (%s), NOT X read_permission Y' % (','.join(basegroups))) |
406 self.commit() |
406 self.commit() |
407 |
407 |
408 def test_nonregr_strange_text_input(self): |
408 def test_nonregr_strange_text_input(self): |
409 """non-regression test checking text input containing "13:03:43" |
409 """non-regression test checking text input containing "13:03:43" |
410 |
410 |
411 this seems to be postgres (tsearch?) specific |
411 this seems to be postgres (tsearch?) specific |
412 """ |
412 """ |
413 self.req.form = { |
413 self.req.form = { |
414 'eid': 'A', '__type:A': 'BlogEntry', |
414 'eid': 'A', '__type:A': 'BlogEntry', |
415 '__maineid' : 'A', |
415 '__maineid' : 'A', |
416 'title:A': u'"13:03:40"', 'edits-title:A': '', |
416 'title:A': u'"13:03:40"', 'edits-title:A': '', |
417 'content:A': u'"13:03:43"', 'edits-content:A': ''} |
417 'content:A': u'"13:03:43"', 'edits-content:A': ''} |
424 |
424 |
425 |
425 |
426 def test_nonregr_multiple_empty_email_addr(self): |
426 def test_nonregr_multiple_empty_email_addr(self): |
427 gueid = self.execute('CWGroup G WHERE G name "users"')[0][0] |
427 gueid = self.execute('CWGroup G WHERE G name "users"')[0][0] |
428 self.req.form = {'eid': ['X', 'Y'], |
428 self.req.form = {'eid': ['X', 'Y'], |
429 |
429 |
430 '__type:X': 'CWUser', |
430 '__type:X': 'CWUser', |
431 'login:X': u'adim', 'edits-login:X': u'', |
431 'login:X': u'adim', 'edits-login:X': u'', |
432 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
432 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
433 'in_group:X': `gueid`, 'edits-in_group:X': INTERNAL_FIELD_VALUE, |
433 'in_group:X': `gueid`, 'edits-in_group:X': INTERNAL_FIELD_VALUE, |
434 |
434 |
435 '__type:Y': 'EmailAddress', |
435 '__type:Y': 'EmailAddress', |
436 'address:Y': u'', 'edits-address:Y': '', |
436 'address:Y': u'', 'edits-address:Y': '', |
437 'alias:Y': u'', 'edits-alias:Y': '', |
437 'alias:Y': u'', 'edits-alias:Y': '', |
438 'use_email:X': 'Y', 'edits-use_email:X': INTERNAL_FIELD_VALUE, |
438 'use_email:X': 'Y', 'edits-use_email:X': INTERNAL_FIELD_VALUE, |
439 } |
439 } |
440 self.assertRaises(ValidationError, self.publish, self.req) |
440 self.assertRaises(ValidationError, self.publish, self.req) |
441 |
441 |
442 def test_nonregr_copy(self): |
442 def test_nonregr_copy(self): |
443 user = self.user() |
443 user = self.user() |
444 self.req.form = {'__cloned_eid:X': user.eid, |
444 self.req.form = {'__cloned_eid:X': user.eid, |
445 'eid': 'X', '__type:X': 'CWUser', |
445 'eid': 'X', '__type:X': 'CWUser', |
446 '__maineid' : 'X', |
446 '__maineid' : 'X', |
447 'login:X': u'toto', 'edits-login:X': u'', |
447 'login:X': u'toto', 'edits-login:X': u'', |
448 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
448 'upassword:X': u'toto', 'upassword-confirm:X': u'toto', 'edits-upassword:X': u'', |
449 } |
449 } |
450 path, params = self.expect_redirect_publish() |
450 path, params = self.expect_redirect_publish() |
451 self.assertEquals(path, 'euser/toto') |
451 self.assertEquals(path, 'euser/toto') |
452 e = self.execute('Any X WHERE X is CWUser, X login "toto"').get_entity(0, 0) |
452 e = self.execute('Any X WHERE X is CWUser, X login "toto"').get_entity(0, 0) |
453 self.assertEquals(e.login, 'toto') |
453 self.assertEquals(e.login, 'toto') |
463 e = self.add_entity('EmailAddress', address=u'doe@doe.com') |
463 e = self.add_entity('EmailAddress', address=u'doe@doe.com') |
464 self.execute('SET P use_email E, P primary_email E WHERE P eid %(p)s, E eid %(e)s', |
464 self.execute('SET P use_email E, P primary_email E WHERE P eid %(p)s, E eid %(e)s', |
465 {'p' : p.eid, 'e' : e.eid}) |
465 {'p' : p.eid, 'e' : e.eid}) |
466 self.req.form = {'__cloned_eid:X': p.eid, |
466 self.req.form = {'__cloned_eid:X': p.eid, |
467 'eid': 'X', '__type:X': 'CWUser', |
467 'eid': 'X', '__type:X': 'CWUser', |
468 'login': u'dodo', 'edits-login': u'dodo', |
468 'login': u'dodo', 'edits-login': u'dodo', |
469 'surname:X': u'Boom', 'edits-surname:X': u'', |
469 'surname:X': u'Boom', 'edits-surname:X': u'', |
470 '__errorurl' : "whatever but required", |
470 '__errorurl' : "whatever but required", |
471 } |
471 } |
472 # try to emulate what really happens in the web application |
472 # try to emulate what really happens in the web application |
473 # 1/ validate form => EditController.publish raises a ValidationError |
473 # 1/ validate form => EditController.publish raises a ValidationError |
508 |
508 |
509 def test_not_usable_by_guets(self): |
509 def test_not_usable_by_guets(self): |
510 self.login('anon') |
510 self.login('anon') |
511 req = self.request() |
511 req = self.request() |
512 self.assertRaises(Unauthorized, self.env.app.select_controller, 'sendmail', req) |
512 self.assertRaises(Unauthorized, self.env.app.select_controller, 'sendmail', req) |
513 |
513 |
514 |
514 |
515 |
515 |
516 class JSONControllerTC(EnvBasedTC): |
516 class JSONControllerTC(EnvBasedTC): |
517 |
517 |
518 def ctrl(self, req=None): |
518 def ctrl(self, req=None): |
528 ## tests ################################################################## |
528 ## tests ################################################################## |
529 def test_simple_exec(self): |
529 def test_simple_exec(self): |
530 ctrl = self.ctrl(self.request(rql='CWUser P WHERE P login "John"', |
530 ctrl = self.ctrl(self.request(rql='CWUser P WHERE P login "John"', |
531 pageid='123')) |
531 pageid='123')) |
532 self.assertTextEquals(ctrl.publish(), |
532 self.assertTextEquals(ctrl.publish(), |
533 xmlize(self.john.view('primary'))) |
533 xhtml_wrap(self.john.view('primary'))) |
534 |
534 |
535 def test_json_exec(self): |
535 def test_json_exec(self): |
536 rql = 'Any T,N WHERE T is Tag, T name N' |
536 rql = 'Any T,N WHERE T is Tag, T name N' |
537 ctrl = self.ctrl(self.request(mode='json', rql=rql, pageid='123')) |
537 ctrl = self.ctrl(self.request(mode='json', rql=rql, pageid='123')) |
538 self.assertEquals(ctrl.publish(), |
538 self.assertEquals(ctrl.publish(), |
542 self.remote_call('tag_entity', self.john.eid, ['python']) |
542 self.remote_call('tag_entity', self.john.eid, ['python']) |
543 self.assertUnorderedIterableEquals([tname for tname, in self.execute('Any N WHERE T is Tag, T name N')], |
543 self.assertUnorderedIterableEquals([tname for tname, in self.execute('Any N WHERE T is Tag, T name N')], |
544 ['python', 'cubicweb']) |
544 ['python', 'cubicweb']) |
545 self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows, |
545 self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows, |
546 [['python']]) |
546 [['python']]) |
547 |
547 |
548 def test_remote_add_new_tag(self): |
548 def test_remote_add_new_tag(self): |
549 self.remote_call('tag_entity', self.john.eid, ['javascript']) |
549 self.remote_call('tag_entity', self.john.eid, ['javascript']) |
550 self.assertUnorderedIterableEquals([tname for tname, in self.execute('Any N WHERE T is Tag, T name N')], |
550 self.assertUnorderedIterableEquals([tname for tname, in self.execute('Any N WHERE T is Tag, T name N')], |
551 ['python', 'cubicweb', 'javascript']) |
551 ['python', 'cubicweb', 'javascript']) |
552 self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows, |
552 self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows, |
615 deletes = req.get_pending_deletes() |
615 deletes = req.get_pending_deletes() |
616 self.assertEquals(deletes, ['12:tags:13']) |
616 self.assertEquals(deletes, ['12:tags:13']) |
617 req.remove_pending_operations() |
617 req.remove_pending_operations() |
618 self.assertEquals(req.get_pending_deletes(), []) |
618 self.assertEquals(req.get_pending_deletes(), []) |
619 self.assertEquals(req.get_pending_inserts(), []) |
619 self.assertEquals(req.get_pending_inserts(), []) |
620 |
620 |
621 |
621 |
622 def test_add_inserts(self): |
622 def test_add_inserts(self): |
623 res, req = self.remote_call('add_pending_inserts', |
623 res, req = self.remote_call('add_pending_inserts', |
624 [('12', 'tags', '13'), ('12', 'tags', '14')]) |
624 [('12', 'tags', '13'), ('12', 'tags', '14')]) |
625 inserts = req.get_pending_inserts() |
625 inserts = req.get_pending_inserts() |
626 self.assertEquals(inserts, ['12:tags:13', '12:tags:14']) |
626 self.assertEquals(inserts, ['12:tags:13', '12:tags:14']) |
627 req.remove_pending_operations() |
627 req.remove_pending_operations() |
628 |
628 |
629 |
629 |
630 # silly tests |
630 # silly tests |
631 def test_external_resource(self): |
631 def test_external_resource(self): |
632 self.assertEquals(self.remote_call('external_resource', 'RSS_LOGO')[0], |
632 self.assertEquals(self.remote_call('external_resource', 'RSS_LOGO')[0], |
633 simplejson.dumps(self.request().external_resource('RSS_LOGO'))) |
633 simplejson.dumps(self.request().external_resource('RSS_LOGO'))) |
637 |
637 |
638 def test_format_date(self): |
638 def test_format_date(self): |
639 self.assertEquals(self.remote_call('format_date', '"2007-01-01 12:00:00"')[0], |
639 self.assertEquals(self.remote_call('format_date', '"2007-01-01 12:00:00"')[0], |
640 simplejson.dumps('2007/01/01')) |
640 simplejson.dumps('2007/01/01')) |
641 |
641 |
642 |
642 |
643 |
643 |
644 |
644 |
645 if __name__ == '__main__': |
645 if __name__ == '__main__': |
646 unittest_main() |
646 unittest_main() |