def test_where_binary_equals_returns_get_attribute_expression_on_lhs(self):
col = []
tree = From(col).where("some.other.property == 'Bernardo'")
error = "Lhs should be GetAttributeExpression but was %s"
class_name = tree.expressions[0].__class__.__name__
assert isinstance(tree.expressions[0].lhs, GetAttributeExpression), \
error % class_name
def test_select_many_returns_proper_results_for_sub_property(self):
class SomeElement(object):
def __init__(self, value):
self.value = value
def __str__(self):
return str(self.value)
col = [
SomeElement(1),
SomeElement(2),
SomeElement(3),
SomeElement(4),
SomeElement(5)
]
items = From(col).where(
"item.value > 2 and item.value < 4").select_many()
assert len(
items
) == 1, "Only item 3 should be in the resulting collection, but it has length of %d" % len(
items)
assert items[
0].value == 3, "Only item 3 should be in the resulting collection but it was %s." % items[
0].value
def test_desc_order_for_expression(self):
result = From(
self.col).order_by("-(item.first + item.second)").select_many()
assert result[0].first == 7
assert result[1].first == 4
assert result[2].first == 1
def test_select_many_returns_proper_results_for_numbers(self):
items = From([1, 2, 3, 4,
5]).where("item > 2 and item < 4").select_many()
assert items == [
3
], "Only item 3 should be in the resulting collection but it was %s." % ",".join(
items)
def test_collection_provider_filters_using_binary_expression(self):
col = ["a", "b"]
query = From(col).where("item == 'a'")
provider = query.provider
result = provider.parse(query, Actions.SelectMany)
assert result == [
'a'
], "The collection was not filtered properly and now is: %s" % result
def test_mixed_expression_order(self):
result = From(
self.col).order_by("item.second + item.third",
"item.first + item.second").select_many()
assert result[0].first == 7
assert result[1].first == 1
assert result[2].first == 4
def test_where_binary_equals_returns_binary_expression(self):
col = []
tree = From(col).where("some.other.property == 'Bernardo'")
assert len(
tree.expressions) == 1, "There should be one where expression"
assert isinstance(tree.expressions[0], BinaryExpression), \
"The first expression of the tree should be a BinaryExpression"
def test_collection_provider_parses_query_using_lesser_than(self):
col = range(5)
query = From(col).where("item <= 3")
provider = query.provider
result = provider.parse(query, Actions.SelectMany)
assert result == range(
4
), "The collection was not filtered properly and now is: %s" % result
def test_where_binary_equals_returns_tree(self):
col = []
tree = From(col).where("some.other.property == 'Bernardo'")
assert tree is not None, "The From method needs to return something"
assert isinstance(
tree,
Query), "The lambda should have resolved to a LambdaExpression"
def select_expression_fields():
two_values_col = [TwoValues(item, item + 2) for item in range(ITERATIONS/2)]
start_time = time.time()
for i in range(2):
total = From(two_values_col).select("item.value + item.value2", "item.value2 - item.value")
print "Selecting Two Expression Fields %d ITEMS OPERATION - 2 iterations took %.2f" % (ITERATIONS/2, (time.time() - start_time))
def run_two_big_collections():
dynamic_col = [OneValue(item) for item in range(ITERATIONS/2)]
start_time = time.time()
for i in range(2):
total = From(dynamic_col).avg("item.value.value")
print "AVG %d ITEMS OPERATION - 2 iterations took %.2f" % (ITERATIONS/2, (time.time() - start_time))
def run_many_small_collections():
start_time = time.time()
fixed_col = [OneValue(1), OneValue(2), OneValue(3)]
for i in range(ITERATIONS):
total = From(fixed_col).avg("item.value.value")
print "AVG FIXED COL OPERATION - %d iterations took %.2f" % (ITERATIONS, (time.time() - start_time))
def test_collection_provider_filters_using_binary_expression_for_numbers(
self):
col = [1, 2, 10, 11, 12]
query = From(col).where("item > 10")
provider = query.provider
result = provider.parse(query, Actions.SelectMany)
assert result == [
11, 12
], "The collection was not filtered properly and now is: %s" % result
def test_querying_with_invalid_action_raises(self):
error = "Invalid action exception. invalid_action is unknown."
q = From([1, 2, 3])
provider = q.provider
self.assertRaisesEx(ValueError,
provider.parse,
q,
"invalid_action",
exc_pattern=re.compile(error))
def test_max_returns_right_amount_for_a_given_sub_property(self):
class OtherValue(object):
def __init__(self, value):
self.value = value
class OneValue(object):
def __init__(self, value):
self.value = OtherValue(value)
value = From([OneValue(1), OneValue(2), OneValue(3)]).max("item.value.value")
assert value == 3, "value should be 3 but was %s" % value
def test_max_raises_for_an_invalid_property(self):
error_message = "The attribute '%s' was not found in the specified collection's items. If you meant to use the raw value of each item in the collection just use the word 'item' as a parameter to .max or use .max()"
class OneValue(object):
def __init__(self, value):
self.value = value
fr = From([OneValue(1), OneValue(2), OneValue(3)])
self.assertRaisesEx(ValueError, fr.max, "value", exc_pattern=re.compile(error_message % "value"))
self.assertRaisesEx(ValueError, fr.max, "item.dumb", exc_pattern=re.compile(error_message % "item.dumb"))
self.assertRaisesEx(ValueError, fr.max, "", exc_pattern=re.compile(error_message % ""))
self.assertRaisesEx(ValueError, fr.max, None, exc_pattern=re.compile(error_message % "None"))
def test_grouping_returns_the_right_items_on_select_many(self):
items = From(self.col).order_by("first").group_by("second").select(
"first", "second")
assert items[2][0].first == 1
assert items[2][0].second == 2
assert items[5][0].first == 4
assert items[5][0].second == 5
assert items[5][1].first == 7
assert items[5][1].second == 5
assert not hasattr(items[2][0], "third")
assert not hasattr(items[5][0], "third")
assert not hasattr(items[5][1], "third")
def test_grouping_with_strings_returns_the_right_items_on_select_many(
self):
new_col = [
self.TestGroupByClass("a", "z", "a"),
self.TestGroupByClass("b", "w", "b"),
self.TestGroupByClass("c", "z", "c")
]
items = From(new_col).order_by("first").group_by(
"second").select_many()
assert items["z"][0].first == "a"
assert items["z"][1].first == "c"
assert items["w"][0].first == "b"
def test_where_binary_equals_returns_tree_name_expressions_as_attributes_on_lhs(
self):
col = []
tree = From(col).where("some.other.property == 'Bernardo'")
error_message = "There should be three attributes "\
"('some','other','property') in the GetAttributeExpression, "\
"but there was %d"
assert len(tree.expressions[0].lhs.attributes) == 3, \
error_message % len(tree.expressions[0].lhs.attributes)
for i in range(3):
error = "The %d parameter should be a NameExpression but was %s"
class_name = tree.expressions[0].lhs.attributes[
i].__class__.__name__
assert isinstance(tree.expressions[0].lhs.attributes[i], NameExpression), \
error % (i, class_name)
def test_select_field_operator_add(self):
class Item:
def __init__(self, name, value, value2):
self.name = name
self.value = value
self.value2 = value2
col = [Item("A", 10, 10), Item("B", 20, 20), Item("C", 30, 30)]
mod = From(col).select("name", "item.value + item.value2")
assert mod[0].name == "A"
assert mod[0].dynamic_1 == 20
assert mod[1].name == "B"
assert mod[1].dynamic_1 == 40
assert mod[2].name == "C"
assert mod[2].dynamic_1 == 60
def test_where_not_returns_proper_results(self):
col = [
self.TwoValues(1, 2),
self.TwoValues(2, 3),
self.TwoValues(3, 4),
self.TwoValues(4, 5),
self.TwoValues(5, 6)
]
items = From(col).where("not (item.value < 4)").select_many()
assert len(
items
) == 2, "Only items 4 and 5 should be in the resulting collection, but it has length of %d" % len(
items)
assert items[
0].value == 4, "Item 4 should be in the resulting collection but it was %s." % items[
0].value
assert items[
1].value == 5, "Item 5 should be in the resulting collection but it was %s." % items[
1].value
def test_select_many_expressions_at_once(self):
class Item:
def __init__(self, name, value, value2):
self.name = name
self.value = value
self.value2 = value2
col = [Item("A", 10, 20), Item("B", 20, 30), Item("C", 30, 40)]
mod = From(col).select("name", "item.value2 - item.value",
"item.value * item.value2")
assert mod[0].name == "A"
assert mod[0].dynamic_1 == 10
assert mod[0].dynamic_2 == 200
assert mod[1].name == "B"
assert mod[1].dynamic_1 == 10
assert mod[1].dynamic_2 == 600
assert mod[2].name == "C"
assert mod[2].dynamic_1 == 10
assert mod[2].dynamic_2 == 1200
def test_min_returns_right_amount_for_full_collection(self):
value = From([1,2,3]).min("item")
assert value == 1, "value should be 1 but was %s" % value
def test_min_returns_right_amount_for_filtered_collection_with_no_keyword(self):
value = From([1,2,3,4]).where("item >= 2").min()
assert value == 2, "value should be 2 but was %s" % value
def test_min_returns_right_amount_for_full_collection_with_no_keyword(self):
value = From([1,2,3]).min()
assert value == 1, "value should be 1 but was %s" % value
def test_max_returns_right_amount_for_filtered_collection(self):
value = From([1,2,3,4]).where("item <= 2").max("item")
assert value == 2, "value should be 2 but was %s" % value
def test_grouping_returns_the_right_items_on_select_many(self):
items = From(
self.col).order_by("first").group_by("second").select_many()
assert items[2][0].first == 1
assert items[5][0].first == 4
assert items[5][1].first == 7
def test_grouping_returns_two_keys_on_select_many(self):
items = From(self.col).group_by("second").select_many()
assert len(items.keys()) == 2
def test_grouping_returns_the_two_right_keys_on_select_many(self):
items = From(self.col).group_by("second").select_many()
assert items.has_key(2)
assert items.has_key(5)
def test_min_returns_right_amount_for_filtered_collection(self):
value = From([1,2,3,4]).where("item > 2").min("item")
assert value == 3, "value should be 3 but was %s" % value
def test_min_returns_right_amount_for_a_given_property(self):
class OneValue(object):
def __init__(self, value):
self.value = value
value = From([OneValue(1), OneValue(2), OneValue(3)]).min("item.value")
assert value == 1, "value should be 1 but was %s" % value
def test_max_returns_right_amount_for_filtered_collection_with_no_keyword(self):
value = From([1,2,3,4]).where("item <= 3").max()
assert value == 3, "value should be 3 but was %s" % value
