Merge pull request #1 from yorrickjansen/feature/ci-cd-pipeline

.github/workflows/ci.yml

@@ -0,0 +1,99 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.13"
+    - name: Install uv
+      run: |
+        pip install --upgrade pip
+        pip install uv
+    - name: Install dependencies
+      run: |
+        uv sync
+    - name: Lint with ruff
+      run: |
+        uv run ruff check .
+        uv run ruff format --check .
+        uv run pyright
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.13"
+    - name: Install uv
+      run: |
+        pip install --upgrade pip
+        pip install uv
+    - name: Install dependencies
+      run: |
+        uv sync
+    - name: Create dummy .env file for tests
+      run: |
+        echo "STRAVA_CLIENT_ID=test_client_id" > .env
+        echo "STRAVA_CLIENT_SECRET=test_client_secret" >> .env
+        echo "STRAVA_REFRESH_TOKEN=test_refresh_token" >> .env
+      
+    - name: Run tests with coverage
+      run: |
+        uv run pytest --cov=strava_mcp && uv run coverage xml
+      
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: ./coverage.xml
+        
+  server-startup:
+    runs-on: ubuntu-latest
+    needs: test
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.13"
+        
+    - name: Install uv
+      run: |
+        pip install --upgrade pip
+        pip install uv
+    
+    - name: Install dependencies
+      run: |
+        uv sync
+        
+    - name: Create dummy .env file for server
+      run: |
+        echo "STRAVA_CLIENT_ID=test_client_id" > .env
+        echo "STRAVA_CLIENT_SECRET=test_client_secret" >> .env
+        echo "STRAVA_REFRESH_TOKEN=test_refresh_token" >> .env
+        
+    - name: Test server startup
+      run: |
+        # Start the server in the background and kill it after 5 seconds
+        timeout 5s uv run mcp dev main.py || code=$?
+        if [ $code -eq 124 ]; then
+          echo "Server started successfully and was terminated after timeout"
+          exit 0
+        else
+          echo "Server failed to start with exit code $code"
+          exit 1
+        fi

.pre-commit-config.yaml

@@ -6,11 +6,6 @@ repos:
         args: [--fix]
     -   id: ruff-format
 
--   repo: https://github.com/pycqa/isort
-    rev: 5.13.2
-    hooks:
-    -   id: isort
-
 -   repo: https://github.com/RobertCraigie/pyright-python
     rev: v1.1.397
     hooks:

README.md

@@ -1,5 +1,8 @@
 # Strava MCP Server
 
