Refactor queryparse tests

Author: snejus

test/dbcore/test_queryparse.py

@@ -1,183 +1,138 @@
 """Tests for dbcore query parsing helpers."""
 
-import unittest
-
 import pytest
 
 from beets.dbcore import ModelQuery, query, sort
 from beets.dbcore.queryparse import QueryTerm
 from beets.test.fixtures import ModelFixture1, SortFixture
 
-
-class QueryParseTest(unittest.TestCase):
-    def pqp(self, part):
-        term = QueryTerm.make(part)
-        return term.field, term.pattern, term.get_query_cls(ModelFixture1)
-
-    def test_one_basic_term(self):
-        q = "test"
-        r = (None, "test", query.SubstringQuery)
-        assert self.pqp(q) == r
-
-    def test_one_keyed_term(self):
-        q = "test:val"
-        r = ("test", "val", query.SubstringQuery)
-        assert self.pqp(q) == r
-
-    def test_colon_at_end(self):
-        q = "test:"
-        r = ("test", "", query.SubstringQuery)
-        assert self.pqp(q) == r
-
-    def test_one_basic_regexp(self):
-        q = r":regexp"
-        r = (None, "regexp", query.RegexpQuery)
-        assert self.pqp(q) == r
-
-    def test_keyed_regexp(self):
-        q = r"test::regexp"
-        r = ("test", "regexp", query.RegexpQuery)
-        assert self.pqp(q) == r
-
-    def test_escaped_colon(self):
-        q = r"test\:val"
-        r = (None, "test:val", query.SubstringQuery)
-        assert self.pqp(q) == r
-
-    def test_escaped_colon_in_regexp(self):
-        q = r":test\:regexp"
-        r = (None, "test:regexp", query.RegexpQuery)
-        assert self.pqp(q) == r
-
-    def test_single_year(self):
-        q = "year:1999"
-        r = ("year", "1999", query.NumericQuery)
-        assert self.pqp(q) == r
-
-    def test_multiple_years(self):
-        q = "year:1999..2010"
-        r = ("year", "1999..2010", query.NumericQuery)
-        assert self.pqp(q) == r
-
-    def test_empty_query_part(self):
-        q = ""
-        r = (None, "", query.SubstringQuery)
-        assert self.pqp(q) == r
-
-    def test_implicit_path(self):
-        q = "/tmp"
-        r = ("path", "/tmp", query.PathQuery)
-        assert self.pqp(q) == r
-
-
-class QueryFromStringsTest(unittest.TestCase):
-    def qfs(self, strings):
-        return ModelQuery.build_and_query(ModelFixture1, strings)
-
-    def test_zero_parts(self):
-        q = self.qfs([])
-        assert isinstance(q, query.TrueQuery)
-
-    def test_two_parts(self):
-        q = self.qfs(["foo", "bar:baz"])
+_p = pytest.param
+
+
+def _parse_query_parts(parts: list[str]):
+    return ModelFixture1.parse_query(parts).query
+
+
+def _parse_sort_parts(parts: list[str]):
+    return ModelFixture1.parse_query(parts).sort
+
+
+class TestQueryTermParsing:
+    @pytest.mark.parametrize(
+        "query_string,expected",
+        [
+            ("test", (None, "test", query.SubstringQuery)),
+            ("test:val", ("test", "val", query.SubstringQuery)),
+            ("test:", ("test", "", query.SubstringQuery)),
+            (r":regexp", (None, "regexp", query.RegexpQuery)),
+            (r"test::regexp", ("test", "regexp", query.RegexpQuery)),
+            (r"test\:val", (None, "test:val", query.SubstringQuery)),
+            (r":test\:regexp", (None, "test:regexp", query.RegexpQuery)),
+            ("year:1999", ("year", "1999", query.NumericQuery)),
+            ("year:1999..2010", ("year", "1999..2010", query.NumericQuery)),
+            ("", (None, "", query.SubstringQuery)),
+            ("/tmp", ("path", "/tmp", query.PathQuery)),
+        ],
+    )
+    def test_query_term_parsing(self, query_string, expected):
+        """Test that various query strings are parsed correctly."""
+        term = QueryTerm.make(query_string)
+        result = term.field, term.pattern, term.get_query_cls(ModelFixture1)
+        assert result == expected
+
+
+class TestQueryFromParts:
+    @pytest.mark.parametrize(
+        "query_parts,expected_type",
+        [
+            _p([], query.TrueQuery, id="zero_parts"),
+            _p([""], query.TrueQuery, id="empty_query_part"),
+            _p(["field_one:2..3"], query.NumericQuery, id="fixed_type_query"),
+            _p(
+                ["some_float_field:2..3"],
+                query.NumericQuery,
+                id="flex_type_query",
+            ),
+        ],
+    )
+    def test_query_from_parts_types(self, query_parts, expected_type):
+        q = _parse_query_parts(query_parts)
+        assert isinstance(q, expected_type)
+
+    def test_query_from_two_parts_builds_and_query(self):
+        q = _parse_query_parts(["foo", "bar:baz"])
         assert isinstance(q, query.AndQuery)
         assert len(q.subqueries) == 2
         assert isinstance(q.subqueries[0], query.OrQuery)
         assert isinstance(q.subqueries[1], query.SubstringQuery)
 
