def test_get_records_filters_variant_ops(
filter_sort_table_obj, op, variant_op
):
filter_sort, engine = filter_sort_table_obj
filter_list = [{"field": "numeric", "op": op, "value": 50}]
record_list = records.get_records(filter_sort, engine, filters=filter_list)
filter_list = [{"field": "numeric", "op": variant_op, "value": 50}]
variant_record_list = records.get_records(filter_sort, engine, filters=filter_list)
assert len(record_list) == len(variant_record_list)
for record, variant_record in zip(record_list, variant_record_list):
assert record == variant_record
def test_get_records_filters_with_miss(roster_table_obj):
roster, engine = roster_table_obj
filter_list = [
{"field": roster.columns["Student Name"], "op": "==", "value": "Amy Gamble"},
{"field": roster.columns["Grade"], "op": "==", "value": 75}
]
record_list = records.get_records(
roster, engine, filters=filter_list
)
assert len(record_list) == 0
def test_get_records_ordered_col_set_different_col_order(roster_table_obj):
roster, engine = roster_table_obj
order_list = [{
"field": "Grade",
"direction": "asc"
}, {
"field": "Student Name",
"direction": "asc"
}]
record_list = records.get_records(roster, engine, order_by=order_list)
assert record_list[0][7] == 25 and record_list[0][2] == "Amy Gamble"
def test_get_records_orders_before_limiting(roster_table_obj):
roster, engine = roster_table_obj
order_list = [{
"field": "Grade",
"direction": "asc"
}, {
"field": "Student Name",
"direction": "asc"
}]
record_list = records.get_records(roster,
engine,
limit=1,
order_by=order_list)
assert record_list[0][7] == 25 and record_list[0][2] == "Amy Gamble"
def test_get_records_filters_boolean_ops(
filter_sort_table_obj, op, field_val_pairs, res_len
):
filter_sort, engine = filter_sort_table_obj
filter_list = [{op: [
{"field": field, "op": "eq", "value": value}
for field, value in field_val_pairs
]}]
record_list = records.get_records(filter_sort, engine, filters=filter_list)
assert len(record_list) == res_len
for record in record_list:
val_func = op_to_python_func[op]
args = [getattr(record, field) == value for field, value in field_val_pairs]
assert val_func(args)
def test_get_records_filters_using_col_str_names(roster_table_obj):
roster, engine = roster_table_obj
filter_list = [
{"field": "Student Name", "op": "==", "value": "Amy Gamble"},
{"field": "Subject", "op": "==", "value": "Math"}
]
record_list = records.get_records(
roster, engine, filters=filter_list
)
assert all(
[
len(record_list) == 1,
record_list[0][2] == "Amy Gamble",
record_list[0][6] == "Math",
]
)
def test_get_distinct_tuple_values_feeds_get_records(roster_table_obj):
roster, engine = roster_table_obj
column_list = [
"Student Number",
"Student Email",
]
distinct_tuples = records.get_distinct_tuple_values(column_list,
engine,
table=roster,
limit=2)
filter_list = records.distinct_tuples_to_filter(distinct_tuples[0])
record_list = records.get_records(roster, engine, filters=filter_list)
assert all([
record[1] == distinct_tuples[0][0][1]
and record[3] == distinct_tuples[0][1][1] for record in record_list
])
def test_get_records_filters_nested_boolean_ops(filter_sort_table_obj):
filter_sort, engine = filter_sort_table_obj
filter_list = [{"and": [
{"or": [
{"field": "varchar", "op": "eq", "value": "string24"},
{"field": "numeric", "op": "eq", "value": 42},
]},
{"or": [
{"field": "varchar", "op": "eq", "value": "string42"},
{"field": "numeric", "op": "eq", "value": 24},
]},
]}]
record_list = records.get_records(filter_sort, engine, filters=filter_list)
assert len(record_list) == 2
for record in record_list:
assert ((record.varchar == "string24" or record.numeric == 42)
and (record.varchar == "string42" or record.numeric == 24))
def test_get_records_filters_ops(
filter_sort_table_obj, field, op, value, res_len
):
filter_sort, engine = filter_sort_table_obj
filter_list = [{"field": field, "op": op}]
if value is not None:
filter_list[0]["value"] = value
record_list = records.get_records(filter_sort, engine, filters=filter_list)
if field == "date" and value is not None:
value = datetime.strptime(value, "%Y-%m-%d").date()
elif field == "array" and value is not None and op not in ["any", "not_any"]:
value = [int(c) for c in value[1:-1].split(",")]
assert len(record_list) == res_len
for record in record_list:
val_func = op_to_python_func[op]
assert val_func(getattr(record, field), value)
def test_get_records_orders_single_field(filter_sort_table_obj, field,
direction, null):
filter_sort, engine = filter_sort_table_obj
order_list = [{"field": field, "direction": direction}]
order_list[0][null] = True
record_list = records.get_records(filter_sort, engine, order_by=order_list)
if null == "nullsfirst":
assert getattr(record_list[0], field) is None
elif null == "nullslast":
assert getattr(record_list[-1], field) is None
for i in range(1, len(record_list)):
prev = getattr(record_list[i - 1], field)
curr = getattr(record_list[i], field)
if prev is None or curr is None:
continue
comp_func = dir_to_python_func[direction]
assert comp_func(prev, curr)
def test_get_records_orders_multiple_fields(roster_table_obj, field_dir_pairs):
roster_sort, engine = roster_table_obj
order_list = [{
"field": field,
"direction": direction
} for field, direction in field_dir_pairs]
record_list = records.get_records(roster_sort, engine, order_by=order_list)
for i in range(1, len(record_list)):
prev_field_equal = True
for field, direction in field_dir_pairs:
prev = getattr(record_list[i - 1], field)
curr = getattr(record_list[i], field)
if prev is None or curr is None:
continue
comp_func = dir_to_python_func[direction]
# Only check order when previous field has equal values
assert not prev_field_equal or comp_func(prev, curr)
prev_field_equal = prev == curr
def sa_all_records(self):
return records.get_records(self._sa_table, self.schema._sa_engine)
def get_records(self, limit=None, offset=None, filters=[], order_by=[]):
return records.get_records(self._sa_table, self.schema._sa_engine, limit,
offset, filters=filters, order_by=order_by)
def test_get_records_gets_ordered_records_str_col_name(roster_table_obj):
roster, engine = roster_table_obj
order_list = [{"field": "Teacher", "direction": "asc"}]
record_list = records.get_records(roster, engine, order_by=order_list)
assert record_list[0][4] == "Amber Hudson"
def test_get_records_gets_ordered_records_num_col_obj(roster_table_obj):
roster, engine = roster_table_obj
order_list = [{"field": roster.columns["Grade"], "direction": "asc"}]
record_list = records.get_records(roster, engine, order_by=order_list)
assert record_list[0][7] == 25
def test_get_records_filters_exceptions(filter_sort_table_obj, filters, exception):
filter_sort, engine = filter_sort_table_obj
with pytest.raises(exception):
records.get_records(filter_sort, engine, filters=filters)
def test_get_records_gets_limited_records(roster_table_obj):
roster, engine = roster_table_obj
record_list = records.get_records(roster, engine, limit=10)
assert len(record_list) == 10
def test_get_records_gets_limited_offset_records(roster_table_obj):
roster, engine = roster_table_obj
base_records = records.get_records(roster, engine, limit=10)
offset_records = records.get_records(roster, engine, limit=10, offset=5)
assert len(offset_records) == 10 and offset_records[0] == base_records[5]
def test_get_records_gets_all_records(roster_table_obj):
roster, engine = roster_table_obj
record_list = records.get_records(roster, engine)
assert len(record_list) == 1000
def test_get_records_orders_exceptions(filter_sort_table_obj, order_list,
exception):
filter_sort, engine = filter_sort_table_obj
with pytest.raises(exception):
records.get_records(filter_sort, engine, order_by=order_list)
