def test_combination_inverted(self):
c = ~((C('foo') == 'bar') & (C('bar') > 5))
ast = c.get_ast()
self.assertEqual(
ast, {
'name': 'not',
'val': {
'name':
'join_and',
'val': [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_gt',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 5
}]
}]
}
})
def test_property_xor(self):
c = (C('foo') == 'bar') ^ (C('bar') > 5)
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'join_xor',
'val': [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_gt',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 5
}]
}]
})
def test_complex_condition(self):
c1 = (C('foo') == 'bar') & (C('bar') > 5)
c2 = (C('foo') == 'bar') & (C('bar') > 5)
c = c1 & c2
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'join_and',
'val': [{
'name':
'join_and',
'val': [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_gt',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 5
}]
}]
}, {
'name':
'join_and',
'val': [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_gt',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 5
}]
}]
}]
})
def test_query_get_one(self):
expected = {'foo': 'bar'}
attrs = {
'find_elements.return_value': [expected]
}
self.feature.configure_mock(**attrs)
result = self.query.all().get(C('foo'))
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'get',
'val': {
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
}
}
])
def test_query_get_none(self):
attrs = {
'find_elements.return_value': []
}
self.feature.configure_mock(**attrs)
result = self.query.all().get(C('foo'))
self.assertIsNone(result)
self.feature.find_elements.assert_called_with([
{
'name': 'get',
'val': {
'name': 'cond_exists',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': True
}
]
}
}
])
def test_query_count(self):
attrs = {
'count_elements.return_value': 3
}
self.feature.configure_mock(**attrs)
result = self.query.all().filter(C('foo') == 'bar').count()
self.assertEqual(result, 3)
self.feature.count_elements.assert_called_with([{
'name': 'filter',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}])
def _get_filter(self):
"""
Convert data to filter matching the data.
:returns: Filter
:rtype: C or CombinedCondition
"""
condition = None
for key, val in iteritems(self.data):
if condition is None:
condition = C(key) == val
else:
condition = condition & (C(key) == val)
return condition
def test_property_andor(self):
c = ((C('foo') == 'bar') & (C('bar') > 5)) | (~C('baz'))
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'join_or',
'val': [{
'name':
'join_and',
'val': [{
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
}, {
'name':
'cond_gt',
'val': [{
'name': 'prop',
'val': 'bar'
}, {
'name': 'val',
'val': 5
}]
}]
}, {
'name':
'cond_exists',
'val': [{
'name': 'prop',
'val': 'baz'
}, {
'name': 'val',
'val': False
}]
}]
})
def test_in_condition(self):
c = C('prop1') == E('prop2')
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'prop1'
}, {
'name': 'ref',
'val': 'prop2'
}]
})
c = C('prop1') == (E('prop2') + E('prop3'))
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'prop1'
}, {
'name':
'op_add',
'val': [{
'name': 'ref',
'val': 'prop2'
}, {
'name': 'ref',
'val': 'prop3'
}]
}]
})
def test_property_greater_than_or_equal(self):
c = C('i') >= 5
ast = c.get_ast()
self.assertEqual(
ast, {
'name': 'cond_gte',
'val': [{
'name': 'prop',
'val': 'i'
}, {
'name': 'val',
'val': 5
}]
})
def test_property_less_than(self):
c = C('i') < 5
ast = c.get_ast()
self.assertEqual(
ast, {
'name': 'cond_lt',
'val': [{
'name': 'prop',
'val': 'i'
}, {
'name': 'val',
'val': 5
}]
})
def test_property_exists(self):
c = C('prop')
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'cond_exists',
'val': [{
'name': 'prop',
'val': 'prop'
}, {
'name': 'val',
'val': True
}]
})
def test_property_equal(self):
c = C('foo') == 'bar'
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'cond_eq',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': 'bar'
}]
})
def test_property_like(self):
c = C('foo') % r'bar.*'
ast = c.get_ast()
self.assertEqual(
ast, {
'name':
'cond_like',
'val': [{
'name': 'prop',
'val': 'foo'
}, {
'name': 'val',
'val': r'bar.*'
}]
})
def test_to_ast(self):
expected = [
{
'name': 'filter',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}
]
q = self.query.all().filter(C('foo') == 'bar')
self.assertEqual(q.to_ast(), expected)
def test_query_exclude(self):
expected = [
{'_id': 'some id 1', 'foo': 'baz'},
{'_id': 'some id 2', 'foo': 'baz'},
{'_id': 'some id 3', 'foo': 'baz'}
]
attrs = {
'find_elements.return_value': expected
}
self.feature.configure_mock(**attrs)
result = self.query.all().exclude(C('foo') == 'bar')
self.assertIsInstance(result, Query)
result = list(result)
self.assertEqual(result, expected)
self.feature.find_elements.assert_called_with([
{
'name': 'exclude',
'val': {
'name': 'cond_eq',
'val': [
{
'name': 'prop',
'val': 'foo'
},
{
'name': 'val',
'val': 'bar'
}
]
}
}
])
def test_wrong_combination(self):
with self.assertRaises(TypeError):
C('foo') & 5