def run_filter(metadata_filter: MetadataFilter, *fns: Mock): for field in metadata_filter.get_fields(): filtered_text = metadata_filter.filter_field(field, "Test") assert filtered_text == "Test" for fn in fns: fn.assert_called()
def test_filtering_strings(): metadata_filter = MetadataFilter({ "artist": [ lambda text: f"{text}1", lambda text: f"{text}2", ], }) assert metadata_filter.filter_field("artist", "Text") == "Text12"
def test_append_same_field(): fn1 = Mock(wraps=dummy_fn) fn2 = Mock(wraps=dummy_fn) metadata_filter = MetadataFilter({"foo": fn1}) run_filter(metadata_filter, fn1) assert fn1.call_count == 1 append_result = metadata_filter.append({"foo": fn2}) assert append_result is metadata_filter run_filter(metadata_filter, fn1, fn2) assert fn1.call_count == 2 assert fn2.call_count == 1
def test_extend_same_field(): fn1 = Mock(wraps=dummy_fn) fn2 = Mock(wraps=dummy_fn) metadata_filter1 = MetadataFilter({"foo": fn1}) run_filter(metadata_filter1, fn1) assert fn1.call_count == 1 metadata_filter2 = MetadataFilter({"foo": fn2}) extend_result = metadata_filter1.extend(metadata_filter2) assert extend_result is metadata_filter1 run_filter(metadata_filter1, fn1, fn2) assert fn1.call_count == 2 assert fn2.call_count == 1
def apply_metadata_filter( metadata_filter: MetadataFilter, orig_artist: str, orig_title: str, orig_album: str, ) -> Tuple[str, str, str, Corrected]: title = metadata_filter.filter_field("track", orig_title) artist = metadata_filter.filter_field("artist", orig_artist) album = metadata_filter.filter_field("album", orig_album) if artist != orig_artist or title != orig_title or album != orig_album: corrected = Corrected.AUTO_CORRECTED else: corrected = Corrected.NOT_CORRECTED return title, artist, album, corrected
def test_canfilter(): metadata_filter = MetadataFilter({"foo": dummy_fn}) assert metadata_filter.can_filter_field("foo") assert not metadata_filter.can_filter_field("bar") metadata_filter.filter_field("bar", "dummy") assert not metadata_filter.can_filter_field("bar")
def run_filter_test(metadata_filter: MetadataFilter, test_case: FilterTestCase): result = metadata_filter.filter_field(test_case["fieldName"], test_case["fieldValue"]) assert result == test_case["expectedValue"]
def test_getfields(): metadata_filter = MetadataFilter({"foo": dummy_fn, "bar": dummy_fn}) assert tuple(sorted(metadata_filter.get_fields())) == ("bar", "foo")
def test_empty_getfields(): metadata_filter = MetadataFilter({}) assert tuple(sorted(metadata_filter.get_fields())) == ()
def test_invalid_filter_function(): with pytest.raises( TypeError, match="Invalid filter function: expected callable, got 'str'"): MetadataFilter({"track": "not_callable"}) # type: ignore
def test_filtering_empty_strings(input_str): should_not_be_called = Mock( side_effect=Exception("This function should not be called.")) metadata_filter = MetadataFilter({"artist": should_not_be_called}) assert metadata_filter.filter_field("artist", input_str) == input_str