chore: move version check into dashboard router, mock Github API call in tests

Author: alex-mcgovern

src/codegate/dashboard/dashboard.py

@@ -1,10 +1,13 @@
 import asyncio
+from concurrent.futures import ThreadPoolExecutor
 import json
 from typing import AsyncGenerator, List, Optional
 
+from httpx import AsyncClient, HTTPStatusError
 import structlog
-from fastapi import APIRouter, Depends, FastAPI
+from fastapi import APIRouter, Depends, FastAPI, HTTPException
 from fastapi.responses import StreamingResponse
+from codegate import __version__
 
 from codegate.dashboard.post_processing import (
     parse_get_alert_conversation,
@@ -18,13 +21,30 @@
 dashboard_router = APIRouter(tags=["Dashboard"])
 db_reader = None
 
-
 def get_db_reader():
     global db_reader
     if db_reader is None:
         db_reader = DbReader()
     return db_reader
 
+def get_http_client() -> AsyncClient:
+    return AsyncClient()
+
+async def fetch_latest_version(client: AsyncClient) -> str:
+    url = "https://api.github.com/repos/stacklok/codegate/releases/latest"
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    }
+    response = await client.get(url, headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    return data.get("tag_name", "unknown")
+
+def fetch_latest_version_sync(client: AsyncClient) -> str:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    return loop.run_until_complete(fetch_latest_version(client))
 
 @dashboard_router.get("/dashboard/messages")
 def get_messages(db_reader: DbReader = Depends(get_db_reader)) -> List[Conversation]:
@@ -61,6 +81,32 @@ async def stream_sse():
     """
     return StreamingResponse(generate_sse_events(), media_type="text/event-stream")
 
+@dashboard_router.get("/dashboard/version")
+def version_check(client: AsyncClient = Depends(get_http_client)):
+    try:
+        with ThreadPoolExecutor() as executor:
+            latest_version = executor.submit(fetch_latest_version_sync, client).result()
+
+        # normalize the versions as github will return them with a 'v' prefix
+        current_version = __version__.lstrip('v')
+        latest_version_stripped = latest_version.lstrip('v')
+
+        is_latest: bool = latest_version_stripped == current_version
+        
+        return {
+            "current_version": current_version,
+            "latest_version": latest_version_stripped,
+            "is_latest": is_latest,
+            "error": None,
+        }
+    except HTTPException as e:
+        return {
+            "current_version": __version__,
+            "latest_version": "unknown",
+            "is_latest": None,
+            "error": e.detail
+        }
+
 
 def generate_openapi():
     # Create a temporary FastAPI app instance

src/codegate/server.py

@@ -2,11 +2,10 @@
 from typing import AsyncGenerator
 
 import structlog
-from fastapi import APIRouter, Depends, FastAPI, HTTPException, Request
+from fastapi import APIRouter, Depends, FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from starlette.middleware.errors import ServerErrorMiddleware
-from httpx import AsyncClient, HTTPStatusError
 
 from codegate import __description__, __version__
 from codegate.dashboard.dashboard import dashboard_router
@@ -20,7 +19,6 @@
 
 logger = structlog.get_logger("codegate")
 
-
 async def custom_error_handler(request, exc: Exception):
     """This is a Middleware to handle exceptions and log them."""
     # Capture the stack trace
@@ -29,24 +27,6 @@ async def custom_error_handler(request, exc: Exception):
     logger.error(traceback.print_list(extracted_traceback[-3:]))
     return JSONResponse({"error": str(exc)}, status_code=500)
 
-async def get_http_client() -> AsyncGenerator[AsyncClient, None]:
-    async with AsyncClient() as client:
-        yield client
-
-async def fetch_latest_version(client: AsyncClient) -> str:
-    url = "https://api.github.com/repos/stacklok/codegate/releases/latest"
-    headers = {
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28"
-    }
-    try:
-        response = await client.get(url, headers=headers)
-        response.raise_for_status()
-        data = response.json()
-        return data.get("tag_name", "unknown")
-    except HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=str(e))
-
 def init_app(pipeline_factory: PipelineFactory) -> FastAPI:
     """Create the FastAPI application."""
     app = FastAPI(
@@ -113,26 +93,6 @@ async def log_user_agent(request: Request, call_next):
     async def health_check():
         return {"status": "healthy"}
 
-    @system_router.get("/version")
-    async def version_check(client: AsyncClient = Depends(get_http_client)):
-        try:
-            latest_version = await fetch_latest_version(client)
-
-            # normalize the versions as github will return them with a 'v' prefix
-            current_version = __version__.lstrip('v')
-            latest_version_stripped = latest_version.lstrip('v')
-
-            is_latest: bool = latest_version_stripped == current_version
-            
-            return {
-                "current_version": current_version,
-                "latest_version": latest_version_stripped,
-                "is_latest": is_latest,
-            }
-        except HTTPException as e:
-            return {"current_version": __version__, "latest_version": "unknown", "error": e.detail}
-
-
     app.include_router(system_router)
     app.include_router(dashboard_router)
 

tests/test_server.py

@@ -81,21 +81,20 @@ def test_health_check(test_client: TestClient) -> None:
     assert response.status_code == 200
     assert response.json() == {"status": "healthy"}
 
-def test_version_endpoint(test_client: TestClient) -> None:
+@pytest.mark.usefixtures("test_client")
+@patch("codegate.dashboard.dashboard.fetch_latest_version", new_callable=AsyncMock)
+def test_version_endpoint(mock_fetch_latest_version, test_client) -> None:
     """Test the version endpoint."""
-    response = test_client.get("/version")
+    mock_fetch_latest_version.return_value = "foo"
+
+    response = test_client.get("/dashboard/version")
     assert response.status_code == 200
 
     response_data = response.json()
-    assert "current_version" in response_data
-    assert isinstance(response_data["current_version"], str)
-
-    assert "latest_version" in response_data
-    assert isinstance(response_data["latest_version"], str)
-
-    assert "is_latest" in response_data
-    assert isinstance(response_data["is_latest"], bool)
 
+    assert response_data["current_version"] == __version__.lstrip('v')
+    assert response_data["latest_version"] == "foo"
+    assert response_data["is_latest"] is False
 
 @patch("codegate.pipeline.secrets.manager.SecretsManager")
 @patch("codegate.server.ProviderRegistry")