def test_recorddao_data_query_scalar_list_has_only(self): """Test that the RecordDAO is retrieving on a has_only list of scalars.""" just_5 = list( self.record_dao.data_query(val_data_list_1=has_only( DataRange(-1, 1), DataRange(7.5, 10)))) # 5 only self.assertEqual(len(just_5), 1) self.assertIn("spam5", just_5)
def test_all_scal_dr(self): """ Given a list of scalar DataRanges and a datum name, we correctly get all Records. A record will be included in the return if the corresponding datum name in that record has a value of a list containing all of the given list of scalars DataRanges. """ list_to_check = [DataRange(0, 2), DataRange(3, 6)] records = list( self.record_dao.get_list(datum_name="eggs", list_of_contents=list_to_check, ids_only=True, operation=ListQueryOperation.ALL)) self.assertEqual(len(records), 2) self.assertTrue(self.record_2.id in records) self.assertTrue(self.record_1.id in records) records = list( self.record_dao.get_list(datum_name="eggs", list_of_contents=list_to_check, operation=ListQueryOperation.ALL)) records_to_check = { records[0].id: records[0], records[1].id: records[1] } self.assertEqual(records_to_check[self.record_1.id].raw, self.record_1.raw) self.assertEqual(records_to_check[self.record_2.id].raw, self.record_2.raw)
def test_find(self): store, kosh_db = self.connect() # Create many datasets ds = store.create(metadata={"key1": 1, "key2": "A"}) ds2 = store.create(metadata={"key2": "B", "key3": 3}) ds3 = store.create() store.create(metadata={"key2": "C", "key3": 4}) ds.associate("tests/baselines/node_extracts2", "something") ds2.associate("tests/baselines/node_extracts2", "something") ds3.associate("tests/baselines/node_extracts2", "something") s = list(store.find(key2=DataRange("A"))) self.assertEqual(len(s), 3) s = list( store.find(key2=DataRange("A"), file=os.path.abspath("tests/baselines/node_extracts2"))) self.assertEqual(len(s), 2) self.assertEqual(len(ds._associated_data_), 1) ds2.dissociate("tests/baselines/node_extracts2") self.assertEqual(len(ds2._associated_data_), 0) s = list( store.find(key2=DataRange("A"), file=os.path.abspath("tests/baselines/node_extracts2"))) self.assertEqual(len(s), 1) os.remove(kosh_db)
def test_sort_and_standardizing(self): """Test the function for processing query criteria.""" criteria = { "numra": DataRange(1, 2), "lexra": DataRange("bar", "foo"), "num": 12, "num2": 2, "listnum": ListCriteria(entries=(1, 2), operation="ALL"), "lex": "cat" } scalar, string, scalar_list, string_list = sort_and_standardize_criteria( criteria) num_equiv = DataRange(12, 12, max_inclusive=True) num2_equiv = DataRange(2, 2, max_inclusive=True) lex_equiv = DataRange("cat", "cat", max_inclusive=True) # assertCountEqual WOULD make sense, except it seems to test on object # identity and not using the == operator. Instead, we sort scalar.sort() string.sort() self.assertEqual(scalar, [("num", num_equiv), ("num2", num2_equiv), ("numra", criteria["numra"])]) self.assertEqual(string, [("lex", lex_equiv), ("lexra", criteria["lexra"])]) self.assertEqual(scalar_list[0], ("listnum", criteria["listnum"])) self.assertFalse(string_list) with self.assertRaises(ValueError) as context: sina.utils.sort_and_standardize_criteria({"bork": ["meow"]}) self.assertIn('criteria must be a number, string', str(context.exception))
def test_any_string_dr(self): """ Given a list of string DataRanges and a datum name, we correctly get any Records. A record will be included in the return if the corresponding datum name in that record has a value of a list containing any of the given list of string DataRanges. """ list_to_check = [ DataRange(min="a", max="c", max_inclusive=True), DataRange(min="d", max="g", max_inclusive=True) ] records = list( self.record_dao.get_list(datum_name="spam", list_of_contents=list_to_check, ids_only=True, operation=ListQueryOperation.ANY)) self.assertEqual(len(records), 2) self.assertTrue(self.record_4.id in records) self.assertTrue(self.record_5.id in records) records = list( self.record_dao.get_list(datum_name="spam", list_of_contents=list_to_check, operation=ListQueryOperation.ANY)) records_to_check = { records[0].id: records[0], records[1].id: records[1] } self.assertEqual(records_to_check[self.record_4.id].raw, self.record_4.raw) self.assertEqual(records_to_check[self.record_5.id].raw, self.record_5.raw)
def test_invert_ranges_many_ranges(self): """Test that we correctly invert multiple DataRanges.""" ranges = [ DataRange(max=2, max_inclusive=False), DataRange(min=4, min_inclusive=True) ] opposite_range = DataRange(min=2, max=4) self.assertEqual(sina.utils.invert_ranges(ranges), [opposite_range])
def test_recorddao_scalar_datum_query_no_match(self): """Test that the RecordDAO data query is retrieving no Records when there's no matches.""" too_small_range = DataRange(min=10.99999, min_inclusive=False) too_small = self.record_dao.data_query(spam_scal=too_small_range) self.assertFalse(list(too_small)) nonexistant_scalar = self.record_dao.data_query( nonexistant_scalar=DataRange(-999, 0)) self.assertFalse(list(nonexistant_scalar))
def test_recorddao_data_query_scalar_list_has_any(self): """Test that the RecordDAO is retrieving on a has_any list of scalars.""" just_5_and_6 = list( self.record_dao.data_query(val_data_list_1=has_any( DataRange(-1, 1), DataRange(7.5, 9)))) # 5 & 6 self.assertEqual(len(just_5_and_6), 2) self.assertIn("spam5", just_5_and_6) self.assertIn("spam6", just_5_and_6)
def test_invert_ranges_one_range(self): """Test that we correctly invert a single DataRange.""" data_range = DataRange(min=2, max=4) opposite_ranges = [ DataRange(max=2, max_inclusive=False), DataRange(min=4, min_inclusive=True) ] self.assertEqual(sina.utils.invert_ranges([data_range]), opposite_ranges)
def test_merge_overlapping_ranges(self): """Test that we merge overlapping DataRanges.""" ranges = [ DataRange(max=0), DataRange(min=0, max=5), DataRange(min=3, max=4) ] merged_range = DataRange(max=5) self.assertEqual(sina.utils.merge_ranges(ranges), [merged_range])
def test_data_range_overlap_bad_types(self): """Test that we refuse to check type-mismatched DataRanges for overlap.""" strings = DataRange("cat", "horse") scalars = DataRange(42, 45) with self.assertRaises(TypeError) as context: self.assertFalse(strings.overlaps(scalars)) self.assertIn( 'Only DataRanges of the same type (numeric or lexicographic)', str(context.exception))
def test_merge_string_ranges(self): """Test that we merge string ranges correctly.""" ranges = [ DataRange(min="cat", max="giraffe", min_inclusive=False), DataRange(min="dog", max="zebra") ] merged_ranges = [ DataRange(min="cat", max="zebra", min_inclusive=False) ] self.assertEqual(sina.utils.merge_ranges(ranges), merged_ranges)
def test_invert_ranges_multitype_error(self): """Test that a TypeError is raised if mixed types of ranges are inverted.""" ranges = [ DataRange(max="cat", max_inclusive=True), DataRange(min=2, min_inclusive=False) ] with self.assertRaises(TypeError) as context: sina.utils.invert_ranges(ranges) self.assertIn('must be only numeric DataRanges or', str(context.exception))
def test_invert_ranges_strings(self): """Test that range inversion works with strings.""" ranges = [ DataRange(max="cat", max_inclusive=True), DataRange(min="dog", min_inclusive=False) ] opposite_range = DataRange(min="cat", max="dog", min_inclusive=False, max_inclusive=True) self.assertEqual(sina.utils.invert_ranges(ranges), [opposite_range])
def test_data_range_is_single(self): """Test the DataRange is_single_value method.""" is_single = DataRange(2, 2, max_inclusive=True) is_also_single = DataRange("cat", "cat", max_inclusive=True) is_not_single = DataRange(2, 10, max_inclusive=True) self.assertTrue(is_single.is_single_value()) self.assertTrue(is_also_single.is_single_value()) self.assertFalse(is_not_single.is_single_value())
def test_data_range_equality(self): """Test the DataRange equality operator.""" basic_case = DataRange(1, 2) flipped_inclusivity = DataRange(1, 2e0, min_inclusive=False, max_inclusive=True) with_strings = DataRange("foo_a", "foo_c") basic_case_again = DataRange(1, 2) self.assertEqual(basic_case, basic_case_again) self.assertNotEqual(basic_case, flipped_inclusivity) self.assertNotEqual(basic_case, with_strings)
def test_merge_disordered_ranges(self): """Test that we correctly order our ranges and their mergings.""" ranges = [ DataRange(min=5.5), DataRange(min=3, max=4, min_inclusive=False), DataRange(min=5, max=6) ] merged_ranges = [ DataRange(min=3, max=4, min_inclusive=False), DataRange(min=5) ] self.assertEqual(sina.utils.merge_ranges(ranges), merged_ranges)
def test_recorddao_data_query_has_only_mixed(self): """ Test that the RecordDAO is retrieving on mixed data types for has_only. Test that we can mix searching on scalars and lists of scalars. """ just_5 = list( self.record_dao.data_query( val_data_list_1=has_only(DataRange(-1, 1), DataRange(7.5, 21)), # 5 & 6 spam_scal_3=DataRange(0, 50))) # 5 only self.assertEqual(len(just_5), 1) self.assertEqual(just_5[0], "spam5")
def test_invert_ranges_one_range_zeroes(self): """ Test that we correctly invert a single DataRange. Checks for correct behavior on range bounds that are "Falsey" (ex: zero). """ data_range = DataRange(min=0, max=0, max_inclusive=True) opposite_ranges = [ DataRange(max=0), DataRange(min=0, min_inclusive=False) ] self.assertEqual(sina.utils.invert_ranges([data_range]), opposite_ranges)
def test_recorddao_data_query_all_list_criteria(self): """ Test that the RecordDAO is retrieving on mixed data types. Test that we can mix searching on strings, scalars, lists of strings, and lists of scalars, using has_all, has_any, and has_only """ no_match = list( self.record_dao.data_query( val_data_list_1=has_any(DataRange(-10, 8.5), DataRange(8.9, 25)), # 5 & 6 spam_scal_3=DataRange(0, 50), # 5 only val_data_list_2=has_all('eggs', DataRange('o', 'z')), # 5 & 6 val_data_3=has_only(0, 9.3))) # 6 only self.assertFalse(no_match) just_5 = list( self.record_dao.data_query( val_data_list_1=has_all(DataRange(-10, 8.5), DataRange(8.9, 25)), # 5 & 6 spam_scal_3=DataRange(0, 50), # 5 only val_data_list_2=has_all('eggs', DataRange('o', 'z')), # 5 & 6 val_data_3='sugar')) # 5 only self.assertEqual(len(just_5), 1) self.assertEqual(just_5[0], "spam5")
def test_data_range_contains(self): """Test the DataRange contains operator.""" flipped_inclusivity = DataRange(1, 2, min_inclusive=False, max_inclusive=True) inf_max = DataRange(max=100) with_strings = DataRange(min="foo_a", min_inclusive=False) self.assertTrue(2 in flipped_inclusivity) self.assertFalse(1 in flipped_inclusivity) self.assertTrue(-999 in inf_max) self.assertFalse(100 in inf_max) self.assertTrue("foo_c" in with_strings) self.assertFalse("foo_a" in with_strings)
def test_data_range_bad_assignment(self): """Tests invalid assignments for DataRanges.""" with self.assertRaises(TypeError) as context: DataRange(30, "fast") self.assertIn('Bad type for portion of range', str(context.exception)) with self.assertRaises(TypeError) as context: DataRange(["foo", "bar"], ["spam", "eggs"]) self.assertIn('Bad type for portion of range', str(context.exception)) with self.assertRaises(ValueError) as context: DataRange(30, 1) self.assertIn('min must be <= max', str(context.exception)) with self.assertRaises(ValueError) as context: DataRange() self.assertIn('Null DataRange', str(context.exception))
def test_data_range_identity(self): """Test functions that return what kind of range the DataRange is.""" numerical = DataRange(min=1) lexographic = DataRange(max="foo_c") self.assertTrue(numerical.is_numeric_range()) self.assertFalse(numerical.is_lexographic_range()) self.assertTrue(lexographic.is_lexographic_range()) self.assertFalse(lexographic.is_numeric_range())
def test_basic_data_range_scalar(self): """Test basic DataRange creation using scalars.""" basic_case = DataRange(1, 2) self.assertEqual(basic_case.min, 1) self.assertEqual(basic_case.max, 2) self.assertTrue(basic_case.min_inclusive) self.assertFalse(basic_case.max_inclusive)
def test_data_range_inclusivity_assignment(self): """Test DataRange creation including inclusivity.""" flipped_inclusivity = DataRange(1, 2, min_inclusive=False, max_inclusive=True) self.assertFalse(flipped_inclusivity.min_inclusive) self.assertTrue(flipped_inclusivity.max_inclusive)
def test_parse_data_string(self): """Test the function for parsing a string to names and DataRanges.""" just_one = "speed=[1,2)" basic_case = DataRange(1, 2) a_few = "speed=(1,2] quadrant=nw" flipped_inclusivity = DataRange(1, 2, min_inclusive=False, max_inclusive=True) both_sides_equal = DataRange("nw", "nw", max_inclusive=True) none = "" self.assertEqual(basic_case, sina.utils.parse_data_string(just_one)["speed"]) few_dict = sina.utils.parse_data_string(a_few) self.assertEqual(flipped_inclusivity, few_dict["speed"]) self.assertEqual(both_sides_equal, few_dict["quadrant"]) self.assertFalse(sina.utils.parse_data_string(none))
def test_recorddao_data_query_string_list_has_all(self): """Test that the RecordDAO is retrieving on a has_all list of strings.""" just_5_and_6 = list( self.record_dao.data_query( val_data_list_2=has_all('eggs', DataRange('o', 'z')))) # 5 & 6 self.assertEqual(len(just_5_and_6), 2) self.assertIn("spam5", just_5_and_6) self.assertIn("spam6", just_5_and_6)
def test_recorddao_many_scalar_data_query(self): """Test that RecordDAO's data query is retrieving on multiple scalars correctly.""" spam_and_spam_3 = DataRange(min=10) one = self.record_dao.data_query( spam_scal=spam_and_spam_3, spam_scal_2=10.5) # Matches spam_3 only self.assertEqual(len(list(one)), 1) none = self.record_dao.data_query(spam_scal=spam_and_spam_3, nonexistant=10101010) self.assertFalse(list(none))
def test_recorddao_string_datum_query(self): """Test that the RecordDAO data query is retrieving based on one string correctly.""" just_right_range = DataRange(min="astounding", max="runny", max_inclusive=True) just_right = self.record_dao.data_query(val_data=just_right_range) just_right_list = list(just_right) self.assertEqual(len(just_right_list), 2) six.assertCountEqual(self, just_right_list, ["spam", "spam3"])
def test_only_string_dr(self): """ Given a list of string DataRanges and a datum name, we correctly get Records. A record will be included in the return if the corresponding datum name in that record has a value of a list containing only the given list of string DataRanges. """ list_to_check = [ DataRange(min="a", max="f", max_inclusive=True), DataRange(min="y", max="zebra", max_inclusive=True) ] records = list( self.record_dao.get_list(datum_name="spam", list_of_contents=list_to_check, ids_only=False, operation=ListQueryOperation.ONLY)) self.assertEqual(len(records), 1) self.assertEqual(records[0].raw, self.record_4.raw)