Fix: Update tests for optional CLI params and resolve CI issues

- Fix test_parse_arguments_missing_required_arg to test validate_required_args
- Fix test_network_timeout to expect RateLimitError instead of TimeoutError
- Add comprehensive test coverage for validate_required_args (7 new tests)
  - Test all args provided, missing api_key/project/limit
  - Test environment variable support and mixed CLI/env usage
- Add #nosec B110 to suppress intentional try/except/pass
- Update README: Add env var support to features, update test count to 25
- Fix Windows venv activation commands (remove 'source')

All 25 tests passing, 86% coverage, all CI checks green.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: kenjudy

README.md

@@ -9,12 +9,13 @@ This Python script exports trace data from LangSmith using the SDK API, designed
 ## Features
 
 - Export N most recent traces from any LangSmith project
+- **Environment variable support** - Configure once via `.env` file for simplified usage
 - Automatic rate limiting with exponential backoff
 - Progress indication for long-running exports
 - Comprehensive error handling (auth, network, rate limits)
 - Structured JSON output with metadata
 - Type-safe implementation with full type hints
-- Test-driven development with pytest suite
+- Test-driven development with pytest suite (25 tests, 86% coverage)
 
 ## Requirements
 
@@ -36,15 +37,15 @@ cd export-langsmith-data
 **Option A: Using uv (recommended)**
 ```bash
 uv venv
-source .venv/Scripts/activate  # Windows
+.venv/Scripts/activate  # Windows
 # or
 source .venv/bin/activate      # Linux/Mac
 ```
 
 **Option B: Using venv**
 ```bash
 python -m venv .venv
-source .venv/Scripts/activate  # Windows
+.venv/Scripts/activate  # Windows
 # or
 source .venv/bin/activate      # Linux/Mac
 ```
@@ -225,14 +226,15 @@ All core features implemented and tested:
 - ✅ Project setup with virtual environment (uv/venv)
 - ✅ Dependencies configuration with CI/CD quality gates
 - ✅ CLI argument parsing with validation
+- ✅ **Environment variable support** - Optional `.env` file configuration for simplified usage
 - ✅ LangSmith client initialization with authentication
 - ✅ Run fetching with exponential backoff rate limiting
 - ✅ Data formatting and transformation with safe field extraction
 - ✅ JSON export functionality with error handling
 - ✅ Comprehensive error scenario handling
 - ✅ Main orchestration with user-friendly progress feedback
 - ✅ End-to-end integration testing
-- ✅ Test suite: 18 tests, 87% coverage
+- ✅ Test suite: 25 tests, 86% coverage
 - ✅ Code quality: Black, Ruff, mypy, Bandit, Safety checks passing
 
 ### Optional Features Not Implemented

export_langsmith_traces.py

@@ -92,9 +92,10 @@ def __init__(self, api_key: str, api_url: str = DEFAULT_API_URL) -> None:
     def _looks_like_uuid(self, value: str) -> bool:
         """Check if a string looks like a UUID."""
         import re
+
         uuid_pattern = re.compile(
-            r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', 
-            re.IGNORECASE
+            r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+            re.IGNORECASE,
         )
         return bool(uuid_pattern.match(value))
 
@@ -115,7 +116,7 @@ def fetch_runs(self, project_name: str, limit: int) -> List[Any]:
         """
         attempt = 0
         last_exception = None
-        
+
         while attempt < self.MAX_RETRIES:
             try:
                 # Try with project_name parameter first
@@ -126,20 +127,25 @@ def fetch_runs(self, project_name: str, limit: int) -> List[Any]:
             except Exception as e:
                 last_exception = e
                 error_msg = str(e).lower()
-                
+
                 # Check if this is a project not found error (not a rate limit or network error)
-                if any(term in error_msg for term in ["not found", "does not exist", "project", "404"]):
+                if any(
+                    term in error_msg
+                    for term in ["not found", "does not exist", "project", "404"]
+                ):
                     # If it looks like a UUID, try as project_id instead
                     if self._looks_like_uuid(project_name):
                         print("Trying project ID instead of name...")
                         try:
                             runs = list(
-                                self.client.list_runs(project_id=project_name, limit=limit)
+                                self.client.list_runs(
+                                    project_id=project_name, limit=limit
+                                )
                             )
                             return runs
-                        except Exception:
-                            pass  # Fall through to retry logic
-                    
+                        except Exception:  # nosec B110
+                            pass  # Intentional: Fall through to retry logic if project_id also fails
+
                     # If first attempt and looks like project name issue, raise specific error
                     if attempt == 0:
                         raise ProjectNotFoundError(
@@ -148,7 +154,7 @@ def fetch_runs(self, project_name: str, limit: int) -> List[Any]:
                             f"You can find the project ID in the LangSmith URL when viewing your project. "
                             f"Original error: {str(e)}"
                         ) from e
-                
+
                 attempt += 1
                 if attempt >= self.MAX_RETRIES:
                     break
@@ -157,7 +163,7 @@ def fetch_runs(self, project_name: str, limit: int) -> List[Any]:
                     self.BACKOFF_MULTIPLIER ** (attempt - 1)
                 )
                 time.sleep(backoff_time)
-        
+
         # If we get here, all retries failed
         raise RateLimitError(
             f"Failed to fetch runs after {self.MAX_RETRIES} attempts. "
@@ -274,10 +280,10 @@ def _get_env_limit() -> int:
         limit_str = os.getenv("LANGSMITH_LIMIT", "0")
         limit = int(limit_str)
         if limit <= 0:
-            return 0 
+            return 0
         return limit
     except ValueError:
-        return 0  
+        return 0
 
 
 def parse_arguments() -> argparse.Namespace:
@@ -289,7 +295,7 @@ def parse_arguments() -> argparse.Namespace:
     """
     # Load environment variables from .env file
     load_dotenv()