-    def test_parse_fixed_type_query(self):
-        q = self.qfs(["field_one:2..3"])
-        assert isinstance(q, query.NumericQuery)
-
-    def test_parse_flex_type_query(self):
-        q = self.qfs(["some_float_field:2..3"])
-        assert isinstance(q, query.NumericQuery)
-
-    def test_empty_query_part(self):
-        q = self.qfs([""])
-        assert isinstance(q, query.TrueQuery)
 
-
-class SortFromStringsTest(unittest.TestCase):
-    def sfs(self, strings):
-        return ModelQuery.get_sort(ModelFixture1, strings)
-
-    def test_zero_parts(self):
-        s = self.sfs([])
+class TestSortFromParts:
+    def test_sort_from_zero_parts(self):
+        s = _parse_sort_parts([])
         assert isinstance(s, sort.NullSort)
         assert s == sort.NullSort()
 
-    def test_one_parts(self):
-        s = self.sfs(["field+"])
+    def test_sort_from_one_part(self):
+        s = _parse_sort_parts(["field+"])
         assert isinstance(s, sort.Sort)
 
-    def test_two_parts(self):
-        s = self.sfs(["field+", "another_field-"])
+    def test_sort_from_two_parts(self):
+        s = _parse_sort_parts(["field+", "another_field-"])
         assert isinstance(s, sort.MultipleSort)
         assert len(s.sorts) == 2
 
-    def test_fixed_field_sort(self):
-        s = self.sfs(["field_one+"])
-        assert isinstance(s, sort.FixedFieldSort)
-        assert s == sort.FixedFieldSort("field_one")
-
-    def test_flex_field_sort(self):
-        s = self.sfs(["flex_field+"])
-        assert isinstance(s, sort.SlowFieldSort)
-        assert s == sort.SlowFieldSort("flex_field")
-
-    def test_special_sort(self):
-        s = self.sfs(["some_sort+"])
-        assert isinstance(s, SortFixture)
-
-
-class ParseSortedQueryTest(unittest.TestCase):
-    def psq(self, parts):
-        return ModelQuery.parse(ModelFixture1, parts.split())
-
-    def test_and_query(self):
-        q, s = self.psq("foo bar")
-        assert isinstance(q, query.AndQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 2
-
-    def test_or_query(self):
-        q, s = self.psq("foo , bar")
-        assert isinstance(q, query.OrQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 4
-
-    def test_no_space_before_comma_or_query(self):
-        q, s = self.psq("foo, bar")
-        assert isinstance(q, query.OrQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 4
-
-    def test_no_spaces_or_query(self):
-        q, s = self.psq("foo,bar")
-        assert isinstance(q, query.OrQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 2
-
-    def test_trailing_comma_or_query(self):
-        q, s = self.psq("foo , bar ,")
-        assert isinstance(q, query.OrQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 5
-
-    def test_leading_comma_or_query(self):
-        q, s = self.psq(", foo , bar")
-        assert isinstance(q, query.OrQuery)
-        assert isinstance(s, sort.NullSort)
-        assert len(q.subqueries) == 5
-
-    def test_only_direction(self):
-        q, s = self.psq("-")
-        assert isinstance(q, query.NotQuery)
-        assert isinstance(s, sort.NullSort)
-
-
-class ParseQueryTest:
+    @pytest.mark.parametrize(
+        "sort_parts,expected_type,expected_sort",
+        [
+            _p(
+                ["field_one+"],
+                sort.FixedFieldSort,
+                sort.FixedFieldSort("field_one"),
+                id="fixed_field_sort",
+            ),
+            _p(
+                ["flex_field+"],
+                sort.SlowFieldSort,
+                sort.SlowFieldSort("flex_field"),
+                id="flex_field_sort",
+            ),
+            _p(["some_sort+"], SortFixture, None, id="special_sort"),
+        ],
+    )
+    def test_sort_from_parts_types(
+        self, sort_parts, expected_type, expected_sort
+    ):
+        s = _parse_sort_parts(sort_parts)
+        assert isinstance(s, expected_type)
+        if expected_sort is not None:
+            assert s == expected_sort
+
+
+class TestParseSortedQuery:
+    @pytest.mark.parametrize(
+        "query_str,expected_type,expected_subqueries",
+        [
+            _p("foo bar", query.AndQuery, 2, id="and_query"),
+            _p("foo , bar", query.OrQuery, 4, id="or_query"),
+            _p("foo, bar", query.OrQuery, 4, id="no_space_before_comma_or_query"),
+            _p("foo,bar", query.OrQuery, 2, id="no_spaces_or_query"),
+            _p("foo , bar ,", query.OrQuery, 5, id="trailing_comma_or_query"),
+            _p(", foo , bar", query.OrQuery, 5, id="leading_comma_or_query"),
+            _p("-", query.NotQuery, None, id="only_direction"),
+        ],
+    )  # fmt: skip
+    def test_parse_sorted_query(
+        self, query_str, expected_type, expected_subqueries
+    ):
+        """Verify that query strings are parsed into the correct query type."""
+        q = _parse_query_parts(query_str.split())
+        assert isinstance(q, expected_type)
+        if expected_subqueries is not None:
+            assert len(q.subqueries) == expected_subqueries
+
+
+class TestModelQueryErrors:
     def test_parse_invalid_query_string(self):
         with pytest.raises(query.ParsingError):
             ModelQuery.parse(ModelFixture1, 'foo"')