+[![CI/CD Pipeline](https://github.com/yorrickjansen/strava-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/yorrickjansen/strava-mcp/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/yorrickjansen/strava-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/yorrickjansen/strava-mcp)
+
 A Model Context Protocol (MCP) server for interacting with the Strava API.
 
 ## Features
@@ -167,7 +170,6 @@ Gets the leaderboard for a specific segment.
 - `tests/`: Unit tests
 - `main.py`: Entry point to run the server
 - `get_token.py`: Utility script to get a refresh token manually
-- `standalone_server.py`: Utility web server for testing OAuth flow
 
 ### Running Tests
 

codecov.yml

@@ -0,0 +1,21 @@
+codecov:
+  require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+    patch:
+      default:
+        target: auto
+        threshold: 1%
+
+comment:
+  layout: "reach,diff,flags,files,footer"
+  behavior: default
+  require_changes: no

get_token.py

@@ -5,6 +5,7 @@ import asyncio
 import logging
 import os
 import sys
+
 from strava_mcp.oauth_server import get_refresh_token_from_oauth
 
 # Configure logging
@@ -20,7 +21,7 @@ async def main():
     # Check if client_id and client_secret are provided as env vars
     client_id = os.environ.get("STRAVA_CLIENT_ID")
     client_secret = os.environ.get("STRAVA_CLIENT_SECRET")
-    
+
     # If not provided as env vars, check command line args
     if not client_id or not client_secret:
         if len(sys.argv) != 3:
@@ -29,21 +30,21 @@ async def main():
             sys.exit(1)
         client_id = sys.argv[1]
         client_secret = sys.argv[2]
-    
+
     print("\nStarting Strava OAuth flow to get a refresh token...")
-    
+
     try:
         token = await get_refresh_token_from_oauth(client_id, client_secret)
         print("\n=================================================================")
         print("SUCCESS! Add this to your environment variables:")
         print(f"export STRAVA_REFRESH_TOKEN={token}")
         print("=================================================================\n")
-        
+
         # Also write to a file for easy access
         with open("strava_token.txt", "w") as f:
             f.write(f"STRAVA_REFRESH_TOKEN={token}\n")
-        print(f"Token also saved to strava_token.txt\n")
-        
+        print("Token also saved to strava_token.txt\n")
+
     except Exception as e:
         logger.exception("Error getting refresh token")
         print(f"Error: {e}")
@@ -51,4 +52,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

main.py

@@ -1,9 +1,14 @@
+import logging
+
 from strava_mcp.server import mcp
 
+logger = logging.getLogger(__name__)
+
 
 def main():
     """Run the Strava MCP server."""
-    mcp.run()
+    logger.info("Starting MCP server")
+    mcp.run(transport="stdio")
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -21,10 +21,19 @@ dev = [
     "pytest-mock>=3.14.0",
     "pytest-asyncio>=0.23.5",
     "ruff>=0.5.1",
+    "pytest-cov>=6.0.0",
+    "pyright>=1.1.385",
 ]
 
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["strava_mcp"]
+
 [tool.ruff]
-line-length = 88
+line-length = 120
 target-version = "py313"
 
 [tool.ruff.lint]
@@ -38,7 +47,7 @@ line-ending = "auto"
 
 [tool.isort]
 profile = "black"
-line_length = 88
+line_length = 120
 
 [tool.pyright]
 typeCheckingMode = "standard"

standalone_server.py

@@ -1,167 +0,0 @@
-"""A standalone web server for testing the Strava OAuth flow."""
-
-import asyncio
-import logging
-import webbrowser
-from contextlib import asynccontextmanager
-
-import uvicorn
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, RedirectResponse
-
-from strava_mcp.auth import StravaAuthenticator
-from strava_mcp.config import StravaSettings
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-logger = logging.getLogger(__name__)
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Set up and tear down the application.
-    
-    Args:
-        app: The FastAPI app
-    """
-    # Load settings from environment variables
-    try:
-        settings = StravaSettings()
-        logger.info("Loaded Strava API settings")
-    except Exception as e:
-        logger.error(f"Failed to load Strava API settings: {str(e)}")
-        raise
-
-    # Set up the Strava authenticator
-    authenticator = StravaAuthenticator(
-        client_id=settings.client_id,
-        client_secret=settings.client_secret,
-        app=app,
-    )
-    authenticator.setup_routes(app)
-    
-    # Store settings and authenticator in app state
-    app.state.settings = settings
-    app.state.authenticator = authenticator
-    
-    # Log the current state of the refresh token
-    if settings.refresh_token:
-        logger.info("Refresh token is already set")
-    else:
-        logger.info("No refresh token set, you will need to authenticate")
-    
-    yield
-    
-    # Clean up resources
-    logger.info("Shutting down")
-
-# Create the FastAPI app
-app = FastAPI(
-    title="Strava OAuth Tester",
-    description="A standalone web server for testing the Strava OAuth flow",
-    lifespan=lifespan,
-)
-
-# Define the root route
-@app.get("/", response_class=HTMLResponse)
-async def root(request: Request):
-    """Root endpoint."""
-    settings = request.app.state.settings
-    
-    # Check if we have a refresh token
-    if settings.refresh_token:
-        return HTMLResponse(
-            """
-            <html>
-                <head>
-                    <title>Strava OAuth Tester</title>
-                </head>
-                <body>
-                    <h1>Strava OAuth Tester</h1>
-                    <p>You already have a refresh token.</p>
-                    <p>Your refresh token: <code>{refresh_token}</code></p>
-                    <p><a href="/auth">Reauthenticate</a></p>
-                </body>
-            </html>
-            """.format(refresh_token=settings.refresh_token)
-        )
-    else:
-        return HTMLResponse(
-            """
-            <html>
-                <head>
-                    <title>Strava OAuth Tester</title>
-                </head>
-                <body>
-                    <h1>Strava OAuth Tester</h1>
-                    <p>You need to authenticate with Strava.</p>
-                    <p><a href="/auth">Authenticate</a></p>
-                </body>
-            </html>
-            """
-        )
-
-# Define a route to get the refresh token manually
-@app.get("/get_token", response_class=HTMLResponse)
-async def get_token(request: Request):
-    """Get a refresh token manually."""
-    settings = request.app.state.settings
-    authenticator = request.app.state.authenticator
-    
-    # Start the auth flow
-    auth_future = asyncio.Future()
-    
-    # Store the old token future and replace it with our own
-    old_token_future = authenticator.token_future
-    authenticator.token_future = auth_future
-    
-    try:
-        # Open the browser for authorization
-        auth_url = authenticator.get_authorization_url()
-        logger.info(f"Opening browser to authorize: {auth_url}")
-        webbrowser.open(auth_url)
-        
-        # Wait for the token with a timeout
-        try:
-            refresh_token = await asyncio.wait_for(auth_future, timeout=300)  # 5 minutes timeout
-            settings.refresh_token = refresh_token
-            return HTMLResponse(
-                """
-                <html>
-                    <head>
-                        <title>Strava OAuth Tester</title>
-                        <meta http-equiv="refresh" content="5;url=/" />
-                    </head>
-                    <body>
-                        <h1>Strava OAuth Tester</h1>
-                        <p>Successfully obtained refresh token!</p>
-                        <p>Your refresh token: <code>{refresh_token}</code></p>
-                        <p>You will be redirected to the home page in 5 seconds...</p>
-                    </body>
-                </html>
-                """.format(refresh_token=refresh_token)
-            )
-        except asyncio.TimeoutError:
-            return HTMLResponse(
-                """
-                <html>
-                    <head>
-                        <title>Strava OAuth Tester</title>
-                    </head>
-                    <body>
-                        <h1>Strava OAuth Tester</h1>
-                        <p>Timed out waiting for authentication.</p>
-                        <p><a href="/get_token">Try again</a></p>
-                    </body>
-                </html>
-                """
-            )
-    finally:
-        # Restore the old token future
-        authenticator.token_future = old_token_future
-
-# Run the server
-if __name__ == "__main__":
-    uvicorn.run(app, host="127.0.0.1", port=8000)

strava_mcp/api.py

@@ -1,18 +1,12 @@
 import logging
 from datetime import datetime
-from typing import Optional
 
 import httpx
 from fastapi import FastAPI
 from httpx import Response
 
 from strava_mcp.config import StravaSettings
-from strava_mcp.models import (
-    Activity,
-    DetailedActivity,
-    ErrorResponse,
-    SegmentEffort,
-)
+from strava_mcp.models import Activity, DetailedActivity, ErrorResponse, SegmentEffort
 
 logger = logging.getLogger(__name__)
 
@@ -20,17 +14,16 @@ logger = logging.getLogger(__name__)
 class StravaAPI:
     """Client for the Strava API."""
 
-    def __init__(self, settings: StravaSettings, app: Optional[FastAPI] = None):
+    def __init__(self, settings: StravaSettings, app: FastAPI | None = None):
         """Initialize the Strava API client.
 
         Args:
             settings: Strava API settings
-            app: FastAPI app for auth routes (optional)
+            app: FastAPI app (not used, kept for backward compatibility)
         """
         self.settings = settings
         self.access_token = None
         self.token_expires_at = None
-        self.app = app
         self.auth_flow_in_progress = False
         self._client = httpx.AsyncClient(
             base_url=settings.base_url,
@@ -42,94 +35,33 @@ class StravaAPI:
         await self._client.aclose()
 
     async def setup_auth_routes(self):
-        """Set up authentication routes if app is available."""
-        if not self.app:
-            logger.warning("No FastAPI app provided, skipping auth routes setup")
-            return
-
-        from strava_mcp.auth import StravaAuthenticator
-        
-        # Check if we have a FastAPI app or a FastMCP server
-        fastapi_app = None
-        
-        # If it's a FastAPI app, use it directly
-        if hasattr(self.app, "add_api_route"):
-            fastapi_app = self.app
-        # If it's a FastMCP server, try to get its FastAPI app
-        elif hasattr(self.app, "_app"):
-            fastapi_app = self.app._app
-        
-        if not fastapi_app:
-            logger.warning("Could not get FastAPI app from the provided object, auth flow will not be available")
-            return
-            
-        # Create authenticator and set up routes
-        try:
-            authenticator = StravaAuthenticator(
-                self.settings.client_id,
-                self.settings.client_secret,
-                fastapi_app
-            )
-            authenticator.setup_routes(fastapi_app)
-            
-            # Store authenticator for later use
-            self._authenticator = authenticator
-            logger.info("Successfully set up Strava auth routes")
-        except Exception as e:
-            logger.error(f"Error setting up auth routes: {e}")
-            return
+        """This method is deprecated and does nothing now.
+        Standalone OAuth server is used instead.
+        """
+        logger.info("Using standalone OAuth server instead of integrated auth routes")
+        return
 
     async def start_auth_flow(self) -> str:
-        """Start the auth flow to get a refresh token.
+        """This method is deprecated.
+        The standalone OAuth server is used instead via _ensure_token().
 
         Returns:
             The refresh token
 
         Raises:
-            Exception: If the auth flow fails or is not available
+            Exception: Always raises exception directing to use standalone flow
         """
-        if not self.app:
-            raise Exception(
-                "No FastAPI app available for auth flow. "
-                "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-            )
-            
-        authenticator = getattr(self, '_authenticator', None)
-        if not authenticator:
-            raise Exception(
-                "Auth routes not set up or setup failed. "
-                "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-            )
-        
-        if self.auth_flow_in_progress:
-            raise Exception("Auth flow already in progress")
-        
-        self.auth_flow_in_progress = True
-        try:
-            # Display instructions to the user and open browser
-            auth_url = self._authenticator.get_authorization_url()
-            logger.info(
-                f"\nNo refresh token available. Opening browser for authorization. "
-                f"If browser doesn't open, please visit this URL manually: {auth_url}"
-            )
-            
-            # Get the refresh token and open browser automatically
-            refresh_token = await self._authenticator.get_refresh_token(open_browser=True)
-            
-            # Store it in settings
-            self.settings.refresh_token = refresh_token
-            
-            logger.info("Successfully obtained refresh token")
-            return refresh_token
-        finally:
-            self.auth_flow_in_progress = False
+        raise Exception(
+            "Integrated auth flow is no longer supported. "
+            "The standalone OAuth server will be used automatically when needed."
+        )
 
     async def _ensure_token(self) -> str:
         """Ensure we have a valid access token.
 
         Returns:
             The access token
-        
+
         Raises:
             Exception: If unable to obtain a valid token
         """
@@ -145,32 +77,21 @@ class StravaAPI:
             try:
                 # Import here to avoid circular import
                 from strava_mcp.oauth_server import get_refresh_token_from_oauth
-                
+
                 logger.info("Starting OAuth flow to get refresh token")
                 self.settings.refresh_token = await get_refresh_token_from_oauth(
-                    self.settings.client_id,
-                    self.settings.client_secret
+                    self.settings.client_id, self.settings.client_secret
                 )
                 logger.info("Successfully obtained refresh token from OAuth flow")
             except Exception as e:
                 error_msg = f"Failed to get refresh token through OAuth flow: {e}"
                 logger.error(error_msg)
-                
-                # Fall back to the original auth flow if available and requested
-                if self.app and not self.auth_flow_in_progress:
-                    logger.info("Falling back to MCP-integrated auth flow")
-                    try:
-                        self.settings.refresh_token = await self.start_auth_flow()
-                    except Exception as fallback_error:
-                        raise Exception(
-                            "No refresh token available and all auth flows failed. "
-                            "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-                        ) from fallback_error
-                else:
-                    raise Exception(
-                        "No refresh token available and OAuth flow failed. "
-                        "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-                    ) from e
+
+                # No fallback to MCP-integrated auth flow anymore
+                raise Exception(
+                    "No refresh token available and OAuth flow failed. "
+                    "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
+                ) from e
 
         # Now that we have a refresh token, refresh the access token
         async with httpx.AsyncClient() as client:
@@ -192,7 +113,7 @@ class StravaAPI:
             data = response.json()
             self.access_token = data["access_token"]
             self.token_expires_at = data["expires_at"]
-            
+
             # Update the refresh token if it changed
             if "refresh_token" in data:
                 self.settings.refresh_token = data["refresh_token"]
@@ -223,21 +144,15 @@ class StravaAPI:
         response = await self._client.request(method, url, headers=headers, **kwargs)
 
         if not response.is_success:
-            error_msg = (
-                f"Strava API request failed: {response.status_code} - {response.text}"
-            )
+            error_msg = f"Strava API request failed: {response.status_code} - {response.text}"
             logger.error(error_msg)
 
             try:
                 error_data = response.json()
                 error = ErrorResponse(**error_data)
-                raise Exception(
-                    f"Strava API error: {error.message} (code: {error.code})"
-                )
+                raise Exception(f"Strava API error: {error.message} (code: {error.code})")
             except Exception as err:
-                msg = (
-                    f"Strava API failed: {response.status_code} - {response.text[:50]}"
-                )
+                msg = f"Strava API failed: {response.status_code} - {response.text[:50]}"
                 raise Exception(msg) from err
 
         return response
@@ -271,9 +186,7 @@ class StravaAPI:
 
         return [Activity(**activity) for activity in data]
 
-    async def get_activity(
-        self, activity_id: int, include_all_efforts: bool = False
-    ) -> DetailedActivity:
+    async def get_activity(self, activity_id: int, include_all_efforts: bool = False) -> DetailedActivity:
         """Get a specific activity.
 
         Args:
@@ -287,9 +200,7 @@ class StravaAPI:
         if include_all_efforts:
             params["include_all_efforts"] = "true"
 
-        response = await self._request(
-            "GET", f"/activities/{activity_id}", params=params
-        )
+        response = await self._request("GET", f"/activities/{activity_id}", params=params)
         data = response.json()
 
         return DetailedActivity(**data)
@@ -325,4 +236,3 @@ class StravaAPI:
             segment_efforts.append(SegmentEffort.model_validate(effort))
 
         return segment_efforts
-

strava_mcp/auth.py

@@ -2,7 +2,6 @@ import asyncio
 import logging
 import os
 import webbrowser
-from typing import Optional
 from urllib.parse import urlencode
 
 import httpx
@@ -21,6 +20,7 @@ REDIRECT_HOST = "127.0.0.1"
 
 class TokenResponse(BaseModel):
     """Response model for Strava token exchange."""
+
     access_token: str
     refresh_token: str
     expires_at: int
@@ -32,13 +32,13 @@ class StravaAuthenticator:
     """Helper class to get a Strava refresh token via OAuth flow."""
 
     def __init__(
-        self, 
-        client_id: str, 
+        self,
+        client_id: str,
         client_secret: str,
-        app: Optional[FastAPI] = None,
+        app: FastAPI | None = None,
         redirect_path: str = "/exchange_token",
         host: str = REDIRECT_HOST,
-        port: int = REDIRECT_PORT
+        port: int = REDIRECT_PORT,
     ):
         """Initialize the authenticator.
 
@@ -72,26 +72,22 @@ class StravaAuthenticator:
         try:
             # Exchange the code for tokens
             token_data = await self._exchange_code_for_token(code)
-            
+
             # If we have a token future (waiting for token), set the result
             if self.token_future and not self.token_future.done():
                 self.token_future.set_result(token_data.refresh_token)
-            
+
             return HTMLResponse(
-                "<h1>Authorization successful!</h1>"
-                "<p>You can close this tab and return to the application.</p>"
+                "<h1>Authorization successful!</h1><p>You can close this tab and return to the application.</p>"
             )
         except Exception as e:
             logger.exception("Error during token exchange")
-            
+
             # If we have a token future (waiting for token), set the exception
             if self.token_future and not self.token_future.done():
                 self.token_future.set_exception(e)
-                
-            return HTMLResponse(
-                "<h1>Authorization failed!</h1>"
-                "<p>An error occurred. Please check the logs.</p>"
-            )
+
+            return HTMLResponse("<h1>Authorization failed!</h1><p>An error occurred. Please check the logs.</p>")
 
     async def _exchange_code_for_token(self, code: str) -> TokenResponse:
         """Exchange the authorization code for tokens.
@@ -115,12 +111,12 @@ class StravaAuthenticator:
                     "grant_type": "authorization_code",
                 },
             )
-            
+
             if response.status_code != 200:
                 error_msg = f"Failed to exchange token: {response.text}"
                 logger.error(error_msg)
                 raise Exception(error_msg)
-            
+
             data = response.json()
             token_data = TokenResponse(**data)
             self.refresh_token = token_data.refresh_token
@@ -141,7 +137,7 @@ class StravaAuthenticator:
         }
         return f"{AUTHORIZE_URL}?{urlencode(params)}"
 
-    def setup_routes(self, app: FastAPI = None):
+    def setup_routes(self, app: FastAPI | None = None):
         """Set up the routes for authentication.
 
         Args:
@@ -150,21 +146,17 @@ class StravaAuthenticator:
         target_app = app or self.app
         if not target_app:
             raise ValueError("No FastAPI app provided")
-        
+
+        # Make sure we have a valid FastAPI app
+        if not hasattr(target_app, "add_api_route"):
+            raise ValueError("Provided app does not appear to be a valid FastAPI instance")
+
         # Add route for the token exchange
-        target_app.add_api_route(
-            self.redirect_path, 
-            self.exchange_token, 
-            methods=["GET"]
-        )
-        
+        target_app.add_api_route(self.redirect_path, self.exchange_token, methods=["GET"])
+
         # Add route to start the auth flow
-        target_app.add_api_route(
-            "/auth", 
-            self.start_auth_flow, 
-            methods=["GET"]
-        )
-    
+        target_app.add_api_route("/auth", self.start_auth_flow, methods=["GET"])
+
     async def start_auth_flow(self):
         """Start the OAuth flow by redirecting to Strava.
 
@@ -189,7 +181,7 @@ class StravaAuthenticator:
         """
         # Create a future to wait for the token
         self.token_future = asyncio.Future()
-        
+
         # Open the browser for authorization if requested
         auth_url = self.get_authorization_url()
         if open_browser:
@@ -200,16 +192,12 @@ class StravaAuthenticator:
                 logger.info(f"Authorization URL: {auth_url}")
         else:
             logger.info(f"Please open this URL to authorize: {auth_url}")
-        
+
         # Wait for the token
         return await self.token_future
 
 
-async def get_strava_refresh_token(
-    client_id: str, 
-    client_secret: str, 
-    app: Optional[FastAPI] = None
-) -> str:
+async def get_strava_refresh_token(client_id: str, client_secret: str, app: FastAPI | None = None) -> str:
     """Get a Strava refresh token via OAuth flow.
 
     Args:
@@ -232,14 +220,15 @@ async def get_strava_refresh_token(
 if __name__ == "__main__":
     # This allows running this file directly to get a refresh token
     import sys
+
     import uvicorn
-    
+
     logging.basicConfig(level=logging.INFO)
-    
+
     # Check if client_id and client_secret are provided as env vars
     client_id = os.environ.get("STRAVA_CLIENT_ID")
     client_secret = os.environ.get("STRAVA_CLIENT_SECRET")
-    
+
     # If not provided as env vars, check command line args
     if not client_id or not client_secret:
         if len(sys.argv) != 3:
@@ -248,17 +237,17 @@ if __name__ == "__main__":
             sys.exit(1)
         client_id = sys.argv[1]
         client_secret = sys.argv[2]
-    
+
     # Create a FastAPI app for standalone operation
     app = FastAPI(title="Strava Auth")
     authenticator = StravaAuthenticator(client_id, client_secret, app)
     authenticator.setup_routes(app)
-    
+
     # Add a root route that redirects to the auth flow
     @app.get("/")
     async def root():
         return RedirectResponse("/auth")
-    
+
     async def main():
         # Start the server
         server = uvicorn.Server(
@@ -269,12 +258,12 @@ if __name__ == "__main__":
                 log_level="info",
             )
         )
-        
+
         # For standalone operation, we'll print instructions
         print("\nStrava Authentication Server")
         print(f"Open http://{REDIRECT_HOST}:{REDIRECT_PORT}/ in your browser to start authentication")
-        
+
         # Run the server (this will block until stopped)
         await server.serve()
 
-    asyncio.run(main())
+    asyncio.run(main())

strava_mcp/config.py

@@ -1,6 +1,4 @@
-from typing import Optional
-
-from pydantic import Field
+from pydantic import Field, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -9,15 +7,30 @@ class StravaSettings(BaseSettings):
 
     client_id: str = Field(..., description="Strava API client ID")
     client_secret: str = Field(..., description="Strava API client secret")
-    refresh_token: Optional[str] = Field(
-        None, description="Strava API refresh token (can be generated through auth flow)"
-    )
-    base_url: str = Field(
-        "https://www.strava.com/api/v3", description="Strava API base URL"
+    refresh_token: str | None = Field(
+        default=None,
+        description="Strava API refresh token (can be generated through auth flow)",
     )
+    base_url: str = Field("https://www.strava.com/api/v3", description="Strava API base URL")
 
-    model_config = SettingsConfigDict(
-        env_prefix="STRAVA_",
-        env_file=".env",
-        env_file_encoding="utf-8"
-    )
+    model_config = SettingsConfigDict(env_prefix="STRAVA_", env_file=".env", env_file_encoding="utf-8")
+
+    @model_validator(mode="after")
+    def load_from_env(self):
+        """Load values from environment variables if not directly provided."""
+        import os
+
+        # Only override empty values with environment values
+        if not self.client_id and os.environ.get("STRAVA_CLIENT_ID"):
+            self.client_id = os.environ["STRAVA_CLIENT_ID"]
+
+        if not self.client_secret and os.environ.get("STRAVA_CLIENT_SECRET"):
+            self.client_secret = os.environ["STRAVA_CLIENT_SECRET"]
+
+        if not self.refresh_token and os.environ.get("STRAVA_REFRESH_TOKEN"):
+            self.refresh_token = os.environ["STRAVA_REFRESH_TOKEN"]
+
+        if not self.base_url and os.environ.get("STRAVA_BASE_URL"):
+            self.base_url = os.environ["STRAVA_BASE_URL"]
+
+        return self

strava_mcp/models.py

@@ -11,15 +11,11 @@ class Activity(BaseModel):
     distance: float = Field(..., description="The distance in meters")
     moving_time: int = Field(..., description="Moving time in seconds")
     elapsed_time: int = Field(..., description="Elapsed time in seconds")
-    total_elevation_gain: float = Field(
-        ..., description="Total elevation gain in meters"
-    )
+    total_elevation_gain: float = Field(..., description="Total elevation gain in meters")
     type: str = Field(..., description="Type of activity")
     sport_type: str = Field(..., description="Type of sport")
     start_date: datetime = Field(..., description="Start date and time in UTC")
-    start_date_local: datetime = Field(
-        ..., description="Start date and time in athlete's timezone"
-    )
+    start_date_local: datetime = Field(..., description="Start date and time in athlete's timezone")
     timezone: str = Field(..., description="The timezone of the activity")
     achievement_count: int = Field(..., description="The number of achievements")
     kudos_count: int = Field(..., description="The number of kudos")
@@ -27,9 +23,7 @@ class Activity(BaseModel):
     athlete_count: int = Field(..., description="The number of athletes")
     photo_count: int = Field(..., description="The number of photos")
     map: dict | None = Field(None, description="The map of the activity")
-    trainer: bool = Field(
-        ..., description="Whether this activity was recorded on a training machine"
-    )
+    trainer: bool = Field(..., description="Whether this activity was recorded on a training machine")
     commute: bool = Field(..., description="Whether this activity is a commute")
     manual: bool = Field(..., description="Whether this activity was created manually")
     private: bool = Field(..., description="Whether this activity is private")
@@ -37,15 +31,9 @@ class Activity(BaseModel):
     workout_type: int | None = Field(None, description="The workout type")
     average_speed: float = Field(..., description="Average speed in meters per second")
     max_speed: float = Field(..., description="Maximum speed in meters per second")
-    has_heartrate: bool = Field(
-        ..., description="Whether the activity has heartrate data"
-    )
-    average_heartrate: float | None = Field(
-        None, description="Average heartrate during activity"
-    )
-    max_heartrate: float | None = Field(
-        None, description="Maximum heartrate during activity"
-    )
+    has_heartrate: bool = Field(..., description="Whether the activity has heartrate data")
+    average_heartrate: float | None = Field(None, description="Average heartrate during activity")
+    max_heartrate: float | None = Field(None, description="Maximum heartrate during activity")
     elev_high: float | None = Field(None, description="The highest elevation")
     elev_low: float | None = Field(None, description="The lowest elevation")
 
@@ -56,19 +44,13 @@ class DetailedActivity(Activity):
     description: str | None = Field(None, description="The description of the activity")
     athlete: dict = Field(..., description="The athlete who performed the activity")
     calories: float | None = Field(None, description="Calories burned during activity")
-    segment_efforts: list[dict] | None = Field(
-        None, description="List of segment efforts"
-    )
+    segment_efforts: list[dict] | None = Field(None, description="List of segment efforts")
     splits_metric: list[dict] | None = Field(None, description="Splits in metric units")
-    splits_standard: list[dict] | None = Field(
-        None, description="Splits in standard units"
-    )
+    splits_standard: list[dict] | None = Field(None, description="Splits in standard units")
     best_efforts: list[dict] | None = Field(None, description="List of best efforts")
     photos: dict | None = Field(None, description="Photos associated with activity")
     gear: dict | None = Field(None, description="Gear used during activity")
-    device_name: str | None = Field(
-        None, description="Name of device used to record activity"
-    )
+    device_name: str | None = Field(None, description="Name of device used to record activity")
 
 
 class Segment(BaseModel):
@@ -78,35 +60,19 @@ class Segment(BaseModel):
     name: str = Field(..., description="The name of the segment")
     activity_type: str = Field(..., description="The activity type of the segment")
     distance: float = Field(..., description="The segment's distance in meters")
-    average_grade: float = Field(
-        ..., description="The segment's average grade, in percents"
-    )
-    maximum_grade: float = Field(
-        ..., description="The segments's maximum grade, in percents"
-    )
-    elevation_high: float = Field(
-        ..., description="The segments's highest elevation, in meters"
-    )
-    elevation_low: float = Field(
-        ..., description="The segments's lowest elevation, in meters"
-    )
-    total_elevation_gain: float = Field(
-        ..., description="The segments's total elevation gain, in meters"
-    )
-    start_latlng: list[float] = Field(
-        ..., description="Start coordinates [latitude, longitude]"
-    )
-    end_latlng: list[float] = Field(
-        ..., description="End coordinates [latitude, longitude]"
-    )
+    average_grade: float = Field(..., description="The segment's average grade, in percents")
+    maximum_grade: float = Field(..., description="The segments's maximum grade, in percents")
+    elevation_high: float = Field(..., description="The segments's highest elevation, in meters")
+    elevation_low: float = Field(..., description="The segments's lowest elevation, in meters")
+    total_elevation_gain: float = Field(..., description="The segments's total elevation gain, in meters")
+    start_latlng: list[float] = Field(..., description="Start coordinates [latitude, longitude]")
+    end_latlng: list[float] = Field(..., description="End coordinates [latitude, longitude]")
     climb_category: int = Field(..., description="The category of the climb [0, 5]")
     city: str | None = Field(None, description="The city this segment is in")
     state: str | None = Field(None, description="The state this segment is in")
     country: str | None = Field(None, description="The country this segment is in")
     private: bool = Field(..., description="Whether this segment is private")
-    starred: bool = Field(
-        ..., description="Whether this segment is starred by the authenticated athlete"
-    )
+    starred: bool = Field(..., description="Whether this segment is starred by the authenticated athlete")
 
 
 class SegmentEffort(BaseModel):
@@ -119,26 +85,18 @@ class SegmentEffort(BaseModel):
     elapsed_time: int = Field(..., description="The elapsed time in seconds")
     moving_time: int = Field(..., description="The moving time in seconds")
     start_date: datetime = Field(..., description="Start date and time in UTC")
-    start_date_local: datetime = Field(
-        ..., description="Start date and time in athlete's timezone"
-    )
+    start_date_local: datetime = Field(..., description="Start date and time in athlete's timezone")
     distance: float = Field(..., description="The effort's distance in meters")
     average_watts: float | None = Field(None, description="Average wattage")
-    device_watts: bool | None = Field(
-        None, description="Whether power data comes from a power meter"
-    )
+    device_watts: bool | None = Field(None, description="Whether power data comes from a power meter")
     average_heartrate: float | None = Field(None, description="Average heartrate")
     max_heartrate: float | None = Field(None, description="Maximum heartrate")
-    pr_rank: int | None = Field(
-        None, description="Personal record rank (1-3), 0 if not a PR"
-    )
+    pr_rank: int | None = Field(None, description="Personal record rank (1-3), 0 if not a PR")
     achievements: list[dict] | None = Field(None, description="List of achievements")
     athlete: dict = Field(..., description="The athlete who performed the effort")
     segment: Segment = Field(..., description="The segment")
 
 
-
-
 class ErrorResponse(BaseModel):
     """Represents an error response from the Strava API."""
 

strava_mcp/oauth_server.py

@@ -3,14 +3,13 @@
 import asyncio
 import logging
 import os
-import threading
 import webbrowser
 from contextlib import asynccontextmanager
 
 import uvicorn
 from fastapi import FastAPI
 
-from strava_mcp.auth import StravaAuthenticator, REDIRECT_HOST, REDIRECT_PORT
+from strava_mcp.auth import REDIRECT_HOST, REDIRECT_PORT, StravaAuthenticator
 
 # Configure logging
 logging.basicConfig(
@@ -24,11 +23,11 @@ class StravaOAuthServer:
     """A standalone server for handling Strava OAuth flow."""
 
     def __init__(
-        self, 
-        client_id: str, 
+        self,
+        client_id: str,
         client_secret: str,
         host: str = REDIRECT_HOST,
-        port: int = REDIRECT_PORT
+        port: int = REDIRECT_PORT,
     ):
         """Initialize the OAuth server.
 
@@ -63,6 +62,8 @@ class StravaOAuthServer:
             await self._initialize_server()
 
         # Open browser to start authorization
+        if self.authenticator is None:
+            raise Exception("Authenticator not initialized")
         auth_url = self.authenticator.get_authorization_url()
         logger.info(f"Opening browser to authorize with Strava: {auth_url}")
         webbrowser.open(auth_url)
@@ -72,18 +73,19 @@ class StravaOAuthServer:
             refresh_token = await self.token_future
             logger.info("Successfully obtained refresh token")
             return refresh_token
-        except asyncio.CancelledError:
+        except asyncio.CancelledError as err:
             logger.error("Token request was cancelled")
-            raise Exception("OAuth flow was cancelled")
+            raise Exception("OAuth flow was cancelled") from err
         except Exception as e:
             logger.exception("Error during OAuth flow")
-            raise Exception(f"OAuth flow failed: {str(e)}")
+            raise Exception(f"OAuth flow failed: {str(e)}") from e
         finally:
             # Stop the server once we have the token
             await self._stop_server()
 
     async def _initialize_server(self):
         """Initialize the FastAPI server for OAuth flow."""
+
         @asynccontextmanager
         async def lifespan(app: FastAPI):
             yield
@@ -114,20 +116,26 @@ class StravaOAuthServer:
 
         # Start server in a separate task
         self.server_task = asyncio.create_task(self._run_server())
-        
+
         # Wait a moment for the server to start
         await asyncio.sleep(0.5)
 
     async def _run_server(self):
         """Run the uvicorn server."""
-        config = uvicorn.Config(
-            app=self.app,
-            host=self.host,
-            port=self.port,
-            log_level="info",
-        )
-        self.server = uvicorn.Server(config)
+        # Ensure app is not None before passing to uvicorn
+        if not self.app:
+            raise ValueError("FastAPI app not initialized")
+
+        # Use fixed port 3008
         try:
+            config = uvicorn.Config(
+                app=self.app,
+                host=self.host,
+                port=self.port,
+                log_level="info",
+            )
+
+            self.server = uvicorn.Server(config)
             await self.server.serve()
         except Exception as e:
             logger.exception("Error running OAuth server")
@@ -141,7 +149,7 @@ class StravaOAuthServer:
             if self.server_task:
                 try:
                     await asyncio.wait_for(self.server_task, timeout=5.0)
-                except asyncio.TimeoutError:
+                except TimeoutError:
                     logger.warning("Server shutdown timed out")
 
 
@@ -165,11 +173,11 @@ async def get_refresh_token_from_oauth(client_id: str, client_secret: str) -> st
 if __name__ == "__main__":
     # This allows running this file directly to get a refresh token
     import sys
-    
+
     # Check if client_id and client_secret are provided as env vars
     client_id = os.environ.get("STRAVA_CLIENT_ID")
     client_secret = os.environ.get("STRAVA_CLIENT_SECRET")
-    
+
     # If not provided as env vars, check command line args
     if not client_id or not client_secret:
         if len(sys.argv) != 3:
@@ -178,9 +186,16 @@ if __name__ == "__main__":
             sys.exit(1)
         client_id = sys.argv[1]
         client_secret = sys.argv[2]
-    
+
+    # Ensure we have non-None values
+    if client_id is None or client_secret is None:
+        print("Error: Missing client_id or client_secret")
+        sys.exit(1)
+
     async def main():
         try:
+            # We've verified these aren't None above
+            assert client_id is not None and client_secret is not None
             token = await get_refresh_token_from_oauth(client_id, client_secret)
             print(f"\nSuccessfully obtained refresh token: {token}")
             print("\nYou can add this to your environment variables:")
@@ -189,4 +204,4 @@ if __name__ == "__main__":
             logger.exception("Error getting refresh token")
             print(f"Error: {str(e)}")
 
-    asyncio.run(main())
+    asyncio.run(main())

strava_mcp/server.py

@@ -1,8 +1,9 @@
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import Any, cast
 
+from fastapi import FastAPI
 from mcp.server.fastmcp import Context, FastMCP
 
 from strava_mcp.config import StravaSettings
@@ -28,19 +29,30 @@ async def lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
     """
     # Load settings from environment variables
     try:
-        settings = StravaSettings()
+        # Let StravaSettings load values directly from env vars
+        settings = StravaSettings(
+            client_id="",  # Will be loaded from environment variables
+            client_secret="",  # Will be loaded from environment variables
+            base_url="https://www.strava.com/api/v3",  # Default value
+        )
+
+        if not settings.client_id:
+            raise ValueError("STRAVA_CLIENT_ID environment variable is not set")
+        if not settings.client_secret:
+            raise ValueError("STRAVA_CLIENT_SECRET environment variable is not set")
+
         logger.info("Loaded Strava API settings")
     except Exception as e:
         logger.error(f"Failed to load Strava API settings: {str(e)}")
         raise
 
-    # Use the FastMCP server itself as we'll adapt our StravaService to work with it
-    fastapi_app = server
-    
-    # Initialize the Strava service with the FastAPI app (or None)
+    # FastMCP extends FastAPI, so we can safely cast it for type checking
+    fastapi_app = cast(FastAPI, server)
+
+    # Initialize the Strava service with the FastAPI app
     service = StravaService(settings, fastapi_app)
     logger.info("Initialized Strava service")
-    
+
     # Set up authentication routes and initialize
     await service.initialize()
     logger.info("Service initialization completed")
@@ -58,6 +70,9 @@ mcp = FastMCP(
     "Strava",
     description="MCP server for interacting with the Strava API",
     lifespan=lifespan,
+    client_id="",  # Will be loaded from environment variables
+    client_secret="",  # Will be loaded from environment variables
+    base_url="",  # Will be loaded from environment variables
 )
 
 
@@ -81,9 +96,16 @@ async def get_user_activities(
     Returns:
         List of activities
     """
-    service = ctx.request_context.lifespan_context["service"]
-
     try:
+        # Safely access service from context
+        if not ctx.request_context.lifespan_context:
+            raise ValueError("Lifespan context not available")
+
+        # Cast service to StravaService to satisfy type checker
+        service = cast(StravaService, ctx.request_context.lifespan_context.get("service"))
+        if not service:
+            raise ValueError("Service not available in context")
+
         activities = await service.get_activities(before, after, page, per_page)
         return [activity.model_dump() for activity in activities]
     except Exception as e:
@@ -107,9 +129,16 @@ async def get_activity(
     Returns:
         The activity details
     """
-    service = ctx.request_context.lifespan_context["service"]
-
     try:
+        # Safely access service from context
+        if not ctx.request_context.lifespan_context:
+            raise ValueError("Lifespan context not available")
+
+        # Cast service to StravaService to satisfy type checker
+        service = cast(StravaService, ctx.request_context.lifespan_context.get("service"))
+        if not service:
+            raise ValueError("Service not available in context")
+
         activity = await service.get_activity(activity_id, include_all_efforts)
         return activity.model_dump()
     except Exception as e:
@@ -131,13 +160,18 @@ async def get_activity_segments(
     Returns:
         List of segment efforts for the activity
     """
-    service = ctx.request_context.lifespan_context["service"]
-
     try:
+        # Safely access service from context
+        if not ctx.request_context.lifespan_context:
+            raise ValueError("Lifespan context not available")
+
+        # Cast service to StravaService to satisfy type checker
+        service = cast(StravaService, ctx.request_context.lifespan_context.get("service"))
+        if not service:
+            raise ValueError("Service not available in context")
+
         segments = await service.get_activity_segments(activity_id)
         return [segment.model_dump() for segment in segments]
     except Exception as e:
         logger.error(f"Error in get_activity_segments tool: {str(e)}")
         raise
-
-

strava_mcp/service.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from fastapi import FastAPI
 
@@ -13,7 +12,7 @@ logger = logging.getLogger(__name__)
 class StravaService:
     """Service for interacting with the Strava API."""
 
-    def __init__(self, settings: StravaSettings, app: Optional[FastAPI] = None):
+    def __init__(self, settings: StravaSettings, app: FastAPI | None = None):
         """Initialize the Strava service.
 
         Args:
@@ -24,15 +23,12 @@ class StravaService:
         self.api = StravaAPI(settings, app)
 
     async def initialize(self):
-        """Initialize the service, setting up auth routes if needed."""
-        # Set up authentication routes if app is available
-        await self.api.setup_auth_routes()
-        
-        # If we don't have a refresh token, log info about OAuth flow
+        """Initialize the service."""
+        # Log info about OAuth flow if no refresh token
         if not self.settings.refresh_token:
             logger.info(
                 "No STRAVA_REFRESH_TOKEN found in environment. "
-                "The OAuth flow will be triggered automatically when needed."
+                "The standalone OAuth flow will be triggered automatically when needed."
             )
 
     async def close(self):
@@ -66,9 +62,7 @@ class StravaService:
             logger.error(f"Error getting activities: {str(e)}")
             raise
 
-    async def get_activity(
-        self, activity_id: int, include_all_efforts: bool = False
-    ) -> DetailedActivity:
+    async def get_activity(self, activity_id: int, include_all_efforts: bool = False) -> DetailedActivity:
         """Get a specific activity.
 
         Args:
@@ -104,4 +98,3 @@ class StravaService:
         except Exception as e:
             logger.error(f"Error getting segments for activity {activity_id}: {str(e)}")
             raise
-

tests/test_api.py

@@ -14,6 +14,7 @@ def settings():
         client_id="test_client_id",
         client_secret="test_client_secret",
         refresh_token="test_refresh_token",
+        base_url="https://www.strava.com/api/v3",
     )
 
 
@@ -175,5 +176,3 @@ async def test_get_activity(api, mock_response):
     assert activity.id == activity_data["id"]
     assert activity.name == activity_data["name"]
     assert activity.description == activity_data["description"]
-
-

tests/test_auth.py

@@ -0,0 +1,268 @@
+"""Tests for the Strava authentication module."""
+
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI
+from httpx import Response
+
+from strava_mcp.auth import StravaAuthenticator, get_strava_refresh_token
+
+
+@pytest.fixture
+def client_credentials():
+    """Fixture for client credentials."""
+    return {
+        "client_id": "test_client_id",
+        "client_secret": "test_client_secret",
+    }
+
+
+@pytest.fixture
+def mock_token_response():
+    """Fixture for token response."""
+    return {
+        "access_token": "test_access_token",
+        "refresh_token": "test_refresh_token",
+        "expires_at": 1609459200,
+        "expires_in": 21600,
+        "token_type": "Bearer",
+    }
+
+
+@pytest.fixture
+def fastapi_app():
+    """Fixture for FastAPI app."""
+    return FastAPI()
+
+
+@pytest.fixture
+def authenticator(client_credentials, fastapi_app):
+    """Fixture for StravaAuthenticator."""
+    return StravaAuthenticator(
+        client_id=client_credentials["client_id"],
+        client_secret=client_credentials["client_secret"],
+        app=fastapi_app,
+    )
+
+
+def test_get_authorization_url(authenticator):
+    """Test getting the authorization URL."""
+    url = authenticator.get_authorization_url()
+
+    # Check that the URL contains the expected parameters
+    assert "https://www.strava.com/oauth/authorize" in url
+    assert f"client_id={authenticator.client_id}" in url
+    # URL is encoded, so we need to check the non-encoded parts
+    assert "redirect_uri=http%3A%2F%2F127.0.0.1%3A3008%2Fexchange_token" in url
+    assert "response_type=code" in url
+    assert "scope=" in url
+
+
+def test_setup_routes(authenticator, fastapi_app):
+    """Test setting up routes."""
+    authenticator.setup_routes(fastapi_app)
+
+    # Check that the routes were added
+    routes = [route.path for route in fastapi_app.routes]
+    assert authenticator.redirect_path in routes
+    assert "/auth" in routes
+
+
+def test_setup_routes_no_app(authenticator):
+    """Test setting up routes with no app."""
+    authenticator.app = None
+    with pytest.raises(ValueError, match="No FastAPI app provided"):
+        authenticator.setup_routes()
+
+
+@pytest.mark.asyncio
+async def test_exchange_token_success(authenticator, mock_token_response):
+    """Test exchanging token successfully."""
+    # Setup mock
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_token_response
+        mock_client.return_value.__aenter__.return_value.post.return_value = mock_response
+
+        # Set up a future to receive the token
+        authenticator.token_future = asyncio.Future()
+
+        # Call the handler
+        response = await authenticator.exchange_token(code="test_code")
+
+        # Check response
+        assert response.status_code == 200
+        assert "Authorization successful" in response.body.decode()
+
+        # Check token future
+        assert authenticator.token_future.done()
+        assert await authenticator.token_future == "test_refresh_token"
+
+        # Check token was saved
+        assert authenticator.refresh_token == "test_refresh_token"
+
+        # Verify correct API call
+        mock_client.return_value.__aenter__.return_value.post.assert_called_once()
+        args, kwargs = mock_client.return_value.__aenter__.return_value.post.call_args
+        assert args[0] == "https://www.strava.com/oauth/token"
+        assert kwargs["data"]["client_id"] == authenticator.client_id
+        assert kwargs["data"]["client_secret"] == authenticator.client_secret
+        assert kwargs["data"]["code"] == "test_code"
+        assert kwargs["data"]["grant_type"] == "authorization_code"
+
+
+@pytest.mark.asyncio
+async def test_exchange_token_failure(authenticator):
+    """Test exchanging token with failure."""
+    # Setup mock
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 400
+        mock_response.text = "Invalid code"
+        mock_client.return_value.__aenter__.return_value.post.return_value = mock_response
+
+        # Set up a future to receive the token
+        authenticator.token_future = asyncio.Future()
+
+        # Call the handler
+        response = await authenticator.exchange_token(code="invalid_code")
+
+        # Check response
+        assert response.status_code == 200
+        assert "Authorization failed" in response.body.decode()
+
+        # Check token future
+        assert authenticator.token_future.done()
+        # We expect a specific exception here, so using pytest.raises is appropriate
+        with pytest.raises(Exception):  # noqa: B017
+            await authenticator.token_future
+
+
+@pytest.mark.asyncio
+async def test_start_auth_flow(authenticator):
+    """Test starting auth flow."""
+    with patch.object(authenticator, "get_authorization_url", return_value="https://example.com/auth"):
+        response = await authenticator.start_auth_flow()
+        assert response.status_code == 307
+        assert response.headers["location"] == "https://example.com/auth"
+
+
+@pytest.mark.asyncio
+async def test_get_refresh_token(authenticator):
+    """Test getting refresh token."""
+    # Mock the webbrowser.open call
+    with patch("webbrowser.open", return_value=True) as mock_open:
+        with patch.object(authenticator, "get_authorization_url", return_value="https://example.com/auth"):
+            # Set the future result after a delay
+            authenticator.token_future = None  # Reset it so a new one is created
+
+            # Start the token request in background
+            task = asyncio.create_task(authenticator.get_refresh_token())
+
+            # Wait a bit and set the result
+            await asyncio.sleep(0.1)
+            # Initialize the token_future before setting result
+            if not authenticator.token_future:
+                authenticator.token_future = asyncio.Future()
+            authenticator.token_future.set_result("test_refresh_token")
+
+            # Get the result
+            token = await task
+
+            # Verify
+            assert token == "test_refresh_token"
+            mock_open.assert_called_once_with("https://example.com/auth")
+
+
+@pytest.mark.asyncio
+async def test_get_refresh_token_no_browser(authenticator):
+    """Test getting refresh token without opening browser."""
+    with patch("webbrowser.open") as mock_open:
+        with patch.object(authenticator, "get_authorization_url", return_value="https://example.com/auth"):
+            # Set the future result after a delay
+            authenticator.token_future = None  # Reset it so a new one is created
+
+            # Start the token request in background
+            task = asyncio.create_task(authenticator.get_refresh_token(open_browser=False))
+
+            # Wait a bit and set the result
+            await asyncio.sleep(0.1)
+            # Initialize the token_future before setting result
+            if not authenticator.token_future:
+                authenticator.token_future = asyncio.Future()
+            authenticator.token_future.set_result("test_refresh_token")
+
+            # Get the result
+            token = await task
+
+            # Verify
+            assert token == "test_refresh_token"
+            mock_open.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_get_refresh_token_browser_fails(authenticator):
+    """Test getting refresh token with browser opening failing."""
+    with patch("webbrowser.open", return_value=False) as mock_open:
+        with patch.object(authenticator, "get_authorization_url", return_value="https://example.com/auth"):
+            # Set the future result after a delay
+            authenticator.token_future = None  # Reset it so a new one is created
+
+            # Start the token request in background
+            task = asyncio.create_task(authenticator.get_refresh_token())
+
+            # Wait a bit and set the result
+            await asyncio.sleep(0.1)
+            # Initialize the token_future before setting result
+            if not authenticator.token_future:
+                authenticator.token_future = asyncio.Future()
+            authenticator.token_future.set_result("test_refresh_token")
+
+            # Get the result
+            token = await task
+
+            # Verify
+            assert token == "test_refresh_token"
+            mock_open.assert_called_once_with("https://example.com/auth")
+
+
+@pytest.mark.asyncio
+async def test_get_strava_refresh_token(client_credentials):
+    """Test get_strava_refresh_token function."""
+    with patch("strava_mcp.auth.StravaAuthenticator") as mock_authenticator_class:
+        # Setup mock
+        mock_authenticator = MagicMock()
+        mock_authenticator.get_refresh_token = AsyncMock(return_value="test_refresh_token")
+        mock_authenticator.setup_routes = MagicMock()
+        mock_authenticator_class.return_value = mock_authenticator
+
+        # Test without app
+        token = await get_strava_refresh_token(client_credentials["client_id"], client_credentials["client_secret"])
+
+        # Verify
+        assert token == "test_refresh_token"
+        mock_authenticator_class.assert_called_once_with(
+            client_credentials["client_id"], client_credentials["client_secret"], None
+        )
+        mock_authenticator.setup_routes.assert_not_called()
+
+        # Reset mocks
+        mock_authenticator_class.reset_mock()
+        mock_authenticator.get_refresh_token.reset_mock()
+        mock_authenticator.setup_routes.reset_mock()
+
+        # Test with app
+        app = FastAPI()
+        token = await get_strava_refresh_token(
+            client_credentials["client_id"], client_credentials["client_secret"], app
+        )
+
+        # Verify
+        assert token == "test_refresh_token"
+        mock_authenticator_class.assert_called_once_with(
+            client_credentials["client_id"], client_credentials["client_secret"], app
+        )
+        mock_authenticator.setup_routes.assert_called_once_with(app)

tests/test_config.py

@@ -0,0 +1,81 @@
+"""Tests for configuration module."""
+
+import os
+from unittest import mock
+
+from strava_mcp.config import StravaSettings
+
+
+def test_strava_settings_defaults():
+    """Test default settings for StravaSettings."""
+    # Use required parameters only
+    with mock.patch.dict(os.environ, {}, clear=True):
+        # Explicitly ensure we're not using STRAVA_REFRESH_TOKEN from environment
+        settings = StravaSettings(
+            client_id="test_client_id",
+            client_secret="test_client_secret",
+            refresh_token=None,
+            base_url="https://www.strava.com/api/v3",
+        )
+
+        assert settings.client_id == "test_client_id"
+        assert settings.client_secret == "test_client_secret"
+        assert settings.refresh_token is None
+        assert settings.base_url == "https://www.strava.com/api/v3"
+
+
+def test_strava_settings_from_env():
+    """Test loading settings from environment variables."""
+    with mock.patch.dict(
+        os.environ,
+        {
+            "STRAVA_CLIENT_ID": "env_client_id",
+            "STRAVA_CLIENT_SECRET": "env_client_secret",
+            "STRAVA_REFRESH_TOKEN": "env_refresh_token",
+            "STRAVA_BASE_URL": "https://custom.strava.api/v3",
+        },
+    ):
+        # Even with env vars, we need to provide required params for type checking
+        settings = StravaSettings(
+            client_id="",  # Will be overridden by env vars
+            client_secret="",  # Will be overridden by env vars
+            base_url="",  # Will be overridden by env vars
+        )
+
+        assert settings.client_id == "env_client_id"
+        assert settings.client_secret == "env_client_secret"
+        assert settings.refresh_token == "env_refresh_token"
+        assert settings.base_url == "https://custom.strava.api/v3"
+
+
+def test_strava_settings_override():
+    """Test overriding environment settings with direct values."""
+    with mock.patch.dict(
+        os.environ,
+        {
+            "STRAVA_CLIENT_ID": "env_client_id",
+            "STRAVA_CLIENT_SECRET": "env_client_secret",
+            "STRAVA_REFRESH_TOKEN": "env_refresh_token",
+        },
+    ):
+        settings = StravaSettings(
+            client_id="direct_client_id",
+            client_secret="",  # Will be taken from env vars
+            refresh_token="direct_refresh_token",
+            base_url="https://www.strava.com/api/v3",
+        )
+
+        # Direct values should override environment variables
+        assert settings.client_id == "direct_client_id"
+        assert settings.client_secret == "env_client_secret"
+        assert settings.refresh_token == "direct_refresh_token"
+
+
+def test_strava_settings_model_config():
+    """Test model configuration for StravaSettings."""
+    # Access model_config safely, with type handling
+    model_config = StravaSettings.model_config
+    # We can safely access these fields as we know they exist in our configuration
+    assert model_config.get("env_prefix") == "STRAVA_"
+    assert model_config.get("env_file") == ".env"
+    assert model_config.get("env_file_encoding") == "utf-8"

tests/test_models.py

@@ -0,0 +1,247 @@
+"""Tests for the Strava models."""
+
+from datetime import datetime
+
+import pytest
+from pydantic import ValidationError
+
+from strava_mcp.models import Activity, DetailedActivity, ErrorResponse, Segment, SegmentEffort
+
+
+@pytest.fixture
+def activity_data():
+    """Fixture with valid activity data."""
+    return {
+        "id": 1234567890,
+        "name": "Morning Run",
+        "distance": 5000.0,
+        "moving_time": 1200,
+        "elapsed_time": 1300,
+        "total_elevation_gain": 50.0,
+        "type": "Run",
+        "sport_type": "Run",
+        "start_date": "2023-01-01T10:00:00Z",
+        "start_date_local": "2023-01-01T10:00:00Z",
+        "timezone": "Europe/London",
+        "achievement_count": 2,
+        "kudos_count": 5,
+        "comment_count": 0,
+        "athlete_count": 1,
+        "photo_count": 0,
+        "trainer": False,
+        "commute": False,
+        "manual": False,
+        "private": False,
+        "flagged": False,
+        "average_speed": 4.167,
+        "max_speed": 5.3,
+        "has_heartrate": True,
+        "average_heartrate": 140.0,
+        "max_heartrate": 160.0,
+    }
+
+
+@pytest.fixture
+def detailed_activity_data(activity_data):
+    """Fixture with valid detailed activity data."""
+    return {
+        **activity_data,
+        "description": "Test description",
+        "athlete": {"id": 123},
+        "calories": 500.0,
+    }
+
+
+@pytest.fixture
+def segment_data():
+    """Fixture with valid segment data."""
+    return {
+        "id": 12345,
+        "name": "Test Segment",
+        "activity_type": "Run",
+        "distance": 1000.0,
+        "average_grade": 5.0,
+        "maximum_grade": 10.0,
+        "elevation_high": 200.0,
+        "elevation_low": 150.0,
+        "total_elevation_gain": 50.0,
+        "start_latlng": [51.5, -0.1],
+        "end_latlng": [51.5, -0.2],
+        "climb_category": 0,
+        "private": False,
+        "starred": False,
+    }
+
+
+@pytest.fixture
+def segment_effort_data(segment_data):
+    """Fixture with valid segment effort data."""
+    return {
+        "id": 67890,
+        "activity_id": 1234567890,
+        "segment_id": 12345,
+        "name": "Test Segment",
+        "elapsed_time": 180,
+        "moving_time": 180,
+        "start_date": "2023-01-01T10:05:00Z",
+        "start_date_local": "2023-01-01T10:05:00Z",
+        "distance": 1000.0,
+        "athlete": {"id": 123},
+        "segment": segment_data,
+    }
+
+
+def test_activity_model(activity_data):
+    """Test the Activity model."""
+    activity = Activity(**activity_data)
+
+    assert activity.id == activity_data["id"]
+    assert activity.name == activity_data["name"]
+    assert activity.distance == activity_data["distance"]
+    assert activity.start_date == datetime.fromisoformat(activity_data["start_date"].replace("Z", "+00:00"))
+    assert activity.start_date_local == datetime.fromisoformat(activity_data["start_date_local"].replace("Z", "+00:00"))
+    assert activity.average_heartrate == activity_data["average_heartrate"]
+    assert activity.max_heartrate == activity_data["max_heartrate"]
+
+
+def test_activity_model_optional_fields(activity_data):
+    """Test the Activity model with optional fields."""
+    # Remove some optional fields
+    data = activity_data.copy()
+    data.pop("average_heartrate")
+    data.pop("max_heartrate")
+
+    activity = Activity(**data)
+
+    assert activity.average_heartrate is None
+    assert activity.max_heartrate is None
+
+
+def test_activity_model_missing_required_fields(activity_data):
+    """Test the Activity model with missing required fields."""
+    data = activity_data.copy()
+    data.pop("id")  # Remove a required field
+
+    with pytest.raises(ValidationError):
+        Activity(**data)
+
+
+def test_detailed_activity_model(detailed_activity_data):
+    """Test the DetailedActivity model."""
+    activity = DetailedActivity(**detailed_activity_data)
+
+    assert activity.id == detailed_activity_data["id"]
+    assert activity.name == detailed_activity_data["name"]
+    assert activity.description == detailed_activity_data["description"]
+    assert activity.athlete == detailed_activity_data["athlete"]
+    assert activity.calories == detailed_activity_data["calories"]
+
+
+def test_detailed_activity_optional_fields(detailed_activity_data):
+    """Test the DetailedActivity model with optional fields."""
+    data = detailed_activity_data.copy()
+    data.pop("description")
+    data.pop("calories")
+
+    activity = DetailedActivity(**data)
+
+    assert activity.description is None
+    assert activity.calories is None
+
+
+def test_segment_model(segment_data):
+    """Test the Segment model."""
+    segment = Segment(**segment_data)
+
+    assert segment.id == segment_data["id"]
+    assert segment.name == segment_data["name"]
+    assert segment.activity_type == segment_data["activity_type"]
+    assert segment.distance == segment_data["distance"]
+    assert segment.start_latlng == segment_data["start_latlng"]
+    assert segment.end_latlng == segment_data["end_latlng"]
+
+
+def test_segment_optional_fields(segment_data):
+    """Test the Segment model with optional fields."""
+    # Add some optional fields
+    data = segment_data.copy()
+    data["city"] = "London"
+    data["state"] = "Greater London"
+    data["country"] = "United Kingdom"
+
+    segment = Segment(**data)
+
+    assert segment.city == "London"
+    assert segment.state == "Greater London"
+    assert segment.country == "United Kingdom"
+
+
+def test_segment_missing_fields(segment_data):
+    """Test the Segment model with missing required fields."""
+    data = segment_data.copy()
+    data.pop("id")  # Remove a required field
+
+    with pytest.raises(ValidationError):
+        Segment(**data)
+
+
+def test_segment_effort_model(segment_effort_data):
+    """Test the SegmentEffort model."""
+    effort = SegmentEffort(**segment_effort_data)
+
+    assert effort.id == segment_effort_data["id"]
+    assert effort.activity_id == segment_effort_data["activity_id"]
+    assert effort.segment_id == segment_effort_data["segment_id"]
+    assert effort.name == segment_effort_data["name"]
+    assert effort.elapsed_time == segment_effort_data["elapsed_time"]
+    assert effort.moving_time == segment_effort_data["moving_time"]
+    assert effort.start_date == datetime.fromisoformat(segment_effort_data["start_date"].replace("Z", "+00:00"))
+    assert effort.start_date_local == datetime.fromisoformat(
+        segment_effort_data["start_date_local"].replace("Z", "+00:00")
+    )
+    assert effort.distance == segment_effort_data["distance"]
+    assert effort.athlete == segment_effort_data["athlete"]
+
+    # Test nested segment object
+    assert effort.segment.id == segment_effort_data["segment"]["id"]
+    assert effort.segment.name == segment_effort_data["segment"]["name"]
+
+
+def test_segment_effort_optional_fields(segment_effort_data):
+    """Test the SegmentEffort model with optional fields."""
+    # Add some optional fields
+    data = segment_effort_data.copy()
+    data["average_watts"] = 200.0
+    data["device_watts"] = True
+    data["average_heartrate"] = 150.0
+    data["max_heartrate"] = 170.0
+    data["pr_rank"] = 1
+    data["achievements"] = [{"type": "overall", "rank": 1}]
+
+    effort = SegmentEffort(**data)
+
+    assert effort.average_watts == 200.0
+    assert effort.device_watts is True
+    assert effort.average_heartrate == 150.0
+    assert effort.max_heartrate == 170.0
+    assert effort.pr_rank == 1
+    assert effort.achievements == [{"type": "overall", "rank": 1}]
+
+
+def test_segment_effort_missing_fields(segment_effort_data):
+    """Test the SegmentEffort model with missing required fields."""
+    data = segment_effort_data.copy()
+    data.pop("segment")  # Remove a required field
+
+    with pytest.raises(ValidationError):
+        SegmentEffort(**data)
+
+
+def test_error_response():
+    """Test the ErrorResponse model."""
+    data = {"message": "Resource not found", "code": 404}
+
+    error = ErrorResponse(**data)
+
+    assert error.message == "Resource not found"
+    assert error.code == 404

tests/test_oauth_server.py

@@ -0,0 +1,272 @@
+"""Tests for the Strava OAuth server module."""
+
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI
+
+from strava_mcp.oauth_server import StravaOAuthServer, get_refresh_token_from_oauth
+
+
+@pytest.fixture
+def client_credentials():
+    """Fixture for client credentials."""
+    return {
+        "client_id": "test_client_id",
+        "client_secret": "test_client_secret",
+    }
+
+
+@pytest.fixture
+def oauth_server(client_credentials):
+    """Fixture for StravaOAuthServer."""
+    return StravaOAuthServer(
+        client_id=client_credentials["client_id"],
+        client_secret=client_credentials["client_secret"],
+    )
+
+
+@pytest.mark.asyncio
+async def test_initialize_server(oauth_server):
+    """Test initializing the server."""
+    # Mock the OAuth server's dependencies directly
+    with patch("strava_mcp.oauth_server.StravaAuthenticator") as mock_authenticator_class:
+        with patch("asyncio.create_task") as mock_create_task:
+            # Setup mocks
+            mock_authenticator = MagicMock()
+            mock_authenticator_class.return_value = mock_authenticator
+            mock_task = MagicMock()
+            mock_create_task.return_value = mock_task
+
+            # Test method
+            await oauth_server._initialize_server()
+
+            # Verify FastAPI app was created
+            assert oauth_server.app is not None
+            assert oauth_server.app.title == "Strava OAuth"
+
+            # Verify authenticator was created and configured
+            mock_authenticator_class.assert_called_once_with(
+                client_id=oauth_server.client_id,
+                client_secret=oauth_server.client_secret,
+                app=oauth_server.app,
+                host=oauth_server.host,
+                port=oauth_server.port,
+            )
+            assert oauth_server.authenticator == mock_authenticator
+
+            # Verify token future was stored in authenticator
+            assert mock_authenticator.token_future is oauth_server.token_future
+
+            # Verify routes were set up
+            mock_authenticator.setup_routes.assert_called_once_with(oauth_server.app)
+
+            # Verify server task was created
+            mock_create_task.assert_called_once()
+            assert oauth_server.server_task == mock_task
+
+
+@pytest.mark.asyncio
+async def test_run_server(oauth_server):
+    """Test running the server."""
+    with patch("uvicorn.Server") as mock_server_class:
+        with patch("uvicorn.Config") as mock_config_class:
+            # Setup mocks
+            mock_server = AsyncMock()
+            mock_server_class.return_value = mock_server
+            mock_config = MagicMock()
+            mock_config_class.return_value = mock_config
+
+            # Create app
+            oauth_server.app = FastAPI()
+
+            # Test method
+            await oauth_server._run_server()
+
+            # Verify config was created correctly
+            mock_config_class.assert_called_once_with(
+                app=oauth_server.app,
+                host=oauth_server.host,
+                port=oauth_server.port,
+                log_level="info",
+            )
+
+            # Verify server was created and run
+            mock_server_class.assert_called_once_with(mock_config)
+            mock_server.serve.assert_called_once()
+            assert oauth_server.server == mock_server
+
+
+@pytest.mark.asyncio
+async def test_run_server_exception(oauth_server):
+    """Test running the server with an exception."""
+    with patch("uvicorn.Server") as mock_server_class:
+        with patch("uvicorn.Config") as mock_config_class:
+            # Setup mocks
+            mock_server = AsyncMock()
+            mock_server.serve = AsyncMock(side_effect=Exception("Test error"))
+            mock_server_class.return_value = mock_server
+            mock_config = MagicMock()
+            mock_config_class.return_value = mock_config
+
+            # Create app and token future
+            oauth_server.app = FastAPI()
+            oauth_server.token_future = asyncio.Future()
+
+            # Test method
+            await oauth_server._run_server()
+
+            # Verify token future has exception
+            assert oauth_server.token_future.done()
+            with pytest.raises(Exception, match="Test error"):
+                await oauth_server.token_future
+
+
+@pytest.mark.asyncio
+async def test_stop_server(oauth_server):
+    """Test stopping the server."""
+    # Setup server and task
+    oauth_server.server = MagicMock()
+    oauth_server.server_task = MagicMock()
+    oauth_server.server_task.done = MagicMock(return_value=False)
+
+    # Make asyncio.wait_for return immediately
+    with patch("asyncio.wait_for", new=AsyncMock()) as mock_wait_for:
+        # Test method
+        await oauth_server._stop_server()
+
+        # Verify server was stopped
+        assert oauth_server.server.should_exit is True
+        mock_wait_for.assert_called_once_with(oauth_server.server_task, timeout=5.0)
+
+
+@pytest.mark.asyncio
+async def test_stop_server_timeout(oauth_server):
+    """Test stopping the server with timeout."""
+    # Setup server and task
+    oauth_server.server = MagicMock()
+    oauth_server.server_task = MagicMock()
+    oauth_server.server_task.done = MagicMock(return_value=False)
+
+    # Make asyncio.wait_for raise TimeoutError
+    with patch("asyncio.wait_for", new=AsyncMock(side_effect=TimeoutError())) as mock_wait_for:
+        # Test method
+        await oauth_server._stop_server()
+
+        # Verify server was stopped
+        assert oauth_server.server.should_exit is True
+        mock_wait_for.assert_called_once_with(oauth_server.server_task, timeout=5.0)
+
+
+@pytest.mark.asyncio
+async def test_get_token(oauth_server):
+    """Test getting a token."""
+    # Setup mocks
+    oauth_server._initialize_server = AsyncMock()
+    oauth_server._stop_server = AsyncMock()
+    oauth_server.authenticator = MagicMock()
+    oauth_server.authenticator.get_authorization_url = MagicMock(return_value="https://example.com/auth")
+
+    with patch("webbrowser.open") as mock_open:
+        # Prepare token future
+        oauth_server.token_future = asyncio.Future()
+        oauth_server.token_future.set_result("test_refresh_token")
+
+        # Test method
+        token = await oauth_server.get_token()
+
+        # Verify
+        assert token == "test_refresh_token"
+        oauth_server._initialize_server.assert_called_once()
+        oauth_server.authenticator.get_authorization_url.assert_called_once()
+        mock_open.assert_called_once_with("https://example.com/auth")
+        oauth_server._stop_server.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_token_no_authenticator(oauth_server):
+    """Test getting a token with no authenticator."""
+    # Setup mocks
+    oauth_server._initialize_server = AsyncMock()
+    oauth_server._stop_server = AsyncMock()
+    oauth_server.authenticator = None
+
+    # Test method
+    with pytest.raises(Exception, match="Authenticator not initialized"):
+        await oauth_server.get_token()
+
+    # Verify
+    oauth_server._initialize_server.assert_called_once()
+    # The stop server is not called because we exit with exception before getting there
+    # oauth_server._stop_server.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_token_cancelled(oauth_server):
+    """Test getting a token that is cancelled."""
+    # Setup mocks
+    oauth_server._initialize_server = AsyncMock()
+    oauth_server._stop_server = AsyncMock()
+    oauth_server.authenticator = MagicMock()
+    oauth_server.authenticator.get_authorization_url = MagicMock(return_value="https://example.com/auth")
+
+    with patch("webbrowser.open") as mock_open:
+        # Prepare token future with cancellation
+        oauth_server.token_future = asyncio.Future()
+        oauth_server.token_future.cancel()
+
+        # Test method
+        with pytest.raises(Exception, match="OAuth flow was cancelled"):
+            await oauth_server.get_token()
+
+        # Verify
+        oauth_server._initialize_server.assert_called_once()
+        oauth_server.authenticator.get_authorization_url.assert_called_once()
+        mock_open.assert_called_once_with("https://example.com/auth")
+        oauth_server._stop_server.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_token_exception(oauth_server):
+    """Test getting a token with exception."""
+    # Setup mocks
+    oauth_server._initialize_server = AsyncMock()
+    oauth_server._stop_server = AsyncMock()
+    oauth_server.authenticator = MagicMock()
+    oauth_server.authenticator.get_authorization_url = MagicMock(return_value="https://example.com/auth")
+
+    with patch("webbrowser.open") as mock_open:
+        # Prepare token future with exception
+        oauth_server.token_future = asyncio.Future()
+        oauth_server.token_future.set_exception(Exception("Test error"))
+
+        # Test method
+        with pytest.raises(Exception, match="OAuth flow failed: Test error"):
+            await oauth_server.get_token()
+
+        # Verify
+        oauth_server._initialize_server.assert_called_once()
+        oauth_server.authenticator.get_authorization_url.assert_called_once()
+        mock_open.assert_called_once_with("https://example.com/auth")
+        oauth_server._stop_server.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_refresh_token_from_oauth(client_credentials):
+    """Test get_refresh_token_from_oauth function."""
+    with patch("strava_mcp.oauth_server.StravaOAuthServer") as mock_oauth_server_class:
+        # Setup mock
+        mock_server = MagicMock()
+        mock_server.get_token = AsyncMock(return_value="test_refresh_token")
+        mock_oauth_server_class.return_value = mock_server
+
+        # Test function
+        token = await get_refresh_token_from_oauth(client_credentials["client_id"], client_credentials["client_secret"])
+
+        # Verify
+        assert token == "test_refresh_token"
+        mock_oauth_server_class.assert_called_once_with(
+            client_credentials["client_id"], client_credentials["client_secret"]
+        )
+        mock_server.get_token.assert_called_once()

tests/test_server.py

@@ -1,8 +1,15 @@
-from unittest.mock import AsyncMock, MagicMock
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from strava_mcp.models import Activity, DetailedActivity, SegmentEffort
+from strava_mcp.models import Activity, DetailedActivity, Segment, SegmentEffort
+
+# Patch the StravaOAuthServer._run_server method to prevent coroutine warnings
+# This must be at the module level before any imports that might create the coroutine
+with patch("strava_mcp.oauth_server.StravaOAuthServer._run_server", new_callable=AsyncMock):
+    # Now imports will use the patched version
+    pass
 
 
 class MockContext:
@@ -39,8 +46,8 @@ async def test_get_user_activities(mock_ctx, mock_service):
         total_elevation_gain=50,
         type="Run",
         sport_type="Run",
-        start_date="2023-01-01T10:00:00Z",
-        start_date_local="2023-01-01T10:00:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
         timezone="Europe/London",
         achievement_count=2,
         kudos_count=5,
@@ -57,6 +64,11 @@ async def test_get_user_activities(mock_ctx, mock_service):
         has_heartrate=True,
         average_heartrate=140,
         max_heartrate=160,
+        # Add required fields with default values
+        map=None,
+        workout_type=None,
+        elev_high=None,
+        elev_low=None,
     )
     mock_service.get_activities.return_value = [mock_activity]
 
@@ -86,8 +98,8 @@ async def test_get_activity(mock_ctx, mock_service):
         total_elevation_gain=50,
         type="Run",
         sport_type="Run",
-        start_date="2023-01-01T10:00:00Z",
-        start_date_local="2023-01-01T10:00:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
         timezone="Europe/London",
         achievement_count=2,
         kudos_count=5,
@@ -106,6 +118,19 @@ async def test_get_activity(mock_ctx, mock_service):
         max_heartrate=160,
         athlete={"id": 123},
         description="Test description",
+        # Add required fields with default values
+        map=None,
+        workout_type=None,
+        elev_high=None,
+        elev_low=None,
+        calories=None,
+        segment_efforts=None,
+        splits_metric=None,
+        splits_standard=None,
+        best_efforts=None,
+        photos=None,
+        gear=None,
+        device_name=None,
     )
     mock_service.get_activity.return_value = mock_activity
 
@@ -133,26 +158,36 @@ async def test_get_activity_segments(mock_ctx, mock_service):
         name="Test Segment",
         elapsed_time=180,
         moving_time=180,
-        start_date="2023-01-01T10:05:00Z",
-        start_date_local="2023-01-01T10:05:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:05:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:05:00+00:00"),
         distance=1000,
         athlete={"id": 123},
-        segment={
-            "id": 12345,
-            "name": "Test Segment",
-            "activity_type": "Run",
-            "distance": 1000,
-            "average_grade": 5.0,
-            "maximum_grade": 10.0,
-            "elevation_high": 200,
-            "elevation_low": 150,
-            "total_elevation_gain": 50,
-            "start_latlng": [51.5, -0.1],
-            "end_latlng": [51.5, -0.2],
-            "climb_category": 0,
-            "private": False,
-            "starred": False,
-        },
+        segment=Segment(
+            id=12345,
+            name="Test Segment",
+            activity_type="Run",
+            distance=1000,
+            average_grade=5.0,
+            maximum_grade=10.0,
+            elevation_high=200,
+            elevation_low=150,
+            total_elevation_gain=50,
+            start_latlng=[51.5, -0.1],
+            end_latlng=[51.5, -0.2],
+            climb_category=0,
+            private=False,
+            starred=False,
+            city=None,
+            state=None,
+            country=None,
+        ),
+        # Add required fields with default values
+        average_watts=None,
+        device_watts=None,
+        average_heartrate=None,
+        max_heartrate=None,
+        pr_rank=None,
+        achievements=None,
     )
     mock_service.get_activity_segments.return_value = [mock_segment]
 
@@ -168,5 +203,3 @@ async def test_get_activity_segments(mock_ctx, mock_service):
     assert len(result) == 1
     assert result[0]["id"] == mock_segment.id
     assert result[0]["name"] == mock_segment.name
-
-

tests/test_service.py

@@ -1,9 +1,10 @@
+from datetime import datetime
 from unittest.mock import AsyncMock, patch
 
 import pytest
 
 from strava_mcp.config import StravaSettings
-from strava_mcp.models import Activity, DetailedActivity, SegmentEffort
+from strava_mcp.models import Activity, DetailedActivity, Segment, SegmentEffort
 from strava_mcp.service import StravaService
 
 
@@ -13,6 +14,7 @@ def settings():
         client_id="test_client_id",
         client_secret="test_client_secret",
         refresh_token="test_refresh_token",
+        base_url="https://www.strava.com/api/v3",
     )
 
 
@@ -44,8 +46,8 @@ async def test_get_activities(service, mock_api):
         total_elevation_gain=50,
         type="Run",
         sport_type="Run",
-        start_date="2023-01-01T10:00:00Z",
-        start_date_local="2023-01-01T10:00:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
         timezone="Europe/London",
         achievement_count=2,
         kudos_count=5,
@@ -62,6 +64,11 @@ async def test_get_activities(service, mock_api):
         has_heartrate=True,
         average_heartrate=140,
         max_heartrate=160,
+        # Add required fields with default values
+        map=None,
+        workout_type=None,
+        elev_high=None,
+        elev_low=None,
     )
     mock_api.get_activities.return_value = [mock_activity]
 
