← Back to branch summary

~free.ekanayaka/storm/any-expr

« back to all changes in this revision

Viewing changes to tests/expr.py

  • Committer: James Henstridge
  • Date: 2009-06-18 15:08:47 UTC
  • mto: This revision was merged to the branch mainline in revision 307.
  • Revision ID: james@jamesh.id.au-20090618150847-8sscruar5muycnth
Add a NEWS item about changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/expr.py
184
184
        expr = Like(elem1, elem2, elem3, False)
185
185
        self.assertEquals(expr.case_sensitive, False)
186
186
 
187
 
    def test_startswith(self):
188
 
        expr = Func1()
189
 
        self.assertRaises(ExprError, expr.startswith, "not a unicode string")
190
 
 
191
 
        like_expr = expr.startswith(u"abc!!_%")
192
 
        self.assertTrue(isinstance(like_expr, Like))
193
 
        self.assertTrue(like_expr.expr1 is expr)
194
 
        self.assertEquals(like_expr.expr2, u"abc!!!!!_!%%")
195
 
        self.assertEquals(like_expr.escape, u"!")
196
 
 
197
 
    def test_endswith(self):
198
 
        expr = Func1()
199
 
        self.assertRaises(ExprError, expr.startswith, "not a unicode string")
200
 
 
201
 
        like_expr = expr.endswith(u"abc!!_%")
202
 
        self.assertTrue(isinstance(like_expr, Like))
203
 
        self.assertTrue(like_expr.expr1 is expr)
204
 
        self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%")
205
 
        self.assertEquals(like_expr.escape, u"!")
206
 
 
207
 
    def test_contains_string(self):
208
 
        expr = Func1()
209
 
        self.assertRaises(
210
 
            ExprError, expr.contains_string, "not a unicode string")
211
 
 
212
 
        like_expr = expr.contains_string(u"abc!!_%")
213
 
        self.assertTrue(isinstance(like_expr, Like))
214
 
        self.assertTrue(like_expr.expr1 is expr)
215
 
        self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%%")
216
 
        self.assertEquals(like_expr.escape, u"!")
217
 
 
218
187
    def test_eq(self):
219
188
        expr = Eq(elem1, elem2)
220
189
        self.assertEquals(expr.expr1, elem1)
306
275
        self.assertEquals(expr.limit, 1)
307
276
        self.assertEquals(expr.offset, 2)
308
277
 
309
 
    def test_union_collapse(self):
310
 
        expr = Union(Union(elem1, elem2), elem3)
311
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
312
 
 
313
 
        # Only first expression is collapsed.
314
 
        expr = Union(elem1, Union(elem2, elem3))
315
 
        self.assertEquals(expr.exprs[0], elem1)
316
 
        self.assertTrue(isinstance(expr.exprs[1], Union))
317
 
 
318
 
        # Don't collapse if all is different.
319
 
        expr = Union(Union(elem1, elem2, all=True), elem3)
320
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
321
 
        expr = Union(Union(elem1, elem2), elem3, all=True)
322
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
323
 
        expr = Union(Union(elem1, elem2, all=True), elem3, all=True)
324
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
325
 
 
326
 
        # Don't collapse if limit or offset are set.
327
 
        expr = Union(Union(elem1, elem2, limit=1), elem3)
328
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
329
 
        expr = Union(Union(elem1, elem2, offset=3), elem3)
330
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
331
 
 
332
 
        # Don't collapse other set expressions.
333
 
        expr = Union(Except(elem1, elem2), elem3)
334
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
335
 
        expr = Union(Intersect(elem1, elem2), elem3)
336
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
337
 
 
338
278
    def test_except(self):
339
279
        expr = Except(elem1, elem2, elem3)
340
280
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
347
287
        self.assertEquals(expr.limit, 1)
348
288
        self.assertEquals(expr.offset, 2)
349
289
 
350
 
    def test_except_collapse(self):
351
 
        expr = Except(Except(elem1, elem2), elem3)
352
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
353
 
 
354
 
        # Only first expression is collapsed.
355
 
        expr = Except(elem1, Except(elem2, elem3))
356
 
        self.assertEquals(expr.exprs[0], elem1)
357
 
        self.assertTrue(isinstance(expr.exprs[1], Except))
358
 
 
359
 
        # Don't collapse if all is different.
360
 
        expr = Except(Except(elem1, elem2, all=True), elem3)
361
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
362
 
        expr = Except(Except(elem1, elem2), elem3, all=True)
363
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
364
 
        expr = Except(Except(elem1, elem2, all=True), elem3, all=True)
365
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
366
 
 
367
 
        # Don't collapse if limit or offset are set.
368
 
        expr = Except(Except(elem1, elem2, limit=1), elem3)
369
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
370
 
        expr = Except(Except(elem1, elem2, offset=3), elem3)
