def test_repr(self): # Check "no select" signature. query = Query(['label1']) regex = r"Query\(\[u?'label1'\]\)" self.assertRegex(repr(query), regex) # Check "no select" with keyword string. query = Query(['label1'], label2='x') regex = r"Query\(\[u?'label1'\], label2='x'\)" self.assertRegex(repr(query), regex) # Check "no select" 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 "select-provided" signature. select = Select([('A', 'B'), ('x', 1), ('y', 2), ('z', 3)]) query = Query(select, ['B']) short_repr = super(Select, 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_get_user_function(self): select = Select([['A', 'B'], ['x', 1], ['y', 2], ['z', 3]]) # Verify that "_user_function_dict" us empty. self.assertEqual(len(select._user_function_dict), 0, 'should be empty dict') # Get existing function. isodd = lambda x: x % 2 == 1 select._create_user_function(isodd) func_name = select._get_user_function(isodd) self.assertEqual(len(select._user_function_dict), 1) self.assertRegex(func_name, r'FUNC\d+') # Get new function. iseven = lambda x: x % 2 == 0 func_name = select._get_user_function(iseven) self.assertEqual(len(select._user_function_dict), 2, 'should be auto-created') self.assertRegex(func_name, r'FUNC\d+')
def test_build_where_clause(self): select = Select([['A', 'B'], ['x', 1], ['y', 2], ['z', 3]]) result = select._build_where_clause({'A': 'x'}) expected = ('A=?', ['x']) self.assertEqual(result, expected) result = select._build_where_clause({'A': set(['x', 'y'])}) self.assertEqual(len(result), 2) self.assertEqual(result[0], 'A IN (?, ?)') self.assertEqual(set(result[1]), set(['x', 'y'])) # User-defined function. userfunc = lambda x: len(x) == 1 result = select._build_where_clause({'A': userfunc}) self.assertEqual(len(result), 2) self.assertRegex(result[0], r'FUNC\d+\(A\)') self.assertEqual(result[1], []) # Predicate (a type) prev_len = len(select._user_function_dict) predicate = int result = select._build_where_clause({'A': predicate}) self.assertEqual(len(result), 2) self.assertRegex(result[0], r'FUNC\d+\(A\)') self.assertEqual(result[1], []) self.assertEqual(len(select._user_function_dict), prev_len + 1) # Predicate (a boolean) prev_len = len(select._user_function_dict) predicate = True result = select._build_where_clause({'A': predicate}) self.assertEqual(len(result), 2) self.assertRegex(result[0], r'FUNC\d+\(A\)') self.assertEqual(result[1], []) self.assertEqual(len(select._user_function_dict), prev_len + 1)
def test_iterate_single_result(self): """Single items should be wrapped as iterators when iterated over.""" select = Select([('A', 'B'), (1, 2), (1, 2)]) query = Query(select, ['B']).sum() self.assertEqual(list(query), [4])
def test_iterate_source(self): select = Select([('A', 'B'), (1, 2), (1, 2)]) query = Query(select, ['B']) self.assertEqual(list(query), [2, 2])
def test_Query(self): source = Select([('A', 'B'), ('x', 1), ('y', 2)]) query = source({'A': 'B'}).apply(lambda x: next(x)) normalized = _get_iteritems(query) self.assertEqual(list(normalized), [('x', 1), ('y', 2)])
def test_repr(self): data = [['A', 'B'], ['x', 100], ['y', 200]] # Empty select. select = Select() self.assertEqual(repr(select), '<Select (no data loaded)>') # Data-only (no args) select = Select(data) expected = "<Select [['A', 'B'], ['x', 100], ['y', 200]]>" self.assertEqual(repr(select), expected) # Data with args (args don't affect repr) iterable = iter(data) select = Select(iterable, 'foo', bar='baz') regex = '<Select <[a-z_]+ object at [^\n>]+>>' self.assertRegex(repr(select), regex) # Extended after instantiation. select = Select() select.load_data([['A', 'B'], ['z', 300]]) select.load_data([['A', 'B'], ['y', 200]]) select.load_data([['A', 'B'], ['x', 100]]) expected = ( "<Select (3 sources):\n" " [['A', 'B'], ['x', 100]]\n" " [['A', 'B'], ['y', 200]]\n" " [['A', 'B'], ['z', 300]]>" ) self.assertEqual(repr(select), expected) # Test long repr truncation. select = Select([ ['xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'], ['yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'], ]) self.assertEqual(len(repr(select)), 72) expected = "<Select [['xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'], ['yyyyyyyyyyyyy...yyyyy']]>" self.assertEqual(repr(select), expected)
def test_iterate(self): select = Select([('A', 'B'), (1, 2), (1, 2)]) self.assertEqual(list(select), [[1, 2], [1, 2]])
def setUp(self): self.select = Select([['A', 'B'], ['x', 1], ['y', 2]])
def test_fieldnames(self): expected = ['label1', 'label2', 'value'] self.assertEqual(self.select.fieldnames, expected) select = Select() # <- Empty select. self.assertEqual(select.fieldnames, [], msg='should be empty list')
def test_empty_select(self): select = Select()
def setUpClass(cls): cls.select = Select([['A', 'B', 'C'], ['x', 'foo', 20], ['x', 'foo', 30], ['y', 'foo', 10], ['y', 'bar', 20], ['z', 'bar', 10], ['z', 'bar', 10]])