@@ -88,8 +95,8 @@ async def test_get_activity(service, mock_api):
         total_elevation_gain=50,
         type="Run",
         sport_type="Run",
-        start_date="2023-01-01T10:00:00Z",
-        start_date_local="2023-01-01T10:00:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:00:00+00:00"),
         timezone="Europe/London",
         achievement_count=2,
         kudos_count=5,
@@ -108,6 +115,19 @@ async def test_get_activity(service, mock_api):
         max_heartrate=160,
         athlete={"id": 123},
         description="Test description",
+        # Add required fields with default values
+        map=None,
+        workout_type=None,
+        elev_high=None,
+        elev_low=None,
+        calories=None,
+        segment_efforts=None,
+        splits_metric=None,
+        splits_standard=None,
+        best_efforts=None,
+        photos=None,
+        gear=None,
+        device_name=None,
     )
     mock_api.get_activity.return_value = mock_activity
 
@@ -131,26 +151,36 @@ async def test_get_activity_segments(service, mock_api):
         name="Test Segment",
         elapsed_time=180,
         moving_time=180,
-        start_date="2023-01-01T10:05:00Z",
-        start_date_local="2023-01-01T10:05:00Z",
+        start_date=datetime.fromisoformat("2023-01-01T10:05:00+00:00"),
+        start_date_local=datetime.fromisoformat("2023-01-01T10:05:00+00:00"),
         distance=1000,
         athlete={"id": 123},
