def test_pairs_to_dict(self):
"""pairs_to_dict should return the expected dict"""
test_dict = {"a": 1, "b": 2, "b": 3}
sorted_items = [("a", 1), ("b", 2), ("b", 3)]
add_one = lambda x: x + 1
double = lambda x: x * 2
set_zero = lambda x: 0
handlers = {"a": add_one, "b": double}
# test default all
self.assertEqual(pairs_to_dict(sorted_items), {"a": 1, "b": 3})
# test 'overwrite_value'
self.assertEqual(pairs_to_dict(sorted_items, "overwrite_value"), {
"a": 1,
"b": 3
})
# test no_duplicated_key, raise
self.assertRaises(ValueError, pairs_to_dict, sorted_items,
"no_duplicated_key")
# test always_multi_value
self.assertEqual(pairs_to_dict(sorted_items, "always_multi_value"), {
"a": [1],
"b": [2, 3]
})
# test allow multi_value
self.assertEqual(pairs_to_dict(sorted_items, "allow_multi_value"), {
"a": 1,
"b": [2, 3]
})
# test raise error when key not found in all_keys
f = curry(pairs_to_dict, all_keys=["a", "c"])
self.assertRaises(ValueError, f, sorted_items)
# test handlers
sorted_items.append(("c", 4))
self.assertEqual(
pairs_to_dict(sorted_items,
handlers=handlers,
default_handler=set_zero),
{
"a": 2,
"b": 6,
"c": 0
},
)
# test raise error when no valid handlers were found
f = curry(pairs_to_dict, handlers=handlers)
self.assertRaises(ValueError, f, sorted_items)
# test sanity
test_dict = dict(sorted_items)
self.assertEqual(pairs_to_dict(list(test_dict.items())), test_dict)
def test_EbiParser(self):
"""EbiParser: """
f = curry(EbiParser, strict=False)
first_valid = fake_records_valid[:-5]
# test valid
self.assertEqual(len(list(f(fake_records_valid))), 2)
def test_MinimalEbiParser_valid(self):
"""MinimalEbiParser: integrity of output """
f = curry(MinimalEbiParser, strict=False)
# test valid result: sequence, number of records, keys of a header
valid_result = list(f(fake_records_valid))
self.assertEqual(len(valid_result), 2)
sequence, header = valid_result[0]
self.assertEqual(sequence, "aaccppgghhh")
# the first fake record use only the required labels, the header is
# deleted of '', which was assigned to sequence
self.assertEqual(
list(sorted(header.keys())),
list(sorted(required_labels))[1:]) # [1:] to exclude the ''
# test selected_labels
selected_labels = ["ID", "DE"]
select_result = list(
f(fake_records_valid, selected_labels=selected_labels))
self.assertEqual(list(sorted(select_result[0][1].keys())),
list(sorted(selected_labels)))
# test bad record - unknown linecode or wrong line format
self.assertRaises(
ValueError,
list,
f(fake_records_valid + ["ID id.", "RR not valid.", "//"]),
)
self.assertRaises(
ValueError,
list,
f(fake_records_valid + ["ID id.", " RN bad format.", "//"]),
)
self.assertRaises(
ValueError,
list,
f(fake_records_valid + ["ID id.", "RN bad format.", "//"]),
)
# test bad record - not end with '//'
self.assertRaises(
RecordError,
list,
f(fake_records_valid + ["ID not end with //", " seq"]),
)
# test strict: lacking required linecodes
# ?? How to test the error message? warn message?
# the first record, [:-5], is valid even when strict=True.
the_first_valid = list(f(fake_records_valid[:-5], strict=True))[0]
# [1] get the header_dict
self.assertEqual(len(the_first_valid[1]), 9)
self.assertRaises(RecordError, list, f(fake_records_valid,
strict=True))
