Make use of index with SQLiteCache.filter(expired=False)

2 files changed, 19 insertions, 16 deletions

diff --git a/tests/integration/test_sqlite.py b/tests/integration/test_sqlite.py
index 9aeaa3f..06b17cb 100644
--- a/tests/integration/test_sqlite.py
+++ b/tests/integration/test_sqlite.py
@@ -308,11 +308,15 @@ class TestSQLiteCache(BaseCacheTest):
         assert session.cache.count(expired=False) == 1
 
     @patch.object(SQLiteDict, 'sorted')
-    def test_filter__expired_only(self, mock_sorted):
-        """Filtering by expired only should use a more efficient SQL query"""
+    def test_filter__expired(self, mock_sorted):
+        """Filtering by expired should use a more efficient SQL query"""
         session = self.init_session()
-        session.cache.filter(valid=False, expired=True)
-        mock_sorted.assert_called_once_with(expired=True)
+
+        session.cache.filter()
+        mock_sorted.assert_called_with(expired=True)
+
+        session.cache.filter(expired=False)
+        mock_sorted.assert_called_with(expired=False)
 
     def test_sorted(self):
         """Test wrapper method for SQLiteDict.sorted(), with all arguments combined"""
diff --git a/tests/unit/test_base_cache.py b/tests/unit/test_base_cache.py
index 23b4e4f..b57ed09 100644
--- a/tests/unit/test_base_cache.py
+++ b/tests/unit/test_base_cache.py
@@ -9,7 +9,7 @@ from unittest.mock import patch
 import pytest
 from requests import Request
 
-from requests_cache.backends import BaseCache, SQLiteDict
+from requests_cache.backends import BaseCache, SQLiteCache, SQLiteDict
 from requests_cache.cache_keys import create_key
 from requests_cache.models import CachedRequest, CachedResponse
 from requests_cache.session import CachedSession
@@ -232,7 +232,7 @@ def test_recreate_keys__same_key_fn(mock_session):
 
 def test_reset_expiration__extend_expiration(mock_session):
     # Start with an expired response
-    mock_session.settings.expire_after = datetime.utcnow() - timedelta(seconds=0.01)
+    mock_session.settings.expire_after = datetime.utcnow() - timedelta(seconds=1)
     mock_session.get(MOCKED_URL)
 
     # Set expiration in the future
@@ -248,7 +248,7 @@ def test_reset_expiration__shorten_expiration(mock_session):
     mock_session.get(MOCKED_URL)
 
     # Set expiration in the past
-    mock_session.cache.reset_expiration(datetime.utcnow() - timedelta(seconds=0.01))
+    mock_session.cache.reset_expiration(datetime.utcnow() - timedelta(seconds=1))
     response = mock_session.get(MOCKED_URL)
     assert response.is_expired is False and response.from_cache is False
 
@@ -289,8 +289,8 @@ def test_urls(mock_normalize_url, mock_session):
 
 def test_urls__error(mock_session):
     responses = [mock_session.get(url) for url in [MOCKED_URL, MOCKED_URL_JSON, MOCKED_URL_HTTPS]]
-    responses[2] = AttributeError
-    with patch.object(SQLiteDict, '__getitem__', side_effect=responses):
+    responses[2] = None
+    with patch.object(SQLiteDict, 'deserialize', side_effect=responses):
         expected_urls = [MOCKED_URL_JSON, MOCKED_URL]
         assert mock_session.cache.urls() == expected_urls
 
@@ -358,6 +358,7 @@ def test_keys(mock_session):
         response_keys = set(mock_session.cache.responses.keys())
         redirect_keys = set(mock_session.cache.redirects.keys())
         assert set(mock_session.cache.keys()) == response_keys | redirect_keys
+        assert len(list(mock_session.cache.keys(check_expiry=True))) == 5
 
 
 def test_remove_expired_responses(mock_session):
@@ -397,16 +398,14 @@ def test_values(mock_session):
     assert all([isinstance(response, CachedResponse) for response in responses])
 
 
-@pytest.mark.parametrize('check_expiry, expected_count', [(True, 1), (False, 2)])
-def test_values__with_invalid_responses(check_expiry, expected_count, mock_session):
-    """values() should always exclude invalid responses, and optionally exclude expired responses"""
+def test_values__with_invalid_responses(mock_session):
     responses = [mock_session.get(url) for url in [MOCKED_URL, MOCKED_URL_JSON, MOCKED_URL_HTTPS]]
-    responses[1] = AttributeError
+    responses[1] = None
     responses[2] = CachedResponse(expires=YESTERDAY, url='test')
 
-    with ignore_deprecation(), patch.object(SQLiteDict, '__getitem__', side_effect=responses):
-        values = mock_session.cache.values(check_expiry=check_expiry)
-        assert len(list(values)) == expected_count
+    with ignore_deprecation(), patch.object(SQLiteCache, 'filter', side_effect=responses):
+        values = mock_session.cache.values(check_expiry=True)
+        assert len(list(values)) == 1
 
     # The invalid response should be skipped, but remain in the cache for now
     assert len(mock_session.cache.responses.keys()) == 3