def test_init_from_object(self):
query1 = Query.from_object([1, 3, 4, 2])
self.assertEqual(query1.source, [1, 3, 4, 2])
self.assertEqual(query1.args, ())
self.assertEqual(query1.kwds, {})
self.assertEqual(query1._query_steps, [])
query2 = Query.from_object({'a': 1, 'b': 2})
self.assertEqual(query2.source, {'a': 1, 'b': 2})
self.assertEqual(query2.args, ())
self.assertEqual(query2.kwds, {})
self.assertEqual(query2._query_steps, [])
# When from_object() receives a Query, it should return
# a copy rather than trying to use it as a data object.
query3 = Query.from_object(query2)
self.assertIsNot(query3, query2)
self.assertEqual(query3.source, {'a': 1, 'b': 2})
self.assertEqual(query3.args, ())
self.assertEqual(query3.kwds, {})
self.assertEqual(query3._query_steps, [])
query4 = Query.from_object('abc')
self.assertEqual(query4.source, ['abc'], msg=\
'Strings or non-iterables should be wrapped as a list')
self.assertEqual(query4.args, ())
self.assertEqual(query4.kwds, {})
self.assertEqual(query4._query_steps, [])
query5 = Query.from_object(123)
self.assertEqual(query5.source, [123], msg=\
'Strings or non-iterables should be wrapped as a list')
self.assertEqual(query5.args, ())
self.assertEqual(query5.kwds, {})
self.assertEqual(query5._query_steps, [])
def test_fuzzy_method(self):
data = {'A': 'aaa', 'B': 'bbx'}
requirement = Query.from_object({'A': 'aaa', 'B': 'bbb'})
validate.fuzzy(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = {'A': 'axx', 'B': 'bbx'}
requirement = Query.from_object({'A': 'aaa', 'B': 'bbb'})
validate.fuzzy(data, requirement)
actual = cm.exception.differences
expected = {'A': Invalid('axx', expected='aaa')}
self.assertEqual(actual, expected)
def test_predicate_regex(self):
data = {'A': 'Alpha', 'B': ['Beta', 'Gamma']}
requirement = Query.from_object({'A': r'^[A-Z]', 'B': r'^[A-Z]'})
validate.regex(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = {'A': 'Alpha', 'B': ['Beta', 'gamma'], 'C': ('b', 2)}
requirement = Query.from_object({
'A': r'^[A-Z]',
'B': r'^[A-Z]',
'C': r'\d'
})
validate.regex(data, requirement)
actual = cm.exception.differences
expected = {
'B': [Invalid('gamma')],
'C': Invalid(('b', 2), expected=r'\d'),
}
self.assertEqual(actual, expected)
def test_approx_method(self):
data = {'A': 5.00000001, 'B': 10.00000001}
requirement = Query.from_object({'A': 5, 'B': 10})
validate.approx(data, requirement)
data = [5.00000001, 10.00000001]
requirement = Query.from_object([5, 10])
validate.approx(data, requirement)
data = {'A': [5.00000001, 10.00000001], 'B': [5.00000001, 10.00000001]}
requirement = Query.from_object({'A': [5, 10], 'B': [5, 10]})
validate.approx(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = {'A': 3, 'B': 10.00000001}
requirement = {'A': 5, 'B': 10}
validate.approx(data, requirement)
actual = cm.exception.differences
expected = {'A': Deviation(-2, 5)}
self.assertEqual(actual, expected)
def test_superset_method(self):
data = [1, 2, 3]
superset = Query.from_object([1, 2, 3, 4])
validate.superset(data, superset)
with self.assertRaises(ValidationError) as cm:
data = {'A': [1, 2, 3], 'B': [3, 4, 5]}
superset = {'A': set([1, 2, 3]), 'B': set([2, 3, 4])}
validate.superset(data, superset)
actual = cm.exception.differences
expected = {'B': [Extra(5)]}
self.assertEqual(actual, expected)
def test_predicate_method(self):
data = {'A': 'aaa', 'B': [1, 2, 3], 'C': ('a', 1)}
requirement = Query.from_object({
'A': set(['aaa', 'bbb']),
'B': int,
'C': ('a', 1)
})
validate.predicate(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = {'A': 'aaa', 'B': [1, 2, 3.5], 'C': ('b', 2)}
requirement = Query.from_object({
'A': set(['aaa', 'bbb']),
'B': int,
'C': ('a', 1)
})
validate.predicate(data, requirement)
actual = cm.exception.differences
expected = {
'B': [Invalid(3.5)],
'C': Invalid(('b', 2), expected=('a', 1)),
}
self.assertEqual(actual, expected)
def test_order_method(self):
data = ['A', 'B', 'C', 'C']
requirement = iter(['A', 'B', 'C', 'C'])
validate.order(data, requirement)
data = ['A', 'B', 'C', 'D']
requirement = Query.from_object(['A', 'B', 'C', 'D'])
validate.order(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = ['A', 'C', 'D', 'F']
requirement = Query.from_object(iter(['A', 'B', 'C', 'D']))
validate.order(data, requirement)
actual = cm.exception.differences
expected = [Missing((1, 'B')), Extra((3, 'F'))]
self.assertEqual(actual, expected)
with self.assertRaises(ValidationError) as cm:
data = {'x': ['A'], 'y': ['B', 'C', 'D']}
requirement = Query.from_object({'x': ['A', 'B'], 'y': ['C', 'D']})
validate.order(data, requirement)
actual = cm.exception.differences
expected = {'x': [Missing((1, 'B'))], 'y': [Extra((0, 'B'))]}
self.assertEqual(actual, expected)
def test_repr(self):
# Check "no selector" signature.
query = Query(['label1'])
regex = r"Query\(\[u?'label1'\]\)"
self.assertRegex(repr(query), regex)
# Check "no selector" with keyword string.
query = Query(['label1'], label2='x')
regex = r"Query\(\[u?'label1'\], label2='x'\)"
self.assertRegex(repr(query), regex)
# Check "no selector" with keyword list.
query = Query(['label1'], label2=['x', 'y'])
regex = r"Query\(\[u?'label1'\], label2=\[u?'x', u?'y'\]\)"
self.assertRegex(repr(query), regex)
# Check "selector-provided" signature.
select = Selector([('A', 'B'), ('x', 1), ('y', 2), ('z', 3)])
query = Query(select, ['B'])
short_repr = super(Selector, select).__repr__()
expected = "Query({0}, {1!r})".format(short_repr, ['B'])
#print(repr(query))
self.assertEqual(repr(query), expected)
# Check "from_object" signature.
query = Query.from_object([1, 2, 3])
expected = "Query.from_object([1, 2, 3])"
self.assertEqual(repr(query), expected)
# Check query steps.
query = Query(['label1']).distinct().count()
regex = r"Query\(\[u?'label1'\]\).distinct\(\).count\(\)"
self.assertRegex(repr(query), regex)
# Check query steps with function argument.
def upper(x):
return str(x.upper())
query = Query(['label1']).map(upper)
regex = r"Query\(\[u?'label1'\]\).map\(upper\)"
self.assertRegex(repr(query), regex)
# Check query steps with lambda argument.
lower = lambda x: str(x).lower()
query = Query(['label1']).map(lower)
regex = r"Query\(\[u?'label1'\]\).map\(<lambda>\)"
self.assertRegex(repr(query), regex)
def test_set_method(self):
data = [1, 2, 3, 4]
requirement = Query.from_object([1, 2, 3, 4])
validate.set(data, requirement)
with self.assertRaises(ValidationError) as cm:
data = [1, 2, 3, 5]
requirement = set([1, 2, 3, 4])
validate.set(data, requirement)
actual = cm.exception.differences
expected = [Missing(4), Extra(5)]
self.assertEqual(actual, expected)
with self.assertRaises(ValidationError) as cm:
data = {'A': [1, 2, 3], 'B': [3]}
requirement = {'A': iter([1, 2]), 'B': iter([3, 4])}
validate.set(data, requirement)
actual = cm.exception.differences
expected = {'A': [Extra(3)], 'B': [Missing(4)]}
self.assertEqual(actual, expected)
def test_execute_other_source(self):
query = Query.from_object([1, 3, 4, 2])
result = query.execute()
self.assertIsInstance(result, Result)
self.assertEqual(result.fetch(), [1, 3, 4, 2])