[Zope-CVS] CVS: Packages/pypes/pypes/tests - test_expression.py:1.13
Casey Duncan
casey at zope.com
Thu Jul 1 23:14:22 EDT 2004
Update of /cvs-repository/Packages/pypes/pypes/tests
In directory cvs.zope.org:/tmp/cvs-serv16938/tests
Modified Files:
test_expression.py
Log Message:
Add criteria and sort expressions for queries
=== Packages/pypes/pypes/tests/test_expression.py 1.12 => 1.13 ===
--- Packages/pypes/pypes/tests/test_expression.py:1.12 Tue May 11 23:58:41 2004
+++ Packages/pypes/pypes/tests/test_expression.py Thu Jul 1 23:14:21 2004
@@ -22,33 +22,36 @@
from zope.interface.verify import verifyObject
from pypes.tests.common import sort
from pypes.expression import Expression, nodesEqual
+from pypes.expression import Criteria, Asc, Desc
from pypes.exceptions import PypesError
class TestExpression(unittest.TestCase):
"""Blackbox expression tests"""
+ expr_factory = Expression
+
def testInterface(self):
from pypes.interfaces import IExpression
- self.failUnless(verifyObject(IExpression, Expression('x')))
+ self.failUnless(verifyObject(IExpression, self.expr_factory('x')))
def testExprFromAst(self):
# Test alternate constructor
ast = parse('sin(1 / x)', mode='eval')
- e = Expression.fromAstNode(ast, {})
+ e = self.expr_factory.fromAstNode(ast, {})
self.assertEqual(e.names(), Set(['sin', 'x']))
self.failUnless(e.ast() is ast)
def testExprParses(self):
- Expression('x')
- self.assertRaises(SyntaxError, Expression, 'beautiful me')
+ self.expr_factory('x')
+ self.assertRaises(SyntaxError, self.expr_factory, 'beautiful me')
def testExprStrAndRepr(self):
s = 'yum + yum'
- self.assertEqual(str(Expression(s)), "Expression('%s')" % s)
- self.assertEqual(repr(Expression(s)), "Expression('%s')" % s)
+ self.assertEqual(str(self.expr_factory(s)), "Expression('%s')" % s)
+ self.assertEqual(repr(self.expr_factory(s)), "Expression('%s')" % s)
def testExprWithStatementsRaises(self):
- self.assertRaises(SyntaxError, Expression, 'def x(): pass')
+ self.assertRaises(SyntaxError, self.expr_factory, 'def x(): pass')
def testExprNames(self):
e = Expression('Yodel.a["hee"] == str(hoo)')
@@ -56,27 +59,28 @@
def testExprBindings(self):
ns = {'a': 2, 'b': 'juju'}
- e = Expression('x == a and y == b', ns)
+ e = self.expr_factory('x == a and y == b', ns)
self.assertEqual(e.bindings(), ns)
- e = Expression('x > y')
+ e = self.expr_factory('x > y')
self.assertEqual(e.bindings(), {})
def testExprFreeNames(self):
- e = Expression('Yodel.a["hee"] == str(hoo)')
+ e = self.expr_factory('Yodel.a["hee"] == str(hoo)')
self.assertEqual(e.freeNames(), Set(['Yodel', 'hoo']))
self.assertEqual(e.freeNames(['str']), Set(['Yodel', 'hoo', 'str']))
def testExprOneName(self):
- e = Expression('x')
+ e = self.expr_factory('x')
self.assertEqual(e.names(), Set(['x']))
def testExprOneFreeName(self):
- e = Expression('x')
+ e = self.expr_factory('x')
self.assertEqual(e.freeNames(), Set(['x']))
def testExprFreeOperands(self):
- e = Expression('x.foo == 1 and y or len(z) in (2,3) and (x == y) < 1',
- {'z':('a','b')})
+ e = self.expr_factory(
+ 'x.foo == 1 and y or len(z) in (2,3) and (x == y) < 1',
+ {'z':('a','b')})
free = e.freeOperands()
self.assertEqual(len(free), 3)
self.assertEqual(free[0].names(), free[0].freeNames(), Set(['x']))
@@ -84,13 +88,13 @@
self.assertEqual(free[2].names(), free[2].freeNames(), Set(['x', 'y']))
def testExprCall(self):
- e = Expression('x == 1 and y > x', {'y':2})
+ e = self.expr_factory('x == 1 and y > x', {'y':2})
self.failUnless(e({'x':1}))
self.failIf(e({'x':2}))
self.failIf(e({'x':1, 'y':1}))
def testExprCallRaises(self):
- e = Expression('len(d) > 5')
+ e = self.expr_factory('len(d) > 5')
d = []
self.assertRaises(NameError, e)
@@ -101,61 +105,73 @@
self.failIf(nodesEqual(e1, e2))
def testOptimizeSimple(self):
- e = Expression('x*z - y < z', {'x':5, 'z':7})
+ e = self.expr_factory('x*z - y < z', {'x':5, 'z':7})
e.optimize()
opt_tree = parse('35 - y < 7', mode='eval')
self.failUnless(nodesEqual(e._tree, opt_tree))
def testOptimizeOr(self):
- e = Expression('len(y) > 1 or x > y', {'y':'somethin'})
+ e = self.expr_factory('len(y) > 1 or x > y', {'y':'somethin'})
e.optimize()
self.failUnless(nodesEqual(e._tree, ast.Expression(ast.Const(True))))
- e = Expression('x > y or len(y) > 1', {'y':'somethin'})
+ e = self.expr_factory('x > y or len(y) > 1', {'y':'somethin'})
e.optimize()
self.failUnless(nodesEqual(e._tree, ast.Expression(ast.Const(True))))
def testOptimizeAnd(self):
- e = Expression('len(y) < 5 and x > y', {'y':'nothin'})
+ e = self.expr_factory('len(y) < 5 and x > y', {'y':'nothin'})
e.optimize()
self.failUnless(nodesEqual(e._tree, ast.Expression(ast.Const(False))))
- e = Expression('x > y and len(y) < 5', {'y':'nothin'})
+ e = self.expr_factory('x > y and len(y) < 5', {'y':'nothin'})
e.optimize()
self.failUnless(nodesEqual(e._tree, ast.Expression(ast.Const(False))))
def testOptimizeFreeNames(self):
- e = Expression('x < y and x > z', {'x':2, 'y':3, 'z':0})
+ e = self.expr_factory('x < y and x > z', {'x':2, 'y':3, 'z':0})
e.optimize(free_names=['x', 'z'])
opt_tree = parse('x < 3 and x > z', mode='eval')
self.failUnless(e._tree, opt_tree)
def testEquals(self):
- self.assertEqual(Expression('x < y'), Expression('x < y'))
- self.assertEqual(Expression('x < y', {'x':1}),
- Expression('x < y', {'x':1}))
- e = Expression('a**2 + b**2 == c**2')
+ self.assertEqual(self.expr_factory('x < y'),
+ self.expr_factory('x < y'))
+ self.assertEqual(self.expr_factory('x < y', {'x':1}),
+ self.expr_factory('x < y', {'x':1}))
+ e = self.expr_factory('a**2 + b**2 == c**2')
self.assertEqual(e, e)
- self.assertNotEqual(Expression('x < y', {'x':1}),
- Expression('x < y', {'x':2}))
- self.assertNotEqual(Expression('x < y'), Expression('x > y'))
- self.assertNotEqual(Expression('x < y', {'x':1}),
- Expression('x > y', {'x':1}))
- self.assertNotEqual(Expression('x < y', {'x':1}),
- Expression('x > y', {'y':1}))
+ self.assertNotEqual(self.expr_factory('x < y', {'x':1}),
+ self.expr_factory('x < y', {'x':2}))
+ self.assertNotEqual(self.expr_factory('x < y'),
+ self.expr_factory('x > y'))
+ self.assertNotEqual(self.expr_factory('x < y', {'x':1}),
+ self.expr_factory('x > y', {'x':1}))
+ self.assertNotEqual(self.expr_factory('x < y', {'x':1}),
+ self.expr_factory('x > y', {'y':1}))
def testOr(self):
- e = Expression('x > 1') | Expression('y < 2')
- self.assertEqual(e, Expression('x > 1 or y < 2'))
+ e = self.expr_factory('x > 1') | self.expr_factory('y < 2')
+ self.assertEqual(e, self.expr_factory('x > 1 or y < 2'))
+
+ def testAndSameNamespace(self):
+ e1 = self.expr_factory('x == 2', {'x':2, 'y':5})
+ e2 = self.expr_factory('y > 5', {'x':2, 'y':5})
+ self.assertEqual(
+ e1 | e2, self.expr_factory('x == 2 or y > 5', {'x':2, 'y':5}))
+
+ def testOrDifferentNamespace(self):
+ e = (self.expr_factory('x > z', {'z':3})
+ | self.expr_factory('y < w',{'y':-1}))
+ self.assertEqual(e, self.expr_factory('x > z or y < w', {'z':3, 'y':-1}))
- def testOrWithNamespace(self):
- e = Expression('x > z', {'z':3}) | Expression('y < w',{'y':-1})
- self.assertEqual(e, Expression('x > z or y < w', {'z':3, 'y':-1}))
+ def testOrIncompatibleNamespaces(self):
self.assertRaises(PypesError, operator.or_,
- Expression('x > z', {'x':100}), Expression('y < x'))
+ self.expr_factory('x > z', {'x':100}), self.expr_factory('y < x'))
self.assertRaises(PypesError, operator.or_,
- Expression('x > z', {'x':100}), Expression('y < x', {'x': 1}))
+ self.expr_factory('x > z', {'x':100}),
+ self.expr_factory('y < x', {'x': 1}))
def testOrCopiesAST(self):
- left, right = Expression('x > 1'), Expression('y < 2')
+ left, right = self.expr_factory('x > 1'), self.expr_factory('y < 2')
e = left | right
left = left.ast().getChildNodes()[0]
right = right.ast().getChildNodes()[0]
@@ -164,19 +180,32 @@
self.failIf(right is right2)
def testAnd(self):
- e = Expression('x > 1') & Expression('y < 2')
- self.assertEqual(e, Expression('x > 1 and y < 2'))
+ e = self.expr_factory('x > 1') & self.expr_factory('y < 2')
+ self.assertEqual(e, self.expr_factory('x > 1 and y < 2'))
+
+ def testAndSameNamespace(self):
+ e1 = self.expr_factory('x == 2', {'x':2, 'y':5})
+ e2 = self.expr_factory('y == 5', {'x':2, 'y':5})
+ e1_and_e2 = e1 & e2
+ self.assertEqual(
+ e1 & e2, self.expr_factory('x == 2 and y == 5', {'x':2, 'y':5}))
+
+ def testAndDifferentNamespaces(self):
+ e = (self.expr_factory('x > z', {'z':3})
+ & self.expr_factory('y < w',{'y':-1}))
+ self.assertEqual(
+ e, self.expr_factory('x > z and y < w', {'z':3, 'y':-1}))
- def testAndWithNamespace(self):
- e = Expression('x > z', {'z':3}) & Expression('y < w',{'y':-1})
- self.assertEqual(e, Expression('x > z and y < w', {'z':3, 'y':-1}))
+ def testAndIncompatibleNamespaces(self):
self.assertRaises(PypesError, operator.and_,
- Expression('x > z', {'x':100}), Expression('y < x'))
+ self.expr_factory('x > z', {'x':100}),
+ self.expr_factory('y < x'))
self.assertRaises(PypesError, operator.and_,
- Expression('x > z', {'x':100}), Expression('y < x', {'x': 1}))
+ self.expr_factory('x > z', {'x':100}),
+ self.expr_factory('y < x', {'x': 1}))
def testAndCopiesAST(self):
- left, right = Expression('x > 1'), Expression('y < 2')
+ left, right = self.expr_factory('x > 1'), self.expr_factory('y < 2')
e = left & right
left = left.ast().getChildNodes()[0]
right = right.ast().getChildNodes()[0]
@@ -185,14 +214,14 @@
self.failIf(right is right2)
def testMakeFunctionSimple(self):
- e = Expression('x < y')
+ e = self.expr_factory('x < y')
f = e.makeFunction(args=['x', 'y'])
self.failUnless(f(1, 2))
self.failIf(f(x=2, y=1))
self.assertRaises(TypeError, f, 5)
def testMakeFunctionWithBindings(self):
- e = Expression('z < len(foo)', {'foo': [1,2,3]})
+ e = self.expr_factory('z < len(foo)', {'foo': [1,2,3]})
f = e.makeFunction(args=['z'])
self.failUnless(f(1))
self.failIf(f(z=6))
@@ -207,6 +236,40 @@
self.failIf(e._bindings is ns)
del ns['lastweek']
self.assertEqual(e._bindings, ns)
+
+class TestCriteria(TestExpression):
+
+ expr_factory = Criteria
+
+ def test_frame_binding(self):
+ x = 1
+ y = 2
+ z = -1
+ e = self.expr_factory('y - x == 1')
+ self.assertEqual(e.bindings(), {'x': 1, 'y': 2})
+
+ def test_names_overrides_frame(self):
+ x = 10
+ e = self.expr_factory('x > 5', {'x': 4})
+ self.assertEqual(e.bindings(), {'x': 4})
+
+class TestAsc(TestCriteria):
+
+ expr_factory = Asc
+
+ def test_interface(self):
+ from pypes.interfaces import IOrderExpression
+ self.failUnless(verifyObject(IOrderExpression, self.expr_factory('x')))
+
+ def test_order_value(self):
+ self.assertEqual(self.expr_factory('x').order, 1)
+
+class TestDesc(TestAsc):
+
+ expr_factory = Desc
+
+ def test_order_value(self):
+ self.assertEqual(self.expr_factory('x').order, -1)
if __name__ == '__main__':
unittest.main()
More information about the Zope-CVS
mailing list