371
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
372
 
 
373
 
        # Don't collapse other set expressions.
374
 
        expr = Except(Union(elem1, elem2), elem3)
375
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
376
 
        expr = Except(Intersect(elem1, elem2), elem3)
377
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
378
 
 
379
290
    def test_intersect(self):
380
291
        expr = Intersect(elem1, elem2, elem3)
381
292
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
389
300
        self.assertEquals(expr.limit, 1)
390
301
        self.assertEquals(expr.offset, 2)
391
302
 
392
 
    def test_intersect_collapse(self):
393
 
        expr = Intersect(Intersect(elem1, elem2), elem3)
394
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
395
 
 
396
 
        # Only first expression is collapsed.
397
 
        expr = Intersect(elem1, Intersect(elem2, elem3))
398
 
        self.assertEquals(expr.exprs[0], elem1)
399
 
        self.assertTrue(isinstance(expr.exprs[1], Intersect))
400
 
 
401
 
        # Don't collapse if all is different.
402
 
        expr = Intersect(Intersect(elem1, elem2, all=True), elem3)
403
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
404
 
        expr = Intersect(Intersect(elem1, elem2), elem3, all=True)
405
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
406
 
        expr = Intersect(Intersect(elem1, elem2, all=True), elem3, all=True)
407
 
        self.assertEquals(expr.exprs, (elem1, elem2, elem3))
408
 
 
409
 
        # Don't collapse if limit or offset are set.
410
 
        expr = Intersect(Intersect(elem1, elem2, limit=1), elem3)
411
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
412
 
        expr = Intersect(Intersect(elem1, elem2, offset=3), elem3)
413
 
        self.assertTrue(isinstance(expr.exprs[0], Intersect))
414
 
 
415
 
        # Don't collapse other set expressions.
416
 
        expr = Intersect(Union(elem1, elem2), elem3)
417
 
        self.assertTrue(isinstance(expr.exprs[0], Union))
418
 
        expr = Intersect(Except(elem1, elem2), elem3)
419
 
        self.assertTrue(isinstance(expr.exprs[0], Except))
420
 
 
421
303
    def test_auto_tables(self):
422
304
        expr = AutoTables(elem1, [elem2])
423
305
        self.assertEquals(expr.expr, elem1)
1434
1316
        self.assertEquals(statement, "UPPER(func1())")
1435
1317
        self.assertEquals(state.parameters, [])
1436
1318
 
1437
 
    def test_coalesce(self):
1438
 
        expr = Coalesce(Func1())
1439
 
        state = State()
1440
 
        statement = compile(expr, state)
1441
 
        self.assertEquals(statement, "COALESCE(func1())")
1442
 
        self.assertEquals(state.parameters, [])
1443
 
 
1444
 
    def test_coalesce_with_many_arguments(self):
1445
 
        expr = Coalesce(Func1(), Func2(), None)
1446
 
        state = State()
1447
 
        statement = compile(expr, state)
1448
 
        self.assertEquals(statement, "COALESCE(func1(), func2(), NULL)")
1449
 
        self.assertEquals(state.parameters, [])
1450
 
 
1451
 
    def test_any(self):
1452
 
        expr = Any(Func1())
1453
 
        state = State()
1454
 
        statement = compile(expr, state)
1455
 
        self.assertEquals(statement, "ANY(func1())")
1456
 
        self.assertEquals(state.parameters, [])
1457
 
 
1458
1319
    def test_not(self):
1459
1320
        expr = Not(Func1())
1460
1321
        state = State()
1469
1330
        self.assertEquals(statement, "EXISTS func1()")
1470
1331
        self.assertEquals(state.parameters, [])
1471
1332
 
1472
 
    def test_neg(self):
1473
 
        expr = Neg(Func1())
1474
 
        state = State()
1475
 
        statement = compile(expr, state)
1476
 
        self.assertEquals(statement, "- func1()")
1477
 
        self.assertEquals(state.parameters, [])
1478
 
 
1479
 
        expr = -Func1()
1480
 
        state = State()
1481
 
        statement = compile(expr, state)
1482
 
        self.assertEquals(statement, "- func1()")
1483
 
        self.assertEquals(state.parameters, [])
1484
 
 
1485
1333
    def test_asc(self):
1486
1334
        expr = Asc(Func1())
1487
1335
        state = State()
2259
2107
        py_expr = compile_python(expr)
2260
2108
        self.assertEquals(py_expr, "elem1+elem2+elem3+elem4")
2261
2109
 
2262
 
    def test_neg(self):
2263
 
        expr = Neg(elem1)
2264
 
        py_expr = compile_python(expr)
2265
 
        self.assertEquals(py_expr, "-elem1")
2266
 
 
2267
2110
    def test_sub(self):
2268
2111
        expr = Sub(elem1, Sub(elem2, elem3))
2269
2112
        py_expr = compile_python(expr)