Cache fixes for version changes

Author: Robbie1977

src/test/test_solr_cache_failover.py

@@ -1,3 +1,5 @@
+import json
+from datetime import datetime, timedelta
 import unittest
 from unittest.mock import MagicMock, patch
 
@@ -38,6 +40,77 @@ def test_disable_and_reenable_on_solr_failure(self):
             # One call for the health check, one for the cache query itself
             self.assertGreaterEqual(get.call_count, 1)
 
+    def test_cache_invalidated_on_major_version_change(self):
+        cache = SolrResultCache()
+        cache._solr_available = MagicMock(return_value=True)
+        cache._package_version = "1.8.1"
+
+        cached_data = {
+            "result": {"foo": "bar"},
+            "cached_at": datetime.now().isoformat(),
+            "expires_at": (datetime.now() + timedelta(hours=1)).isoformat(),
+            "params": {"limit": -1},
+            "hit_count": 0,
+            "cache_version": "1.0",
+            "package_version": "1.8.0",
+            "ttl_hours": 2160,
+        }
+
+        response_doc = {"response": {"docs": [{"cache_data": json.dumps(cached_data)}]}}
+
+        with patch("vfbquery.solr_result_cache.requests.get") as get:
+            get.return_value = MagicMock(status_code=200, json=lambda: response_doc)
+            result = cache.get_cached_result("term_info", "FBbt_00000000")
+            self.assertIsNone(result)
+            self.assertEqual(get.call_count, 1)
+
+    def test_cache_retained_on_patch_version_change(self):
+        cache = SolrResultCache()
+        cache._solr_available = MagicMock(return_value=True)
+        cache._package_version = "1.8.2"
+
+        cached_data = {
+            "result": {"foo": "bar"},
+            "cached_at": datetime.now().isoformat(),
+            "expires_at": (datetime.now() + timedelta(hours=1)).isoformat(),
+            "params": {"limit": -1},
+            "hit_count": 0,
+            "cache_version": "1.0",
+            "package_version": "1.8.1",
+            "ttl_hours": 2160,
+        }
+
+        response_doc = {"response": {"docs": [{"cache_data": json.dumps(cached_data)}]}}
+
+        with patch("vfbquery.solr_result_cache.requests.get") as get:
+            get.return_value = MagicMock(status_code=200, json=lambda: response_doc)
+            result = cache.get_cached_result("term_info", "FBbt_00000000")
+            self.assertEqual(result, {"foo": "bar"})
+            self.assertEqual(get.call_count, 1)
+
+    def test_cache_invalidated_when_cached_version_missing(self):
+        cache = SolrResultCache()
+        cache._solr_available = MagicMock(return_value=True)
+        cache._package_version = "1.8.2"
+
+        cached_data = {
+            "result": {"foo": "bar"},
+            "cached_at": datetime.now().isoformat(),
+            "expires_at": (datetime.now() + timedelta(hours=1)).isoformat(),
+            "params": {"limit": -1},
+            "hit_count": 0,
+            "cache_version": "1.0",
+            "ttl_hours": 2160,
+        }
+
+        response_doc = {"response": {"docs": [{"cache_data": json.dumps(cached_data)}]}}
+
+        with patch("vfbquery.solr_result_cache.requests.get") as get:
+            get.return_value = MagicMock(status_code=200, json=lambda: response_doc)
+            result = cache.get_cached_result("term_info", "FBbt_00000000")
+            self.assertIsNone(result)
+            self.assertEqual(get.call_count, 1)
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

src/vfbquery/solr_result_cache.py

@@ -12,6 +12,7 @@
 
 import json
 import os
+import re
 import requests
 import hashlib
 import time
@@ -23,6 +24,15 @@
 import pandas as pd
 from vfbquery.term_info_queries import NumpyEncoder
 
+try:
+    from importlib.metadata import version as get_distribution_version, PackageNotFoundError
+except ImportError:
+    try:
+        from importlib_metadata import version as get_distribution_version, PackageNotFoundError
+    except ImportError:
+        get_distribution_version = None
+        PackageNotFoundError = Exception
+
 logger = logging.getLogger(__name__)
 
 @dataclass 
@@ -105,9 +115,49 @@ def _create_cache_metadata(self, result: Any, **params) -> Optional[Dict[str, An
             "params": params,  # Store the parameters used for this query
             "hit_count": 0,
             "cache_version": "1.0",  # For future compatibility
+            "package_version": self._get_cache_package_version(),
             "ttl_hours": self.ttl_hours  # Store TTL for debugging
         }
 
+    def _normalize_version(self, version: Optional[str]) -> Optional[str]:
+        """Normalize a version string to major.minor only."""
+        if not version or not isinstance(version, str):
+            return None
+        match = re.match(r'^\s*(\d+)(?:\.(\d+))?', version)
+        if not match:
+            return None
+        major = match.group(1)
+        minor = match.group(2) or '0'
+        return f"{major}.{minor}"
+
+    def _get_package_version(self) -> Optional[str]:
+        """Return the VFBquery package version for cache validation."""
+        if hasattr(self, '_package_version') and self._package_version is not None:
+            return self._package_version
+
+        version_value = os.getenv('VFBQUERY_VERSION')
+        if version_value:
+            self._package_version = version_value
+            return version_value
+
+        if get_distribution_version is None:
+            self._package_version = None
+            return None
+
+        try:
+            self._package_version = get_distribution_version('vfbquery')
+        except PackageNotFoundError:
+            self._package_version = None
+        except Exception as e:
+            logger.warning(f"Could not determine package version for cache validation: {e}")
+            self._package_version = None
+
+        return self._package_version
+
+    def _get_cache_package_version(self) -> Optional[str]:
+        """Return the normalized package version used for cache invalidation."""
+        return self._normalize_version(self._get_package_version())
+
     def _solr_available(self) -> bool:
         """Return True if Solr caching looks operational.
 
@@ -198,6 +248,17 @@ def get_cached_result(self, query_type: str, term_id: str, **params) -> Optional
             # Parse the cached metadata and result
             cached_data = json.loads(cached_field)
 
+            # Check package version before anything else so stale cache is rejected early
+            current_version = self._get_cache_package_version()
+            cached_version = self._normalize_version(cached_data.get("package_version") or cached_data.get("version"))
+            if current_version and cached_version != current_version:
+                logger.info(
+                    f"Cache invalidated for {query_type}({term_id}) because package major.minor version changed "
+                    f"(cached={cached_version}, current={current_version})"
+                )
+                self._clear_expired_cache_document(cache_doc_id)
+                return None
+
             # Check expiration (3-month max age)
             try:
                 expires_at = datetime.fromisoformat(cached_data["expires_at"].replace('Z', '+00:00'))