def test_should_sniff_raise_exception(self):
invalid_call_args = [
(('type', 1), ), # Invalid type
]
for invalid_call_arg in invalid_call_args:
with self.assertRaises(InvalidOperator):
Operator.sniff(invalid_call_arg)
def _parse_expression(expression, order=None):
equations = []
if not order:
order = expression.keys()
for column in order:
operator, value = Operator.sniff(expression[column])
equations.append(OperatorParser(operator).parse(column, value))
return equations
def test_select_from_where(self):
"""Asserts Statement object Where"""
scenarios = [{
'expected': 'WHERE A == 1',
'elements': ('A == 1', )
}, {
'expected': 'WHERE A == 1',
'elements': (Ex({'A': 1}), )
}, {
'expected': 'WHERE A == 1',
'elements': (Ex({'A': op.equal(1)}), )
}, {
'expected': 'WHERE A > 1',
'elements': (Ex({'A': op.bigger(1)}), )
}, {
'expected': 'WHERE A >= 1',
'elements': (Ex({'A': op.bigger_or_equal(1)}), )
}, {
'expected': 'WHERE A < 1',
'elements': (Ex({'A': op.smaller(1)}), )
}, {
'expected': 'WHERE A <= 1',
'elements': (Ex({'A': op.smaller_or_equal(1)}), )
}, {
'expected': 'WHERE A <> 1',
'elements': (Ex({'A': op.different(1)}), )
}, {
'expected': 'WHERE DAY IN (20, 30, 40)',
'elements': (Ex({'DAY': [20, 30, 40]}), )
}, {
'expected': 'WHERE DAY IN (20, 30, 40)',
'elements': (Ex({'DAY': op.in_operator([20, 30, 40])}), )
}, {
'expected': 'WHERE DAY IN (\'20\', \'30\', \'40\')',
'elements': (Ex({'DAY': ['20', '30', '40']}), )
}, {
'expected':
'WHERE REFERENCE_DAY BETWEEN \'20170101\' AND \'20170731\'',
'elements':
('REFERENCE_DAY BETWEEN \'20170101\' AND \'20170731\'', )
}, {
'expected':
'WHERE REFERENCE_DAY BETWEEN \'20170701\' AND \'20170731\'',
'elements':
(Ex({'REFERENCE_DAY': op.between('20170701', '20170731')}), )
}, {
'expected': 'WHERE A == 1 OR B == 1',
'elements': ('A == 1 OR B == 1', )
}, {
'expected': 'WHERE (A == 1 OR B == 1)',
'elements': (ExOr({
'A': 1,
'B': 1
}, order=['A', 'B']), )
}, {
'expected':
'WHERE (A == 1 AND (B == 2 OR C == 3))',
'elements': (Ex(Ex({'A': 1}),
ExOr({
'B': 2,
'C': 3
}, order=['B', 'C'])), )
}, {
'expected': 'WHERE A == 1 AND B == 2',
'elements': (Ex({
'A': 1
}).add(Ex({'B': 2})), )
}, {
'expected': 'WHERE A == 1 AND B == 2',
'elements': (Ex({'A': 1}) + Ex({'B': 2}), )
}]
for scenario in scenarios:
elements = scenario['elements']
expected = scenario['expected']
statement = Where().add(*elements)
actual = statement.parse()
self.assertEqualQueries(expected, actual)
def test_should_sniff_operator(self):
scenarios = [
{
'expected': (
EQUAL_OPERATOR_STR,
1,
),
'call_args': Operator.equal(1)
},
{
'expected': (
BIGGER_OPERATOR_STR,
1,
),
'call_args': Operator.bigger(1)
},
{
'expected': (
BIGGER_OR_EQUAL_OPERATOR_STR,
1,
),
'call_args': Operator.bigger_or_equal(1)
},
{
'expected': (
SMALLER_OPERATOR_STR,
1,
),
'call_args': Operator.smaller(1)
},
{
'expected': (
SMALLER_OR_EQUAL_OPERATOR_STR,
1,
),
'call_args': Operator.smaller_or_equal(1)
},
{
'expected': (
DIFFERENT_OPERATOR_STR,
1,
),
'call_args': Operator.different(1)
},
{
'expected': (
IN_OPERATOR_STR,
[1, 2, 3],
),
'call_args': Operator.in_operator(1, 2, 3)
},
{
'expected': (
IN_OPERATOR_STR,
[1, 2, 3],
),
'call_args': Operator.in_operator([1, 2, 3])
},
{
'expected': (
LIKE_OPERATOR_STR,
'%WORKA%',
),
'call_args': Operator.like('%WORKA%')
},
{
'expected': (
BETWEEN_OPERATOR_STR,
(
'20170701',
'20170731',
),
),
'call_args': Operator.between('20170701', '20170731')
},
]
for scenario in scenarios:
expected = scenario['expected']
call_args = scenario['call_args']
actual = Operator.sniff(call_args)
self.assertEqual(expected, actual)
def test_should_sniff_tuple(self):
expected = IN_OPERATOR_STR, [1, 2]
actual = Operator().sniff(1, 2)
self.assertEqual(expected, actual)
def test_should_sniff_single_argument(self):
expected = EQUAL_OPERATOR_STR, 1
actual = Operator().sniff(1)
self.assertEqual(expected, actual)
def test_in_operator_list_provided(self):
expected = IN_OPERATOR_STR, ['BRAZIL', 'NETHERLANDS', 'FINLAND']
actual = Operator.in_operator(['BRAZIL', 'NETHERLANDS', 'FINLAND'])
self.assertEqual(expected, actual)
def test_in_operator_single_element_provided(self):
expected = IN_OPERATOR_STR, ['BRAZIL']
actual = Operator.in_operator('BRAZIL')
self.assertEqual(expected, actual)
def test_between_operator(self):
expected = BETWEEN_OPERATOR_STR, ('20170701', '20170731')
actual = Operator.between('20170701', '20170731')
self.assertEqual(expected, actual)
def test_equal_operator(self):
expected = EQUAL_OPERATOR_STR, 'Uberaba'
actual = Operator.equal('Uberaba')
self.assertEqual(expected, actual)
def test_like_operator(self):
expected = LIKE_OPERATOR_STR, '%WORKER%'
actual = Operator.like('%WORKER%')
self.assertEqual(expected, actual)