-        segment={
-            "id": 12345,
-            "name": "Test Segment",
-            "activity_type": "Run",
-            "distance": 1000,
-            "average_grade": 5.0,
-            "maximum_grade": 10.0,
-            "elevation_high": 200,
-            "elevation_low": 150,
-            "total_elevation_gain": 50,
-            "start_latlng": [51.5, -0.1],
-            "end_latlng": [51.5, -0.2],
-            "climb_category": 0,
-            "private": False,
-            "starred": False,
-        },
+        segment=Segment(
+            id=12345,
+            name="Test Segment",
+            activity_type="Run",
+            distance=1000,
+            average_grade=5.0,
+            maximum_grade=10.0,
+            elevation_high=200,
+            elevation_low=150,
+            total_elevation_gain=50,
+            start_latlng=[51.5, -0.1],
+            end_latlng=[51.5, -0.2],
+            climb_category=0,
+            private=False,
+            starred=False,
+            city=None,
+            state=None,
+            country=None,
+        ),
+        # Add required fields with default values
+        average_watts=None,
+        device_watts=None,
+        average_heartrate=None,
+        max_heartrate=None,
+        pr_rank=None,
+        achievements=None,
     )
     mock_api.get_activity_segments.return_value = [mock_segment]
 
@@ -163,5 +193,3 @@ async def test_get_activity_segments(service, mock_api):
     # Verify response
     assert len(segments) == 1
     assert segments[0] == mock_segment
