def test_group_join(self):
self.assertRaises(TypeError, Enumerable.empty().group_join, [])
self.assertListEqual([], Enumerable().group_join(Enumerable()).to_list())
simple_empty_gj = Enumerable([1, 2, 3]).group_join(self.empty)
self.assertListEqual([], simple_empty_gj.to_list())
complex_simple_gj = Enumerable(
[{"value": 1}, {"value": 2}, {"value": 3}]
).group_join(Enumerable([1, 2, 3, 3]), outer_key=lambda x: x["value"])
self.assertListEqual(
[({"value": 1}, [1]), ({"value": 2}, [2]), ({"value": 3}, [3, 3])],
complex_simple_gj.select(lambda g: (g[0], g[1].to_list())).to_list(),
)
simple_gj = Enumerable([1, 2, 3]).group_join(
Enumerable([2, 3]),
result_func=lambda x: {"number": x[0], "collection": x[1].to_list()},
)
self.assertEqual(2, simple_gj.count())
self.assertListEqual(
[
{"number": 2, "collection": [2]},
{"number": 3, "collection": [3]},
],
simple_gj.to_list(),
)
def test_any(self):
self.assertFalse(Enumerable.empty().any(lambda x: x == 1))
self.assertFalse(Enumerable.empty().any())
self.assertTrue(Enumerable([1, 2, 3]).any(lambda x: x == 1))
self.assertTrue(Enumerable([1, 2, 3]).any())
self.assertTrue(Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any())
self.assertFalse(
Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any(
lambda x: x["value"] < 1
)
)
self.assertTrue(
Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any(
lambda x: x["value"] >= 1
)
)
def test_distinct(self):
self.assertListEqual([], Enumerable.empty().distinct().to_list())
six.assertCountEqual(
self,
[1, 2, 3],
Enumerable([1, 2, 3]).concat(Enumerable([1, 2, 3])).distinct().to_list(),
)
locations = Enumerable(_locations).distinct(lambda x: x[0])
self.assertEqual(locations.count(), 3)
def test_select(self):
self.assertListEqual(
[], Enumerable.empty().select(lambda x: x["value"]).to_list()
)
self.assertListEqual(
[{"value": 1}, {"value": 2}, {"value": 3}],
Enumerable([1, 2, 3]).select(lambda x: {"value": x}).to_list(),
)
self.assertListEqual(
[1, 2, 3],
Enumerable(
[
{"value": 1},
{"value": 2},
{"value": 3},
]
)
.select(lambda x: x["value"])
.to_list(),
)
def test_join(self):
self.assertRaises(TypeError, Enumerable.empty().join, [])
self.assertListEqual([], Enumerable().join(Enumerable()).to_list())
self.assertListEqual([], Enumerable().join(Enumerable([1, 2, 3])).to_list())
self.assertListEqual(
[],
Enumerable()
.join(Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]))
.to_list(),
)
self.assertListEqual(
[(1, 1), (2, 2), (3, 3)],
Enumerable([1, 2, 3])
.join(Enumerable([1, 2, 3]))
.order_by(lambda x: (x[0], x[1]))
.to_list(),
)
self.assertListEqual(
[(1, 1), (2, 2), (3, 3)],
Enumerable([1, 2, 3])
.join(
Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]),
inner_key=lambda x: x["value"],
result_func=lambda x: (x[0], x[1]["value"]),
)
.order_by(lambda x: (x[0], x[1]))
.to_list(),
)
self.assertListEqual(
[(1, 1), (2, 2), (3, 3)],
Enumerable([{"value": 1}, {"value": 2}, {"value": 3}])
.join(
Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]),
result_func=lambda x: (x[0]["value"], x[1]["value"]),
)
.order_by(lambda x: (x[0], x[1]))
.to_list(),
)
def test_empty(self):
test = Enumerable.empty()
self.assertIsInstance(test, Enumerable)
self.assertEqual(test.count(), 0)
def test_intersect(self):
self.assertRaises(TypeError, Enumerable.empty().intersect, [])
self.assertListEqual([], Enumerable().intersect(Enumerable.empty()).to_list())
self.assertListEqual(
[], Enumerable.empty().intersect(Enumerable([1, 2, 3])).to_list()
)
self.assertListEqual(
[1, 2, 3], Enumerable([1, 2, 3]).intersect(Enumerable([1, 2, 3])).to_list()
)
self.assertListEqual(
[2], Enumerable([1, 2, 3]).intersect(Enumerable([2])).to_list()
)
self.assertListEqual(
[],
Enumerable([1, 2, 3])
.intersect(
Enumerable(
[
{"value": 1},
{"value": 2},
{"value": 3},
]
)
)
.to_list(),
)
self.assertListEqual(
[
{"value": 1},
{"value": 2},
{"value": 3},
],
Enumerable(
[
{"value": 1},
{"value": 2},
{"value": 3},
]
)
.intersect(
Enumerable(
[
{"value": 1},
{"value": 2},
{"value": 3},
]
)
)
.to_list(),
)
self.assertListEqual(
Enumerable(
[
{"value": 1},
{"value": 2},
{"value": 3},
]
)
.intersect(Enumerable([{"value": 1}]))
.to_list(),
[{"value": 1}],
)
