Fix targeted clear coverage and pickle flow

Author: shaypal5

src/cachier/cores/pickle.py

@@ -272,10 +272,14 @@ async def _aset_entry(self, key: str, func_res: Any) -> bool:
         return self._set_entry(key, func_res)
 
     def mark_entry_being_calculated_separate_files(self, key: str) -> None:
-        self._save_cache(
-            CacheEntry(value=None, time=datetime.now(), stale=False, _processing=True),
-            separate_file_key=key,
+        entry = self._load_cache_by_key(key) or CacheEntry(
+            value=None,
+            time=datetime.now(),
+            stale=False,
+            _processing=False,
         )
+        entry._processing = True
+        self._save_cache(entry, separate_file_key=key)
 
     def _mark_entry_not_calculated_separate_files(self, key: str) -> None:
         _, entry = self.get_entry_by_key(key)

tests/mongo_tests/clients.py

@@ -69,3 +69,11 @@ async def delete_many(self, query=None, **kwargs):
             del self._docs[key]
             deleted += 1
         return {"deleted_count": deleted}
+
+    async def delete_one(self, query=None, **kwargs):
+        if query is None:
+            query = kwargs.get("filter", {})
+        key = (query.get("func"), query.get("key"))
+        existed = key in self._docs
+        self._docs.pop(key, None)
+        return {"deleted_count": int(existed)}

tests/mongo_tests/test_async_mongo_core.py

@@ -152,6 +152,10 @@ async def test_async_mongo_core_mark_clear_and_stale_paths():
 
     await core.amark_entry_being_calculated("fresh")
     await core.amark_entry_not_calculated("fresh")
+    await core.aclear_cache_entry("fresh")
+    assert (core._func_str, "fresh") not in collection._docs
+
+    await core.aset_entry("fresh", 2)
     await core.aclear_being_calculated()
     await core.adelete_stale_entries(timedelta(hours=1))
 

tests/pickle_tests/test_pickle_core.py

@@ -287,7 +287,7 @@ def test_being_calc_next_time(separate_files):
         separate_files=separate_files,
     )
     _being_calc_next_time_decorated.clear_cache()
-    _being_calc_next_time(0.13, 0.02)
+    _being_calc_next_time_decorated(0.13, 0.02)
     sleep(1.1)
     res_queue = queue.Queue()
     thread1 = threading.Thread(

tests/redis_tests/test_async_redis_core.py

@@ -224,8 +224,14 @@ async def test_async_redis_core_mark_and_clear_paths():
     assert clean1._processing is False
     assert clean2._processing is False
 
+    await core.aclear_cache_entry("cleanup-1")
+    _, cleared_one = await core.aget_entry_by_key("cleanup-1")
+    _, kept = await core.aget_entry_by_key("cleanup-2")
+    assert cleared_one is None
+    assert kept is not None
+
     await core.aclear_cache()
-    _, cleared = await core.aget_entry_by_key("cleanup-1")
+    _, cleared = await core.aget_entry_by_key("cleanup-2")
     assert cleared is None
 
     await core.aclear_cache()
@@ -252,6 +258,11 @@ async def test_async_redis_core_mark_and_clear_exceptions():
     with pytest.warns(UserWarning, match="Redis clear_cache failed"):
         await core.aclear_cache()
 
+    client.fail_keys = False
+    client.fail_delete = True
+    with pytest.warns(UserWarning, match="Redis clear_cache_entry failed"):
+        await core.aclear_cache_entry("k")
+
 
 @pytest.mark.redis
 @pytest.mark.asyncio

tests/redis_tests/test_redis_core_exceptions.py

@@ -96,6 +96,12 @@ def test_clear_cache_exceptions(self, core, mock_redis):
         with pytest.warns(UserWarning, match="Redis clear_cache failed"):
             core.clear_cache()
 
+    def test_clear_cache_entry_exceptions(self, core, mock_redis):
+        """Test clear_cache_entry Redis delete exception handling."""
+        mock_redis.delete.side_effect = Exception("Redis error")
+        with pytest.warns(UserWarning, match="Redis clear_cache_entry failed"):
+            core.clear_cache_entry("key")
+
     def test_clear_being_calculated_exceptions(self, core, mock_redis):
         """Test clear_being_calculated Redis keys exception handling."""
         mock_redis.keys.side_effect = Exception("Redis error")

tests/s3_tests/test_s3_core.py

@@ -699,6 +699,16 @@ def _dummy(x):
     core.clear_cache()
     assert client.delete_objects.call_count == 2
 
+    client.delete_object = Mock(return_value=None)
+    core.clear_cache_entry("k")
+    assert client.delete_object.called
+
+    client.delete_object = Mock(side_effect=RuntimeError("delete failed"))
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        core.clear_cache_entry("k")
+    assert any("clear_cache_entry failed" in str(w.message) for w in caught)
+
     client.get_paginator = Mock(side_effect=RuntimeError("paginate failed"))
     with warnings.catch_warnings(record=True) as caught:
         warnings.simplefilter("always")

tests/sql_tests/test_async_sql_core.py

@@ -138,6 +138,45 @@ async def test_sqlcore_async_session_requires_async_engine():
         await core._get_async_session()
 
 
+@pytest.mark.sql
+@pytest.mark.asyncio
+async def test_async_sql_clear_cache_entry_executes_delete(monkeypatch):
+    core = _SQLCore.__new__(_SQLCore)
+    core._func_str = "test_func"
+
+    class FakeSession:
+        def __init__(self):
+            self.executed = []
+            self.committed = False
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return None
+
+        async def execute(self, stmt):
+            self.executed.append(stmt)
+
+        async def commit(self):
+            self.committed = True
+
+    session = FakeSession()
+
+    def session_factory():
+        return session
+
+    async def fake_get_async_session():
+        return session_factory
+
+    monkeypatch.setattr(core, "_get_async_session", fake_get_async_session)
+
+    await core.aclear_cache_entry("one-key")
+
+    assert session.executed
+    assert session.committed is True
+
+
 @pytest.mark.sql
 @pytest.mark.asyncio
 async def test_sqlcore_async_session_creates_tables_once(async_sql_engine):