From 9c460c6db7e6a4e7f8ed3e8d93032c7ef070efee Mon Sep 17 00:00:00 2001
From: Wolfgang Müller
Date: Thu, 20 Feb 2025 13:40:40 +0100
Subject: Add filter for association counts

This will replace the old 'empty' filter on comic associations and
introduce a generic way of matching against association counts, along
with support for different operators like 'greater than' or 'lower
than'.

Models that did not previously have a way of matching against their
associates (like filtering for Artists that have N comics associated
with them) now gain that functionality.

For now the frontend keeps the simpler approach of allowing the user to
only filter for empty associations, but we nonetheless need to adjust
the 'empty' field to instead be linked to the new 'count' field.
---
 tests/api/test_filter.py | 99 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 76 insertions(+), 23 deletions(-)

(limited to 'tests/api/test_filter.py')

diff --git a/tests/api/test_filter.py b/tests/api/test_filter.py
index 1438785..6eb2934 100644
--- a/tests/api/test_filter.py
+++ b/tests/api/test_filter.py
@@ -421,51 +421,59 @@ async def test_field_presence(query_comic_filter, gen_comic, empty_comic, filter
     "filter,ids",
     [
         (
-            {"include": {"artists": {"empty": True}}},
+            {"include": {"artists": {"count": {"value": 0}}}},
             [100],
         ),
         (
-            {"include": {"artists": {"empty": False}}},
-            [1, 2],
+            {"include": {"artists": {"count": {"value": 0, "operator": "EQUAL"}}}},
+            [100],
         ),
         (
-            {"exclude": {"artists": {"empty": True}}},
-            [1, 2],
+            {
+                "include": {
+                    "artists": {"count": {"value": 1, "operator": "GREATER_THAN"}}
+                }
+            },
+            [1],
         ),
         (
-            {"exclude": {"artists": {"empty": False}}},
-            [100],
+            {"include": {"artists": {"count": {"value": 3, "operator": "LOWER_THAN"}}}},
+            [1, 2, 100],
         ),
         (
-            {"include": {"tags": {"empty": True}}},
-            [100],
+            {"exclude": {"artists": {"count": {"value": 0}}}},
+            [1, 2],
         ),
         (
-            {"include": {"tags": {"empty": False}}},
+            {"exclude": {"artists": {"count": {"value": 0, "operator": "EQUAL"}}}},
             [1, 2],
         ),
         (
-            {"exclude": {"tags": {"empty": True}}},
-            [1, 2],
+            {
+                "exclude": {
+                    "artists": {"count": {"value": 1, "operator": "GREATER_THAN"}}
+                }
+            },
+            [2, 100],
         ),
         (
-            {"exclude": {"tags": {"empty": False}}},
-            [100],
+            {"exclude": {"artists": {"count": {"value": 3, "operator": "LOWER_THAN"}}}},
+            [],
         ),
     ],
     ids=[
-        "includes artist empty",
-        "includes artist not empty",
-        "excludes artist empty",
-        "excludes artist not empty",
-        "includes tags empty",
-        "includes tags not empty",
-        "excludes tags empty",
-        "excludes tags not empty",
+        "include equal (default)",
+        "include equal (explicit)",
+        "include greater than",
+        "include lower than",
+        "exclude equal (default)",
+        "exclude equal (explicit)",
+        "exclude greater than",
+        "exclude lower than",
     ],
 )
 @pytest.mark.anyio
-async def test_assoc_presence(query_comic_filter, gen_comic, empty_comic, filter, ids):
+async def test_assoc_counts(query_comic_filter, gen_comic, empty_comic, filter, ids):
     await DB.add(next(gen_comic))
     await DB.add(next(gen_comic))
     await DB.add(empty_comic)
@@ -520,3 +528,48 @@ async def test_tag_assoc_filter(query_tag_filter, gen_namespace, gen_tag, filter
     response.assert_is("TagFilterResult")
 
     assert id_list(response.edges) == ids
+
+
+@pytest.mark.parametrize(
+    "filter,expect",
+    [
+        ({"include": {"comics": {"count": {"value": 1}}}}, [2, 3]),
+        ({"include": {"comics": {"count": {"value": 2, "operator": "EQUAL"}}}}, [1, 4]),
+        (
+            {
+                "include": {
+                    "comics": {"count": {"value": 3, "operator": "GREATER_THAN"}}
+                }
+            },
+            [],
+        ),
+        (
+            {"include": {"comics": {"count": {"value": 2, "operator": "LOWER_THAN"}}}},
+            [2, 3],
+        ),
+        (
+            {"exclude": {"comics": {"count": {"value": 1}}}},
+            [1, 4],
+        ),
+        (
+            {"exclude": {"comics": {"count": {"value": 1, "operator": "LOWER_THAN"}}}},
+            [1, 2, 3, 4],
+        ),
+    ],
+    ids=[
+        "include equal (default)",
+        "include equal (explicit)",
+        "include greater than",
+        "include lower than",
+        "exclude equal (default)",
+        "exclude lower than",
+    ],
+)
+@pytest.mark.anyio
+async def test_count_filter(query_string_filter, gen_comic, filter, expect):
+    await DB.add_all(*gen_comic)
+
+    response = Response(await query_string_filter(filter))
+    response.assert_is("ArtistFilterResult")
+
+    assert id_list(response.edges) == expect
-- 
cgit v1.2.3-2-gb3c3