-
-

uv.lock

@@ -118,6 +118,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180 },
 ]
 
+[[package]]
+name = "coverage"
+version = "7.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/bf/3effb7453498de9c14a81ca21e1f92e6723ce7ebdc5402ae30e4dcc490ac/coverage-7.7.1.tar.gz", hash = "sha256:199a1272e642266b90c9f40dec7fd3d307b51bf639fa0d15980dc0b3246c1393", size = 810332 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/2a/1a254eaadb01c163b29d6ce742aa380fc5cfe74a82138ce6eb944c42effa/coverage-7.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eebd927b86761a7068a06d3699fd6c20129becf15bb44282db085921ea0f1585", size = 211277 },
+    { url = "https://files.pythonhosted.org/packages/cf/00/9636028365efd4eb6db71cdd01d99e59f25cf0d47a59943dbee32dd1573b/coverage-7.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2a79c4a09765d18311c35975ad2eb1ac613c0401afdd9cb1ca4110aeb5dd3c4c", size = 211551 },
+    { url = "https://files.pythonhosted.org/packages/6f/c8/14aed97f80363f055b6cd91e62986492d9fe3b55e06b4b5c82627ae18744/coverage-7.7.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b1c65a739447c5ddce5b96c0a388fd82e4bbdff7251396a70182b1d83631019", size = 245068 },
+    { url = "https://files.pythonhosted.org/packages/d6/76/9c5fe3f900e01d7995b0cda08fc8bf9773b4b1be58bdd626f319c7d4ec11/coverage-7.7.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:392cc8fd2b1b010ca36840735e2a526fcbd76795a5d44006065e79868cc76ccf", size = 242109 },
+    { url = "https://files.pythonhosted.org/packages/c0/81/760993bb536fb674d3a059f718145dcd409ed6d00ae4e3cbf380019fdfd0/coverage-7.7.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9bb47cc9f07a59a451361a850cb06d20633e77a9118d05fd0f77b1864439461b", size = 244129 },
+    { url = "https://files.pythonhosted.org/packages/00/be/1114a19f93eae0b6cd955dabb5bee80397bd420d846e63cd0ebffc134e3d/coverage-7.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b4c144c129343416a49378e05c9451c34aae5ccf00221e4fa4f487db0816ee2f", size = 244201 },
+    { url = "https://files.pythonhosted.org/packages/06/8d/9128fd283c660474c7dc2b1ea5c66761bc776b970c1724989ed70e9d6eee/coverage-7.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bc96441c9d9ca12a790b5ae17d2fa6654da4b3962ea15e0eabb1b1caed094777", size = 242282 },
+    { url = "https://files.pythonhosted.org/packages/d4/2a/6d7dbfe9c1f82e2cdc28d48f4a0c93190cf58f057fa91ba2391b92437fe6/coverage-7.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d03287eb03186256999539d98818c425c33546ab4901028c8fa933b62c35c3a", size = 243570 },
+    { url = "https://files.pythonhosted.org/packages/cf/3e/29f1e4ce3bb951bcf74b2037a82d94c5064b3334304a3809a95805628838/coverage-7.7.1-cp313-cp313-win32.whl", hash = "sha256:8fed429c26b99641dc1f3a79179860122b22745dd9af36f29b141e178925070a", size = 213772 },
+    { url = "https://files.pythonhosted.org/packages/bc/3a/cf029bf34aefd22ad34f0e808eba8d5830f297a1acb483a2124f097ff769/coverage-7.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:092b134129a8bb940c08b2d9ceb4459af5fb3faea77888af63182e17d89e1cf1", size = 214575 },
+    { url = "https://files.pythonhosted.org/packages/92/4c/fb8b35f186a2519126209dce91ab8644c9a901cf04f8dfa65576ca2dd9e8/coverage-7.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3154b369141c3169b8133973ac00f63fcf8d6dbcc297d788d36afbb7811e511", size = 212113 },
+    { url = "https://files.pythonhosted.org/packages/59/90/e834ffc86fd811c5b570a64ee1895b20404a247ec18a896b9ba543b12097/coverage-7.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:264ff2bcce27a7f455b64ac0dfe097680b65d9a1a293ef902675fa8158d20b24", size = 212333 },
+    { url = "https://files.pythonhosted.org/packages/a5/a1/27f0ad39569b3b02410b881c42e58ab403df13fcd465b475db514b83d3d3/coverage-7.7.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba8480ebe401c2f094d10a8c4209b800a9b77215b6c796d16b6ecdf665048950", size = 256566 },
+    { url = "https://files.pythonhosted.org/packages/9f/3b/21fa66a1db1b90a0633e771a32754f7c02d60236a251afb1b86d7e15d83a/coverage-7.7.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:520af84febb6bb54453e7fbb730afa58c7178fd018c398a8fcd8e269a79bf96d", size = 252276 },
+    { url = "https://files.pythonhosted.org/packages/d6/e5/4ab83a59b0f8ac4f0029018559fc4c7d042e1b4552a722e2bfb04f652296/coverage-7.7.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88d96127ae01ff571d465d4b0be25c123789cef88ba0879194d673fdea52f54e", size = 254616 },
+    { url = "https://files.pythonhosted.org/packages/db/7a/4224417c0ccdb16a5ba4d8d1fcfaa18439be1624c29435bb9bc88ccabdfb/coverage-7.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:0ce92c5a9d7007d838456f4b77ea159cb628187a137e1895331e530973dcf862", size = 255707 },
+    { url = "https://files.pythonhosted.org/packages/51/20/ff18a329ccaa3d035e2134ecf3a2e92a52d3be6704c76e74ca5589ece260/coverage-7.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:0dab4ef76d7b14f432057fdb7a0477e8bffca0ad39ace308be6e74864e632271", size = 253876 },
+    { url = "https://files.pythonhosted.org/packages/e4/e8/1d6f1a6651672c64f45ffad05306dad9c4c189bec694270822508049b2cb/coverage-7.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7e688010581dbac9cab72800e9076e16f7cccd0d89af5785b70daa11174e94de", size = 254687 },
+    { url = "https://files.pythonhosted.org/packages/6b/ea/1b9a14cf3e2bc3fd9de23a336a8082091711c5f480b500782d59e84a8fe5/coverage-7.7.1-cp313-cp313t-win32.whl", hash = "sha256:e52eb31ae3afacdacfe50705a15b75ded67935770c460d88c215a9c0c40d0e9c", size = 214486 },
+    { url = "https://files.pythonhosted.org/packages/cc/bb/faa6bcf769cb7b3b660532a30d77c440289b40636c7f80e498b961295d07/coverage-7.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a6b6b3bd121ee2ec4bd35039319f3423d0be282b9752a5ae9f18724bc93ebe7c", size = 215647 },
+    { url = "https://files.pythonhosted.org/packages/52/26/9f53293ff4cc1d47d98367ce045ca2e62746d6be74a5c6851a474eabf59b/coverage-7.7.1-py3-none-any.whl", hash = "sha256:822fa99dd1ac686061e1219b67868e25d9757989cf2259f735a4802497d6da31", size = 203006 },
+]
+
 [[package]]
 name = "debugpy"
 version = "1.8.13"
