23 |
23 |
24 class CoreHooksTC(RepositoryBasedTC): |
24 class CoreHooksTC(RepositoryBasedTC): |
25 |
25 |
26 def test_delete_internal_entities(self): |
26 def test_delete_internal_entities(self): |
27 self.assertRaises(RepositoryError, self.execute, |
27 self.assertRaises(RepositoryError, self.execute, |
28 'DELETE EEType X WHERE X name "EEType"') |
28 'DELETE CWEType X WHERE X name "CWEType"') |
29 self.assertRaises(RepositoryError, self.execute, |
29 self.assertRaises(RepositoryError, self.execute, |
30 'DELETE ERType X WHERE X name "relation_type"') |
30 'DELETE CWRType X WHERE X name "relation_type"') |
31 self.assertRaises(RepositoryError, self.execute, |
31 self.assertRaises(RepositoryError, self.execute, |
32 'DELETE EGroup X WHERE X name "owners"') |
32 'DELETE CWGroup X WHERE X name "owners"') |
33 |
33 |
34 def test_delete_required_relations_subject(self): |
34 def test_delete_required_relations_subject(self): |
35 self.execute('INSERT EUser X: X login "toto", X upassword "hop", X in_group Y, X in_state S ' |
35 self.execute('INSERT CWUser X: X login "toto", X upassword "hop", X in_group Y, X in_state S ' |
36 'WHERE Y name "users", S name "activated"') |
36 'WHERE Y name "users", S name "activated"') |
37 self.commit() |
37 self.commit() |
38 self.execute('DELETE X in_group Y WHERE X login "toto", Y name "users"') |
38 self.execute('DELETE X in_group Y WHERE X login "toto", Y name "users"') |
39 self.assertRaises(ValidationError, self.commit) |
39 self.assertRaises(ValidationError, self.commit) |
40 self.execute('DELETE X in_group Y WHERE X login "toto"') |
40 self.execute('DELETE X in_group Y WHERE X login "toto"') |
45 self.skip('no sample in the schema ! YAGNI ? Kermaat ?') |
45 self.skip('no sample in the schema ! YAGNI ? Kermaat ?') |
46 |
46 |
47 def test_static_vocabulary_check(self): |
47 def test_static_vocabulary_check(self): |
48 self.assertRaises(ValidationError, |
48 self.assertRaises(ValidationError, |
49 self.execute, |
49 self.execute, |
50 'SET X composite "whatever" WHERE X from_entity FE, FE name "EUser", X relation_type RT, RT name "in_group"') |
50 'SET X composite "whatever" WHERE X from_entity FE, FE name "CWUser", X relation_type RT, RT name "in_group"') |
51 |
51 |
52 def test_missing_required_relations_subject_inline(self): |
52 def test_missing_required_relations_subject_inline(self): |
53 # missing in_group relation |
53 # missing in_group relation |
54 self.execute('INSERT EUser X: X login "toto", X upassword "hop"') |
54 self.execute('INSERT CWUser X: X login "toto", X upassword "hop"') |
55 self.assertRaises(ValidationError, |
55 self.assertRaises(ValidationError, |
56 self.commit) |
56 self.commit) |
57 |
57 |
58 def test_delete_if_singlecard1(self): |
58 def test_delete_if_singlecard1(self): |
59 self.assertEquals(self.repo.schema['in_state'].inlined, False) |
59 self.assertEquals(self.repo.schema['in_state'].inlined, False) |
60 ueid, = self.execute('INSERT EUser X: X login "toto", X upassword "hop", X in_group Y, X in_state S ' |
60 ueid, = self.execute('INSERT CWUser X: X login "toto", X upassword "hop", X in_group Y, X in_state S ' |
61 'WHERE Y name "users", S name "activated"')[0] |
61 'WHERE Y name "users", S name "activated"')[0] |
62 self.commit() |
62 self.commit() |
63 self.execute('SET X in_state S WHERE S name "deactivated", X eid %(x)s', {'x': ueid}) |
63 self.execute('SET X in_state S WHERE S name "deactivated", X eid %(x)s', {'x': ueid}) |
64 rset = self.execute('Any S WHERE X in_state S, X eid %(x)s', {'x': ueid}) |
64 rset = self.execute('Any S WHERE X in_state S, X eid %(x)s', {'x': ueid}) |
65 self.assertEquals(len(rset), 1) |
65 self.assertEquals(len(rset), 1) |
158 self.assertRaises(AuthenticationError, |
158 self.assertRaises(AuthenticationError, |
159 self.repo.connect, u'toto', 'hop') |
159 self.repo.connect, u'toto', 'hop') |
160 self.commit() |
160 self.commit() |
161 cnxid = self.repo.connect(u'toto', 'hop') |
161 cnxid = self.repo.connect(u'toto', 'hop') |
162 self.failIfEqual(cnxid, self.cnxid) |
162 self.failIfEqual(cnxid, self.cnxid) |
163 self.execute('DELETE EUser X WHERE X login "toto"') |
163 self.execute('DELETE CWUser X WHERE X login "toto"') |
164 self.repo.execute(cnxid, 'State X') |
164 self.repo.execute(cnxid, 'State X') |
165 self.commit() |
165 self.commit() |
166 self.assertRaises(BadConnectionId, |
166 self.assertRaises(BadConnectionId, |
167 self.repo.execute, cnxid, 'State X') |
167 self.repo.execute, cnxid, 'State X') |
168 |
168 |
192 eid = self.execute('INSERT EmailAddress X: X address "toto@logilab.fr"')[0][0] |
192 eid = self.execute('INSERT EmailAddress X: X address "toto@logilab.fr"')[0][0] |
193 self.execute('DELETE EmailAddress X WHERE X eid %s' % eid) |
193 self.execute('DELETE EmailAddress X WHERE X eid %s' % eid) |
194 self.commit() |
194 self.commit() |
195 self.failIf(self.execute('Any X WHERE X created_by Y, X eid >= %(x)s', {'x': eid})) |
195 self.failIf(self.execute('Any X WHERE X created_by Y, X eid >= %(x)s', {'x': eid})) |
196 |
196 |
197 class EPropertyHooksTC(RepositoryBasedTC): |
197 class CWPropertyHooksTC(RepositoryBasedTC): |
198 |
198 |
199 def test_unexistant_eproperty(self): |
199 def test_unexistant_eproperty(self): |
200 ex = self.assertRaises(ValidationError, |
200 ex = self.assertRaises(ValidationError, |
201 self.execute, 'INSERT EProperty X: X pkey "bla.bla", X value "hop", X for_user U') |
201 self.execute, 'INSERT CWProperty X: X pkey "bla.bla", X value "hop", X for_user U') |
202 self.assertEquals(ex.errors, {'pkey': 'unknown property key'}) |
202 self.assertEquals(ex.errors, {'pkey': 'unknown property key'}) |
203 ex = self.assertRaises(ValidationError, |
203 ex = self.assertRaises(ValidationError, |
204 self.execute, 'INSERT EProperty X: X pkey "bla.bla", X value "hop"') |
204 self.execute, 'INSERT CWProperty X: X pkey "bla.bla", X value "hop"') |
205 self.assertEquals(ex.errors, {'pkey': 'unknown property key'}) |
205 self.assertEquals(ex.errors, {'pkey': 'unknown property key'}) |
206 |
206 |
207 def test_site_wide_eproperty(self): |
207 def test_site_wide_eproperty(self): |
208 ex = self.assertRaises(ValidationError, |
208 ex = self.assertRaises(ValidationError, |
209 self.execute, 'INSERT EProperty X: X pkey "ui.site-title", X value "hop", X for_user U') |
209 self.execute, 'INSERT CWProperty X: X pkey "ui.site-title", X value "hop", X for_user U') |
210 self.assertEquals(ex.errors, {'for_user': "site-wide property can't be set for user"}) |
210 self.assertEquals(ex.errors, {'for_user': "site-wide property can't be set for user"}) |
211 |
211 |
212 def test_bad_type_eproperty(self): |
212 def test_bad_type_eproperty(self): |
213 ex = self.assertRaises(ValidationError, |
213 ex = self.assertRaises(ValidationError, |
214 self.execute, 'INSERT EProperty X: X pkey "ui.language", X value "hop", X for_user U') |
214 self.execute, 'INSERT CWProperty X: X pkey "ui.language", X value "hop", X for_user U') |
215 self.assertEquals(ex.errors, {'value': u'unauthorized value'}) |
215 self.assertEquals(ex.errors, {'value': u'unauthorized value'}) |
216 ex = self.assertRaises(ValidationError, |
216 ex = self.assertRaises(ValidationError, |
217 self.execute, 'INSERT EProperty X: X pkey "ui.language", X value "hop"') |
217 self.execute, 'INSERT CWProperty X: X pkey "ui.language", X value "hop"') |
218 self.assertEquals(ex.errors, {'value': u'unauthorized value'}) |
218 self.assertEquals(ex.errors, {'value': u'unauthorized value'}) |
219 |
219 |
220 |
220 |
221 class SchemaHooksTC(RepositoryBasedTC): |
221 class SchemaHooksTC(RepositoryBasedTC): |
222 |
222 |
223 def test_duplicate_etype_error(self): |
223 def test_duplicate_etype_error(self): |
224 # check we can't add a EEType or ERType entity if it already exists one |
224 # check we can't add a CWEType or CWRType entity if it already exists one |
225 # with the same name |
225 # with the same name |
226 # |
226 # |
227 # according to hook order, we'll get a repository or validation error |
227 # according to hook order, we'll get a repository or validation error |
228 self.assertRaises((ValidationError, RepositoryError), |
228 self.assertRaises((ValidationError, RepositoryError), |
229 self.execute, 'INSERT EEType X: X name "Societe"') |
229 self.execute, 'INSERT CWEType X: X name "Societe"') |
230 self.assertRaises((ValidationError, RepositoryError), |
230 self.assertRaises((ValidationError, RepositoryError), |
231 self.execute, 'INSERT ERType X: X name "in_group"') |
231 self.execute, 'INSERT CWRType X: X name "in_group"') |
232 |
232 |
233 def test_validation_unique_constraint(self): |
233 def test_validation_unique_constraint(self): |
234 self.assertRaises(ValidationError, |
234 self.assertRaises(ValidationError, |
235 self.execute, 'INSERT EUser X: X login "admin"') |
235 self.execute, 'INSERT CWUser X: X login "admin"') |
236 try: |
236 try: |
237 self.execute('INSERT EUser X: X login "admin"') |
237 self.execute('INSERT CWUser X: X login "admin"') |
238 except ValidationError, ex: |
238 except ValidationError, ex: |
239 self.assertIsInstance(ex.entity, int) |
239 self.assertIsInstance(ex.entity, int) |
240 self.assertEquals(ex.errors, {'login': 'the value "admin" is already used, use another one'}) |
240 self.assertEquals(ex.errors, {'login': 'the value "admin" is already used, use another one'}) |
241 |
241 |
242 |
242 |
262 dbhelper = self.session.pool.source('system').dbhelper |
262 dbhelper = self.session.pool.source('system').dbhelper |
263 sqlcursor = self.session.pool['system'] |
263 sqlcursor = self.session.pool['system'] |
264 self.failIf(schema.has_entity('Societe2')) |
264 self.failIf(schema.has_entity('Societe2')) |
265 self.failIf(schema.has_entity('concerne2')) |
265 self.failIf(schema.has_entity('concerne2')) |
266 # schema should be update on insertion (after commit) |
266 # schema should be update on insertion (after commit) |
267 self.execute('INSERT EEType X: X name "Societe2", X description "", X meta FALSE, X final FALSE') |
267 self.execute('INSERT CWEType X: X name "Societe2", X description "", X meta FALSE, X final FALSE') |
268 self.execute('INSERT ERType X: X name "concerne2", X description "", X meta FALSE, X final FALSE, X symetric FALSE') |
268 self.execute('INSERT CWRType X: X name "concerne2", X description "", X meta FALSE, X final FALSE, X symetric FALSE') |
269 self.failIf(schema.has_entity('Societe2')) |
269 self.failIf(schema.has_entity('Societe2')) |
270 self.failIf(schema.has_entity('concerne2')) |
270 self.failIf(schema.has_entity('concerne2')) |
271 self.execute('SET X read_permission G WHERE X is EEType, X name "Societe2", G is EGroup') |
271 self.execute('SET X read_permission G WHERE X is CWEType, X name "Societe2", G is CWGroup') |
272 self.execute('SET X read_permission G WHERE X is ERType, X name "concerne2", G is EGroup') |
272 self.execute('SET X read_permission G WHERE X is CWRType, X name "concerne2", G is CWGroup') |
273 self.execute('SET X add_permission G WHERE X is EEType, X name "Societe2", G is EGroup, G name "managers"') |
273 self.execute('SET X add_permission G WHERE X is CWEType, X name "Societe2", G is CWGroup, G name "managers"') |
274 self.execute('SET X add_permission G WHERE X is ERType, X name "concerne2", G is EGroup, G name "managers"') |
274 self.execute('SET X add_permission G WHERE X is CWRType, X name "concerne2", G is CWGroup, G name "managers"') |
275 self.execute('SET X delete_permission G WHERE X is EEType, X name "Societe2", G is EGroup, G name "owners"') |
275 self.execute('SET X delete_permission G WHERE X is CWEType, X name "Societe2", G is CWGroup, G name "owners"') |
276 self.execute('SET X delete_permission G WHERE X is ERType, X name "concerne2", G is EGroup, G name "owners"') |
276 self.execute('SET X delete_permission G WHERE X is CWRType, X name "concerne2", G is CWGroup, G name "owners"') |
277 # have to commit before adding definition relations |
277 # have to commit before adding definition relations |
278 self.commit() |
278 self.commit() |
279 self.failUnless(schema.has_entity('Societe2')) |
279 self.failUnless(schema.has_entity('Societe2')) |
280 self.failUnless(schema.has_relation('concerne2')) |
280 self.failUnless(schema.has_relation('concerne2')) |
281 self.execute('INSERT EFRDef X: X cardinality "11", X defaultval "noname", X indexed TRUE, X relation_type RT, X from_entity E, X to_entity F ' |
281 self.execute('INSERT CWAttribute X: X cardinality "11", X defaultval "noname", X indexed TRUE, X relation_type RT, X from_entity E, X to_entity F ' |
282 'WHERE RT name "nom", E name "Societe2", F name "String"') |
282 'WHERE RT name "nom", E name "Societe2", F name "String"') |
283 concerne2_rdef_eid = self.execute( |
283 concerne2_rdef_eid = self.execute( |
284 'INSERT ENFRDef X: X cardinality "**", X relation_type RT, X from_entity E, X to_entity E ' |
284 'INSERT CWRelation X: X cardinality "**", X relation_type RT, X from_entity E, X to_entity E ' |
285 'WHERE RT name "concerne2", E name "Societe2"')[0][0] |
285 'WHERE RT name "concerne2", E name "Societe2"')[0][0] |
286 self.execute('INSERT ENFRDef X: X cardinality "?*", X relation_type RT, X from_entity E, X to_entity C ' |
286 self.execute('INSERT CWRelation X: X cardinality "?*", X relation_type RT, X from_entity E, X to_entity C ' |
287 'WHERE RT name "comments", E name "Societe2", C name "Comment"') |
287 'WHERE RT name "comments", E name "Societe2", C name "Comment"') |
288 self.failIf('nom' in schema['Societe2'].subject_relations()) |
288 self.failIf('nom' in schema['Societe2'].subject_relations()) |
289 self.failIf('concerne2' in schema['Societe2'].subject_relations()) |
289 self.failIf('concerne2' in schema['Societe2'].subject_relations()) |
290 self.failIf(self.index_exists('Societe2', 'nom')) |
290 self.failIf(self.index_exists('Societe2', 'nom')) |
291 self.commit() |
291 self.commit() |
297 self.execute('Societe2 X WHERE X nom "logilab"') |
297 self.execute('Societe2 X WHERE X nom "logilab"') |
298 self.execute('SET X concerne2 X WHERE X nom "logilab"') |
298 self.execute('SET X concerne2 X WHERE X nom "logilab"') |
299 rset = self.execute('Any X WHERE X concerne2 Y') |
299 rset = self.execute('Any X WHERE X concerne2 Y') |
300 self.assertEquals(rset.rows, [[s2eid]]) |
300 self.assertEquals(rset.rows, [[s2eid]]) |
301 # check that when a relation definition is deleted, existing relations are deleted |
301 # check that when a relation definition is deleted, existing relations are deleted |
302 self.execute('INSERT ENFRDef X: X cardinality "**", X relation_type RT, X from_entity E, X to_entity E ' |
302 self.execute('INSERT CWRelation X: X cardinality "**", X relation_type RT, X from_entity E, X to_entity E ' |
303 'WHERE RT name "concerne2", E name "Societe"') |
303 'WHERE RT name "concerne2", E name "Societe"') |
304 self.commit() |
304 self.commit() |
305 self.execute('DELETE ENFRDef X WHERE X eid %(x)s', {'x': concerne2_rdef_eid}, 'x') |
305 self.execute('DELETE CWRelation X WHERE X eid %(x)s', {'x': concerne2_rdef_eid}, 'x') |
306 self.commit() |
306 self.commit() |
307 self.failUnless('concerne2' in schema['Societe'].subject_relations()) |
307 self.failUnless('concerne2' in schema['Societe'].subject_relations()) |
308 self.failIf('concerne2' in schema['Societe2'].subject_relations()) |
308 self.failIf('concerne2' in schema['Societe2'].subject_relations()) |
309 self.failIf(self.execute('Any X WHERE X concerne2 Y')) |
309 self.failIf(self.execute('Any X WHERE X concerne2 Y')) |
310 # schema should be cleaned on delete (after commit) |
310 # schema should be cleaned on delete (after commit) |
311 self.execute('DELETE EEType X WHERE X name "Societe2"') |
311 self.execute('DELETE CWEType X WHERE X name "Societe2"') |
312 self.execute('DELETE ERType X WHERE X name "concerne2"') |
312 self.execute('DELETE CWRType X WHERE X name "concerne2"') |
313 self.failUnless(self.index_exists('Societe2', 'nom')) |
313 self.failUnless(self.index_exists('Societe2', 'nom')) |
314 self.failUnless(schema.has_entity('Societe2')) |
314 self.failUnless(schema.has_entity('Societe2')) |
315 self.failUnless(schema.has_relation('concerne2')) |
315 self.failUnless(schema.has_relation('concerne2')) |
316 self.commit() |
316 self.commit() |
317 self.failIf(self.index_exists('Societe2', 'nom')) |
317 self.failIf(self.index_exists('Societe2', 'nom')) |
334 self.failUnless('subdiv' in snames) |
334 self.failUnless('subdiv' in snames) |
335 |
335 |
336 |
336 |
337 def test_perms_synchronization_1(self): |
337 def test_perms_synchronization_1(self): |
338 schema = self.repo.schema |
338 schema = self.repo.schema |
339 self.assertEquals(schema['EUser'].get_groups('read'), set(('managers', 'users'))) |
339 self.assertEquals(schema['CWUser'].get_groups('read'), set(('managers', 'users'))) |
340 self.failUnless(self.execute('Any X, Y WHERE X is EEType, X name "EUser", Y is EGroup, Y name "users"')[0]) |
340 self.failUnless(self.execute('Any X, Y WHERE X is CWEType, X name "CWUser", Y is CWGroup, Y name "users"')[0]) |
341 self.execute('DELETE X read_permission Y WHERE X is EEType, X name "EUser", Y name "users"') |
341 self.execute('DELETE X read_permission Y WHERE X is CWEType, X name "CWUser", Y name "users"') |
342 self.assertEquals(schema['EUser'].get_groups('read'), set(('managers', 'users', ))) |
342 self.assertEquals(schema['CWUser'].get_groups('read'), set(('managers', 'users', ))) |
343 self.commit() |
343 self.commit() |
344 self.assertEquals(schema['EUser'].get_groups('read'), set(('managers', ))) |
344 self.assertEquals(schema['CWUser'].get_groups('read'), set(('managers', ))) |
345 self.execute('SET X read_permission Y WHERE X is EEType, X name "EUser", Y name "users"') |
345 self.execute('SET X read_permission Y WHERE X is CWEType, X name "CWUser", Y name "users"') |
346 self.commit() |
346 self.commit() |
347 self.assertEquals(schema['EUser'].get_groups('read'), set(('managers', 'users',))) |
347 self.assertEquals(schema['CWUser'].get_groups('read'), set(('managers', 'users',))) |
348 |
348 |
349 def test_perms_synchronization_2(self): |
349 def test_perms_synchronization_2(self): |
350 schema = self.repo.schema['in_group'] |
350 schema = self.repo.schema['in_group'] |
351 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
351 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
352 self.execute('DELETE X read_permission Y WHERE X is ERType, X name "in_group", Y name "guests"') |
352 self.execute('DELETE X read_permission Y WHERE X is CWRType, X name "in_group", Y name "guests"') |
353 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
353 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
354 self.commit() |
354 self.commit() |
355 self.assertEquals(schema.get_groups('read'), set(('managers', 'users'))) |
355 self.assertEquals(schema.get_groups('read'), set(('managers', 'users'))) |
356 self.execute('SET X read_permission Y WHERE X is ERType, X name "in_group", Y name "guests"') |
356 self.execute('SET X read_permission Y WHERE X is CWRType, X name "in_group", Y name "guests"') |
357 self.assertEquals(schema.get_groups('read'), set(('managers', 'users'))) |
357 self.assertEquals(schema.get_groups('read'), set(('managers', 'users'))) |
358 self.commit() |
358 self.commit() |
359 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
359 self.assertEquals(schema.get_groups('read'), set(('managers', 'users', 'guests'))) |
360 |
360 |
361 def test_nonregr_user_edit_itself(self): |
361 def test_nonregr_user_edit_itself(self): |
362 ueid = self.session.user.eid |
362 ueid = self.session.user.eid |
363 groupeids = [eid for eid, in self.execute('EGroup G WHERE G name in ("managers", "users")')] |
363 groupeids = [eid for eid, in self.execute('CWGroup G WHERE G name in ("managers", "users")')] |
364 self.execute('DELETE X in_group Y WHERE X eid %s' % ueid) |
364 self.execute('DELETE X in_group Y WHERE X eid %s' % ueid) |
365 self.execute('SET X surname "toto" WHERE X eid %s' % ueid) |
365 self.execute('SET X surname "toto" WHERE X eid %s' % ueid) |
366 self.execute('SET X in_group Y WHERE X eid %s, Y name "managers"' % ueid) |
366 self.execute('SET X in_group Y WHERE X eid %s, Y name "managers"' % ueid) |
367 self.commit() |
367 self.commit() |
368 eeid = self.execute('Any X WHERE X is EEType, X name "EEType"')[0][0] |
368 eeid = self.execute('Any X WHERE X is CWEType, X name "CWEType"')[0][0] |
369 self.execute('DELETE X read_permission Y WHERE X eid %s' % eeid) |
369 self.execute('DELETE X read_permission Y WHERE X eid %s' % eeid) |
370 self.execute('SET X final FALSE WHERE X eid %s' % eeid) |
370 self.execute('SET X final FALSE WHERE X eid %s' % eeid) |
371 self.execute('SET X read_permission Y WHERE X eid %s, Y eid in (%s, %s)' |
371 self.execute('SET X read_permission Y WHERE X eid %s, Y eid in (%s, %s)' |
372 % (eeid, groupeids[0], groupeids[1])) |
372 % (eeid, groupeids[0], groupeids[1])) |
373 self.commit() |
373 self.commit() |
374 self.execute('Any X WHERE X is EEType, X name "EEType"') |
374 self.execute('Any X WHERE X is CWEType, X name "CWEType"') |
375 |
375 |
376 # schema modification hooks tests ######################################### |
376 # schema modification hooks tests ######################################### |
377 |
377 |
378 def test_uninline_relation(self): |
378 def test_uninline_relation(self): |
379 dbhelper = self.session.pool.source('system').dbhelper |
379 dbhelper = self.session.pool.source('system').dbhelper |
430 def test_unique_change(self): |
430 def test_unique_change(self): |
431 dbhelper = self.session.pool.source('system').dbhelper |
431 dbhelper = self.session.pool.source('system').dbhelper |
432 sqlcursor = self.session.pool['system'] |
432 sqlcursor = self.session.pool['system'] |
433 try: |
433 try: |
434 try: |
434 try: |
435 self.execute('INSERT EConstraint X: X cstrtype CT, DEF constrained_by X ' |
435 self.execute('INSERT CWConstraint X: X cstrtype CT, DEF constrained_by X ' |
436 'WHERE CT name "UniqueConstraint", DEF relation_type RT, DEF from_entity E,' |
436 'WHERE CT name "UniqueConstraint", DEF relation_type RT, DEF from_entity E,' |
437 'RT name "sujet", E name "Affaire"') |
437 'RT name "sujet", E name "Affaire"') |
438 self.failIf(self.schema['Affaire'].has_unique_values('sujet')) |
438 self.failIf(self.schema['Affaire'].has_unique_values('sujet')) |
439 self.failIf(self.index_exists('Affaire', 'sujet', unique=True)) |
439 self.failIf(self.index_exists('Affaire', 'sujet', unique=True)) |
440 self.commit() |
440 self.commit() |
459 |
459 |
460 def setUp(self): |
460 def setUp(self): |
461 RepositoryBasedTC.setUp(self) |
461 RepositoryBasedTC.setUp(self) |
462 self.s_activated = self.execute('State X WHERE X name "activated"')[0][0] |
462 self.s_activated = self.execute('State X WHERE X name "activated"')[0][0] |
463 self.s_deactivated = self.execute('State X WHERE X name "deactivated"')[0][0] |
463 self.s_deactivated = self.execute('State X WHERE X name "deactivated"')[0][0] |
464 self.s_dummy = self.execute('INSERT State X: X name "dummy", X state_of E WHERE E name "EUser"')[0][0] |
464 self.s_dummy = self.execute('INSERT State X: X name "dummy", X state_of E WHERE E name "CWUser"')[0][0] |
465 self.create_user('stduser') |
465 self.create_user('stduser') |
466 # give access to users group on the user's wf transitions |
466 # give access to users group on the user's wf transitions |
467 # so we can test wf enforcing on euser (managers don't have anymore this |
467 # so we can test wf enforcing on euser (managers don't have anymore this |
468 # enforcement |
468 # enforcement |
469 self.execute('SET X require_group G WHERE G name "users", X transition_of ET, ET name "EUser"') |
469 self.execute('SET X require_group G WHERE G name "users", X transition_of ET, ET name "CWUser"') |
470 self.commit() |
470 self.commit() |
471 |
471 |
472 def tearDown(self): |
472 def tearDown(self): |
473 self.execute('DELETE X require_group G WHERE G name "users", X transition_of ET, ET name "EUser"') |
473 self.execute('DELETE X require_group G WHERE G name "users", X transition_of ET, ET name "CWUser"') |
474 self.commit() |
474 self.commit() |
475 RepositoryBasedTC.tearDown(self) |
475 RepositoryBasedTC.tearDown(self) |
476 |
476 |
477 def test_set_initial_state(self): |
477 def test_set_initial_state(self): |
478 ueid = self.execute('INSERT EUser E: E login "x", E upassword "x", E in_group G ' |
478 ueid = self.execute('INSERT CWUser E: E login "x", E upassword "x", E in_group G ' |
479 'WHERE G name "users"')[0][0] |
479 'WHERE G name "users"')[0][0] |
480 self.failIf(self.execute('Any N WHERE S name N, X in_state S, X eid %(x)s', |
480 self.failIf(self.execute('Any N WHERE S name N, X in_state S, X eid %(x)s', |
481 {'x' : ueid})) |
481 {'x' : ueid})) |
482 self.commit() |
482 self.commit() |
483 initialstate = self.execute('Any N WHERE S name N, X in_state S, X eid %(x)s', |
483 initialstate = self.execute('Any N WHERE S name N, X in_state S, X eid %(x)s', |
486 |
486 |
487 def test_initial_state(self): |
487 def test_initial_state(self): |
488 cnx = self.login('stduser') |
488 cnx = self.login('stduser') |
489 cu = cnx.cursor() |
489 cu = cnx.cursor() |
490 self.assertRaises(ValidationError, cu.execute, |
490 self.assertRaises(ValidationError, cu.execute, |
491 'INSERT EUser X: X login "badaboum", X upassword %(pwd)s, ' |
491 'INSERT CWUser X: X login "badaboum", X upassword %(pwd)s, ' |
492 'X in_state S WHERE S name "deactivated"', {'pwd': 'oops'}) |
492 'X in_state S WHERE S name "deactivated"', {'pwd': 'oops'}) |
493 cnx.close() |
493 cnx.close() |
494 # though managers can do whatever he want |
494 # though managers can do whatever he want |
495 self.execute('INSERT EUser X: X login "badaboum", X upassword %(pwd)s, ' |
495 self.execute('INSERT CWUser X: X login "badaboum", X upassword %(pwd)s, ' |
496 'X in_state S, X in_group G WHERE S name "deactivated", G name "users"', {'pwd': 'oops'}) |
496 'X in_state S, X in_group G WHERE S name "deactivated", G name "users"', {'pwd': 'oops'}) |
497 self.commit() |
497 self.commit() |
498 |
498 |
499 # test that the workflow is correctly enforced |
499 # test that the workflow is correctly enforced |
500 def test_transition_checking1(self): |
500 def test_transition_checking1(self): |