fix(cache): json query distinct & list comparisons

Author: ddkasa

tests/test_meta/test_cache.py

@@ -1,5 +1,6 @@
 import json
 import random
+import sys
 import time
 from copy import deepcopy
 from dataclasses import asdict
@@ -12,7 +13,7 @@
 from toggl_api.meta import CustomDecoder, CustomEncoder, JSONCache, RequestMethod
 from toggl_api.meta.cache.base_cache import Comparison, TogglQuery
 from toggl_api.meta.cache.json_cache import JSONSession
-from toggl_api.models.models import TogglTracker
+from toggl_api.models.models import TogglTag, TogglTracker
 from toggl_api.user import UserEndpoint
 
 
@@ -176,6 +177,44 @@ def test_query(model_data, tracker_object, faker):
     assert len(tracker_object.query(TogglQuery("name", names[:5]))) == 5  # noqa: PLR2004
 
 
+@pytest.mark.unit
+def test_query_distinct(model_data, tracker_object, faker):
+    t = model_data.pop("tracker")
+    t.id = 1
+
+    d = asdict(t)
+    for i in range(1, 13):
+        d["id"] += i
+        d["timestamp"] = datetime.now(timezone.utc)
+        tracker_object.save_cache(TogglTracker.from_kwargs(**d), RequestMethod.GET)
+
+    tracker_object.cache.commit()
+    assert len(tracker_object.load_cache()) == 12  # noqa: PLR2004
+    assert len(tracker_object.query(TogglQuery("name", t["name"]), distinct=True)) == 1
+
+
+@pytest.mark.unit
+def test_query_tag(model_data, tracker_object, faker, number):
+    names = [faker.name() for _ in range(12)]
+    t = model_data.pop("tracker")
+    t.id = 1
+
+    d = asdict(t)
+    tracker_object.save_cache(TogglTracker.from_kwargs(**d), RequestMethod.GET)
+    tag = TogglTag(number.randint(50, sys.maxsize), faker.name())
+
+    for i in range(1, 3):
+        d["id"] += i
+        d["name"] = names[i - 1]
+        d["timestamp"] = datetime.now(timezone.utc)
+        d["tags"] = [tag]
+        tracker_object.save_cache(TogglTracker.from_kwargs(**d), RequestMethod.GET)
+
+    tracker_object.cache.commit()
+    assert len(tracker_object.load_cache()) == 3  # noqa: PLR2004
+    assert len(tracker_object.query(TogglQuery("tags", [tag]))) == 2  # noqa: PLR2004
+
+
 @pytest.mark.unit
 def test_query_parent(tmp_path):
     cache = JSONCache(Path(tmp_path))

toggl_api/meta/cache/json_cache.py

@@ -272,34 +272,58 @@ def query(self, *query: TogglQuery, distinct: bool = False) -> list[TogglClass]:
         search = self.session.data
         existing: defaultdict[str, set[Any]] = defaultdict(set)
 
-        return [model for model in search if self._query_helper(model, query, existing, min_ts)]
+        return [
+            model
+            for model in search
+            if self._query_helper(
+                model,
+                query,
+                existing,
+                min_ts,
+                distinct=distinct,
+            )
+        ]
 
     def _query_helper(
         self,
         model: TogglClass,
         queries: tuple[TogglQuery, ...],
         existing: dict[str, set[Any]],
         min_ts: Optional[datetime],
+        *,
+        distinct: bool,
     ) -> bool:
         if self.expire_after and min_ts and model.timestamp and min_ts >= model.timestamp:
             return False
 
         for query in queries:
-            if model[query.key] in existing[query.key] or not self._match_query(model, query):
+            if (
+                distinct and not isinstance(query.value, list) and model[query.key] in existing[query.key]
+            ) or not self._match_query(model, query):
                 return False
 
-        for query in queries:
-            existing[query.key].add(model[query.key])
+        if distinct:
+            for query in queries:
+                existing[query.key].add(model[query.key])
 
         return True
 
+    @staticmethod
+    def _match_equal(model: TogglClass, query: TogglQuery):
+        if isinstance(query.value, Sequence) and not isinstance(query.value, str):
+            value = model[query.key]
+
+            if isinstance(value, list):
+                return any(v == comp for comp in query.value for v in value)
+
+            return any(value == comp for comp in query.value)
+
+        return model[query.key] == query.value
+
     @staticmethod
     def _match_query(model: TogglClass, query: TogglQuery) -> bool:
         if query.comparison == Comparison.EQUAL:
-            if isinstance(query.value, Sequence) and not isinstance(query.value, str):
-                value = model[query.key]
-                return any(value == comp for comp in query.value)
-            return model[query.key] == query.value
+            return JSONCache._match_equal(model, query)
         if query.comparison == Comparison.LESS_THEN:
             return model[query.key] < query.value
         if query.comparison == Comparison.LESS_THEN_OR_EQUAL: