def test_ordered(self):
data = ("one", "two", "three", "opq")
ret = Q(data)\
.group_by_ordered(lambda x: x[0])\
.select(lambda x: (x.key, Q(x.items).to_tuple()))\
.to_list()
self.assertSequenceEqual([('o', ('one', )), ('t', ('two', 'three')),
('o', ('opq', ))], ret)
def test_unordered(self):
data = ("one", "two", "three", "opq")
ret = Q(data)\
.group_by(lambda x: x[0])\
.select(lambda x: (x.key, Q(x.items).to_tuple()))\
.to_set()
self.assertSetEqual({('o', ('one', 'opq')), ('t', ('two', 'three'))},
ret)
def test_union(self):
data1 = [1, 2, 3, 4]
data2 = [3, 4, 5, 6, 7]
ret = Q(data1).union(data2).to_set()
self.assertSetEqual({1, 2, 3, 4, 5, 6, 7}, ret)
def test_generator(self):
data = (i for i in range(10))
ret = Q(data).to_list()
self.assertIsInstance(ret, list)
self.assertSequenceEqual(list(range(10)), ret)
def test_intersection(self):
data1 = [1, 2, 3, 4]
data2 = [3, 4, 5, 6, 7]
ret = Q(data1).intersect(data2).to_set()
self.assertSetEqual({3, 4}, ret)
def test_max_length(self):
data = (i for i in range(100))
ret = Q(data).to_deque(5)
self.assertIsInstance(ret, deque)
self.assertSequenceEqual([95, 96, 97, 98, 99], ret)
def test_difference(self):
data1 = [1, 2, 3, 4]
data2 = [3, 4, 5, 6, 7]
ret = Q(data1).except_(data2).to_set()
self.assertSetEqual({1, 2}, ret)
def sort_by_multiple_with_different_orders(self):
data = [1, 2, 5, 3, 8, -5]
ret = Q(data)\
.sort_by(lambda x: x%2)\
.then_by_desc(lambda x: x)\
.to_list()
self.assertSequenceEqual([8, 2, 5, 3, 1, -5], ret)
def sort_by_multiple(self):
data = [1, 2, 5, 3, 8, -5]
ret = Q(data)\
.sort_by(lambda x: x%2)\
.then_by(lambda x: x)\
.to_list()
self.assertSequenceEqual([2, 8, -5, 1, 3, 5], ret)
def test_tee(self):
data = iter(range(10))
q = Q(data)
ret1 = q.tee().where(lambda x: x < 5).to_list()
ret2 = q.tee().where(lambda x: x % 2 == 0).to_list()
self.assertSequenceEqual([0, 1, 2, 3, 4], ret1)
self.assertSequenceEqual([0, 2, 4, 6, 8], ret2)
def test_having_max_multiple(self):
data = [
TestObject(a=5, b=20),
TestObject(a=1, b=10),
TestObject(a=1, b=20)
]
ret = Q(data).having_max(lambda x: x.b).to_list()
self.assertSequenceEqual([data[0], data[2]], ret)
def test_having_min_one(self):
data = [
TestObject(a=5, b=20),
TestObject(a=1, b=10),
TestObject(a=1, b=20)
]
ret = Q(data).having_min(lambda x: x.b).to_list()
self.assertSequenceEqual([data[1]], ret)
def test_inner_join(self):
data = ['foo', 'bar', 'over', 'rack', 'kick']
ret = Q(data)\
.inner_join(data, lambda x: x[-1], lambda x: x[0])\
.select(lambda x: (x.left, x.right))\
.to_set()
self.assertSetEqual(
{('foo', 'over'), ('bar', 'rack'), ('over', 'rack'),
('rack', 'kick'), ('kick', 'kick')}, ret)
def test_group_join(self):
data = ['foo', 'bar', 'over', 'rack', 'kick']
ret = Q(data)\
.group_join(data, lambda x: x[-1], lambda x: x[0])\
.select(lambda x: (x.left_items.to_frozenset(), x.right_items.to_frozenset()))\
.to_set()
self.assertSetEqual(
{
(frozenset(('foo', )), frozenset(('over', ))),
(frozenset(('bar', 'over')), frozenset(('rack', ))),
(frozenset(('rack', 'kick')), frozenset(('kick', ))),
(frozenset(), frozenset(('foo', ))),
(frozenset(), frozenset(('bar', ))),
}, ret)
def test_any_non_empty(self):
data = ("one", "two", "three")
ret = Q(data).any()
self.assertTrue(ret)
def test_all_false(self):
data = ("one", "two", "three")
ret = Q(data).all(lambda x: len(x) == 3)
self.assertFalse(ret)
def test_all_true(self):
data = ("one", "two", "three")
ret = Q(data).all(lambda x: len(x) > 0)
self.assertTrue(ret)
def test_any_not_contains(self):
data = ("one", "two", "three")
ret = Q(data).any(lambda x: x.startswith("f"))
self.assertFalse(ret)
def test_any_empty(self):
data = ()
ret = Q(data).any()
self.assertFalse(ret)
def test_take_last_having(self):
ret = Q.range(1, 9).take_last_having(lambda x: x % 2).to_list()
self.assertSequenceEqual((9, ), ret)
def test_skip_last_having(self):
ret = Q.range(1, 9).skip_last_having(lambda x: x % 2).to_list()
self.assertSequenceEqual((1, 2, 3, 4, 5, 6, 7, 8), ret)
def test_cast(self):
data = [1, 2, 3]
ret = Q(data).cast(float).to_list()
self.assertSequenceEqual(ret, [1.0, 2.0, 3.0])
self.assertTrue(all(isinstance(i, float) for i in ret))
def test_simple_sort(self):
data = [1, 5, 3, 8, -5]
ret = Q(data).sort_by(lambda x: x).to_list()
self.assertSequenceEqual([-5, 1, 3, 5, 8], ret)
def test_tuple(self):
data = (1, 2, 3)
ret = Q(data).to_list()
self.assertIsInstance(ret, list)
self.assertSequenceEqual(data, ret)
def test_simple_contains(self):
data = [1, 2, 3]
self.assertTrue(Q(data).contains(1))
self.assertFalse(Q(data).contains(0))
def test_contains_any(self):
data = [1, 2, 3]
self.assertTrue(Q(data).contains_any((1, 2)))
self.assertTrue(Q(data).contains_any((2, 4)))
self.assertFalse(Q(data).contains_any((5, 6)))
def test_reverse_and_where(self):
data = (1, 2, 3)
ret = Q(data).where(lambda x: x > 1).reverse().to_list()
self.assertSequenceEqual((3, 2), ret)
def test_q_to_dict(self):
data = {'h': ['hi', 'hello'], 'f': ['foo']}
ret = Q(data).to_dict(lambda x: x.key, lambda x: Q(x.value).count())
self.assertDictEqual({'h': 2, 'f': 1}, ret)
def test_non_frozen(self):
data = [1, 2, 3]
ret = Q(data).to_set()
self.assertIsInstance(ret, set)
self.assertSetEqual(set(data), ret)
def test_only_reverse(self):
data = [1, 2, 3]
ret = Q(data).reverse().to_list()
self.assertSequenceEqual((3, 2, 1), ret)
