262 self.assertEqual(len(description), orig_length - 1) |
262 self.assertEqual(len(description), orig_length - 1) |
263 self.assertEqual(len(rset.rows), orig_length - 1) |
263 self.assertEqual(len(rset.rows), orig_length - 1) |
264 self.assertNotEqual(rset.rows[0][0], 9999999) |
264 self.assertNotEqual(rset.rows[0][0], 9999999) |
265 |
265 |
266 def test_build_descr2(self): |
266 def test_build_descr2(self): |
267 rset = self.execute('Any X,Y WITH X,Y BEING ((Any G,NULL WHERE G is CWGroup) UNION (Any U,G WHERE U in_group G))') |
267 rset = self.qexecute('Any X,Y WITH X,Y BEING ((Any G,NULL WHERE G is CWGroup) UNION ' |
|
268 '(Any U,G WHERE U in_group G))') |
268 for x, y in rset.description: |
269 for x, y in rset.description: |
269 if y is not None: |
270 if y is not None: |
270 self.assertEqual(y, 'CWGroup') |
271 self.assertEqual(y, 'CWGroup') |
271 |
272 |
272 def test_build_descr3(self): |
273 def test_build_descr3(self): |
273 rset = self.execute('(Any G,NULL WHERE G is CWGroup) UNION (Any U,G WHERE U in_group G)') |
274 rset = self.qexecute('(Any G,NULL WHERE G is CWGroup) UNION ' |
|
275 '(Any U,G WHERE U in_group G)') |
274 for x, y in rset.description: |
276 for x, y in rset.description: |
275 if y is not None: |
277 if y is not None: |
276 self.assertEqual(y, 'CWGroup') |
278 self.assertEqual(y, 'CWGroup') |
277 |
279 |
278 |
280 |
279 class QuerierTC(BaseQuerierTC): |
281 class QuerierTC(BaseQuerierTC): |
280 setUpClass = classmethod(setUpClass) |
282 setUpClass = classmethod(setUpClass) |
281 tearDownClass = classmethod(tearDownClass) |
283 tearDownClass = classmethod(tearDownClass) |
282 |
284 |
283 def test_encoding_pb(self): |
285 def test_encoding_pb(self): |
284 self.assertRaises(RQLSyntaxError, self.execute, |
286 self.assertRaises(RQLSyntaxError, self.qexecute, |
285 'Any X WHERE X is CWRType, X name "öwned_by"') |
287 'Any X WHERE X is CWRType, X name "öwned_by"') |
286 |
288 |
287 def test_unknown_eid(self): |
289 def test_unknown_eid(self): |
288 # should return an empty result set |
290 # should return an empty result set |
289 self.assertFalse(self.execute('Any X WHERE X eid 99999999')) |
291 self.assertFalse(self.qexecute('Any X WHERE X eid 99999999')) |
290 |
292 |
291 def test_typed_eid(self): |
293 def test_typed_eid(self): |
292 # should return an empty result set |
294 # should return an empty result set |
293 rset = self.execute('Any X WHERE X eid %(x)s', {'x': '1'}) |
295 rset = self.qexecute('Any X WHERE X eid %(x)s', {'x': '1'}) |
294 self.assertIsInstance(rset[0][0], (int, long)) |
296 self.assertIsInstance(rset[0][0], (int, long)) |
295 |
297 |
296 def test_bytes_storage(self): |
298 def test_bytes_storage(self): |
297 feid = self.execute('INSERT File X: X data_name "foo.pdf", X data_format "text/plain", X data %(data)s', |
299 feid = self.qexecute('INSERT File X: X data_name "foo.pdf", ' |
|
300 'X data_format "text/plain", X data %(data)s', |
298 {'data': Binary("xxx")})[0][0] |
301 {'data': Binary("xxx")})[0][0] |
299 fdata = self.execute('Any D WHERE X data D, X eid %(x)s', {'x': feid})[0][0] |
302 fdata = self.qexecute('Any D WHERE X data D, X eid %(x)s', {'x': feid})[0][0] |
300 self.assertIsInstance(fdata, Binary) |
303 self.assertIsInstance(fdata, Binary) |
301 self.assertEqual(fdata.getvalue(), 'xxx') |
304 self.assertEqual(fdata.getvalue(), 'xxx') |
302 |
305 |
303 # selection queries tests ################################################# |
306 # selection queries tests ################################################# |
304 |
307 |
305 def test_select_1(self): |
308 def test_select_1(self): |
306 rset = self.execute('Any X ORDERBY X WHERE X is CWGroup') |
309 rset = self.qexecute('Any X ORDERBY X WHERE X is CWGroup') |
307 result, descr = rset.rows, rset.description |
310 result, descr = rset.rows, rset.description |
308 self.assertEqual(tuplify(result), [(2,), (3,), (4,), (5,)]) |
311 self.assertEqual(tuplify(result), [(2,), (3,), (4,), (5,)]) |
309 self.assertEqual(descr, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
312 self.assertEqual(descr, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
310 |
313 |
311 def test_select_2(self): |
314 def test_select_2(self): |
312 rset = self.execute('Any X ORDERBY N WHERE X is CWGroup, X name N') |
315 rset = self.qexecute('Any X ORDERBY N WHERE X is CWGroup, X name N') |
313 self.assertEqual(tuplify(rset.rows), [(2,), (3,), (4,), (5,)]) |
316 self.assertEqual(tuplify(rset.rows), [(2,), (3,), (4,), (5,)]) |
314 self.assertEqual(rset.description, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
317 self.assertEqual(rset.description, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
315 rset = self.execute('Any X ORDERBY N DESC WHERE X is CWGroup, X name N') |
318 rset = self.qexecute('Any X ORDERBY N DESC WHERE X is CWGroup, X name N') |
316 self.assertEqual(tuplify(rset.rows), [(5,), (4,), (3,), (2,)]) |
319 self.assertEqual(tuplify(rset.rows), [(5,), (4,), (3,), (2,)]) |
317 |
320 |
318 def test_select_3(self): |
321 def test_select_3(self): |
319 rset = self.execute('Any N GROUPBY N WHERE X is CWGroup, X name N') |
322 rset = self.qexecute('Any N GROUPBY N WHERE X is CWGroup, X name N') |
320 result, descr = rset.rows, rset.description |
323 result, descr = rset.rows, rset.description |
321 result.sort() |
324 result.sort() |
322 self.assertEqual(tuplify(result), [('guests',), ('managers',), ('owners',), ('users',)]) |
325 self.assertEqual(tuplify(result), [('guests',), ('managers',), ('owners',), ('users',)]) |
323 self.assertEqual(descr, [('String',), ('String',), ('String',), ('String',)]) |
326 self.assertEqual(descr, [('String',), ('String',), ('String',), ('String',)]) |
324 |
327 |
325 def test_select_is(self): |
328 def test_select_is(self): |
326 rset = self.execute('Any X, TN ORDERBY TN LIMIT 10 WHERE X is T, T name TN') |
329 rset = self.qexecute('Any X, TN ORDERBY TN LIMIT 10 WHERE X is T, T name TN') |
327 result, descr = rset.rows, rset.description |
330 result, descr = rset.rows, rset.description |
328 self.assertEqual(result[0][1], descr[0][0]) |
331 self.assertEqual(result[0][1], descr[0][0]) |
329 |
332 |
330 def test_select_is_aggr(self): |
333 def test_select_is_aggr(self): |
331 rset = self.execute('Any TN, COUNT(X) GROUPBY TN ORDERBY 2 DESC WHERE X is T, T name TN') |
334 rset = self.qexecute('Any TN, COUNT(X) GROUPBY TN ORDERBY 2 DESC WHERE X is T, T name TN') |
332 result, descr = rset.rows, rset.description |
335 result, descr = rset.rows, rset.description |
333 self.assertEqual(descr[0][0], 'String') |
336 self.assertEqual(descr[0][0], 'String') |
334 self.assertEqual(descr[0][1], 'Int') |
337 self.assertEqual(descr[0][1], 'Int') |
335 self.assertEqual(result[0][0], 'CWRelation') # XXX may change as schema evolve |
338 self.assertEqual(result[0][0], 'CWRelation') # XXX may change as schema evolve |
336 |
339 |
337 def test_select_groupby_orderby(self): |
340 def test_select_groupby_orderby(self): |
338 rset = self.execute('Any N GROUPBY N ORDERBY N WHERE X is CWGroup, X name N') |
341 rset = self.qexecute('Any N GROUPBY N ORDERBY N WHERE X is CWGroup, X name N') |
339 self.assertEqual(tuplify(rset.rows), [('guests',), ('managers',), ('owners',), ('users',)]) |
342 self.assertEqual(tuplify(rset.rows), [('guests',), ('managers',), ('owners',), ('users',)]) |
340 self.assertEqual(rset.description, [('String',), ('String',), ('String',), ('String',)]) |
343 self.assertEqual(rset.description, [('String',), ('String',), ('String',), ('String',)]) |
341 |
344 |
342 def test_select_complex_groupby(self): |
345 def test_select_complex_groupby(self): |
343 rset = self.execute('Any N GROUPBY N WHERE X name N') |
346 rset = self.qexecute('Any N GROUPBY N WHERE X name N') |
344 rset = self.execute('Any N,MAX(D) GROUPBY N LIMIT 5 WHERE X name N, X creation_date D') |
347 rset = self.qexecute('Any N,MAX(D) GROUPBY N LIMIT 5 WHERE X name N, X creation_date D') |
345 |
348 |
346 def test_select_inlined_groupby(self): |
349 def test_select_inlined_groupby(self): |
347 seid = self.execute('State X WHERE X name "deactivated"')[0][0] |
350 seid = self.qexecute('State X WHERE X name "deactivated"')[0][0] |
348 rset = self.execute('Any U,L,S GROUPBY U,L,S WHERE X in_state S, U login L, S eid %s' % seid) |
351 rset = self.qexecute('Any U,L,S GROUPBY U,L,S WHERE X in_state S, U login L, S eid %s' % seid) |
349 |
352 |
350 def test_select_groupby_funccall(self): |
353 def test_select_groupby_funccall(self): |
351 rset = self.execute('Any YEAR(CD), COUNT(X) GROUPBY YEAR(CD) WHERE X is CWUser, X creation_date CD') |
354 rset = self.qexecute('Any YEAR(CD), COUNT(X) GROUPBY YEAR(CD) ' |
|
355 'WHERE X is CWUser, X creation_date CD') |
352 self.assertListEqual(rset.rows, [[date.today().year, 2]]) |
356 self.assertListEqual(rset.rows, [[date.today().year, 2]]) |
353 |
357 |
354 def test_select_groupby_colnumber(self): |
358 def test_select_groupby_colnumber(self): |
355 rset = self.execute('Any YEAR(CD), COUNT(X) GROUPBY 1 WHERE X is CWUser, X creation_date CD') |
359 rset = self.qexecute('Any YEAR(CD), COUNT(X) GROUPBY 1 ' |
|
360 'WHERE X is CWUser, X creation_date CD') |
356 self.assertListEqual(rset.rows, [[date.today().year, 2]]) |
361 self.assertListEqual(rset.rows, [[date.today().year, 2]]) |
357 |
362 |
358 def test_select_complex_orderby(self): |
363 def test_select_complex_orderby(self): |
359 rset1 = self.execute('Any N ORDERBY N WHERE X name N') |
364 rset1 = self.qexecute('Any N ORDERBY N WHERE X name N') |
360 self.assertEqual(sorted(rset1.rows), rset1.rows) |
365 self.assertEqual(sorted(rset1.rows), rset1.rows) |
361 rset = self.execute('Any N ORDERBY N LIMIT 5 OFFSET 1 WHERE X name N') |
366 rset = self.qexecute('Any N ORDERBY N LIMIT 5 OFFSET 1 WHERE X name N') |
362 self.assertEqual(rset.rows[0][0], rset1.rows[1][0]) |
367 self.assertEqual(rset.rows[0][0], rset1.rows[1][0]) |
363 self.assertEqual(len(rset), 5) |
368 self.assertEqual(len(rset), 5) |
364 |
369 |
365 def test_select_5(self): |
370 def test_select_5(self): |
366 rset = self.execute('Any X, TMP ORDERBY TMP WHERE X name TMP, X is CWGroup') |
371 rset = self.qexecute('Any X, TMP ORDERBY TMP WHERE X name TMP, X is CWGroup') |
367 self.assertEqual(tuplify(rset.rows), [(2, 'guests',), (3, 'managers',), (4, 'owners',), (5, 'users',)]) |
372 self.assertEqual(tuplify(rset.rows), |
368 self.assertEqual(rset.description, [('CWGroup', 'String',), ('CWGroup', 'String',), ('CWGroup', 'String',), ('CWGroup', 'String',)]) |
373 [(2, 'guests',), |
|
374 (3, 'managers',), |
|
375 (4, 'owners',), |
|
376 (5, 'users',)]) |
|
377 self.assertEqual(rset.description, |
|
378 [('CWGroup', 'String',), |
|
379 ('CWGroup', 'String',), |
|
380 ('CWGroup', 'String',), |
|
381 ('CWGroup', 'String',)]) |
369 |
382 |
370 def test_select_6(self): |
383 def test_select_6(self): |
371 self.execute("INSERT Personne X: X nom 'bidule'")[0] |
384 self.qexecute("INSERT Personne X: X nom 'bidule'")[0] |
372 rset = self.execute('Any Y where X name TMP, Y nom in (TMP, "bidule")') |
385 rset = self.qexecute('Any Y where X name TMP, Y nom in (TMP, "bidule")') |
373 #self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
386 #self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
374 self.assertIn(('Personne',), rset.description) |
387 self.assertIn(('Personne',), rset.description) |
375 rset = self.execute('DISTINCT Any Y where X name TMP, Y nom in (TMP, "bidule")') |
388 rset = self.qexecute('DISTINCT Any Y where X name TMP, Y nom in (TMP, "bidule")') |
376 self.assertIn(('Personne',), rset.description) |
389 self.assertIn(('Personne',), rset.description) |
377 |
390 |
378 def test_select_not_attr(self): |
391 def test_select_not_attr(self): |
379 peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
392 peid = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
380 seid = self.execute("INSERT Societe X: X nom 'chouette'")[0][0] |
393 seid = self.qexecute("INSERT Societe X: X nom 'chouette'")[0][0] |
381 rset = self.execute('Personne X WHERE NOT X nom "bidule"') |
394 rset = self.qexecute('Personne X WHERE NOT X nom "bidule"') |
382 self.assertEqual(len(rset.rows), 0, rset.rows) |
395 self.assertEqual(len(rset.rows), 0, rset.rows) |
383 rset = self.execute('Personne X WHERE NOT X nom "bid"') |
396 rset = self.qexecute('Personne X WHERE NOT X nom "bid"') |
384 self.assertEqual(len(rset.rows), 1, rset.rows) |
397 self.assertEqual(len(rset.rows), 1, rset.rows) |
385 self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
398 self.qexecute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
386 rset = self.execute('Personne X WHERE NOT X travaille S') |
399 rset = self.qexecute('Personne X WHERE NOT X travaille S') |
387 self.assertEqual(len(rset.rows), 0, rset.rows) |
400 self.assertEqual(len(rset.rows), 0, rset.rows) |
388 |
401 |
389 def test_select_is_in(self): |
402 def test_select_is_in(self): |
390 self.execute("INSERT Personne X: X nom 'bidule'") |
403 self.qexecute("INSERT Personne X: X nom 'bidule'") |
391 self.execute("INSERT Societe X: X nom 'chouette'") |
404 self.qexecute("INSERT Societe X: X nom 'chouette'") |
392 self.assertEqual(len(self.execute("Any X WHERE X is IN (Personne, Societe)")), |
405 self.assertEqual(len(self.qexecute("Any X WHERE X is IN (Personne, Societe)")), |
393 2) |
406 2) |
394 |
407 |
395 def test_select_not_rel(self): |
408 def test_select_not_rel(self): |
396 self.execute("INSERT Personne X: X nom 'bidule'") |
409 self.qexecute("INSERT Personne X: X nom 'bidule'") |
397 self.execute("INSERT Societe X: X nom 'chouette'") |
410 self.qexecute("INSERT Societe X: X nom 'chouette'") |
398 self.execute("INSERT Personne X: X nom 'autre'") |
411 self.qexecute("INSERT Personne X: X nom 'autre'") |
399 self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
412 self.qexecute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
400 rset = self.execute('Personne X WHERE NOT X travaille S') |
413 rset = self.qexecute('Personne X WHERE NOT X travaille S') |
401 self.assertEqual(len(rset.rows), 1, rset.rows) |
414 self.assertEqual(len(rset.rows), 1, rset.rows) |
402 rset = self.execute('Personne X WHERE NOT X travaille S, S nom "chouette"') |
415 rset = self.qexecute('Personne X WHERE NOT X travaille S, S nom "chouette"') |
403 self.assertEqual(len(rset.rows), 1, rset.rows) |
416 self.assertEqual(len(rset.rows), 1, rset.rows) |
404 |
417 |
405 def test_select_nonregr_inlined(self): |
418 def test_select_nonregr_inlined(self): |
406 self.execute("INSERT Note X: X para 'bidule'") |
419 self.execute("INSERT Note X: X para 'bidule'") |
407 self.execute("INSERT Personne X: X nom 'chouette'") |
420 self.execute("INSERT Personne X: X nom 'chouette'") |
411 'N ecrit_par U, N type T')#, {'x': self.ueid}) |
424 'N ecrit_par U, N type T')#, {'x': self.ueid}) |
412 self.assertEqual(len(rset.rows), 0) |
425 self.assertEqual(len(rset.rows), 0) |
413 |
426 |
414 def test_select_nonregr_edition_not(self): |
427 def test_select_nonregr_edition_not(self): |
415 groupeids = set((2, 3, 4)) |
428 groupeids = set((2, 3, 4)) |
416 groupreadperms = set(r[0] for r in self.execute('Any Y WHERE X name "CWGroup", Y eid IN(2, 3, 4), X read_permission Y')) |
429 groupreadperms = set(r[0] for r in self.qexecute('Any Y WHERE X name "CWGroup", ' |
417 rset = self.execute('DISTINCT Any Y WHERE X is CWEType, X name "CWGroup", Y eid IN(2, 3, 4), NOT X read_permission Y') |
430 'Y eid IN(2, 3, 4), X read_permission Y')) |
|
431 rset = self.qexecute('DISTINCT Any Y WHERE X is CWEType, X name "CWGroup", ' |
|
432 'Y eid IN(2, 3, 4), NOT X read_permission Y') |
418 self.assertEqual(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
433 self.assertEqual(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
419 rset = self.execute('DISTINCT Any Y WHERE X name "CWGroup", Y eid IN(2, 3, 4), NOT X read_permission Y') |
434 rset = self.qexecute('DISTINCT Any Y WHERE X name "CWGroup", ' |
|
435 'Y eid IN(2, 3, 4), NOT X read_permission Y') |
420 self.assertEqual(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
436 self.assertEqual(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
421 |
437 |
422 def test_select_outer_join(self): |
438 def test_select_outer_join(self): |
423 peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
439 peid1 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
424 peid2 = self.execute("INSERT Personne X: X nom 'autre'")[0][0] |
440 peid2 = self.qexecute("INSERT Personne X: X nom 'autre'")[0][0] |
425 seid1 = self.execute("INSERT Societe X: X nom 'chouette'")[0][0] |
441 seid1 = self.qexecute("INSERT Societe X: X nom 'chouette'")[0][0] |
426 seid2 = self.execute("INSERT Societe X: X nom 'chouetos'")[0][0] |
442 seid2 = self.qexecute("INSERT Societe X: X nom 'chouetos'")[0][0] |
427 rset = self.execute('Any X,S ORDERBY X WHERE X travaille S?') |
443 rset = self.qexecute('Any X,S ORDERBY X WHERE X travaille S?') |
428 self.assertEqual(rset.rows, [[peid1, None], [peid2, None]]) |
444 self.assertEqual(rset.rows, [[peid1, None], [peid2, None]]) |
429 self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
445 self.qexecute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
430 rset = self.execute('Any X,S ORDERBY X WHERE X travaille S?') |
446 rset = self.qexecute('Any X,S ORDERBY X WHERE X travaille S?') |
431 self.assertEqual(rset.rows, [[peid1, seid1], [peid2, None]]) |
447 self.assertEqual(rset.rows, [[peid1, seid1], [peid2, None]]) |
432 rset = self.execute('Any S,X ORDERBY S WHERE X? travaille S') |
448 rset = self.qexecute('Any S,X ORDERBY S WHERE X? travaille S') |
433 self.assertEqual(rset.rows, [[seid1, peid1], [seid2, None]]) |
449 self.assertEqual(rset.rows, [[seid1, peid1], [seid2, None]]) |
434 |
450 |
435 def test_select_outer_join_optimized(self): |
451 def test_select_outer_join_optimized(self): |
436 peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
452 peid1 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
437 rset = self.execute('Any X WHERE X eid %(x)s, P? connait X', {'x':peid1}) |
453 rset = self.qexecute('Any X WHERE X eid %(x)s, P? connait X', {'x':peid1}) |
438 self.assertEqual(rset.rows, [[peid1]]) |
454 self.assertEqual(rset.rows, [[peid1]]) |
439 rset = self.execute('Any X WHERE X eid %(x)s, X require_permission P?', |
455 rset = self.qexecute('Any X WHERE X eid %(x)s, X require_permission P?', |
440 {'x':peid1}) |
456 {'x':peid1}) |
441 self.assertEqual(rset.rows, [[peid1]]) |
457 self.assertEqual(rset.rows, [[peid1]]) |
442 |
458 |
443 def test_select_left_outer_join(self): |
459 def test_select_left_outer_join(self): |
444 rset = self.execute('DISTINCT Any G WHERE U? in_group G') |
460 rset = self.qexecute('DISTINCT Any G WHERE U? in_group G') |
445 self.assertEqual(len(rset), 4) |
461 self.assertEqual(len(rset), 4) |
446 rset = self.execute('DISTINCT Any G WHERE U? in_group G, U eid %(x)s', |
462 rset = self.qexecute('DISTINCT Any G WHERE U? in_group G, U eid %(x)s', |
447 {'x': self.session.user.eid}) |
463 {'x': self.session.user.eid}) |
448 self.assertEqual(len(rset), 4) |
464 self.assertEqual(len(rset), 4) |
449 |
465 |
450 def test_select_ambigous_outer_join(self): |
466 def test_select_ambigous_outer_join(self): |
451 teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
467 teid = self.qexecute("INSERT Tag X: X name 'tag'")[0][0] |
452 self.execute("INSERT Tag X: X name 'tagbis'")[0][0] |
468 self.qexecute("INSERT Tag X: X name 'tagbis'")[0][0] |
453 geid = self.execute("CWGroup G WHERE G name 'users'")[0][0] |
469 geid = self.qexecute("CWGroup G WHERE G name 'users'")[0][0] |
454 self.execute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
470 self.qexecute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
455 {'g': geid, 't': teid}) |
471 {'g': geid, 't': teid}) |
456 rset = self.execute("Any GN,TN ORDERBY GN WHERE T? tags G, T name TN, G name GN") |
472 rset = self.qexecute("Any GN,TN ORDERBY GN WHERE T? tags G, T name TN, G name GN") |
457 self.assertIn(['users', 'tag'], rset.rows) |
473 self.assertIn(['users', 'tag'], rset.rows) |
458 self.assertIn(['activated', None], rset.rows) |
474 self.assertIn(['activated', None], rset.rows) |
459 rset = self.execute("Any GN,TN ORDERBY GN WHERE T tags G?, T name TN, G name GN") |
475 rset = self.qexecute("Any GN,TN ORDERBY GN WHERE T tags G?, T name TN, G name GN") |
460 self.assertEqual(rset.rows, [[None, 'tagbis'], ['users', 'tag']]) |
476 self.assertEqual(rset.rows, [[None, 'tagbis'], ['users', 'tag']]) |
461 |
477 |
462 def test_select_not_inline_rel(self): |
478 def test_select_not_inline_rel(self): |
463 self.execute("INSERT Personne X: X nom 'bidule'") |
479 self.execute("INSERT Personne X: X nom 'bidule'") |
464 self.execute("INSERT Note X: X type 'a'") |
480 self.execute("INSERT Note X: X type 'a'") |
466 self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
482 self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
467 rset = self.execute('Note X WHERE NOT X ecrit_par P') |
483 rset = self.execute('Note X WHERE NOT X ecrit_par P') |
468 self.assertEqual(len(rset.rows), 1, rset.rows) |
484 self.assertEqual(len(rset.rows), 1, rset.rows) |
469 |
485 |
470 def test_select_not_unlinked_multiple_solutions(self): |
486 def test_select_not_unlinked_multiple_solutions(self): |
471 self.execute("INSERT Personne X: X nom 'bidule'") |
487 self.qexecute("INSERT Personne X: X nom 'bidule'") |
472 self.execute("INSERT Note X: X type 'a'") |
488 self.qexecute("INSERT Note X: X type 'a'") |
473 self.execute("INSERT Note X: X type 'b'") |
489 self.qexecute("INSERT Note X: X type 'b'") |
474 self.execute("SET Y evaluee X WHERE X type 'a', Y nom 'bidule'") |
490 self.qexecute("SET Y evaluee X WHERE X type 'a', Y nom 'bidule'") |
475 rset = self.execute('Note X WHERE NOT Y evaluee X') |
491 rset = self.qexecute('Note X WHERE NOT Y evaluee X') |
476 self.assertEqual(len(rset.rows), 1, rset.rows) |
492 self.assertEqual(len(rset.rows), 1, rset.rows) |
477 |
493 |
478 def test_select_date_extraction(self): |
494 def test_select_date_extraction(self): |
479 self.execute("INSERT Personne X: X nom 'foo', X datenaiss %(d)s", |
495 self.qexecute("INSERT Personne X: X nom 'foo', X datenaiss %(d)s", |
480 {'d': datetime(2001, 2,3, 12,13)}) |
496 {'d': datetime(2001, 2,3, 12,13)}) |
481 test_data = [('YEAR', 2001), ('MONTH', 2), ('DAY', 3), |
497 test_data = [('YEAR', 2001), ('MONTH', 2), ('DAY', 3), |
482 ('HOUR', 12), ('MINUTE', 13), ('WEEKDAY', 6)] |
498 ('HOUR', 12), ('MINUTE', 13), ('WEEKDAY', 6)] |
483 for funcname, result in test_data: |
499 for funcname, result in test_data: |
484 rset = self.execute('Any %s(D) WHERE X is Personne, X datenaiss D' |
500 rset = self.qexecute('Any %s(D) WHERE X is Personne, X datenaiss D' |
485 % funcname) |
501 % funcname) |
486 self.assertEqual(len(rset.rows), 1) |
502 self.assertEqual(len(rset.rows), 1) |
487 self.assertEqual(rset.rows[0][0], result) |
503 self.assertEqual(rset.rows[0][0], result) |
488 self.assertEqual(rset.description, [('Int',)]) |
504 self.assertEqual(rset.description, [('Int',)]) |
489 |
505 |
490 def test_regexp_based_pattern_matching(self): |
506 def test_regexp_based_pattern_matching(self): |
491 peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
507 peid1 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
492 peid2 = self.execute("INSERT Personne X: X nom 'cidule'")[0][0] |
508 peid2 = self.qexecute("INSERT Personne X: X nom 'cidule'")[0][0] |
493 rset = self.execute('Any X WHERE X is Personne, X nom REGEXP "^b"') |
509 rset = self.qexecute('Any X WHERE X is Personne, X nom REGEXP "^b"') |
494 self.assertEqual(len(rset.rows), 1, rset.rows) |
510 self.assertEqual(len(rset.rows), 1, rset.rows) |
495 self.assertEqual(rset.rows[0][0], peid1) |
511 self.assertEqual(rset.rows[0][0], peid1) |
496 rset = self.execute('Any X WHERE X is Personne, X nom REGEXP "idu"') |
512 rset = self.qexecute('Any X WHERE X is Personne, X nom REGEXP "idu"') |
497 self.assertEqual(len(rset.rows), 2, rset.rows) |
513 self.assertEqual(len(rset.rows), 2, rset.rows) |
498 |
514 |
499 def test_select_aggregat_count(self): |
515 def test_select_aggregat_count(self): |
500 rset = self.execute('Any COUNT(X)') |
516 rset = self.qexecute('Any COUNT(X)') |
501 self.assertEqual(len(rset.rows), 1) |
517 self.assertEqual(len(rset.rows), 1) |
502 self.assertEqual(len(rset.rows[0]), 1) |
518 self.assertEqual(len(rset.rows[0]), 1) |
503 self.assertEqual(rset.description, [('Int',)]) |
519 self.assertEqual(rset.description, [('Int',)]) |
504 |
520 |
505 def test_select_aggregat_sum(self): |
521 def test_select_aggregat_sum(self): |
506 rset = self.execute('Any SUM(O) WHERE X ordernum O') |
522 rset = self.qexecute('Any SUM(O) WHERE X ordernum O') |
507 self.assertEqual(len(rset.rows), 1) |
523 self.assertEqual(len(rset.rows), 1) |
508 self.assertEqual(len(rset.rows[0]), 1) |
524 self.assertEqual(len(rset.rows[0]), 1) |
509 self.assertEqual(rset.description, [('Int',)]) |
525 self.assertEqual(rset.description, [('Int',)]) |
510 |
526 |
511 def test_select_aggregat_min(self): |
527 def test_select_aggregat_min(self): |
512 rset = self.execute('Any MIN(X) WHERE X is Personne') |
528 rset = self.qexecute('Any MIN(X) WHERE X is Personne') |
513 self.assertEqual(len(rset.rows), 1) |
529 self.assertEqual(len(rset.rows), 1) |
514 self.assertEqual(len(rset.rows[0]), 1) |
530 self.assertEqual(len(rset.rows[0]), 1) |
515 self.assertEqual(rset.description, [('Personne',)]) |
531 self.assertEqual(rset.description, [('Personne',)]) |
516 rset = self.execute('Any MIN(O) WHERE X ordernum O') |
532 rset = self.qexecute('Any MIN(O) WHERE X ordernum O') |
517 self.assertEqual(len(rset.rows), 1) |
533 self.assertEqual(len(rset.rows), 1) |
518 self.assertEqual(len(rset.rows[0]), 1) |
534 self.assertEqual(len(rset.rows[0]), 1) |
519 self.assertEqual(rset.description, [('Int',)]) |
535 self.assertEqual(rset.description, [('Int',)]) |
520 |
536 |
521 def test_select_aggregat_max(self): |
537 def test_select_aggregat_max(self): |
522 rset = self.execute('Any MAX(X) WHERE X is Personne') |
538 rset = self.qexecute('Any MAX(X) WHERE X is Personne') |
523 self.assertEqual(len(rset.rows), 1) |
539 self.assertEqual(len(rset.rows), 1) |
524 self.assertEqual(len(rset.rows[0]), 1) |
540 self.assertEqual(len(rset.rows[0]), 1) |
525 self.assertEqual(rset.description, [('Personne',)]) |
541 self.assertEqual(rset.description, [('Personne',)]) |
526 rset = self.execute('Any MAX(O) WHERE X ordernum O') |
542 rset = self.qexecute('Any MAX(O) WHERE X ordernum O') |
527 self.assertEqual(len(rset.rows), 1) |
543 self.assertEqual(len(rset.rows), 1) |
528 self.assertEqual(len(rset.rows[0]), 1) |
544 self.assertEqual(len(rset.rows[0]), 1) |
529 self.assertEqual(rset.description, [('Int',)]) |
545 self.assertEqual(rset.description, [('Int',)]) |
530 |
546 |
531 def test_select_custom_aggregat_concat_string(self): |
547 def test_select_custom_aggregat_concat_string(self): |
532 rset = self.execute('Any GROUP_CONCAT(N) WHERE X is CWGroup, X name N') |
548 rset = self.qexecute('Any GROUP_CONCAT(N) WHERE X is CWGroup, X name N') |
533 self.assertTrue(rset) |
549 self.assertTrue(rset) |
534 self.assertEqual(sorted(rset[0][0].split(', ')), ['guests', 'managers', |
550 self.assertEqual(sorted(rset[0][0].split(', ')), ['guests', 'managers', |
535 'owners', 'users']) |
551 'owners', 'users']) |
536 |
552 |
537 def test_select_custom_regproc_limit_size(self): |
553 def test_select_custom_regproc_limit_size(self): |
538 rset = self.execute('Any TEXT_LIMIT_SIZE(N, 3) WHERE X is CWGroup, X name N, X name "managers"') |
554 rset = self.qexecute('Any TEXT_LIMIT_SIZE(N, 3) WHERE X is CWGroup, X name N, X name "managers"') |
539 self.assertTrue(rset) |
555 self.assertTrue(rset) |
540 self.assertEqual(rset[0][0], 'man...') |
556 self.assertEqual(rset[0][0], 'man...') |
541 self.execute("INSERT Basket X: X name 'bidule', X description '<b>hop hop</b>', X description_format 'text/html'") |
557 self.qexecute("INSERT Basket X: X name 'bidule', X description '<b>hop hop</b>', X description_format 'text/html'") |
542 rset = self.execute('Any LIMIT_SIZE(D, DF, 3) WHERE X is Basket, X description D, X description_format DF') |
558 rset = self.qexecute('Any LIMIT_SIZE(D, DF, 3) WHERE X is Basket, X description D, X description_format DF') |
543 self.assertTrue(rset) |
559 self.assertTrue(rset) |
544 self.assertEqual(rset[0][0], 'hop...') |
560 self.assertEqual(rset[0][0], 'hop...') |
545 |
561 |
546 def test_select_regproc_orderby(self): |
562 def test_select_regproc_orderby(self): |
547 rset = self.execute('DISTINCT Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, X name "managers"') |
563 rset = self.qexecute('DISTINCT Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, X name "managers"') |
548 self.assertEqual(len(rset), 1) |
564 self.assertEqual(len(rset), 1) |
549 self.assertEqual(rset[0][1], 'managers') |
565 self.assertEqual(rset[0][1], 'managers') |
550 rset = self.execute('Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, NOT U in_group X, U login "admin"') |
566 rset = self.qexecute('Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, NOT U in_group X, U login "admin"') |
551 self.assertEqual(len(rset), 3) |
567 self.assertEqual(len(rset), 3) |
552 self.assertEqual(rset[0][1], 'owners') |
568 self.assertEqual(rset[0][1], 'owners') |
553 |
569 |
554 def test_select_aggregat_sort(self): |
570 def test_select_aggregat_sort(self): |
555 rset = self.execute('Any G, COUNT(U) GROUPBY G ORDERBY 2 WHERE U in_group G') |
571 rset = self.qexecute('Any G, COUNT(U) GROUPBY G ORDERBY 2 WHERE U in_group G') |
556 self.assertEqual(len(rset.rows), 2) |
572 self.assertEqual(len(rset.rows), 2) |
557 self.assertEqual(len(rset.rows[0]), 2) |
573 self.assertEqual(len(rset.rows[0]), 2) |
558 self.assertEqual(rset.description[0], ('CWGroup', 'Int',)) |
574 self.assertEqual(rset.description[0], ('CWGroup', 'Int',)) |
559 |
575 |
560 def test_select_aggregat_having(self): |
576 def test_select_aggregat_having(self): |
561 rset = self.execute('Any N,COUNT(RDEF) GROUPBY N ORDERBY 2,N ' |
577 rset = self.qexecute('Any N,COUNT(RDEF) GROUPBY N ORDERBY 2,N ' |
562 'WHERE RT name N, RDEF relation_type RT ' |
578 'WHERE RT name N, RDEF relation_type RT ' |
563 'HAVING COUNT(RDEF) > 10') |
579 'HAVING COUNT(RDEF) > 10') |
564 self.assertListEqual(rset.rows, |
580 self.assertListEqual(rset.rows, |
565 [[u'description_format', 12], |
581 [[u'description_format', 12], |
566 [u'description', 13], |
582 [u'description', 13], |
575 [u'modification_date', 43], |
591 [u'modification_date', 43], |
576 [u'owned_by', 43]]) |
592 [u'owned_by', 43]]) |
577 |
593 |
578 def test_select_aggregat_having_dumb(self): |
594 def test_select_aggregat_having_dumb(self): |
579 # dumb but should not raise an error |
595 # dumb but should not raise an error |
580 rset = self.execute('Any U,COUNT(X) GROUPBY U ' |
596 rset = self.qexecute('Any U,COUNT(X) GROUPBY U ' |
581 'WHERE U eid %(x)s, X owned_by U ' |
597 'WHERE U eid %(x)s, X owned_by U ' |
582 'HAVING COUNT(X) > 10', {'x': self.ueid}) |
598 'HAVING COUNT(X) > 10', {'x': self.ueid}) |
583 self.assertEqual(len(rset.rows), 1) |
599 self.assertEqual(len(rset.rows), 1) |
584 self.assertEqual(rset.rows[0][0], self.ueid) |
600 self.assertEqual(rset.rows[0][0], self.ueid) |
585 |
601 |
586 def test_select_having_non_aggregat_1(self): |
602 def test_select_having_non_aggregat_1(self): |
587 rset = self.execute('Any L WHERE X login L, X creation_date CD ' |
603 rset = self.qexecute('Any L WHERE X login L, X creation_date CD ' |
588 'HAVING YEAR(CD) = %s' % date.today().year) |
604 'HAVING YEAR(CD) = %s' % date.today().year) |
589 self.assertListEqual(rset.rows, |
605 self.assertListEqual(rset.rows, |
590 [[u'admin'], |
606 [[u'admin'], |
591 [u'anon']]) |
607 [u'anon']]) |
592 |
608 |
593 def test_select_having_non_aggregat_2(self): |
609 def test_select_having_non_aggregat_2(self): |
594 rset = self.execute('Any L GROUPBY L WHERE X login L, X in_group G, ' |
610 rset = self.qexecute('Any L GROUPBY L WHERE X login L, X in_group G, ' |
595 'X creation_date CD HAVING YEAR(CD) = %s OR COUNT(G) > 1' |
611 'X creation_date CD HAVING YEAR(CD) = %s OR COUNT(G) > 1' |
596 % date.today().year) |
612 % date.today().year) |
597 self.assertListEqual(rset.rows, |
613 self.assertListEqual(rset.rows, |
598 [[u'admin'], |
614 [[u'admin'], |
599 [u'anon']]) |
615 [u'anon']]) |
600 |
616 |
601 def test_select_complex_sort(self): |
617 def test_select_complex_sort(self): |
602 """need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix""" |
618 """need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix""" |
603 rset = self.execute('Any X ORDERBY X,D LIMIT 5 WHERE X creation_date D') |
619 rset = self.qexecute('Any X ORDERBY X,D LIMIT 5 WHERE X creation_date D') |
604 result = rset.rows |
620 result = rset.rows |
605 result.sort() |
621 result.sort() |
606 self.assertEqual(tuplify(result), [(1,), (2,), (3,), (4,), (5,)]) |
622 self.assertEqual(tuplify(result), [(1,), (2,), (3,), (4,), (5,)]) |
607 |
623 |
608 def test_select_upper(self): |
624 def test_select_upper(self): |
609 rset = self.execute('Any X, UPPER(L) ORDERBY L WHERE X is CWUser, X login L') |
625 rset = self.qexecute('Any X, UPPER(L) ORDERBY L WHERE X is CWUser, X login L') |
610 self.assertEqual(len(rset.rows), 2) |
626 self.assertEqual(len(rset.rows), 2) |
611 self.assertEqual(rset.rows[0][1], 'ADMIN') |
627 self.assertEqual(rset.rows[0][1], 'ADMIN') |
612 self.assertEqual(rset.description[0], ('CWUser', 'String',)) |
628 self.assertEqual(rset.description[0], ('CWUser', 'String',)) |
613 self.assertEqual(rset.rows[1][1], 'ANON') |
629 self.assertEqual(rset.rows[1][1], 'ANON') |
614 self.assertEqual(rset.description[1], ('CWUser', 'String',)) |
630 self.assertEqual(rset.description[1], ('CWUser', 'String',)) |
615 eid = rset.rows[0][0] |
631 eid = rset.rows[0][0] |
616 rset = self.execute('Any UPPER(L) WHERE X eid %s, X login L'%eid) |
632 rset = self.qexecute('Any UPPER(L) WHERE X eid %s, X login L'%eid) |
617 self.assertEqual(rset.rows[0][0], 'ADMIN') |
633 self.assertEqual(rset.rows[0][0], 'ADMIN') |
618 self.assertEqual(rset.description, [('String',)]) |
634 self.assertEqual(rset.description, [('String',)]) |
619 |
635 |
620 def test_select_float_abs(self): |
636 def test_select_float_abs(self): |
621 # test positive number |
637 # test positive number |
622 eid = self.execute('INSERT Affaire A: A invoiced %(i)s', {'i': 1.2})[0][0] |
638 eid = self.qexecute('INSERT Affaire A: A invoiced %(i)s', {'i': 1.2})[0][0] |
623 rset = self.execute('Any ABS(I) WHERE X eid %(x)s, X invoiced I', {'x': eid}) |
639 rset = self.qexecute('Any ABS(I) WHERE X eid %(x)s, X invoiced I', {'x': eid}) |
624 self.assertEqual(rset.rows[0][0], 1.2) |
640 self.assertEqual(rset.rows[0][0], 1.2) |
625 # test negative number |
641 # test negative number |
626 eid = self.execute('INSERT Affaire A: A invoiced %(i)s', {'i': -1.2})[0][0] |
642 eid = self.qexecute('INSERT Affaire A: A invoiced %(i)s', {'i': -1.2})[0][0] |
627 rset = self.execute('Any ABS(I) WHERE X eid %(x)s, X invoiced I', {'x': eid}) |
643 rset = self.qexecute('Any ABS(I) WHERE X eid %(x)s, X invoiced I', {'x': eid}) |
628 self.assertEqual(rset.rows[0][0], 1.2) |
644 self.assertEqual(rset.rows[0][0], 1.2) |
629 |
645 |
630 def test_select_int_abs(self): |
646 def test_select_int_abs(self): |
631 # test positive number |
647 # test positive number |
632 eid = self.execute('INSERT Affaire A: A duration %(d)s', {'d': 12})[0][0] |
648 eid = self.qexecute('INSERT Affaire A: A duration %(d)s', {'d': 12})[0][0] |
633 rset = self.execute('Any ABS(D) WHERE X eid %(x)s, X duration D', {'x': eid}) |
649 rset = self.qexecute('Any ABS(D) WHERE X eid %(x)s, X duration D', {'x': eid}) |
634 self.assertEqual(rset.rows[0][0], 12) |
650 self.assertEqual(rset.rows[0][0], 12) |
635 # test negative number |
651 # test negative number |
636 eid = self.execute('INSERT Affaire A: A duration %(d)s', {'d': -12})[0][0] |
652 eid = self.qexecute('INSERT Affaire A: A duration %(d)s', {'d': -12})[0][0] |
637 rset = self.execute('Any ABS(D) WHERE X eid %(x)s, X duration D', {'x': eid}) |
653 rset = self.qexecute('Any ABS(D) WHERE X eid %(x)s, X duration D', {'x': eid}) |
638 self.assertEqual(rset.rows[0][0], 12) |
654 self.assertEqual(rset.rows[0][0], 12) |
639 |
655 |
640 ## def test_select_simplified(self): |
656 ## def test_select_simplified(self): |
641 ## ueid = self.session.user.eid |
657 ## ueid = self.session.user.eid |
642 ## rset = self.execute('Any L WHERE %s login L'%ueid) |
658 ## rset = self.execute('Any L WHERE %s login L'%ueid) |
643 ## self.assertEqual(rset.rows[0][0], 'admin') |
659 ## self.assertEqual(rset.rows[0][0], 'admin') |
644 ## rset = self.execute('Any L WHERE %(x)s login L', {'x':ueid}) |
660 ## rset = self.execute('Any L WHERE %(x)s login L', {'x':ueid}) |
645 ## self.assertEqual(rset.rows[0][0], 'admin') |
661 ## self.assertEqual(rset.rows[0][0], 'admin') |
646 |
662 |
647 def test_select_searchable_text_1(self): |
663 def test_select_searchable_text_1(self): |
648 rset = self.execute(u"INSERT Personne X: X nom 'bidüle'") |
664 rset = self.qexecute(u"INSERT Personne X: X nom 'bidüle'") |
649 rset = self.execute(u"INSERT Societe X: X nom 'bidüle'") |
665 rset = self.qexecute(u"INSERT Societe X: X nom 'bidüle'") |
650 rset = self.execute("INSERT Societe X: X nom 'chouette'") |
666 rset = self.qexecute("INSERT Societe X: X nom 'chouette'") |
651 self.commit() |
667 self.commit() |
652 rset = self.execute('Any X where X has_text %(text)s', {'text': u'bidüle'}) |
668 rset = self.qexecute('Any X where X has_text %(text)s', {'text': u'bidüle'}) |
653 self.assertEqual(len(rset.rows), 2, rset.rows) |
669 self.assertEqual(len(rset.rows), 2, rset.rows) |
654 rset = self.execute(u'Any N where N has_text "bidüle"') |
670 rset = self.qexecute(u'Any N where N has_text "bidüle"') |
655 self.assertEqual(len(rset.rows), 2, rset.rows) |
671 self.assertEqual(len(rset.rows), 2, rset.rows) |
656 biduleeids = [r[0] for r in rset.rows] |
672 biduleeids = [r[0] for r in rset.rows] |
657 rset = self.execute(u'Any N where NOT N has_text "bidüle"') |
673 rset = self.qexecute(u'Any N where NOT N has_text "bidüle"') |
658 self.assertFalse([r[0] for r in rset.rows if r[0] in biduleeids]) |
674 self.assertFalse([r[0] for r in rset.rows if r[0] in biduleeids]) |
659 # duh? |
675 # duh? |
660 rset = self.execute('Any X WHERE X has_text %(text)s', {'text': u'ça'}) |
676 rset = self.qexecute('Any X WHERE X has_text %(text)s', {'text': u'ça'}) |
661 |
677 |
662 def test_select_searchable_text_2(self): |
678 def test_select_searchable_text_2(self): |
663 rset = self.execute("INSERT Personne X: X nom 'bidule'") |
679 rset = self.qexecute("INSERT Personne X: X nom 'bidule'") |
664 rset = self.execute("INSERT Personne X: X nom 'chouette'") |
680 rset = self.qexecute("INSERT Personne X: X nom 'chouette'") |
665 rset = self.execute("INSERT Societe X: X nom 'bidule'") |
681 rset = self.qexecute("INSERT Societe X: X nom 'bidule'") |
666 self.commit() |
682 self.commit() |
667 rset = self.execute('Personne N where N has_text "bidule"') |
683 rset = self.qexecute('Personne N where N has_text "bidule"') |
668 self.assertEqual(len(rset.rows), 1, rset.rows) |
684 self.assertEqual(len(rset.rows), 1, rset.rows) |
669 |
685 |
670 def test_select_searchable_text_3(self): |
686 def test_select_searchable_text_3(self): |
671 rset = self.execute("INSERT Personne X: X nom 'bidule', X sexe 'M'") |
687 rset = self.qexecute("INSERT Personne X: X nom 'bidule', X sexe 'M'") |
672 rset = self.execute("INSERT Personne X: X nom 'bidule', X sexe 'F'") |
688 rset = self.qexecute("INSERT Personne X: X nom 'bidule', X sexe 'F'") |
673 rset = self.execute("INSERT Societe X: X nom 'bidule'") |
689 rset = self.qexecute("INSERT Societe X: X nom 'bidule'") |
674 self.commit() |
690 self.commit() |
675 rset = self.execute('Any X where X has_text "bidule" and X sexe "M"') |
691 rset = self.qexecute('Any X where X has_text "bidule" and X sexe "M"') |
676 self.assertEqual(len(rset.rows), 1, rset.rows) |
692 self.assertEqual(len(rset.rows), 1, rset.rows) |
677 |
693 |
678 def test_select_multiple_searchable_text(self): |
694 def test_select_multiple_searchable_text(self): |
679 self.execute(u"INSERT Personne X: X nom 'bidüle'") |
695 self.qexecute(u"INSERT Personne X: X nom 'bidüle'") |
680 self.execute("INSERT Societe X: X nom 'chouette', S travaille X") |
696 self.qexecute("INSERT Societe X: X nom 'chouette', S travaille X") |
681 self.execute(u"INSERT Personne X: X nom 'bidüle'") |
697 self.qexecute(u"INSERT Personne X: X nom 'bidüle'") |
682 self.commit() |
698 self.commit() |
683 rset = self.execute('Personne X WHERE X has_text %(text)s, X travaille S, S has_text %(text2)s', |
699 rset = self.qexecute('Personne X WHERE X has_text %(text)s, X travaille S, S has_text %(text2)s', |
684 {'text': u'bidüle', |
700 {'text': u'bidüle', |
685 'text2': u'chouette',} |
701 'text2': u'chouette',} |
686 ) |
702 ) |
687 self.assertEqual(len(rset.rows), 1, rset.rows) |
703 self.assertEqual(len(rset.rows), 1, rset.rows) |
688 |
704 |
689 def test_select_no_descr(self): |
705 def test_select_no_descr(self): |
690 rset = self.execute('Any X WHERE X is CWGroup', build_descr=0) |
706 rset = self.qexecute('Any X WHERE X is CWGroup', build_descr=0) |
691 rset.rows.sort() |
707 rset.rows.sort() |
692 self.assertEqual(tuplify(rset.rows), [(2,), (3,), (4,), (5,)]) |
708 self.assertEqual(tuplify(rset.rows), [(2,), (3,), (4,), (5,)]) |
693 self.assertEqual(rset.description, ()) |
709 self.assertEqual(rset.description, ()) |
694 |
710 |
695 def test_select_limit_offset(self): |
711 def test_select_limit_offset(self): |
696 rset = self.execute('CWGroup X ORDERBY N LIMIT 2 WHERE X name N') |
712 rset = self.qexecute('CWGroup X ORDERBY N LIMIT 2 WHERE X name N') |
697 self.assertEqual(tuplify(rset.rows), [(2,), (3,)]) |
713 self.assertEqual(tuplify(rset.rows), [(2,), (3,)]) |
698 self.assertEqual(rset.description, [('CWGroup',), ('CWGroup',)]) |
714 self.assertEqual(rset.description, [('CWGroup',), ('CWGroup',)]) |
699 rset = self.execute('CWGroup X ORDERBY N LIMIT 2 OFFSET 2 WHERE X name N') |
715 rset = self.qexecute('CWGroup X ORDERBY N LIMIT 2 OFFSET 2 WHERE X name N') |
700 self.assertEqual(tuplify(rset.rows), [(4,), (5,)]) |
716 self.assertEqual(tuplify(rset.rows), [(4,), (5,)]) |
701 |
717 |
702 def test_select_symmetric(self): |
718 def test_select_symmetric(self): |
703 self.execute("INSERT Personne X: X nom 'machin'") |
719 self.qexecute("INSERT Personne X: X nom 'machin'") |
704 self.execute("INSERT Personne X: X nom 'bidule'") |
720 self.qexecute("INSERT Personne X: X nom 'bidule'") |
705 self.execute("INSERT Personne X: X nom 'chouette'") |
721 self.qexecute("INSERT Personne X: X nom 'chouette'") |
706 self.execute("INSERT Personne X: X nom 'trucmuche'") |
722 self.qexecute("INSERT Personne X: X nom 'trucmuche'") |
707 self.execute("SET X connait Y WHERE X nom 'chouette', Y nom 'bidule'") |
723 self.qexecute("SET X connait Y WHERE X nom 'chouette', Y nom 'bidule'") |
708 self.execute("SET X connait Y WHERE X nom 'machin', Y nom 'chouette'") |
724 self.qexecute("SET X connait Y WHERE X nom 'machin', Y nom 'chouette'") |
709 rset = self.execute('Any P WHERE P connait P2') |
725 rset = self.qexecute('Any P WHERE P connait P2') |
710 self.assertEqual(len(rset.rows), 4, rset.rows) |
726 self.assertEqual(len(rset.rows), 4, rset.rows) |
711 rset = self.execute('Any P WHERE NOT P connait P2') |
727 rset = self.qexecute('Any P WHERE NOT P connait P2') |
712 self.assertEqual(len(rset.rows), 1, rset.rows) # trucmuche |
728 self.assertEqual(len(rset.rows), 1, rset.rows) # trucmuche |
713 rset = self.execute('Any P WHERE P connait P2, P2 nom "bidule"') |
729 rset = self.qexecute('Any P WHERE P connait P2, P2 nom "bidule"') |
714 self.assertEqual(len(rset.rows), 1, rset.rows) |
730 self.assertEqual(len(rset.rows), 1, rset.rows) |
715 rset = self.execute('Any P WHERE P2 connait P, P2 nom "bidule"') |
731 rset = self.qexecute('Any P WHERE P2 connait P, P2 nom "bidule"') |
716 self.assertEqual(len(rset.rows), 1, rset.rows) |
732 self.assertEqual(len(rset.rows), 1, rset.rows) |
717 rset = self.execute('Any P WHERE P connait P2, P2 nom "chouette"') |
733 rset = self.qexecute('Any P WHERE P connait P2, P2 nom "chouette"') |
718 self.assertEqual(len(rset.rows), 2, rset.rows) |
734 self.assertEqual(len(rset.rows), 2, rset.rows) |
719 rset = self.execute('Any P WHERE P2 connait P, P2 nom "chouette"') |
735 rset = self.qexecute('Any P WHERE P2 connait P, P2 nom "chouette"') |
720 self.assertEqual(len(rset.rows), 2, rset.rows) |
736 self.assertEqual(len(rset.rows), 2, rset.rows) |
721 |
737 |
722 def test_select_inline(self): |
738 def test_select_inline(self): |
723 self.execute("INSERT Personne X: X nom 'bidule'") |
739 self.execute("INSERT Personne X: X nom 'bidule'") |
724 self.execute("INSERT Note X: X type 'a'") |
740 self.execute("INSERT Note X: X type 'a'") |
725 self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
741 self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
726 rset = self.execute('Any N where N ecrit_par X, X nom "bidule"') |
742 rset = self.execute('Any N where N ecrit_par X, X nom "bidule"') |
727 self.assertEqual(len(rset.rows), 1, rset.rows) |
743 self.assertEqual(len(rset.rows), 1, rset.rows) |
728 |
744 |
729 def test_select_creation_date(self): |
745 def test_select_creation_date(self): |
730 self.execute("INSERT Personne X: X nom 'bidule'") |
746 self.qexecute("INSERT Personne X: X nom 'bidule'") |
731 rset = self.execute('Any D WHERE X nom "bidule", X creation_date D') |
747 rset = self.qexecute('Any D WHERE X nom "bidule", X creation_date D') |
732 self.assertEqual(len(rset.rows), 1) |
748 self.assertEqual(len(rset.rows), 1) |
733 |
749 |
734 def test_select_or_relation(self): |
750 def test_select_or_relation(self): |
735 self.execute("INSERT Personne X: X nom 'bidule'") |
751 self.qexecute("INSERT Personne X: X nom 'bidule'") |
736 self.execute("INSERT Personne X: X nom 'chouette'") |
752 self.qexecute("INSERT Personne X: X nom 'chouette'") |
737 self.execute("INSERT Societe X: X nom 'logilab'") |
753 self.qexecute("INSERT Societe X: X nom 'logilab'") |
738 self.execute("INSERT Societe X: X nom 'caesium'") |
754 self.qexecute("INSERT Societe X: X nom 'caesium'") |
739 self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'logilab'") |
755 self.qexecute("SET P travaille S WHERE P nom 'bidule', S nom 'logilab'") |
740 rset = self.execute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
756 rset = self.qexecute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
741 self.assertEqual(len(rset.rows), 1) |
757 self.assertEqual(len(rset.rows), 1) |
742 self.execute("SET P travaille S WHERE P nom 'chouette', S nom 'caesium'") |
758 self.qexecute("SET P travaille S WHERE P nom 'chouette', S nom 'caesium'") |
743 rset = self.execute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
759 rset = self.qexecute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
744 self.assertEqual(len(rset.rows), 2) |
760 self.assertEqual(len(rset.rows), 2) |
745 |
761 |
746 def test_select_or_sym_relation(self): |
762 def test_select_or_sym_relation(self): |
747 self.execute("INSERT Personne X: X nom 'bidule'") |
763 self.qexecute("INSERT Personne X: X nom 'bidule'") |
748 self.execute("INSERT Personne X: X nom 'chouette'") |
764 self.qexecute("INSERT Personne X: X nom 'chouette'") |
749 self.execute("INSERT Personne X: X nom 'truc'") |
765 self.qexecute("INSERT Personne X: X nom 'truc'") |
750 self.execute("SET P connait S WHERE P nom 'bidule', S nom 'chouette'") |
766 self.qexecute("SET P connait S WHERE P nom 'bidule', S nom 'chouette'") |
751 rset = self.execute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
767 rset = self.qexecute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
752 self.assertEqual(len(rset.rows), 1, rset.rows) |
768 self.assertEqual(len(rset.rows), 1, rset.rows) |
753 rset = self.execute('DISTINCT Any P WHERE P connait S or S connait P, S nom "chouette"') |
769 rset = self.qexecute('DISTINCT Any P WHERE P connait S or S connait P, S nom "chouette"') |
754 self.assertEqual(len(rset.rows), 1, rset.rows) |
770 self.assertEqual(len(rset.rows), 1, rset.rows) |
755 self.execute("SET P connait S WHERE P nom 'chouette', S nom 'truc'") |
771 self.qexecute("SET P connait S WHERE P nom 'chouette', S nom 'truc'") |
756 rset = self.execute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
772 rset = self.qexecute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
757 self.assertEqual(len(rset.rows), 2, rset.rows) |
773 self.assertEqual(len(rset.rows), 2, rset.rows) |
758 rset = self.execute('DISTINCT Any P WHERE P connait S OR S connait P, S nom "chouette"') |
774 rset = self.qexecute('DISTINCT Any P WHERE P connait S OR S connait P, S nom "chouette"') |
759 self.assertEqual(len(rset.rows), 2, rset.rows) |
775 self.assertEqual(len(rset.rows), 2, rset.rows) |
760 |
776 |
761 def test_select_follow_relation(self): |
777 def test_select_follow_relation(self): |
762 self.execute("INSERT Affaire X: X sujet 'cool'") |
778 self.qexecute("INSERT Affaire X: X sujet 'cool'") |
763 self.execute("INSERT Societe X: X nom 'chouette'") |
779 self.qexecute("INSERT Societe X: X nom 'chouette'") |
764 self.execute("SET A concerne S WHERE A is Affaire, S is Societe") |
780 self.qexecute("SET A concerne S WHERE A is Affaire, S is Societe") |
765 self.execute("INSERT Note X: X para 'truc'") |
781 self.qexecute("INSERT Note X: X para 'truc'") |
766 self.execute("SET S evaluee N WHERE S is Societe, N is Note") |
782 self.qexecute("SET S evaluee N WHERE S is Societe, N is Note") |
767 self.execute("INSERT Societe X: X nom 'bidule'") |
783 self.qexecute("INSERT Societe X: X nom 'bidule'") |
768 self.execute("INSERT Note X: X para 'troc'") |
784 self.qexecute("INSERT Note X: X para 'troc'") |
769 self.execute("SET S evaluee N WHERE S nom 'bidule', N para 'troc'") |
785 self.qexecute("SET S evaluee N WHERE S nom 'bidule', N para 'troc'") |
770 rset = self.execute('DISTINCT Any A,N WHERE A concerne S, S evaluee N') |
786 rset = self.qexecute('DISTINCT Any A,N WHERE A concerne S, S evaluee N') |
771 self.assertEqual(len(rset.rows), 1, rset.rows) |
787 self.assertEqual(len(rset.rows), 1, rset.rows) |
772 |
788 |
773 def test_select_ordered_distinct_1(self): |
789 def test_select_ordered_distinct_1(self): |
774 self.assertRaises(BadRQLQuery, |
790 self.assertRaises(BadRQLQuery, |
775 self.execute, 'DISTINCT Any S ORDERBY R WHERE A is Affaire, A sujet S, A ref R') |
791 self.qexecute, 'DISTINCT Any S ORDERBY R WHERE A is Affaire, A sujet S, A ref R') |
776 |
792 |
777 def test_select_ordered_distinct_2(self): |
793 def test_select_ordered_distinct_2(self): |
778 self.execute("INSERT Affaire X: X sujet 'minor'") |
794 self.qexecute("INSERT Affaire X: X sujet 'minor'") |
779 self.execute("INSERT Affaire X: X sujet 'zou'") |
795 self.qexecute("INSERT Affaire X: X sujet 'zou'") |
780 self.execute("INSERT Affaire X: X sujet 'abcd'") |
796 self.qexecute("INSERT Affaire X: X sujet 'abcd'") |
781 rset = self.execute('DISTINCT Any S ORDERBY S WHERE A is Affaire, A sujet S') |
797 rset = self.qexecute('DISTINCT Any S ORDERBY S WHERE A is Affaire, A sujet S') |
782 self.assertEqual(rset.rows, [['abcd'], ['minor'], ['zou']]) |
798 self.assertEqual(rset.rows, [['abcd'], ['minor'], ['zou']]) |
783 |
799 |
784 def test_select_ordered_distinct_3(self): |
800 def test_select_ordered_distinct_3(self): |
785 rset = self.execute('DISTINCT Any N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N') |
801 rset = self.qexecute('DISTINCT Any N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N') |
786 self.assertEqual(rset.rows, [['owners'], ['guests'], ['users'], ['managers']]) |
802 self.assertEqual(rset.rows, [['owners'], ['guests'], ['users'], ['managers']]) |
787 |
803 |
788 def test_select_or_value(self): |
804 def test_select_or_value(self): |
789 rset = self.execute('Any U WHERE U in_group G, G name "owners" OR G name "users"') |
805 rset = self.qexecute('Any U WHERE U in_group G, G name "owners" OR G name "users"') |
790 self.assertEqual(len(rset.rows), 0) |
806 self.assertEqual(len(rset.rows), 0) |
791 rset = self.execute('Any U WHERE U in_group G, G name "guests" OR G name "managers"') |
807 rset = self.qexecute('Any U WHERE U in_group G, G name "guests" OR G name "managers"') |
792 self.assertEqual(len(rset.rows), 2) |
808 self.assertEqual(len(rset.rows), 2) |
793 |
809 |
794 def test_select_explicit_eid(self): |
810 def test_select_explicit_eid(self): |
795 rset = self.execute('Any X,E WHERE X owned_by U, X eid E, U eid %(u)s', {'u': self.session.user.eid}) |
811 rset = self.qexecute('Any X,E WHERE X owned_by U, X eid E, U eid %(u)s', {'u': self.session.user.eid}) |
796 self.assertTrue(rset) |
812 self.assertTrue(rset) |
797 self.assertEqual(rset.description[0][1], 'Int') |
813 self.assertEqual(rset.description[0][1], 'Int') |
798 |
814 |
799 # def test_select_rewritten_optional(self): |
815 # def test_select_rewritten_optional(self): |
800 # eid = self.execute("INSERT Affaire X: X sujet 'cool'")[0][0] |
816 # eid = self.qexecute("INSERT Affaire X: X sujet 'cool'")[0][0] |
801 # rset = self.execute('Any X WHERE X eid %(x)s, EXISTS(X owned_by U) OR EXISTS(X concerne S?, S owned_by U)', |
817 # rset = self.qexecute('Any X WHERE X eid %(x)s, EXISTS(X owned_by U) OR EXISTS(X concerne S?, S owned_by U)', |
802 # {'x': eid}, 'x') |
818 # {'x': eid}, 'x') |
803 # self.assertEqual(rset.rows, [[eid]]) |
819 # self.assertEqual(rset.rows, [[eid]]) |
804 |
820 |
805 def test_today_bug(self): |
821 def test_today_bug(self): |
806 self.execute("INSERT Tag X: X name 'bidule', X creation_date NOW") |
822 self.qexecute("INSERT Tag X: X name 'bidule', X creation_date NOW") |
807 self.execute("INSERT Tag Y: Y name 'toto'") |
823 self.qexecute("INSERT Tag Y: Y name 'toto'") |
808 rset = self.execute("Any D WHERE X name in ('bidule', 'toto') , X creation_date D") |
824 rset = self.qexecute("Any D WHERE X name in ('bidule', 'toto') , X creation_date D") |
809 self.assertIsInstance(rset.rows[0][0], datetime) |
825 self.assertIsInstance(rset.rows[0][0], datetime) |
810 rset = self.execute('Tag X WHERE X creation_date TODAY') |
826 rset = self.qexecute('Tag X WHERE X creation_date TODAY') |
811 self.assertEqual(len(rset.rows), 2) |
827 self.assertEqual(len(rset.rows), 2) |
812 rset = self.execute('Any MAX(D) WHERE X is Tag, X creation_date D') |
828 rset = self.qexecute('Any MAX(D) WHERE X is Tag, X creation_date D') |
813 self.assertIsInstance(rset[0][0], datetime) |
829 self.assertIsInstance(rset[0][0], datetime) |
814 |
830 |
815 def test_today(self): |
831 def test_today(self): |
816 self.execute("INSERT Tag X: X name 'bidule', X creation_date TODAY") |
832 self.qexecute("INSERT Tag X: X name 'bidule', X creation_date TODAY") |
817 self.execute("INSERT Tag Y: Y name 'toto'") |
833 self.qexecute("INSERT Tag Y: Y name 'toto'") |
818 rset = self.execute('Tag X WHERE X creation_date TODAY') |
834 rset = self.qexecute('Tag X WHERE X creation_date TODAY') |
819 self.assertEqual(len(rset.rows), 2) |
835 self.assertEqual(len(rset.rows), 2) |
820 |
836 |
821 def test_select_boolean(self): |
837 def test_select_boolean(self): |
822 rset = self.execute('Any N WHERE X is CWEType, X name N, X final %(val)s', |
838 rset = self.qexecute('Any N WHERE X is CWEType, X name N, X final %(val)s', |
823 {'val': True}) |
839 {'val': True}) |
824 self.assertEqual(sorted(r[0] for r in rset.rows), ['BigInt', 'Boolean', 'Bytes', |
840 self.assertEqual(sorted(r[0] for r in rset.rows), ['BigInt', 'Boolean', 'Bytes', |
825 'Date', 'Datetime', |
841 'Date', 'Datetime', |
826 'Decimal', 'Float', |
842 'Decimal', 'Float', |
827 'Int', 'Interval', |
843 'Int', 'Interval', |
828 'Password', 'String', |
844 'Password', 'String', |
829 'TZDatetime', 'TZTime', |
845 'TZDatetime', 'TZTime', |
830 'Time']) |
846 'Time']) |
831 rset = self.execute('Any N WHERE X is CWEType, X name N, X final TRUE') |
847 rset = self.qexecute('Any N WHERE X is CWEType, X name N, X final TRUE') |
832 self.assertEqual(sorted(r[0] for r in rset.rows), ['BigInt', 'Boolean', 'Bytes', |
848 self.assertEqual(sorted(r[0] for r in rset.rows), ['BigInt', 'Boolean', 'Bytes', |
833 'Date', 'Datetime', |
849 'Date', 'Datetime', |
834 'Decimal', 'Float', |
850 'Decimal', 'Float', |
835 'Int', 'Interval', |
851 'Int', 'Interval', |
836 'Password', 'String', |
852 'Password', 'String', |
889 ' UNION ' |
906 ' UNION ' |
890 '(Any N,COUNT(X) GROUPBY N WHERE X name N, X is Transition HAVING COUNT(X)>1))') |
907 '(Any N,COUNT(X) GROUPBY N WHERE X name N, X is Transition HAVING COUNT(X)>1))') |
891 self.assertEqual(rset.rows, [[u'hop', 2], [u'hop', 2]]) |
908 self.assertEqual(rset.rows, [[u'hop', 2], [u'hop', 2]]) |
892 |
909 |
893 def test_select_union_selection_with_diff_variables(self): |
910 def test_select_union_selection_with_diff_variables(self): |
894 rset = self.execute('(Any N WHERE X name N, X is State)' |
911 rset = self.qexecute('(Any N WHERE X name N, X is State)' |
895 ' UNION ' |
912 ' UNION ' |
896 '(Any NN WHERE XX name NN, XX is Transition)') |
913 '(Any NN WHERE XX name NN, XX is Transition)') |
897 self.assertEqual(sorted(r[0] for r in rset.rows), |
914 self.assertEqual(sorted(r[0] for r in rset.rows), |
898 ['abort', 'activate', 'activated', 'ben non', |
915 ['abort', 'activate', 'activated', 'ben non', |
899 'deactivate', 'deactivated', 'done', 'en cours', |
916 'deactivate', 'deactivated', 'done', 'en cours', |
900 'end', 'finie', 'markasdone', 'pitetre', 'redoit', |
917 'end', 'finie', 'markasdone', 'pitetre', 'redoit', |
901 'start', 'todo']) |
918 'start', 'todo']) |
902 |
919 |
903 def test_select_union_description_diff_var(self): |
920 def test_select_union_description_diff_var(self): |
904 eid1 = self.execute('CWGroup X WHERE X name "managers"')[0][0] |
921 eid1 = self.qexecute('CWGroup X WHERE X name "managers"')[0][0] |
905 eid2 = self.execute('CWUser X WHERE X login "admin"')[0][0] |
922 eid2 = self.qexecute('CWUser X WHERE X login "admin"')[0][0] |
906 rset = self.execute('(Any X WHERE X eid %(x)s)' |
923 rset = self.qexecute('(Any X WHERE X eid %(x)s)' |
907 ' UNION ' |
924 ' UNION ' |
908 '(Any Y WHERE Y eid %(y)s)', |
925 '(Any Y WHERE Y eid %(y)s)', |
909 {'x': eid1, 'y': eid2}) |
926 {'x': eid1, 'y': eid2}) |
910 self.assertEqual(rset.description[:], [('CWGroup',), ('CWUser',)]) |
927 self.assertEqual(rset.description[:], [('CWGroup',), ('CWUser',)]) |
911 |
928 |
912 def test_exists(self): |
929 def test_exists(self): |
913 geid = self.execute("INSERT CWGroup X: X name 'lulufanclub'")[0][0] |
930 geid = self.qexecute("INSERT CWGroup X: X name 'lulufanclub'")[0][0] |
914 self.execute("SET U in_group G WHERE G name 'lulufanclub'") |
931 self.qexecute("SET U in_group G WHERE G name 'lulufanclub'") |
915 peid = self.execute("INSERT Personne X: X prenom 'lulu', X nom 'petit'")[0][0] |
932 peid = self.qexecute("INSERT Personne X: X prenom 'lulu', X nom 'petit'")[0][0] |
916 rset = self.execute("Any X WHERE X prenom 'lulu'," |
933 rset = self.qexecute("Any X WHERE X prenom 'lulu'," |
917 "EXISTS (U in_group G, G name 'lulufanclub' OR G name 'managers');") |
934 "EXISTS (U in_group G, G name 'lulufanclub' OR G name 'managers');") |
918 self.assertEqual(rset.rows, [[peid]]) |
935 self.assertEqual(rset.rows, [[peid]]) |
919 |
936 |
920 def test_identity(self): |
937 def test_identity(self): |
921 eid = self.execute('Any X WHERE X identity Y, Y eid 1')[0][0] |
938 eid = self.qexecute('Any X WHERE X identity Y, Y eid 1')[0][0] |
922 self.assertEqual(eid, 1) |
939 self.assertEqual(eid, 1) |
923 eid = self.execute('Any X WHERE Y identity X, Y eid 1')[0][0] |
940 eid = self.qexecute('Any X WHERE Y identity X, Y eid 1')[0][0] |
924 self.assertEqual(eid, 1) |
941 self.assertEqual(eid, 1) |
925 login = self.execute('Any L WHERE X login "admin", X identity Y, Y login L')[0][0] |
942 login = self.qexecute('Any L WHERE X login "admin", X identity Y, Y login L')[0][0] |
926 self.assertEqual(login, 'admin') |
943 self.assertEqual(login, 'admin') |
927 |
944 |
928 def test_select_date_mathexp(self): |
945 def test_select_date_mathexp(self): |
929 rset = self.execute('Any X, TODAY - CD WHERE X is CWUser, X creation_date CD') |
946 rset = self.qexecute('Any X, TODAY - CD WHERE X is CWUser, X creation_date CD') |
930 self.assertTrue(rset) |
947 self.assertTrue(rset) |
931 self.assertEqual(rset.description[0][1], 'Interval') |
948 self.assertEqual(rset.description[0][1], 'Interval') |
932 eid, = self.execute("INSERT Personne X: X nom 'bidule'")[0] |
949 eid, = self.qexecute("INSERT Personne X: X nom 'bidule'")[0] |
933 rset = self.execute('Any X, NOW - CD WHERE X is Personne, X creation_date CD') |
950 rset = self.qexecute('Any X, NOW - CD WHERE X is Personne, X creation_date CD') |
934 self.assertEqual(rset.description[0][1], 'Interval') |
951 self.assertEqual(rset.description[0][1], 'Interval') |
935 |
952 |
936 def test_select_subquery_aggregat_1(self): |
953 def test_select_subquery_aggregat_1(self): |
937 # percent users by groups |
954 # percent users by groups |
938 self.execute('SET X in_group G WHERE G name "users"') |
955 self.qexecute('SET X in_group G WHERE G name "users"') |
939 rset = self.execute('Any GN, COUNT(X)*100/T GROUPBY GN ORDERBY 2,1' |
956 rset = self.qexecute('Any GN, COUNT(X)*100/T GROUPBY GN ORDERBY 2,1' |
940 ' WHERE G name GN, X in_group G' |
957 ' WHERE G name GN, X in_group G' |
941 ' WITH T BEING (Any COUNT(U) WHERE U is CWUser)') |
958 ' WITH T BEING (Any COUNT(U) WHERE U is CWUser)') |
942 self.assertEqual(rset.rows, [[u'guests', 50], [u'managers', 50], [u'users', 100]]) |
959 self.assertEqual(rset.rows, [[u'guests', 50], [u'managers', 50], [u'users', 100]]) |
943 self.assertEqual(rset.description, [('String', 'Int'), ('String', 'Int'), ('String', 'Int')]) |
960 self.assertEqual(rset.description, [('String', 'Int'), ('String', 'Int'), ('String', 'Int')]) |
944 |
961 |
945 def test_select_subquery_aggregat_2(self): |
962 def test_select_subquery_aggregat_2(self): |
946 expected = self.execute('Any X, 0, COUNT(T) GROUPBY X ' |
963 expected = self.qexecute('Any X, 0, COUNT(T) GROUPBY X ' |
947 'WHERE X is Workflow, T transition_of X').rows |
964 'WHERE X is Workflow, T transition_of X').rows |
948 rset = self.execute(''' |
965 rset = self.qexecute(''' |
949 Any P1,B,E WHERE P1 identity P2 WITH |
966 Any P1,B,E WHERE P1 identity P2 WITH |
950 P1,B BEING (Any P,COUNT(T) GROUPBY P WHERE P is Workflow, T is Transition, |
967 P1,B BEING (Any P,COUNT(T) GROUPBY P WHERE P is Workflow, T is Transition, |
951 T? transition_of P, T type "auto"), |
968 T? transition_of P, T type "auto"), |
952 P2,E BEING (Any P,COUNT(T) GROUPBY P WHERE P is Workflow, T is Transition, |
969 P2,E BEING (Any P,COUNT(T) GROUPBY P WHERE P is Workflow, T is Transition, |
953 T? transition_of P, T type "normal")''') |
970 T? transition_of P, T type "normal")''') |
954 self.assertEqual(sorted(rset.rows), sorted(expected)) |
971 self.assertEqual(sorted(rset.rows), sorted(expected)) |
955 |
972 |
956 def test_select_subquery_const(self): |
973 def test_select_subquery_const(self): |
957 rset = self.execute('Any X WITH X BEING ((Any NULL) UNION (Any "toto"))') |
974 rset = self.qexecute('Any X WITH X BEING ((Any NULL) UNION (Any "toto"))') |
958 self.assertEqual(rset.rows, [[None], ['toto']]) |
975 self.assertEqual(rset.rows, [[None], ['toto']]) |
959 self.assertEqual(rset.description, [(None,), ('String',)]) |
976 self.assertEqual(rset.description, [(None,), ('String',)]) |
960 |
977 |
961 # insertion queries tests ################################################# |
978 # insertion queries tests ################################################# |
962 |
979 |
963 def test_insert_is(self): |
980 def test_insert_is(self): |
964 eid, = self.execute("INSERT Personne X: X nom 'bidule'")[0] |
981 eid, = self.qexecute("INSERT Personne X: X nom 'bidule'")[0] |
965 etype, = self.execute("Any TN WHERE X is T, X eid %s, T name TN" % eid)[0] |
982 etype, = self.qexecute("Any TN WHERE X is T, X eid %s, T name TN" % eid)[0] |
966 self.assertEqual(etype, 'Personne') |
983 self.assertEqual(etype, 'Personne') |
967 self.execute("INSERT Personne X: X nom 'managers'") |
984 self.qexecute("INSERT Personne X: X nom 'managers'") |
968 |
985 |
969 def test_insert_1(self): |
986 def test_insert_1(self): |
970 rset = self.execute("INSERT Personne X: X nom 'bidule'") |
987 rset = self.qexecute("INSERT Personne X: X nom 'bidule'") |
971 self.assertEqual(len(rset.rows), 1) |
988 self.assertEqual(len(rset.rows), 1) |
972 self.assertEqual(rset.description, [('Personne',)]) |
989 self.assertEqual(rset.description, [('Personne',)]) |
973 rset = self.execute('Personne X WHERE X nom "bidule"') |
990 rset = self.qexecute('Personne X WHERE X nom "bidule"') |
974 self.assert_(rset.rows) |
991 self.assert_(rset.rows) |
975 self.assertEqual(rset.description, [('Personne',)]) |
992 self.assertEqual(rset.description, [('Personne',)]) |
976 |
993 |
977 def test_insert_1_multiple(self): |
994 def test_insert_1_multiple(self): |
978 self.execute("INSERT Personne X: X nom 'bidule'") |
995 self.qexecute("INSERT Personne X: X nom 'bidule'") |
979 self.execute("INSERT Personne X: X nom 'chouette'") |
996 self.qexecute("INSERT Personne X: X nom 'chouette'") |
980 rset = self.execute("INSERT Societe Y: Y nom N, P travaille Y WHERE P nom N") |
997 rset = self.qexecute("INSERT Societe Y: Y nom N, P travaille Y WHERE P nom N") |
981 self.assertEqual(len(rset.rows), 2) |
998 self.assertEqual(len(rset.rows), 2) |
982 self.assertEqual(rset.description, [('Societe',), ('Societe',)]) |
999 self.assertEqual(rset.description, [('Societe',), ('Societe',)]) |
983 |
1000 |
984 def test_insert_2(self): |
1001 def test_insert_2(self): |
985 rset = self.execute("INSERT Personne X, Personne Y: X nom 'bidule', Y nom 'tutu'") |
1002 rset = self.qexecute("INSERT Personne X, Personne Y: X nom 'bidule', Y nom 'tutu'") |
986 self.assertEqual(rset.description, [('Personne', 'Personne')]) |
1003 self.assertEqual(rset.description, [('Personne', 'Personne')]) |
987 rset = self.execute('Personne X WHERE X nom "bidule" or X nom "tutu"') |
1004 rset = self.qexecute('Personne X WHERE X nom "bidule" or X nom "tutu"') |
988 self.assert_(rset.rows) |
1005 self.assert_(rset.rows) |
989 self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
1006 self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
990 |
1007 |
991 def test_insert_3(self): |
1008 def test_insert_3(self): |
992 self.execute("INSERT Personne X: X nom Y WHERE U login 'admin', U login Y") |
1009 self.qexecute("INSERT Personne X: X nom Y WHERE U login 'admin', U login Y") |
993 rset = self.execute('Personne X WHERE X nom "admin"') |
1010 rset = self.qexecute('Personne X WHERE X nom "admin"') |
994 self.assert_(rset.rows) |
1011 self.assert_(rset.rows) |
995 self.assertEqual(rset.description, [('Personne',)]) |
1012 self.assertEqual(rset.description, [('Personne',)]) |
996 |
1013 |
997 def test_insert_4(self): |
1014 def test_insert_4(self): |
998 self.execute("INSERT Societe Y: Y nom 'toto'") |
1015 self.qexecute("INSERT Societe Y: Y nom 'toto'") |
999 self.execute("INSERT Personne X: X nom 'bidule', X travaille Y WHERE Y nom 'toto'") |
1016 self.qexecute("INSERT Personne X: X nom 'bidule', X travaille Y WHERE Y nom 'toto'") |
1000 rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1017 rset = self.qexecute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1001 self.assert_(rset.rows) |
1018 self.assert_(rset.rows) |
1002 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1019 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1003 |
1020 |
1004 def test_insert_4bis(self): |
1021 def test_insert_4bis(self): |
1005 peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1022 peid = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1006 seid = self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1023 seid = self.qexecute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1007 {'x': str(peid)})[0][0] |
1024 {'x': str(peid)})[0][0] |
1008 self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 1) |
1025 self.assertEqual(len(self.qexecute('Any X, Y WHERE X travaille Y')), 1) |
1009 self.execute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
1026 self.qexecute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
1010 {'x': str(seid)}) |
1027 {'x': str(seid)}) |
1011 self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 2) |
1028 self.assertEqual(len(self.qexecute('Any X, Y WHERE X travaille Y')), 2) |
1012 |
1029 |
1013 def test_insert_4ter(self): |
1030 def test_insert_4ter(self): |
1014 peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1031 peid = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1015 seid = self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1032 seid = self.qexecute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1016 {'x': unicode(peid)})[0][0] |
1033 {'x': unicode(peid)})[0][0] |
1017 self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 1) |
1034 self.assertEqual(len(self.qexecute('Any X, Y WHERE X travaille Y')), 1) |
1018 self.execute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
1035 self.qexecute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
1019 {'x': unicode(seid)}) |
1036 {'x': unicode(seid)}) |
1020 self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 2) |
1037 self.assertEqual(len(self.qexecute('Any X, Y WHERE X travaille Y')), 2) |
1021 |
1038 |
1022 def test_insert_5(self): |
1039 def test_insert_5(self): |
1023 self.execute("INSERT Personne X: X nom 'bidule'") |
1040 self.qexecute("INSERT Personne X: X nom 'bidule'") |
1024 self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X nom 'bidule'") |
1041 self.qexecute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X nom 'bidule'") |
1025 rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1042 rset = self.qexecute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1026 self.assert_(rset.rows) |
1043 self.assert_(rset.rows) |
1027 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1044 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1028 |
1045 |
1029 def test_insert_5bis(self): |
1046 def test_insert_5bis(self): |
1030 peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1047 peid = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1031 self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1048 self.qexecute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
1032 {'x': peid}) |
1049 {'x': peid}) |
1033 rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1050 rset = self.qexecute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1034 self.assert_(rset.rows) |
1051 self.assert_(rset.rows) |
1035 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1052 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1036 |
1053 |
1037 def test_insert_6(self): |
1054 def test_insert_6(self): |
1038 self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto', X travaille Y") |
1055 self.qexecute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto', X travaille Y") |
1039 rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1056 rset = self.qexecute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
1040 self.assert_(rset.rows) |
1057 self.assert_(rset.rows) |
1041 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1058 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1042 |
1059 |
1043 def test_insert_7(self): |
1060 def test_insert_7(self): |
1044 self.execute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y WHERE U login 'admin', U login N") |
1061 self.qexecute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', " |
1045 rset = self.execute('Any X, Y WHERE X nom "admin", Y nom "toto", X travaille Y') |
1062 "X travaille Y WHERE U login 'admin', U login N") |
|
1063 rset = self.qexecute('Any X, Y WHERE X nom "admin", Y nom "toto", X travaille Y') |
1046 self.assert_(rset.rows) |
1064 self.assert_(rset.rows) |
1047 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1065 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1048 |
1066 |
1049 def test_insert_7_2(self): |
1067 def test_insert_7_2(self): |
1050 self.execute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y WHERE U login N") |
1068 self.qexecute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', " |
1051 rset = self.execute('Any X, Y WHERE Y nom "toto", X travaille Y') |
1069 "X travaille Y WHERE U login N") |
|
1070 rset = self.qexecute('Any X, Y WHERE Y nom "toto", X travaille Y') |
1052 self.assertEqual(len(rset), 2) |
1071 self.assertEqual(len(rset), 2) |
1053 self.assertEqual(rset.description, [('Personne', 'Societe',), |
1072 self.assertEqual(rset.description, [('Personne', 'Societe',), |
1054 ('Personne', 'Societe',)]) |
1073 ('Personne', 'Societe',)]) |
1055 |
1074 |
1056 def test_insert_8(self): |
1075 def test_insert_8(self): |
1057 self.execute("INSERT Societe Y, Personne X: Y nom N, X nom 'toto', X travaille Y WHERE U login 'admin', U login N") |
1076 self.qexecute("INSERT Societe Y, Personne X: Y nom N, X nom 'toto', X travaille Y " |
1058 rset = self.execute('Any X, Y WHERE X nom "toto", Y nom "admin", X travaille Y') |
1077 "WHERE U login 'admin', U login N") |
|
1078 rset = self.qexecute('Any X, Y WHERE X nom "toto", Y nom "admin", X travaille Y') |
1059 self.assert_(rset.rows) |
1079 self.assert_(rset.rows) |
1060 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1080 self.assertEqual(rset.description, [('Personne', 'Societe',)]) |
1061 |
1081 |
1062 def test_insert_9(self): |
1082 def test_insert_9(self): |
1063 self.execute("INSERT Societe X: X nom 'Lo'") |
1083 self.qexecute("INSERT Societe X: X nom 'Lo'") |
1064 self.execute("INSERT Societe X: X nom 'Gi'") |
1084 self.qexecute("INSERT Societe X: X nom 'Gi'") |
1065 self.execute("INSERT SubDivision X: X nom 'Lab'") |
1085 self.qexecute("INSERT SubDivision X: X nom 'Lab'") |
1066 rset = self.execute("INSERT Personne X: X nom N, X travaille Y, X travaille_subdivision Z WHERE Y is Societe, Z is SubDivision, Y nom N") |
1086 rset = self.qexecute("INSERT Personne X: X nom N, X travaille Y, X travaille_subdivision Z " |
|
1087 "WHERE Y is Societe, Z is SubDivision, Y nom N") |
1067 self.assertEqual(len(rset), 2) |
1088 self.assertEqual(len(rset), 2) |
1068 self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
1089 self.assertEqual(rset.description, [('Personne',), ('Personne',)]) |
1069 # self.assertSetEqual(set(x.nom for x in rset.entities()), |
1090 # self.assertSetEqual(set(x.nom for x in rset.entities()), |
1070 # ['Lo', 'Gi']) |
1091 # ['Lo', 'Gi']) |
1071 # self.assertSetEqual(set(y.nom for x in rset.entities() for y in x.travaille), |
1092 # self.assertSetEqual(set(y.nom for x in rset.entities() for y in x.travaille), |
1073 # self.assertEqual([y.nom for x in rset.entities() for y in x.travaille_subdivision], |
1094 # self.assertEqual([y.nom for x in rset.entities() for y in x.travaille_subdivision], |
1074 # ['Lab', 'Lab']) |
1095 # ['Lab', 'Lab']) |
1075 |
1096 |
1076 def test_insert_query_error(self): |
1097 def test_insert_query_error(self): |
1077 self.assertRaises(Exception, |
1098 self.assertRaises(Exception, |
1078 self.execute, |
1099 self.qexecute, |
1079 "INSERT Personne X: X nom 'toto', X is Personne") |
1100 "INSERT Personne X: X nom 'toto', X is Personne") |
1080 self.assertRaises(Exception, |
1101 self.assertRaises(Exception, |
1081 self.execute, |
1102 self.qexecute, |
1082 "INSERT Personne X: X nom 'toto', X is_instance_of Personne") |
1103 "INSERT Personne X: X nom 'toto', X is_instance_of Personne") |
1083 self.assertRaises(QueryError, |
1104 self.assertRaises(QueryError, |
1084 self.execute, |
1105 self.qexecute, |
1085 "INSERT Personne X: X nom 'toto', X has_text 'tutu'") |
1106 "INSERT Personne X: X nom 'toto', X has_text 'tutu'") |
1086 |
1107 |
1087 self.assertRaises(QueryError, |
1108 self.assertRaises(QueryError, |
1088 self.execute, |
1109 self.qexecute, |
1089 "INSERT CWUser X: X login 'toto', X eid %s" % cnx.user(self.session).eid) |
1110 "INSERT CWUser X: X login 'toto', X eid %s" % cnx.user(self.session).eid) |
1090 |
1111 |
1091 def test_insertion_description_with_where(self): |
1112 def test_insertion_description_with_where(self): |
1092 rset = self.execute('INSERT CWUser E, EmailAddress EM: E login "X", E upassword "X", ' |
1113 rset = self.qexecute('INSERT CWUser E, EmailAddress EM: E login "X", E upassword "X", ' |
1093 'E primary_email EM, EM address "X", E in_group G ' |
1114 'E primary_email EM, EM address "X", E in_group G ' |
1094 'WHERE G name "managers"') |
1115 'WHERE G name "managers"') |
1095 self.assertEqual(list(rset.description[0]), ['CWUser', 'EmailAddress']) |
1116 self.assertEqual(list(rset.description[0]), ['CWUser', 'EmailAddress']) |
1096 |
1117 |
1097 # deletion queries tests ################################################## |
1118 # deletion queries tests ################################################## |
1098 |
1119 |
1099 def test_delete_1(self): |
1120 def test_delete_1(self): |
1100 self.execute("INSERT Personne Y: Y nom 'toto'") |
1121 self.qexecute("INSERT Personne Y: Y nom 'toto'") |
1101 rset = self.execute('Personne X WHERE X nom "toto"') |
1122 rset = self.qexecute('Personne X WHERE X nom "toto"') |
1102 self.assertEqual(len(rset.rows), 1) |
1123 self.assertEqual(len(rset.rows), 1) |
1103 drset = self.execute("DELETE Personne Y WHERE Y nom 'toto'") |
1124 drset = self.qexecute("DELETE Personne Y WHERE Y nom 'toto'") |
1104 self.assertEqual(drset.rows, rset.rows) |
1125 self.assertEqual(drset.rows, rset.rows) |
1105 rset = self.execute('Personne X WHERE X nom "toto"') |
1126 rset = self.qexecute('Personne X WHERE X nom "toto"') |
1106 self.assertEqual(len(rset.rows), 0) |
1127 self.assertEqual(len(rset.rows), 0) |
1107 |
1128 |
1108 def test_delete_2(self): |
1129 def test_delete_2(self): |
1109 rset = self.execute("INSERT Personne X, Personne Y, Societe Z : X nom 'syt', Y nom 'adim', Z nom 'Logilab', X travaille Z, Y travaille Z") |
1130 rset = self.qexecute("INSERT Personne X, Personne Y, Societe Z : " |
|
1131 "X nom 'syt', Y nom 'adim', Z nom 'Logilab', X travaille Z, Y travaille Z") |
1110 self.assertEqual(len(rset), 1) |
1132 self.assertEqual(len(rset), 1) |
1111 self.assertEqual(len(rset[0]), 3) |
1133 self.assertEqual(len(rset[0]), 3) |
1112 self.assertEqual(rset.description[0], ('Personne', 'Personne', 'Societe')) |
1134 self.assertEqual(rset.description[0], ('Personne', 'Personne', 'Societe')) |
1113 self.assertEqual(self.execute('Any N WHERE X nom N, X eid %s'% rset[0][0])[0][0], 'syt') |
1135 self.assertEqual(self.qexecute('Any N WHERE X nom N, X eid %s'% rset[0][0])[0][0], 'syt') |
1114 rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1136 rset = self.qexecute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1115 self.assertEqual(len(rset.rows), 2, rset.rows) |
1137 self.assertEqual(len(rset.rows), 2, rset.rows) |
1116 self.execute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilabo'") |
1138 self.qexecute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilabo'") |
1117 rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1139 rset = self.qexecute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1118 self.assertEqual(len(rset.rows), 2, rset.rows) |
1140 self.assertEqual(len(rset.rows), 2, rset.rows) |
1119 self.execute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilab'") |
1141 self.qexecute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilab'") |
1120 rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1142 rset = self.qexecute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
1121 self.assertEqual(len(rset.rows), 0, rset.rows) |
1143 self.assertEqual(len(rset.rows), 0, rset.rows) |
1122 |
1144 |
1123 def test_delete_3(self): |
1145 def test_delete_3(self): |
1124 s = self.user_groups_session('users') |
1146 s = self.user_groups_session('users') |
1125 peid, = self.o.execute(s, "INSERT Personne P: P nom 'toto'")[0] |
1147 peid, = self.o.execute(s, "INSERT Personne P: P nom 'toto'")[0] |
1126 seid, = self.o.execute(s, "INSERT Societe S: S nom 'logilab'")[0] |
1148 seid, = self.o.execute(s, "INSERT Societe S: S nom 'logilab'")[0] |
1127 self.o.execute(s, "SET P travaille S") |
1149 self.o.execute(s, "SET P travaille S") |
1128 rset = self.execute('Personne P WHERE P travaille S') |
1150 rset = self.execute('Personne P WHERE P travaille S') |
1129 self.assertEqual(len(rset.rows), 1) |
1151 self.assertEqual(len(rset.rows), 1) |
1130 self.execute("DELETE X travaille Y WHERE X eid %s, Y eid %s" % (peid, seid)) |
1152 self.qexecute("DELETE X travaille Y WHERE X eid %s, Y eid %s" % (peid, seid)) |
1131 rset = self.execute('Personne P WHERE P travaille S') |
1153 rset = self.qexecute('Personne P WHERE P travaille S') |
1132 self.assertEqual(len(rset.rows), 0) |
1154 self.assertEqual(len(rset.rows), 0) |
1133 |
1155 |
1134 def test_delete_symmetric(self): |
1156 def test_delete_symmetric(self): |
1135 teid1 = self.execute("INSERT Folder T: T name 'toto'")[0][0] |
1157 teid1 = self.qexecute("INSERT Folder T: T name 'toto'")[0][0] |
1136 teid2 = self.execute("INSERT Folder T: T name 'tutu'")[0][0] |
1158 teid2 = self.qexecute("INSERT Folder T: T name 'tutu'")[0][0] |
1137 self.execute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1159 self.qexecute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1138 rset = self.execute('Any X,Y WHERE X see_also Y') |
1160 rset = self.qexecute('Any X,Y WHERE X see_also Y') |
1139 self.assertEqual(len(rset) , 2, rset.rows) |
1161 self.assertEqual(len(rset) , 2, rset.rows) |
1140 self.execute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1162 self.qexecute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1141 rset = self.execute('Any X,Y WHERE X see_also Y') |
1163 rset = self.qexecute('Any X,Y WHERE X see_also Y') |
1142 self.assertEqual(len(rset) , 0) |
1164 self.assertEqual(len(rset) , 0) |
1143 self.execute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1165 self.qexecute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
1144 rset = self.execute('Any X,Y WHERE X see_also Y') |
1166 rset = self.qexecute('Any X,Y WHERE X see_also Y') |
1145 self.assertEqual(len(rset) , 2) |
1167 self.assertEqual(len(rset) , 2) |
1146 self.execute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid2, teid1)) |
1168 self.qexecute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid2, teid1)) |
1147 rset = self.execute('Any X,Y WHERE X see_also Y') |
1169 rset = self.qexecute('Any X,Y WHERE X see_also Y') |
1148 self.assertEqual(len(rset) , 0) |
1170 self.assertEqual(len(rset) , 0) |
1149 |
1171 |
1150 def test_nonregr_delete_cache(self): |
1172 def test_nonregr_delete_cache(self): |
1151 """test that relations are properly cleaned when an entity is deleted |
1173 """test that relations are properly cleaned when an entity is deleted |
1152 (using cachekey on sql generation returned always the same query for an eid, |
1174 (using cachekey on sql generation returned always the same query for an eid, |
1162 self.assertEqual(len(sqlc.fetchall()), 0) |
1184 self.assertEqual(len(sqlc.fetchall()), 0) |
1163 sqlc.execute('SELECT * FROM owned_by_relation WHERE eid_from=%s'%eeid) |
1185 sqlc.execute('SELECT * FROM owned_by_relation WHERE eid_from=%s'%eeid) |
1164 self.assertEqual(len(sqlc.fetchall()), 0) |
1186 self.assertEqual(len(sqlc.fetchall()), 0) |
1165 |
1187 |
1166 def test_nonregr_delete_cache2(self): |
1188 def test_nonregr_delete_cache2(self): |
1167 eid = self.execute("INSERT Folder T: T name 'toto'")[0][0] |
1189 eid = self.qexecute("INSERT Folder T: T name 'toto'")[0][0] |
1168 self.commit() |
1190 self.commit() |
1169 # fill the cache |
1191 # fill the cache |
1170 self.execute("Any X WHERE X eid %(x)s", {'x': eid}) |
1192 self.qexecute("Any X WHERE X eid %(x)s", {'x': eid}) |
1171 self.execute("Any X WHERE X eid %s" % eid) |
1193 self.qexecute("Any X WHERE X eid %s" % eid) |
1172 self.execute("Folder X WHERE X eid %(x)s", {'x': eid}) |
1194 self.qexecute("Folder X WHERE X eid %(x)s", {'x': eid}) |
1173 self.execute("Folder X WHERE X eid %s" % eid) |
1195 self.qexecute("Folder X WHERE X eid %s" % eid) |
1174 self.execute("DELETE Folder T WHERE T eid %s" % eid) |
1196 self.qexecute("DELETE Folder T WHERE T eid %s" % eid) |
1175 self.commit() |
1197 self.commit() |
1176 rset = self.execute("Any X WHERE X eid %(x)s", {'x': eid}) |
1198 rset = self.qexecute("Any X WHERE X eid %(x)s", {'x': eid}) |
1177 self.assertEqual(rset.rows, []) |
1199 self.assertEqual(rset.rows, []) |
1178 rset = self.execute("Any X WHERE X eid %s" % eid) |
1200 rset = self.qexecute("Any X WHERE X eid %s" % eid) |
1179 self.assertEqual(rset.rows, []) |
1201 self.assertEqual(rset.rows, []) |
1180 rset = self.execute("Folder X WHERE X eid %(x)s", {'x': eid}) |
1202 rset = self.qexecute("Folder X WHERE X eid %(x)s", {'x': eid}) |
1181 self.assertEqual(rset.rows, []) |
1203 self.assertEqual(rset.rows, []) |
1182 rset = self.execute("Folder X WHERE X eid %s" %eid) |
1204 rset = self.qexecute("Folder X WHERE X eid %s" %eid) |
1183 self.assertEqual(rset.rows, []) |
1205 self.assertEqual(rset.rows, []) |
1184 |
1206 |
1185 # update queries tests #################################################### |
1207 # update queries tests #################################################### |
1186 |
1208 |
1187 def test_update_1(self): |
1209 def test_update_1(self): |
1188 peid = self.execute("INSERT Personne Y: Y nom 'toto'")[0][0] |
1210 peid = self.qexecute("INSERT Personne Y: Y nom 'toto'")[0][0] |
1189 rset = self.execute('Personne X WHERE X nom "toto"') |
1211 rset = self.qexecute('Personne X WHERE X nom "toto"') |
1190 self.assertEqual(len(rset.rows), 1) |
1212 self.assertEqual(len(rset.rows), 1) |
1191 rset = self.execute("SET X nom 'tutu', X prenom 'original' WHERE X is Personne, X nom 'toto'") |
1213 rset = self.qexecute("SET X nom 'tutu', X prenom 'original' WHERE X is Personne, X nom 'toto'") |
1192 self.assertEqual(tuplify(rset.rows), [(peid, 'tutu', 'original')]) |
1214 self.assertEqual(tuplify(rset.rows), [(peid, 'tutu', 'original')]) |
1193 rset = self.execute('Any Y, Z WHERE X is Personne, X nom Y, X prenom Z') |
1215 rset = self.qexecute('Any Y, Z WHERE X is Personne, X nom Y, X prenom Z') |
1194 self.assertEqual(tuplify(rset.rows), [('tutu', 'original')]) |
1216 self.assertEqual(tuplify(rset.rows), [('tutu', 'original')]) |
1195 |
1217 |
1196 def test_update_2(self): |
1218 def test_update_2(self): |
1197 peid, seid = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'")[0] |
1219 peid, seid = self.qexecute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'")[0] |
1198 rset = self.execute("SET X travaille Y WHERE X nom 'bidule', Y nom 'toto'") |
1220 rset = self.qexecute("SET X travaille Y WHERE X nom 'bidule', Y nom 'toto'") |
1199 self.assertEqual(tuplify(rset.rows), [(peid, seid)]) |
1221 self.assertEqual(tuplify(rset.rows), [(peid, seid)]) |
1200 rset = self.execute('Any X, Y WHERE X travaille Y') |
1222 rset = self.qexecute('Any X, Y WHERE X travaille Y') |
1201 self.assertEqual(len(rset.rows), 1) |
1223 self.assertEqual(len(rset.rows), 1) |
1202 |
1224 |
1203 def test_update_2bis(self): |
1225 def test_update_2bis(self): |
1204 rset = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1226 rset = self.qexecute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1205 eid1, eid2 = rset[0][0], rset[0][1] |
1227 eid1, eid2 = rset[0][0], rset[0][1] |
1206 self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
1228 self.qexecute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
1207 {'x': str(eid1), 'y': str(eid2)}) |
1229 {'x': str(eid1), 'y': str(eid2)}) |
1208 rset = self.execute('Any X, Y WHERE X travaille Y') |
1230 rset = self.qexecute('Any X, Y WHERE X travaille Y') |
1209 self.assertEqual(len(rset.rows), 1) |
1231 self.assertEqual(len(rset.rows), 1) |
1210 # test add of an existant relation but with NOT X rel Y protection |
1232 # test add of an existant relation but with NOT X rel Y protection |
1211 self.assertFalse(self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s," |
1233 self.assertFalse(self.qexecute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s," |
1212 "NOT X travaille Y", |
1234 "NOT X travaille Y", |
1213 {'x': str(eid1), 'y': str(eid2)})) |
1235 {'x': str(eid1), 'y': str(eid2)})) |
1214 |
1236 |
1215 def test_update_2ter(self): |
1237 def test_update_2ter(self): |
1216 rset = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1238 rset = self.qexecute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1217 eid1, eid2 = rset[0][0], rset[0][1] |
1239 eid1, eid2 = rset[0][0], rset[0][1] |
1218 self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
1240 self.qexecute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
1219 {'x': unicode(eid1), 'y': unicode(eid2)}) |
1241 {'x': unicode(eid1), 'y': unicode(eid2)}) |
1220 rset = self.execute('Any X, Y WHERE X travaille Y') |
1242 rset = self.qexecute('Any X, Y WHERE X travaille Y') |
1221 self.assertEqual(len(rset.rows), 1) |
1243 self.assertEqual(len(rset.rows), 1) |
1222 |
1244 |
1223 def test_update_multiple1(self): |
1245 def test_update_multiple1(self): |
1224 peid1 = self.execute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
1246 peid1 = self.qexecute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
1225 peid2 = self.execute("INSERT Personne Y: Y nom 'toto'")[0][0] |
1247 peid2 = self.qexecute("INSERT Personne Y: Y nom 'toto'")[0][0] |
1226 self.execute("SET X nom 'tutu', Y nom 'toto' WHERE X nom 'toto', Y nom 'tutu'") |
1248 self.qexecute("SET X nom 'tutu', Y nom 'toto' WHERE X nom 'toto', Y nom 'tutu'") |
1227 self.assertEqual(self.execute('Any X WHERE X nom "toto"').rows, [[peid1]]) |
1249 self.assertEqual(self.qexecute('Any X WHERE X nom "toto"').rows, [[peid1]]) |
1228 self.assertEqual(self.execute('Any X WHERE X nom "tutu"').rows, [[peid2]]) |
1250 self.assertEqual(self.qexecute('Any X WHERE X nom "tutu"').rows, [[peid2]]) |
1229 |
1251 |
1230 def test_update_multiple2(self): |
1252 def test_update_multiple2(self): |
1231 ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
1253 ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
1232 peid1 = self.execute("INSERT Personne Y: Y nom 'turlu'")[0][0] |
1254 peid1 = self.execute("INSERT Personne Y: Y nom 'turlu'")[0][0] |
1233 peid2 = self.execute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
1255 peid2 = self.execute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
1237 % (peid1, ueid))) |
1259 % (peid1, ueid))) |
1238 self.assertTrue(self.execute('Any X WHERE X eid %s, X owned_by U, U eid %s' |
1260 self.assertTrue(self.execute('Any X WHERE X eid %s, X owned_by U, U eid %s' |
1239 % (peid2, ueid))) |
1261 % (peid2, ueid))) |
1240 |
1262 |
1241 def test_update_math_expr(self): |
1263 def test_update_math_expr(self): |
1242 orders = [r[0] for r in self.execute('Any O ORDERBY O WHERE ST name "Personne", X from_entity ST, X ordernum O')] |
1264 orders = [r[0] for r in self.qexecute('Any O ORDERBY O WHERE ST name "Personne", ' |
|
1265 'X from_entity ST, X ordernum O')] |
1243 for i,v in enumerate(orders): |
1266 for i,v in enumerate(orders): |
1244 if v != orders[0]: |
1267 if v != orders[0]: |
1245 splitidx = i |
1268 splitidx = i |
1246 break |
1269 break |
1247 self.execute('SET X ordernum Y+1 WHERE X from_entity SE, SE name "Personne", X ordernum Y, X ordernum >= %(order)s', |
1270 self.qexecute('SET X ordernum Y+1 WHERE X from_entity SE, SE name "Personne", ' |
|
1271 'X ordernum Y, X ordernum >= %(order)s', |
1248 {'order': orders[splitidx]}) |
1272 {'order': orders[splitidx]}) |
1249 orders2 = [r[0] for r in self.execute('Any O ORDERBY O WHERE ST name "Personne", X from_entity ST, X ordernum O')] |
1273 orders2 = [r[0] for r in self.qexecute('Any O ORDERBY O WHERE ST name "Personne", ' |
|
1274 'X from_entity ST, X ordernum O')] |
1250 orders = orders[:splitidx] + [o+1 for o in orders[splitidx:]] |
1275 orders = orders[:splitidx] + [o+1 for o in orders[splitidx:]] |
1251 self.assertEqual(orders2, orders) |
1276 self.assertEqual(orders2, orders) |
1252 |
1277 |
1253 def test_update_string_concat(self): |
1278 def test_update_string_concat(self): |
1254 beid = self.execute("INSERT Bookmark Y: Y title 'toto', Y path '/view'")[0][0] |
1279 beid = self.qexecute("INSERT Bookmark Y: Y title 'toto', Y path '/view'")[0][0] |
1255 self.execute('SET X title XN + %(suffix)s WHERE X is Bookmark, X title XN', {'suffix': u'-moved'}) |
1280 self.qexecute('SET X title XN + %(suffix)s WHERE X is Bookmark, X title XN', |
1256 newname = self.execute('Any XN WHERE X eid %(x)s, X title XN', {'x': beid})[0][0] |
1281 {'suffix': u'-moved'}) |
|
1282 newname = self.qexecute('Any XN WHERE X eid %(x)s, X title XN', {'x': beid})[0][0] |
1257 self.assertEqual(newname, 'toto-moved') |
1283 self.assertEqual(newname, 'toto-moved') |
1258 |
1284 |
1259 def test_update_not_exists(self): |
1285 def test_update_not_exists(self): |
1260 rset = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1286 rset = self.qexecute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
1261 eid1, eid2 = rset[0][0], rset[0][1] |
1287 eid1, eid2 = rset[0][0], rset[0][1] |
1262 rset = self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s, " |
1288 rset = self.qexecute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s, " |
1263 "NOT EXISTS(Z ecrit_par X)", |
1289 "NOT EXISTS(Z ecrit_par X)", |
1264 {'x': unicode(eid1), 'y': unicode(eid2)}) |
1290 {'x': unicode(eid1), 'y': unicode(eid2)}) |
1265 self.assertEqual(tuplify(rset.rows), [(eid1, eid2)]) |
1291 self.assertEqual(tuplify(rset.rows), [(eid1, eid2)]) |
1266 |
1292 |
1267 def test_update_query_error(self): |
1293 def test_update_query_error(self): |
1268 self.execute("INSERT Personne Y: Y nom 'toto'") |
1294 self.qexecute("INSERT Personne Y: Y nom 'toto'") |
1269 self.assertRaises(Exception, self.execute, "SET X nom 'toto', X is Personne") |
1295 self.assertRaises(Exception, self.qexecute, "SET X nom 'toto', X is Personne") |
1270 self.assertRaises(QueryError, self.execute, "SET X nom 'toto', X has_text 'tutu' WHERE X is Personne") |
1296 self.assertRaises(QueryError, self.qexecute, "SET X nom 'toto', X has_text 'tutu' " |
1271 self.assertRaises(QueryError, self.execute, "SET X login 'tutu', X eid %s" % cnx.user(self.session).eid) |
1297 "WHERE X is Personne") |
|
1298 self.assertRaises(QueryError, |
|
1299 self.qexecute, |
|
1300 "SET X login 'tutu', X eid %s" % cnx.user(self.session).eid) |
1272 |
1301 |
1273 |
1302 |
1274 # HAVING on write queries test ############################################# |
1303 # HAVING on write queries test ############################################# |
1275 |
1304 |
1276 def test_update_having(self): |
1305 def test_update_having(self): |
1277 peid1 = self.execute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1306 peid1 = self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1278 peid2 = self.execute("INSERT Personne Y: Y nom 'hop', Y tel 2")[0][0] |
1307 peid2 = self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 2")[0][0] |
1279 rset = self.execute("SET X tel 3 WHERE X tel TEL HAVING TEL&1=1") |
1308 rset = self.qexecute("SET X tel 3 WHERE X tel TEL HAVING TEL&1=1") |
1280 self.assertEqual(tuplify(rset.rows), [(peid1, 3)]) |
1309 self.assertEqual(tuplify(rset.rows), [(peid1, 3)]) |
1281 |
1310 |
1282 def test_insert_having(self): |
1311 def test_insert_having(self): |
1283 self.skipTest('unsupported yet') |
1312 self.skipTest('unsupported yet') |
1284 self.execute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1313 self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1285 self.assertFalse(self.execute("INSERT Personne Y: Y nom 'hop', Y tel 2 WHERE X tel XT HAVING XT&2=2")) |
1314 self.assertFalse(self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 2 " |
1286 self.assertTrue(self.execute("INSERT Personne Y: Y nom 'hop', Y tel 2 WHERE X tel XT HAVING XT&1=1")) |
1315 "WHERE X tel XT HAVING XT&2=2")) |
|
1316 self.assertTrue(self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 2 " |
|
1317 "WHERE X tel XT HAVING XT&1=1")) |
1287 |
1318 |
1288 def test_delete_having(self): |
1319 def test_delete_having(self): |
1289 self.execute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1320 self.qexecute("INSERT Personne Y: Y nom 'hop', Y tel 1")[0][0] |
1290 self.assertFalse(self.execute("DELETE Personne Y WHERE X tel XT HAVING XT&2=2")) |
1321 self.assertFalse(self.qexecute("DELETE Personne Y WHERE X tel XT HAVING XT&2=2")) |
1291 self.assertTrue(self.execute("DELETE Personne Y WHERE X tel XT HAVING XT&1=1")) |
1322 self.assertTrue(self.qexecute("DELETE Personne Y WHERE X tel XT HAVING XT&1=1")) |
1292 |
1323 |
1293 # upassword encryption tests ################################################# |
1324 # upassword encryption tests ################################################# |
1294 |
1325 |
1295 def test_insert_upassword(self): |
1326 def test_insert_upassword(self): |
1296 rset = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'") |
1327 rset = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'") |
1324 self.assertEqual(rset.description, [('CWUser',)]) |
1355 self.assertEqual(rset.description, [('CWUser',)]) |
1325 |
1356 |
1326 # ZT datetime tests ######################################################## |
1357 # ZT datetime tests ######################################################## |
1327 |
1358 |
1328 def test_tz_datetime(self): |
1359 def test_tz_datetime(self): |
1329 self.execute("INSERT Personne X: X nom 'bob', X tzdatenaiss %(date)s", |
1360 self.qexecute("INSERT Personne X: X nom 'bob', X tzdatenaiss %(date)s", |
1330 {'date': datetime(1977, 6, 7, 2, 0, tzinfo=FixedOffset(1))}) |
1361 {'date': datetime(1977, 6, 7, 2, 0, tzinfo=FixedOffset(1))}) |
1331 datenaiss = self.execute("Any XD WHERE X nom 'bob', X tzdatenaiss XD")[0][0] |
1362 datenaiss = self.qexecute("Any XD WHERE X nom 'bob', X tzdatenaiss XD")[0][0] |
1332 self.assertEqual(datenaiss.tzinfo, None) |
1363 self.assertEqual(datenaiss.tzinfo, None) |
1333 self.assertEqual(datenaiss.utctimetuple()[:5], (1977, 6, 7, 1, 0)) |
1364 self.assertEqual(datenaiss.utctimetuple()[:5], (1977, 6, 7, 1, 0)) |
1334 |
1365 |
1335 # non regression tests ##################################################### |
1366 # non regression tests ##################################################### |
1336 |
1367 |
1337 def test_nonregr_1(self): |
1368 def test_nonregr_1(self): |
1338 teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
1369 teid = self.qexecute("INSERT Tag X: X name 'tag'")[0][0] |
1339 self.execute("SET X tags Y WHERE X name 'tag', Y is State, Y name 'activated'") |
1370 self.qexecute("SET X tags Y WHERE X name 'tag', Y is State, Y name 'activated'") |
1340 rset = self.execute('Any X WHERE T tags X') |
1371 rset = self.qexecute('Any X WHERE T tags X') |
1341 self.assertEqual(len(rset.rows), 1, rset.rows) |
1372 self.assertEqual(len(rset.rows), 1, rset.rows) |
1342 rset = self.execute('Any T WHERE T tags X, X is State') |
1373 rset = self.qexecute('Any T WHERE T tags X, X is State') |
1343 self.assertEqual(rset.rows, [[teid]]) |
1374 self.assertEqual(rset.rows, [[teid]]) |
1344 rset = self.execute('Any T WHERE T tags X') |
1375 rset = self.qexecute('Any T WHERE T tags X') |
1345 self.assertEqual(rset.rows, [[teid]]) |
1376 self.assertEqual(rset.rows, [[teid]]) |
1346 |
1377 |
1347 def test_nonregr_2(self): |
1378 def test_nonregr_2(self): |
1348 teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
1379 teid = self.qexecute("INSERT Tag X: X name 'tag'")[0][0] |
1349 geid = self.execute("CWGroup G WHERE G name 'users'")[0][0] |
1380 geid = self.qexecute("CWGroup G WHERE G name 'users'")[0][0] |
1350 self.execute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
1381 self.qexecute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
1351 {'g': geid, 't': teid}) |
1382 {'g': geid, 't': teid}) |
1352 rset = self.execute('Any X WHERE E eid %(x)s, E tags X', |
1383 rset = self.qexecute('Any X WHERE E eid %(x)s, E tags X', |
1353 {'x': teid}) |
1384 {'x': teid}) |
1354 self.assertEqual(rset.rows, [[geid]]) |
1385 self.assertEqual(rset.rows, [[geid]]) |
1355 |
1386 |
1356 def test_nonregr_3(self): |
1387 def test_nonregr_3(self): |
1357 """bad sql generated on the second query (destination_state is not |
1388 """bad sql generated on the second query (destination_state is not |
1358 detected as an inlined relation) |
1389 detected as an inlined relation) |
1359 """ |
1390 """ |
1360 rset = self.execute('Any S,ES,T WHERE S state_of WF, WF workflow_of ET, ET name "CWUser",' |
1391 rset = self.qexecute('Any S,ES,T WHERE S state_of WF, WF workflow_of ET, ET name "CWUser",' |
1361 'ES allowed_transition T, T destination_state S') |
1392 'ES allowed_transition T, T destination_state S') |
1362 self.assertEqual(len(rset.rows), 2) |
1393 self.assertEqual(len(rset.rows), 2) |
1363 |
1394 |
1364 def test_nonregr_4(self): |
1395 def test_nonregr_4(self): |
1365 # fix variables'type, else we get (nb of entity types with a 'name' attribute)**3 |
1396 # fix variables'type, else we get (nb of entity types with a 'name' attribute)**3 |
1366 # union queries and that make for instance a 266Ko sql query which is refused |
1397 # union queries and that make for instance a 266Ko sql query which is refused |
1367 # by the server (or client lib) |
1398 # by the server (or client lib) |
1368 rset = self.execute('Any ER,SE,OE WHERE SE name "Comment", ER name "comments", OE name "Comment",' |
1399 rset = self.qexecute('Any ER,SE,OE WHERE SE name "Comment", ER name "comments", OE name "Comment",' |
1369 'ER is CWRType, SE is CWEType, OE is CWEType') |
1400 'ER is CWRType, SE is CWEType, OE is CWEType') |
1370 self.assertEqual(len(rset), 1) |
1401 self.assertEqual(len(rset), 1) |
1371 |
1402 |
1372 def test_nonregr_5(self): |
1403 def test_nonregr_5(self): |
1373 # jpl #15505: equivalent queries returning different result sets |
1404 # jpl #15505: equivalent queries returning different result sets |
1374 teid1 = self.execute("INSERT Folder X: X name 'hop'")[0][0] |
1405 teid1 = self.qexecute("INSERT Folder X: X name 'hop'")[0][0] |
1375 teid2 = self.execute("INSERT Folder X: X name 'hip'")[0][0] |
1406 teid2 = self.qexecute("INSERT Folder X: X name 'hip'")[0][0] |
1376 neid = self.execute("INSERT Note X: X todo_by U, X filed_under T WHERE U login 'admin', T name 'hop'")[0][0] |
1407 neid = self.qexecute("INSERT Note X: X todo_by U, X filed_under T " |
1377 weid = self.execute("INSERT Affaire X: X concerne N, X filed_under T WHERE N is Note, T name 'hip'")[0][0] |
1408 "WHERE U login 'admin', T name 'hop'")[0][0] |
1378 rset1 = self.execute('Any N,U WHERE N filed_under T, T eid %s,' |
1409 weid = self.qexecute("INSERT Affaire X: X concerne N, X filed_under T " |
|
1410 "WHERE N is Note, T name 'hip'")[0][0] |
|
1411 rset1 = self.qexecute('Any N,U WHERE N filed_under T, T eid %s,' |
1379 'N todo_by U, W concerne N,' |
1412 'N todo_by U, W concerne N,' |
1380 'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
1413 'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
1381 rset2 = self.execute('Any N,U WHERE N filed_under T, T eid %s,' |
1414 rset2 = self.qexecute('Any N,U WHERE N filed_under T, T eid %s,' |
1382 'N todo_by U, W concerne N,' |
1415 'N todo_by U, W concerne N,' |
1383 'W filed_under A, A eid %s' % (teid1, teid2)) |
1416 'W filed_under A, A eid %s' % (teid1, teid2)) |
1384 rset3 = self.execute('Any N,U WHERE N todo_by U, T eid %s,' |
1417 rset3 = self.qexecute('Any N,U WHERE N todo_by U, T eid %s,' |
1385 'N filed_under T, W concerne N,' |
1418 'N filed_under T, W concerne N,' |
1386 'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
1419 'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
1387 rset4 = self.execute('Any N,U WHERE N todo_by U, T eid %s,' |
1420 rset4 = self.qexecute('Any N,U WHERE N todo_by U, T eid %s,' |
1388 'N filed_under T, W concerne N,' |
1421 'N filed_under T, W concerne N,' |
1389 'W filed_under A, A eid %s' % (teid1, teid2)) |
1422 'W filed_under A, A eid %s' % (teid1, teid2)) |
1390 self.assertEqual(rset1.rows, rset2.rows) |
1423 self.assertEqual(rset1.rows, rset2.rows) |
1391 self.assertEqual(rset1.rows, rset3.rows) |
1424 self.assertEqual(rset1.rows, rset3.rows) |
1392 self.assertEqual(rset1.rows, rset4.rows) |
1425 self.assertEqual(rset1.rows, rset4.rows) |
1393 |
1426 |
1394 def test_nonregr_6(self): |
1427 def test_nonregr_6(self): |
1395 self.execute('Any N,COUNT(S) GROUPBY N ORDERBY COUNT(N) WHERE S name N, S is State') |
1428 self.qexecute('Any N,COUNT(S) GROUPBY N ORDERBY COUNT(N) WHERE S name N, S is State') |
1396 |
1429 |
1397 def test_sqlite_encoding(self): |
1430 def test_sqlite_encoding(self): |
1398 """XXX this test was trying to show a bug on use of lower which only |
1431 """XXX this test was trying to show a bug on use of lower which only |
1399 occurs with non ascii string and misconfigured locale |
1432 occurs with non ascii string and misconfigured locale |
1400 """ |
1433 """ |
1401 self.execute("INSERT Tag X: X name %(name)s," |
1434 self.qexecute("INSERT Tag X: X name %(name)s," |
1402 "X modification_date %(modification_date)s," |
1435 "X modification_date %(modification_date)s," |
1403 "X creation_date %(creation_date)s", |
1436 "X creation_date %(creation_date)s", |
1404 {'name': u'éname0', |
1437 {'name': u'éname0', |
1405 'modification_date': '2003/03/12 11:00', |
1438 'modification_date': '2003/03/12 11:00', |
1406 'creation_date': '2000/07/03 11:00'}) |
1439 'creation_date': '2000/07/03 11:00'}) |
1407 rset = self.execute('Any lower(N) ORDERBY LOWER(N) WHERE X is Tag, X name N,' |
1440 rset = self.qexecute('Any lower(N) ORDERBY LOWER(N) WHERE X is Tag, X name N,' |
1408 'X owned_by U, U eid %(x)s', |
1441 'X owned_by U, U eid %(x)s', |
1409 {'x':self.session.user.eid}) |
1442 {'x':self.session.user.eid}) |
1410 self.assertEqual(rset.rows, [[u'\xe9name0']]) |
1443 self.assertEqual(rset.rows, [[u'\xe9name0']]) |
1411 |
1444 |
1412 |
1445 |
1413 def test_nonregr_description(self): |
1446 def test_nonregr_description(self): |
1414 """check that a correct description is built in case where infered |
1447 """check that a correct description is built in case where infered |
1415 solutions may be "fusionned" into one by the querier while all solutions |
1448 solutions may be "fusionned" into one by the querier while all solutions |
1416 are needed to build the result's description |
1449 are needed to build the result's description |
1417 """ |
1450 """ |
1418 self.execute("INSERT Personne X: X nom 'bidule'") |
1451 self.qexecute("INSERT Personne X: X nom 'bidule'") |
1419 self.execute("INSERT Societe Y: Y nom 'toto'") |
1452 self.qexecute("INSERT Societe Y: Y nom 'toto'") |
1420 beid = self.execute("INSERT Basket B: B name 'mybasket'")[0][0] |
1453 beid = self.qexecute("INSERT Basket B: B name 'mybasket'")[0][0] |
1421 self.execute("SET X in_basket B WHERE X is Personne") |
1454 self.qexecute("SET X in_basket B WHERE X is Personne") |
1422 self.execute("SET X in_basket B WHERE X is Societe") |
1455 self.qexecute("SET X in_basket B WHERE X is Societe") |
1423 rset = self.execute('Any X WHERE X in_basket B, B eid %s' % beid) |
1456 rset = self.qexecute('Any X WHERE X in_basket B, B eid %s' % beid) |
1424 self.assertEqual(len(rset), 2) |
1457 self.assertEqual(len(rset), 2) |
1425 self.assertEqual(rset.description, [('Personne',), ('Societe',)]) |
1458 self.assertEqual(rset.description, [('Personne',), ('Societe',)]) |
1426 |
1459 |
1427 |
1460 |
1428 def test_nonregr_cache_1(self): |
1461 def test_nonregr_cache_1(self): |
1429 peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1462 peid = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1430 beid = self.execute("INSERT Basket X: X name 'tag'")[0][0] |
1463 beid = self.qexecute("INSERT Basket X: X name 'tag'")[0][0] |
1431 self.execute("SET X in_basket Y WHERE X is Personne, Y eid %(y)s", |
1464 self.qexecute("SET X in_basket Y WHERE X is Personne, Y eid %(y)s", |
1432 {'y': beid}) |
1465 {'y': beid}) |
1433 rset = self.execute("Any X WHERE X in_basket B, B eid %(x)s", |
1466 rset = self.qexecute("Any X WHERE X in_basket B, B eid %(x)s", |
1434 {'x': beid}) |
1467 {'x': beid}) |
1435 self.assertEqual(rset.rows, [[peid]]) |
1468 self.assertEqual(rset.rows, [[peid]]) |
1436 rset = self.execute("Any X WHERE X in_basket B, B eid %(x)s", |
1469 rset = self.qexecute("Any X WHERE X in_basket B, B eid %(x)s", |
1437 {'x': beid}) |
1470 {'x': beid}) |
1438 self.assertEqual(rset.rows, [[peid]]) |
1471 self.assertEqual(rset.rows, [[peid]]) |
1439 |
1472 |
1440 def test_nonregr_has_text_cache(self): |
1473 def test_nonregr_has_text_cache(self): |
1441 eid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1474 eid1 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1442 eid2 = self.execute("INSERT Personne X: X nom 'tag'")[0][0] |
1475 eid2 = self.qexecute("INSERT Personne X: X nom 'tag'")[0][0] |
1443 self.commit() |
1476 self.commit() |
1444 rset = self.execute("Any X WHERE X has_text %(text)s", {'text': 'bidule'}) |
1477 rset = self.qexecute("Any X WHERE X has_text %(text)s", {'text': 'bidule'}) |
1445 self.assertEqual(rset.rows, [[eid1]]) |
1478 self.assertEqual(rset.rows, [[eid1]]) |
1446 rset = self.execute("Any X WHERE X has_text %(text)s", {'text': 'tag'}) |
1479 rset = self.qexecute("Any X WHERE X has_text %(text)s", {'text': 'tag'}) |
1447 self.assertEqual(rset.rows, [[eid2]]) |
1480 self.assertEqual(rset.rows, [[eid2]]) |
1448 |
1481 |
1449 def test_nonregr_sortterm_management(self): |
1482 def test_nonregr_sortterm_management(self): |
1450 """Error: Variable has no attribute 'sql' in rql2sql.py (visit_variable) |
1483 """Error: Variable has no attribute 'sql' in rql2sql.py (visit_variable) |
1451 |
1484 |
1452 cause: old variable ref inserted into a fresh rqlst copy |
1485 cause: old variable ref inserted into a fresh rqlst copy |
1453 (in RQLSpliter._complex_select_plan) |
1486 (in RQLSpliter._complex_select_plan) |
1454 |
1487 |
1455 need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix |
1488 need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix |
1456 """ |
1489 """ |
1457 self.execute('Any X ORDERBY D DESC WHERE X creation_date D') |
1490 self.qexecute('Any X ORDERBY D DESC WHERE X creation_date D') |
1458 |
1491 |
1459 def test_nonregr_extra_joins(self): |
1492 def test_nonregr_extra_joins(self): |
1460 ueid = self.session.user.eid |
1493 ueid = self.session.user.eid |
1461 teid1 = self.execute("INSERT Folder X: X name 'folder1'")[0][0] |
1494 teid1 = self.qexecute("INSERT Folder X: X name 'folder1'")[0][0] |
1462 teid2 = self.execute("INSERT Folder X: X name 'folder2'")[0][0] |
1495 teid2 = self.qexecute("INSERT Folder X: X name 'folder2'")[0][0] |
1463 neid1 = self.execute("INSERT Note X: X para 'note1'")[0][0] |
1496 neid1 = self.qexecute("INSERT Note X: X para 'note1'")[0][0] |
1464 neid2 = self.execute("INSERT Note X: X para 'note2'")[0][0] |
1497 neid2 = self.qexecute("INSERT Note X: X para 'note2'")[0][0] |
1465 self.execute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
1498 self.qexecute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
1466 % (neid1, teid1)) |
1499 % (neid1, teid1)) |
1467 self.execute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
1500 self.qexecute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
1468 % (neid2, teid2)) |
1501 % (neid2, teid2)) |
1469 self.execute("SET X todo_by Y WHERE X is Note, Y eid %s" % ueid) |
1502 self.qexecute("SET X todo_by Y WHERE X is Note, Y eid %s" % ueid) |
1470 rset = self.execute('Any N WHERE N todo_by U, N is Note, U eid %s, N filed_under T, T eid %s' |
1503 rset = self.qexecute('Any N WHERE N todo_by U, N is Note, U eid %s, N filed_under T, T eid %s' |
1471 % (ueid, teid1)) |
1504 % (ueid, teid1)) |
1472 self.assertEqual(len(rset), 1) |
1505 self.assertEqual(len(rset), 1) |
1473 |
1506 |
1474 def test_nonregr_XXX(self): |
1507 def test_nonregr_XXX(self): |
1475 teid = self.execute('Transition S WHERE S name "deactivate"')[0][0] |
1508 teid = self.qexecute('Transition S WHERE S name "deactivate"')[0][0] |
1476 rset = self.execute('Any O WHERE O is State, ' |
1509 rset = self.qexecute('Any O WHERE O is State, ' |
1477 'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
1510 'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
1478 self.assertEqual(len(rset), 2) |
1511 self.assertEqual(len(rset), 2) |
1479 rset = self.execute('Any O WHERE O is State, NOT S destination_state O, ' |
1512 rset = self.qexecute('Any O WHERE O is State, NOT S destination_state O, ' |
1480 'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
1513 'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
1481 self.assertEqual(len(rset), 1) |
1514 self.assertEqual(len(rset), 1) |
1482 |
1515 |
1483 |
1516 |
1484 def test_nonregr_set_datetime(self): |
1517 def test_nonregr_set_datetime(self): |
1485 # huum, psycopg specific |
1518 # huum, psycopg specific |
1486 self.execute('SET X creation_date %(date)s WHERE X eid 1', {'date': date.today()}) |
1519 self.qexecute('SET X creation_date %(date)s WHERE X eid 1', {'date': date.today()}) |
1487 |
1520 |
1488 def test_nonregr_set_query(self): |
1521 def test_nonregr_set_query(self): |
1489 ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
1522 ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
1490 self.execute("SET E in_group G, E firstname %(firstname)s, E surname %(surname)s " |
1523 self.execute("SET E in_group G, E firstname %(firstname)s, E surname %(surname)s " |
1491 "WHERE E eid %(x)s, G name 'users'", |
1524 "WHERE E eid %(x)s, G name 'users'", |
1492 {'x':ueid, 'firstname': u'jean', 'surname': u'paul'}) |
1525 {'x':ueid, 'firstname': u'jean', 'surname': u'paul'}) |
1493 |
1526 |
1494 def test_nonregr_u_owned_by_u(self): |
1527 def test_nonregr_u_owned_by_u(self): |
1495 ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto', X in_group G " |
1528 ueid = self.qexecute("INSERT CWUser X: X login 'bob', X upassword 'toto', X in_group G " |
1496 "WHERE G name 'users'")[0][0] |
1529 "WHERE G name 'users'")[0][0] |
1497 rset = self.execute("CWUser U") |
1530 rset = self.qexecute("CWUser U") |
1498 self.assertEqual(len(rset), 3) # bob + admin + anon |
1531 self.assertEqual(len(rset), 3) # bob + admin + anon |
1499 rset = self.execute("Any U WHERE NOT U owned_by U") |
1532 rset = self.qexecute("Any U WHERE NOT U owned_by U") |
1500 self.assertEqual(len(rset), 0) # even admin created at repo initialization time should belong to itself |
1533 # even admin created at repo initialization time should belong to itself |
|
1534 self.assertEqual(len(rset), 0) |
1501 |
1535 |
1502 def test_nonreg_update_index(self): |
1536 def test_nonreg_update_index(self): |
1503 # this is the kind of queries generated by "cubicweb-ctl db-check -ry" |
1537 # this is the kind of queries generated by "cubicweb-ctl db-check -ry" |
1504 self.execute("SET X description D WHERE X is State, X description D") |
1538 self.qexecute("SET X description D WHERE X is State, X description D") |
1505 |
1539 |
1506 def test_nonregr_is(self): |
1540 def test_nonregr_is(self): |
1507 uteid = self.execute('Any ET WHERE ET name "CWUser"')[0][0] |
1541 uteid = self.qexecute('Any ET WHERE ET name "CWUser"')[0][0] |
1508 self.execute('Any X, ET WHERE X is ET, ET eid %s' % uteid) |
1542 self.qexecute('Any X, ET WHERE X is ET, ET eid %s' % uteid) |
1509 |
1543 |
1510 def test_nonregr_orderby(self): |
1544 def test_nonregr_orderby(self): |
1511 seid = self.execute('Any X WHERE X name "activated"')[0][0] |
1545 seid = self.qexecute('Any X WHERE X name "activated"')[0][0] |
1512 self.execute('Any X,S, MAX(T) GROUPBY X,S ORDERBY S WHERE X is CWUser, T tags X, S eid IN(%s), X in_state S' % seid) |
1546 self.qexecute('Any X,S, MAX(T) GROUPBY X,S ORDERBY S ' |
|
1547 'WHERE X is CWUser, T tags X, S eid IN(%s), X in_state S' % seid) |
1513 |
1548 |
1514 def test_nonregr_solution_cache(self): |
1549 def test_nonregr_solution_cache(self): |
1515 self.skipTest('XXX should be fixed or documented') # (doesn't occur if cache key is provided.) |
1550 self.skipTest('XXX should be fixed or documented') # (doesn't occur if cache key is provided.) |
1516 rset = self.execute('Any X WHERE X is CWUser, X eid %(x)s', {'x':self.ueid}) |
1551 rset = self.qexecute('Any X WHERE X is CWUser, X eid %(x)s', {'x':self.ueid}) |
1517 self.assertEqual(len(rset), 1) |
1552 self.assertEqual(len(rset), 1) |
1518 rset = self.execute('Any X WHERE X is CWUser, X eid %(x)s', {'x':12345}) |
1553 rset = self.qexecute('Any X WHERE X is CWUser, X eid %(x)s', {'x':12345}) |
1519 self.assertEqual(len(rset), 0) |
1554 self.assertEqual(len(rset), 0) |
1520 |
1555 |
1521 def test_nonregr_final_norestr(self): |
1556 def test_nonregr_final_norestr(self): |
1522 self.assertRaises(BadRQLQuery, self.execute, 'Date X') |
1557 self.assertRaises(BadRQLQuery, self.qexecute, 'Date X') |
1523 |
1558 |
1524 def test_nonregr_eid_cmp(self): |
1559 def test_nonregr_eid_cmp(self): |
1525 peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1560 peid1 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1526 peid2 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
1561 peid2 = self.qexecute("INSERT Personne X: X nom 'bidule'")[0][0] |
1527 rset = self.execute('Any X,Y WHERE X is Personne, Y is Personne, X nom XD, Y nom XD, X eid Z, Y eid > Z') |
1562 rset = self.qexecute('Any X,Y WHERE X is Personne, Y is Personne, ' |
|
1563 'X nom XD, Y nom XD, X eid Z, Y eid > Z') |
1528 self.assertEqual(rset.rows, [[peid1, peid2]]) |
1564 self.assertEqual(rset.rows, [[peid1, peid2]]) |
1529 rset = self.execute('Any X,Y WHERE X nom XD, Y nom XD, X eid Z, Y eid > Z') |
1565 rset = self.qexecute('Any X,Y WHERE X nom XD, Y nom XD, X eid Z, Y eid > Z') |
1530 self.assertEqual(rset.rows, [[peid1, peid2]]) |
1566 self.assertEqual(rset.rows, [[peid1, peid2]]) |
1531 |
1567 |
1532 def test_nonregr_has_text_ambiguity_1(self): |
1568 def test_nonregr_has_text_ambiguity_1(self): |
1533 peid = self.execute("INSERT CWUser X: X login 'bidule', X upassword 'bidule', X in_group G WHERE G name 'users'")[0][0] |
1569 peid = self.qexecute("INSERT CWUser X: X login 'bidule', X upassword 'bidule', " |
1534 aeid = self.execute("INSERT Affaire X: X ref 'bidule'")[0][0] |
1570 "X in_group G WHERE G name 'users'")[0][0] |
|
1571 aeid = self.qexecute("INSERT Affaire X: X ref 'bidule'")[0][0] |
1535 self.commit() |
1572 self.commit() |
1536 rset = self.execute('Any X WHERE X is CWUser, X has_text "bidule"') |
1573 rset = self.qexecute('Any X WHERE X is CWUser, X has_text "bidule"') |
1537 self.assertEqual(rset.rows, [[peid]]) |
1574 self.assertEqual(rset.rows, [[peid]]) |
1538 rset = self.execute('Any X WHERE X is CWUser, X has_text "bidule", X in_state S, S name SN') |
1575 rset = self.qexecute('Any X WHERE X is CWUser, X has_text "bidule", ' |
|
1576 'X in_state S, S name SN') |
1539 self.assertEqual(rset.rows, [[peid]]) |
1577 self.assertEqual(rset.rows, [[peid]]) |
1540 |
1578 |
1541 |
1579 |
1542 def test_nonregr_sql_cache(self): |
1580 def test_nonregr_sql_cache(self): |
1543 # different SQL generated when 'name' is None or not (IS NULL). |
1581 # different SQL generated when 'name' is None or not (IS NULL). |
1544 self.assertFalse(self.execute('Any X WHERE X is CWEType, X name %(name)s', {'name': None})) |
1582 self.assertFalse(self.qexecute('Any X WHERE X is CWEType, X name %(name)s', |
1545 self.assertTrue(self.execute('Any X WHERE X is CWEType, X name %(name)s', {'name': 'CWEType'})) |
1583 {'name': None})) |
|
1584 self.assertTrue(self.qexecute('Any X WHERE X is CWEType, X name %(name)s', |
|
1585 {'name': 'CWEType'})) |
1546 |
1586 |
1547 |
1587 |
1548 class NonRegressionTC(CubicWebTC): |
1588 class NonRegressionTC(CubicWebTC): |
1549 |
1589 |
1550 def test_has_text_security_cache_bug(self): |
1590 def test_has_text_security_cache_bug(self): |