def test_ConstraintOperator_size(self):
"Test the ConstraintOperator class sizes."
obj = vv.ConstraintOperator('size>')
self.failUnless(obj.is_size() and obj.is_size_gt())
obj = vv.ConstraintOperator('size')
self.failUnless(obj.is_size() and obj.is_size_eq())
obj = vv.ConstraintOperator('size$')
self.failUnless(obj.is_size() and obj.is_variable())
def test_MongoClause(self):
"Test MongoClause class"
self.assertRaises(AssertionError, vv.MongoClause, None)
fld = vv.Field('foo')
op = vv.ConstraintOperator('>=')
cn = vv.Constraint(fld, op, 10)
obj = vv.MongoClause(cn)
self.assert_(obj.query_loc == vv.MongoClause.LOC_MAIN)
def test_Constraint(self):
"Test the Constraint class"
for f, o, v in ((None, None, None), (1, 2, 3), ('a', 'b', 'c')):
self.assertRaises(ValueError, vv.Constraint, f, o, v)
obj = vv.Constraint(vv.Field('foo'), vv.ConstraintOperator('>'), 10)
self.failIf(obj.passes(None)[0])
self.failIf(obj.passes('dude')[0])
self.failIf(obj.passes(10)[0])
self.failUnless(obj.passes(11)[0])
def test_ConstraintGroup(self):
"Test ConstraintGroup class"
CG = vv.ConstraintGroup
foobar = vv.Field('foo.bar/baz')
obj = CG(foobar)
self.failUnlessEqual(obj.has_array(), False)
self.failUnlessEqual(obj.get_conflicts(), [])
# add constraint
op, val = vv.ConstraintOperator('>'), 10
obj.add_constraint(op, val)
self.failUnlessEqual(obj.has_array(), True)
def test_MongoClause_where(self):
"Test MongoClause class for where"
fld = vv.Field('foo')
for suffix, where in zip(('$', '>', ''), (True, True, True)):
sz = 'size' + suffix
op = vv.ConstraintOperator(sz)
cn = vv.Constraint(fld, op, 10)
obj = vv.MongoClause(cn)
if where:
self.failUnlessEqual(obj.query_loc, vv.MongoClause.LOC_WHERE)
else:
self.failIfEqual(obj.query_loc, vv.MongoClause.LOC_WHERE)
def test_ConstraintGroup_exists(self):
"Test ConstraintGroup class, exists addition"
CG = vv.ConstraintGroup
foobar = vv.Field('foo.bar')
obj = CG(foobar)
op, val = vv.ConstraintOperator('>'), 10
obj.add_constraint(op, val)
obj.add_existence(rev=False)
# expect 1 constraint and auxiliary existence constraint
self.failUnless(len(obj.constraints) == 1)
self.failUnlessEqual(obj.constraints[0].op, op)
self.failUnlessEqual(obj.constraints[0].value, val)
self.failUnlessEqual(len(obj.existence_constraints), 1)
self.failUnless(obj.existence_constraints[0].op.is_exists())
self.failUnlessEqual(obj.existence_constraints[0].value, True)
def test_Projection(self):
"""Test Projection class
"""
# Empty
p = vv.Projection()
self.failUnlessEqual(p.to_mongo(), {})
# 1 field
p.add(vv.Field('one'))
expect = {'one': 1}
self.failUnlessEqual(p.to_mongo(), expect)
# 1 field with static size
szop = vv.ConstraintOperator(vv.ConstraintOperator.SIZE)
p.add(vv.Field('one'), szop, 10)
expect.update({'one': {'$slice': 11}})
self.failUnlessEqual(p.to_mongo(), expect)
# a field with variable size
szop = vv.ConstraintOperator(vv.ConstraintOperator.SIZE + '$')
p.add(vv.Field('two'), szop, 'foo')
expect.update({'two': 1, 'foo': 1})
self.failUnlessEqual(p.to_mongo(), expect)
# subfields
p = vv.Projection()
p.add(vv.Field('a/bee'))
self.failUnlessEqual(p.to_mongo(), {'a.bee': 1})
def test_ConstraintOperator_type(self):
"Test the ConstraintOperator class for types"
obj = vv.ConstraintOperator('type')
self.failUnless(obj.is_type())
def test_ConstraintOperator_rev(self):
"Test the ConstraintOperator class, reverse."
obj = vv.ConstraintOperator('=')
obj.reverse()
self.failUnless(obj.is_neq())
def test_ConstraintOperator_ineq(self):
"Test the ConstraintOperator class, inequalities."
for ineq in '<', '>', '>=', '<=':
obj = vv.ConstraintOperator('>')
self.failUnless(obj.is_inequality())
def test_ConstraintOperator_type(self):
"Test the ConstraintOperator class for types"
obj = vv.ConstraintOperator('type')
self.assertTrue(obj.is_type())