@@ -622,6 +651,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
 ]
 
+[[package]]
+name = "pyright"
+version = "1.1.397"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/92/23/cefa10c9cb198e0858ed0b9233371d62bca880337f628e58f50dfdfb12f0/pyright-1.1.397.tar.gz", hash = "sha256:07530fd65a449e4b0b28dceef14be0d8e0995a7a5b1bb2f3f897c3e548451ce3", size = 3818998 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/b5/98ec41e1e0ad5576ecd42c90ec363560f7b389a441722ea3c7207682dec7/pyright-1.1.397-py3-none-any.whl", hash = "sha256:2e93fba776e714a82b085d68f8345b01f91ba43e1ab9d513e79b70fc85906257", size = 5693631 },
+]
+
 [[package]]
 name = "pytest"
 version = "8.3.5"
@@ -649,6 +691,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467 },
 ]
 
+[[package]]
+name = "pytest-cov"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 },
+]
+
 [[package]]
 name = "pytest-mock"
 version = "3.14.0"
@@ -846,7 +901,7 @@ wheels = [
 [[package]]
 name = "strava"
 version = "0.1.0"
-source = { virtual = "." }
+source = { editable = "." }
 dependencies = [
     { name = "fastapi" },
     { name = "httpx" },
@@ -860,8 +915,10 @@ dev = [
     { name = "devtools" },
     { name = "ipykernel" },
     { name = "pre-commit" },
+    { name = "pyright" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
     { name = "pytest-mock" },
     { name = "ruff" },
 ]
@@ -880,8 +937,10 @@ dev = [
     { name = "devtools", specifier = ">=0.12.2" },
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "pre-commit", specifier = ">=3.7.1" },
+    { name = "pyright", specifier = ">=1.1.385" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "pytest-asyncio", specifier = ">=0.23.5" },
+    { name = "pytest-cov", specifier = ">=6.0.0" },
     { name = "pytest-mock", specifier = ">=3.14.0" },
     { name = "ruff", specifier = ">=0.5.1" },
 ]