-    
+
     parser = argparse.ArgumentParser(
         description="Export LangSmith trace data for offline analysis",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -325,7 +331,7 @@ def parse_arguments() -> argparse.Namespace:
         type=str,
         required=False,
         default=os.getenv("LANGSMITH_PROJECT"),
-        help="LangSmith project name or ID (default: LANGSMITH_PROJECT env var)"
+        help="LangSmith project name or ID (default: LANGSMITH_PROJECT env var)",
     )
 
     parser.add_argument(
@@ -346,24 +352,24 @@ def parse_arguments() -> argparse.Namespace:
 def validate_required_args(args: argparse.Namespace) -> None:
     """
     Validate that required arguments are provided via CLI or environment.
-    
+
     Args:
         args: Parsed command line arguments
-        
+
     Raises:
         SystemExit: If required arguments are missing
     """
     errors = []
-    
+
     if not args.api_key:
         errors.append("--api-key is required (or set LANGSMITH_API_KEY in .env)")
-    
+
     if not args.project:
         errors.append("--project is required (or set LANGSMITH_PROJECT in .env)")
-    
+
     if not args.limit:
         errors.append("--limit is required (or set LANGSMITH_LIMIT in .env)")
-    
+
     if errors:
         print("❌ Missing required arguments:", file=sys.stderr)
         for error in errors:
@@ -399,7 +405,7 @@ def main() -> None:
     try:
         # Parse arguments
         args = parse_arguments()
-        
+
         # Validate that required arguments are available
         validate_required_args(args)
 

test_export_langsmith_traces.py

@@ -15,8 +15,10 @@
 from export_langsmith_traces import (
     LangSmithExporter,
     parse_arguments,
+    validate_required_args,
     AuthenticationError,
     ExportError,
+    RateLimitError,
 )
 
 
@@ -48,8 +50,8 @@ def test_parse_arguments_with_required_args(self):
         assert args.output == "test_output.json"
 
     def test_parse_arguments_missing_required_arg(self):
-        """Test that missing required argument raises error."""
-        # Arrange - missing --api-key argument
+        """Test that missing required argument (no env var fallback) raises error."""
+        # Arrange - missing --api-key argument and no env var
         test_args = [
             "--project",
             "test-project",
@@ -59,10 +61,20 @@ def test_parse_arguments_missing_required_arg(self):
             "test_output.json",
         ]
 
-        # Act & Assert - should raise SystemExit
-        with patch("sys.argv", ["export_langsmith_traces.py"] + test_args):
-            with pytest.raises(SystemExit):
-                parse_arguments()
+        # Act & Assert - parse_arguments with no env vars, then validate should fail
+        with patch.dict(
+            "os.environ", {}, clear=True
+        ):  # Clear all env vars before parsing
+            with patch(
+                "export_langsmith_traces.load_dotenv"
+            ):  # Prevent loading .env file
+                with patch("sys.argv", ["export_langsmith_traces.py"] + test_args):
+                    args = parse_arguments()
+                    # api_key should be None since not provided via CLI or env
+                    assert args.api_key is None
+                    # Now validate_required_args should raise SystemExit
+                    with pytest.raises(SystemExit):
+                        validate_required_args(args)
 
     def test_parse_arguments_invalid_limit(self):
         """Test that negative or zero limit is rejected."""
@@ -84,6 +96,123 @@ def test_parse_arguments_invalid_limit(self):
                 parse_arguments()
 
 
+class TestValidateRequiredArgs:
+    """Test validate_required_args function with various argument combinations."""
+
+    def test_validate_with_all_args_provided(self):
+        """Test validation passes when all required args are provided."""
+        # Arrange
+        from argparse import Namespace
+
+        args = Namespace(
+            api_key="test_key", project="test-project", limit=100, output="test.json"
+        )
+
+        # Act & Assert - should not raise
+        validate_required_args(args)
+
+    def test_validate_missing_api_key(self):
+        """Test validation fails when api_key is missing."""
+        # Arrange
+        from argparse import Namespace
+
+        args = Namespace(
+            api_key=None, project="test-project", limit=100, output="test.json"
+        )
+
+        # Act & Assert
+        with pytest.raises(SystemExit):
+            validate_required_args(args)
+
+    def test_validate_missing_project(self):
+        """Test validation fails when project is missing."""
+        # Arrange
+        from argparse import Namespace
+
+        args = Namespace(
+            api_key="test_key", project=None, limit=100, output="test.json"
+        )
+
+        # Act & Assert
+        with pytest.raises(SystemExit):
+            validate_required_args(args)
+
+    def test_validate_missing_limit(self):
+        """Test validation fails when limit is missing."""
+        # Arrange
+        from argparse import Namespace
+
+        args = Namespace(
+            api_key="test_key", project="test-project", limit=None, output="test.json"
+        )
+
+        # Act & Assert
+        with pytest.raises(SystemExit):
+            validate_required_args(args)
+
+    def test_validate_multiple_missing_args(self):
+        """Test validation fails when multiple args are missing."""
+        # Arrange
+        from argparse import Namespace
+
+        args = Namespace(api_key=None, project=None, limit=None, output="test.json")
+
+        # Act & Assert
+        with pytest.raises(SystemExit):
+            validate_required_args(args)
+
+    def test_parse_with_env_vars(self):
+        """Test that args can be provided via environment variables."""
+        # Arrange
+        test_args = ["--output", "test.json"]
+
+        # Act
+        with patch.dict(
+            "os.environ",
+            {
+                "LANGSMITH_API_KEY": "env_api_key",
+                "LANGSMITH_PROJECT": "env_project",
+                "LANGSMITH_LIMIT": "200",
+            },
+        ):
+            with patch("sys.argv", ["export_langsmith_traces.py"] + test_args):
+                args = parse_arguments()
+
+        # Assert
+        assert args.api_key == "env_api_key"
+        assert args.project == "env_project"
+        assert args.limit == 200
+        assert args.output == "test.json"
+
+        # Validate should pass
+        validate_required_args(args)
+
+    def test_parse_with_mixed_cli_and_env(self):
+        """Test that CLI args override environment variables."""
+        # Arrange
+        test_args = ["--api-key", "cli_key", "--output", "test.json"]
+
+        # Act
+        with patch.dict(
+            "os.environ",
+            {
+                "LANGSMITH_API_KEY": "env_key",
+                "LANGSMITH_PROJECT": "env_project",
+                "LANGSMITH_LIMIT": "200",
+            },
+        ):
+            with patch("sys.argv", ["export_langsmith_traces.py"] + test_args):
+                args = parse_arguments()
+
+        # Assert - CLI should override env
+        assert args.api_key == "cli_key"  # From CLI
+        assert args.project == "env_project"  # From env
+        assert args.limit == 200  # From env
+
+        # Validate should pass
+        validate_required_args(args)
+
+
 class TestLangSmithExporter:
     """Test LangSmithExporter class methods."""
 
@@ -439,10 +568,13 @@ def test_network_timeout(self, mock_sleep, mock_client_class):
 
         exporter = LangSmithExporter(api_key="test_key")
 
-        # Act & Assert - should retry and eventually fail
-        with pytest.raises(TimeoutError):
+        # Act & Assert - should retry and eventually raise RateLimitError
+        with pytest.raises(RateLimitError) as exc_info:
             exporter.fetch_runs(project_name="test-project", limit=10)
 
+        # Verify the error message contains info about the timeout
+        assert "Connection timeout" in str(exc_info.value)
+
         # Should have retried MAX_RETRIES times
         assert mock_client.list_runs.call_count == exporter.MAX_RETRIES