dummy

Author: Yuri Zmytrakov

Makefile

@@ -82,7 +82,7 @@ test-datetime-filtering-os:
 	docker compose down
 
 .PHONY: test
-test: test-elasticsearch test-datetime-filtering-es test-opensearch test-datetime-filtering-os test-redis-es test-redis-os
+test: test-opensearch
 
 .PHONY: run-database-es
 run-database-es:

stac_fastapi/core/stac_fastapi/core/core.py

@@ -24,7 +24,7 @@
 from stac_fastapi.core.base_settings import ApiBaseSettings
 from stac_fastapi.core.datetime_utils import format_datetime_range
 from stac_fastapi.core.models.links import PagingLinks
-from stac_fastapi.core.redis_utils import connect_redis, get_prev_link, save_self_link
+from stac_fastapi.core.redis_utils import _handle_pagination_via_redis
 from stac_fastapi.core.serializers import CollectionSerializer, ItemSerializer
 from stac_fastapi.core.session import Session
 from stac_fastapi.core.utilities import filter_fields, get_bool_env
@@ -329,20 +329,8 @@ async def all_collections(
             if parsed_sort:
                 sort = parsed_sort
 
-        current_url = str(request.url)
         redis_enable = get_bool_env("REDIS_ENABLE", default=False)
 
-        redis = None
-        if redis_enable:
-            try:
-                redis = await connect_redis()
-                logger.info("Redis connection established successfully")
-            except Exception as e:
-                redis = None
-                logger.warning(
-                    f"Redis connection failed, continuing without Redis: {e}"
-                )
-
         # Convert q to a list if it's a string
         q_list = None
         if q is not None:
@@ -441,21 +429,7 @@ async def all_collections(
             },
         ]
 
-        if redis_enable and redis:
-            if next_token:
-                await save_self_link(redis, next_token, current_url)
-
-            prev_link = await get_prev_link(redis, token)
-            if prev_link:
-                links.insert(
-                    0,
-                    {
-                        "rel": "prev",
-                        "type": "application/json",
-                        "method": "GET",
-                        "href": prev_link,
-                    },
-                )
+        _handle_pagination_via_redis(redis_enable, next_token, token, request, links)
 
         if next_token:
             next_link = PagingLinks(next=next_token, request=request).link_next()
@@ -901,29 +875,9 @@ async def post_search(
                 )
         links.extend(collection_links)
 
-        if redis_enable:
-            redis = None
-            try:
-                redis = await connect_redis()
-                logger.info("Redis connection established successfully")
-                self_link = str(request.url)
-                await save_self_link(redis, next_token, self_link)
-
-                prev_link = await get_prev_link(redis, token_param)
-                if prev_link:
-                    links.insert(
-                        0,
-                        {
-                            "rel": "prev",
-                            "type": "application/json",
-                            "method": "GET",
-                            "href": prev_link,
-                        },
-                    )
-            except Exception as e:
-                logger.warning(
-                    f"Redis connection failed, continuing without Redis: {e}"
-                )
+        _handle_pagination_via_redis(
+            redis_enable, next_token, token_param, request, links
+        )
 
         return stac_types.ItemCollection(
             type="FeatureCollection",

stac_fastapi/core/stac_fastapi/core/redis_utils.py

@@ -1,11 +1,15 @@
 """Utilities for connecting to and managing Redis connections."""
 
-from typing import Optional
+import logging
+from typing import Dict, List, Optional
 
+from fastapi import Request
 from pydantic_settings import BaseSettings
 from redis import asyncio as aioredis
 from redis.asyncio.sentinel import Sentinel
 
+logger = logging.getLogger(__name__)
+
 redis_pool: Optional[aioredis.Redis] = None
 
 
@@ -122,3 +126,38 @@ async def get_prev_link(redis: aioredis.Redis, token: Optional[str]) -> Optional
     if not token:
         return None
     return await redis.get(f"nav:self:{token}")
+
+
+async def _handle_pagination_via_redis(
+    redis_enable: bool,
+    next_token: Optional[str],
+    token_param: Optional[str],
+    request: Request,
+    links: List[Dict],
+) -> None:
+    """Handle Redis connection and operations for pagination links."""
+    if not redis_enable:
+        return
+
+    redis = None
+    try:
+        redis = await connect_redis()
+        logger.info("Redis connection established successfully")
+
+        if redis and next_token:
+            self_link = str(request.url)
+            await save_self_link(redis, next_token, self_link)
+
+            prev_link = await get_prev_link(redis, token_param)
+            if prev_link:
+                links.insert(
+                    0,
+                    {
+                        "rel": "prev",
+                        "type": "application/json",
+                        "method": "GET",
+                        "href": prev_link,
+                    },
+                )
+    except Exception as e:
+        logger.warning(f"Redis connection failed, continuing without Redis: {e}")

stac_fastapi/tests/redis/test_redis_pagination.py

@@ -10,7 +10,9 @@ async def test_search_pagination_uses_redis_cache(
     app_client, txn_client, load_test_data
 ):
     """Test Redis caching and navigation for the /search endpoint."""
-
+    import os
+    print(f"REDIS_ENABLE: {os.getenv('REDIS_ENABLE')}")
+    
     collection = load_test_data("test_collection.json")
     collection_id = f"test-pagination-collection-{uuid.uuid4()}"
     collection["id"] = collection_id
@@ -22,27 +24,39 @@ async def test_search_pagination_uses_redis_cache(
         item["collection"] = collection_id
         await create_item(txn_client, item)
 
+    # First request - should save to Redis
     resp = await app_client.post(
         "/search", json={"collections": [collection_id], "limit": 1}
     )
     resp_json = resp.json()
+    print(f"First response links: {[link['rel'] for link in resp_json['links']]}")
 
     next_link = next(
         (link for link in resp_json["links"] if link["rel"] == "next"), None
     )
+    assert next_link is not None, "No next link found in first response"
     next_token = next_link["body"]["token"]
+    print(f"Next token: {next_token}")
 
-    # Expect the previous link on the second page to be retrieved from Redis cache
+    # Second request - should retrieve from Redis
     resp2 = await app_client.post(
         "/search",
         json={"collections": [collection_id], "limit": 1, "token": next_token},
     )
     resp2_json = resp2.json()
+    print(f"Second response links: {[link['rel'] for link in resp2_json['links']]}")
 
     prev_link = next(
         (link for link in resp2_json["links"] if link["rel"] == "prev"), None
     )
-    assert prev_link is not None
+    
+    if prev_link is None:
+        print("DEBUG: No prev link found. Checking all links:")
+        for link in resp2_json["links"]:
+            print(f"  - {link['rel']}: {link.get('href', 'No href')}")
+    
+    assert prev_link is not None, "No prev link found - Redis may not be working"
+    print(f"Prev link found: {prev_link['href']}")
 
 
 @pytest.mark.asyncio