@mseep/csv-editor 1.0.0

package/tests/test_basic.py

@@ -0,0 +1,103 @@
+"""Basic unit tests for CSV Editor."""
+
+import pytest
+
+from src.csv_editor.models import get_session_manager
+from src.csv_editor.utils.validators import sanitize_filename, validate_column_name, validate_url
+
+
+class TestValidators:
+    """Test validation utilities."""
+
+    def test_validate_column_name(self):
+        """Test column name validation."""
+        # Valid names
+        assert validate_column_name("age")[0] == True
+        assert validate_column_name("first_name")[0] == True
+        assert validate_column_name("_id")[0] == True
+
+        # Invalid names
+        assert validate_column_name("123name")[0] == False
+        assert validate_column_name("name-with-dash")[0] == False
+        assert validate_column_name("")[0] == False
+
+    def test_sanitize_filename(self):
+        """Test filename sanitization."""
+        assert sanitize_filename("test.csv") == "test.csv"
+        assert sanitize_filename("test<>file.csv") == "test__file.csv"
+        assert sanitize_filename("../../../etc/passwd") == "passwd"
+
+    def test_validate_url(self):
+        """Test URL validation."""
+        # Valid URLs
+        assert validate_url("https://example.com/data.csv")[0] == True
+        assert validate_url("http://localhost:8000/file.csv")[0] == True
+
+        # Invalid URLs
+        assert validate_url("ftp://example.com/data.csv")[0] == False
+        assert validate_url("not-a-url")[0] == False
+
+
+class TestSessionManager:
+    """Test session management."""
+
+    def test_create_session(self):
+        """Test session creation."""
+        manager = get_session_manager()
+        session_id = manager.create_session()
+
+        assert session_id is not None
+        assert manager.get_session(session_id) is not None
+
+        # Cleanup
+        manager.remove_session(session_id)
+
+    def test_session_cleanup(self):
+        """Test session removal."""
+        manager = get_session_manager()
+        session_id = manager.create_session()
+
+        # Session should exist
+        assert manager.get_session(session_id) is not None
+
+        # Remove session
+        manager.remove_session(session_id)
+
+        # Session should not exist
+        assert manager.get_session(session_id) is None
+
+
+@pytest.mark.asyncio
+class TestDataOperations:
+    """Test basic data operations."""
+
+    async def test_load_csv_from_content(self):
+        """Test loading CSV from string content."""
+        from src.csv_editor.tools.io_operations import load_csv_from_content
+
+        csv_content = """a,b,c
+1,2,3
+4,5,6"""
+
+        result = await load_csv_from_content(content=csv_content, delimiter=",")
+
+        assert result["success"] == True
+        assert result["rows_affected"] == 2
+        assert len(result["columns_affected"]) == 3
+
+        # Cleanup
+        manager = get_session_manager()
+        manager.remove_session(result["session_id"])
+
+    async def test_filter_rows(self, test_session):
+        """Test filtering rows."""
+        from src.csv_editor.tools.transformations import filter_rows
+
+        result = await filter_rows(
+            session_id=test_session,
+            conditions=[{"column": "price", "operator": ">", "value": 50}],
+            mode="and",
+        )
+
+        assert result["success"] == True
+        assert result["rows_after"] < result["rows_before"]

package/tests/test_integration.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python
+"""
+Test script for CSV MCP Server
+
+This script tests the core functionality of the CSV MCP Server
+without requiring an MCP client.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from src.csv_editor.models.csv_session import get_session_manager
+from src.csv_editor.tools.analytics import (
+    detect_outliers,
+    get_correlation_matrix,
+    get_statistics,
+    group_by_aggregate,
+    profile_data,
+)
+from src.csv_editor.tools.io_operations import (
+    export_csv,
+    get_session_info,
+    list_sessions,
+    load_csv_from_content,
+)
+from src.csv_editor.tools.transformations import (
+    add_column,
+    fill_missing_values,
+    filter_rows,
+    select_columns,
+    sort_data,
+)
+from src.csv_editor.tools.validation import check_data_quality, find_anomalies, validate_schema
+
+# Test data
+TEST_CSV_CONTENT = """name,age,salary,department,hire_date
+Alice,28,55000,Engineering,2021-01-15
+Bob,35,65000,Engineering,2019-06-01
+Charlie,42,75000,Management,2018-03-20
+Diana,31,58000,Marketing,2020-08-10
+Eve,29,52000,Sales,2021-03-25
+Frank,45,85000,Management,2017-11-30
+Grace,26,48000,Marketing,2022-02-14
+Henry,38,70000,Engineering,2019-09-15
+Iris,33,62000,Sales,2020-05-20
+Jack,41,78000,Management,2018-07-12
+Kate,27,,Marketing,2021-11-01
+Leo,36,68000,Engineering,2019-04-18
+Mia,30,56000,Sales,2020-12-05
+Nathan,44,82000,Management,2017-09-08
+Olivia,25,45000,Marketing,2022-06-30
+Peter,39,72000,Engineering,2018-10-22
+Quinn,32,60000,Sales,2020-03-15
+Rachel,28,54000,Marketing,2021-07-20
+Sam,37,69000,Engineering,2019-02-28
+Tina,34,64000,Sales,2020-01-10
+"""
+
+
+class Colors:
+    """ANSI color codes for terminal output"""
+
+    HEADER = "\033[95m"
+    BLUE = "\033[94m"
+    CYAN = "\033[96m"
+    GREEN = "\033[92m"
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+
+
+def print_test(name: str):
+    """Print test header"""
+    print(f"\n{Colors.HEADER}{Colors.BOLD}Testing: {name}{Colors.ENDC}")
+
+
+def print_success(msg: str):
+    """Print success message"""
+    print(f"{Colors.GREEN}✓ {msg}{Colors.ENDC}")
+
+
+def print_error(msg: str):
+    """Print error message"""
+    print(f"{Colors.FAIL}✗ {msg}{Colors.ENDC}")
+
+
+def print_info(msg: str):
+    """Print info message"""
+    print(f"{Colors.CYAN}ℹ {msg}{Colors.ENDC}")
+
+
+def print_data(data: any, indent: int = 2):
+    """Print data with indentation"""
+    indent_str = " " * indent
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if isinstance(value, (dict, list)) and len(str(value)) > 50:
+                print(
+                    f"{indent_str}{Colors.BLUE}{key}:{Colors.ENDC} <{type(value).__name__} with {len(value)} items>"
+                )
+            else:
+                print(f"{indent_str}{Colors.BLUE}{key}:{Colors.ENDC} {value}")
+    elif isinstance(data, pd.DataFrame):
+        print(f"{indent_str}DataFrame shape: {data.shape}")
+        print(data.head().to_string().replace("\n", f"\n{indent_str}"))
+    else:
+        print(f"{indent_str}{data}")
+
+
+async def test_io_operations():
+    """Test I/O operations"""
+    print_test("I/O Operations")
+
+    # Load CSV from content
+    result = await load_csv_from_content(content=TEST_CSV_CONTENT, delimiter=",")
+
+    if result["success"]:
+        session_id = result["session_id"]
+        print_success(f"Loaded CSV with session ID: {session_id}")
+        print_info(f"Rows: {result['rows_affected']}, Columns: {len(result['columns_affected'])}")
+        print_info(f"Column names: {', '.join(result['columns_affected'])}")
+    else:
+        print_error("Failed to load CSV")
+        return None
+
+    # Get session info
+    info = await get_session_info(session_id=session_id)
+    if info["success"]:
+        print_success("Retrieved session info")
+        print_data(info.get("data", info))
+
+    # List sessions
+    sessions = await list_sessions()
+    if sessions["success"]:
+        print_success(f"Listed {len(sessions.get('sessions', []))} active session(s)")
+
+    return session_id
+
+
+async def test_transformations(session_id: str):
+    """Test data transformation operations"""
+    print_test("Data Transformations")
+
+    # Filter rows
+    result = await filter_rows(
+        session_id=session_id,
+        conditions=[
+            {"column": "salary", "operator": ">", "value": 60000},
+            {"column": "department", "operator": "in", "value": ["Engineering", "Management"]},
+        ],
+        mode="and",
+    )
+    if result["success"]:
+        print_success(f"Filtered rows: {result['rows_before']} → {result['rows_after']}")
+
+    # Sort data
+    result = await sort_data(
+        session_id=session_id,
+        columns=[
+            {"column": "department", "ascending": True},
+            {"column": "salary", "ascending": False},
+        ],
+    )
+    if result["success"]:
+        print_success("Sorted data by department and salary")
+
+    # Select columns
+    result = await select_columns(session_id=session_id, columns=["name", "department", "salary"])
+    if result["success"]:
+        print_success(f"Selected columns: {', '.join(result['selected_columns'])}")
+
+    # Add calculated column
+    result = await add_column(
+        session_id=session_id,
+        name="salary_level",
+        value=None,
+        formula="lambda row: 'High' if row['salary'] > 65000 else 'Medium' if row['salary'] > 55000 else 'Low' if pd.notna(row['salary']) else 'Unknown'",
+    )
+    if result["success"]:
+        print_success("Added column 'salary_level'")
+
+    # Fill missing values
+    result = await fill_missing_values(session_id=session_id, strategy="mean", columns=["salary"])
+    if result["success"]:
+        print_success(f"Filled {result['values_filled']} missing value(s)")
+
+
+async def test_analytics(session_id: str):
+    """Test analytics operations"""
+    print_test("Analytics")
+
+    # Get statistics
+    result = await get_statistics(session_id=session_id, columns=["salary"])
+    if result["success"]:
+        print_success("Got statistics for salary column")
+        print_data(result["statistics"])
+
+    # Get correlation matrix
+    result = await get_correlation_matrix(
+        session_id=session_id, method="pearson", min_correlation=0.3
+    )
+    if result["success"]:
+        print_success("Got correlation matrix")
+        if result["significant_correlations"]:
+            print_info("Significant correlations found:")
+            for corr in result["significant_correlations"]:
+                print(f"    {corr['column1']} ↔ {corr['column2']}: {corr['correlation']:.3f}")
+
+    # Group by and aggregate
+    result = await group_by_aggregate(
+        session_id=session_id,
+        group_by=["department"],
+        aggregations={"salary": ["mean", "min", "max", "count"]},
+    )
+    if result["success"]:
+        print_success("Grouped by department with aggregations")
+        print_info("Department salary statistics:")
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+        if session and session.df is not None:
+            print(session.df.head(10).to_string())
+
+    # Detect outliers
+    result = await detect_outliers(
+        session_id=session_id, columns=["salary"], method="iqr", threshold=1.5
+    )
+    if result["success"]:
+        print_success(f"Detected {result['total_outliers']} outlier(s)")
+        if result["outliers"]:
+            print_info("Outlier details:")
+            for col, details in result["outliers"].items():
+                print(f"    {col}: {details['count']} outliers")
+
+    # Profile data
+    result = await profile_data(
+        session_id=session_id, include_correlations=True, include_outliers=True
+    )
+    if result["success"]:
+        print_success("Generated data profile")
+        print_info(
+            f"Profile summary: {result['profile']['summary']['total_rows']} rows, "
+            f"{result['profile']['summary']['total_columns']} columns"
+        )
+
+
+async def test_validation(session_id: str):
+    """Test validation operations"""
+    print_test("Data Validation")
+
+    # Validate schema
+    schema = {
+        "name": {"type": "string", "required": True},
+        "salary": {"type": "numeric", "min": 0, "max": 200000},
+        "department": {
+            "type": "string",
+            "allowed_values": ["Engineering", "Management", "Marketing", "Sales"],
+        },
+    }
+
+    result = await validate_schema(session_id=session_id, schema=schema)
+    if result["success"]:
+        if result["valid"]:
+            print_success("Data validates against schema")
+        else:
+            print_info(f"Schema validation found {len(result['errors'])} error(s)")
+
+    # Check data quality
+    result = await check_data_quality(session_id=session_id)
+    if result["success"]:
+        quality_score = result["quality_results"]["overall_score"]
+        print_success(f"Data quality score: {quality_score:.1f}%")
+        print_info("Quality metrics:")
+        for metric, score in result["quality_results"]["metrics"].items():
+            status = "✓" if score == 100 else "⚠" if score >= 80 else "✗"
+            print(f"    {status} {metric}: {score:.1f}%")
+
+    # Find anomalies
+    result = await find_anomalies(session_id=session_id, columns=["salary"])
+    if result["success"]:
+        total_anomalies = result["summary"]["total_anomalies"]
+        print_success(f"Found {total_anomalies} anomaly(ies)")
+        if total_anomalies > 0:
+            print_info("Anomaly types:")
+            for atype, count in result["summary"]["by_type"].items():
+                print(f"    {atype}: {count}")
+
+
+async def test_export(session_id: str):
+    """Test export operations"""
+    print_test("Export Operations")
+
+    # Create test output directory
+    output_dir = Path("test_output")
+    output_dir.mkdir(exist_ok=True)
+
+    # Export to different formats
+    formats = ["csv", "json", "html", "markdown"]
+
+    for fmt in formats:
+        output_file = output_dir / f"test_export.{fmt if fmt != 'markdown' else 'md'}"
+        result = await export_csv(session_id=session_id, file_path=str(output_file), format=fmt)
+        if result["success"]:
+            print_success(f"Exported to {fmt.upper()}: {output_file}")
+        else:
+            print_error(f"Failed to export to {fmt.upper()}")
+
+
+async def main():
+    """Main test function"""
+    print(f"\n{Colors.HEADER}{Colors.BOLD}═══════════════════════════════════════════{Colors.ENDC}")
+    print(f"{Colors.HEADER}{Colors.BOLD}    CSV MCP Server Test Suite{Colors.ENDC}")
+    print(f"{Colors.HEADER}{Colors.BOLD}═══════════════════════════════════════════{Colors.ENDC}")
+
+    try:
+        # Test I/O operations
+        session_id = await test_io_operations()
+        if not session_id:
+            print_error("Failed to create session, aborting tests")
+            return
+
+        # Test transformations
+        await test_transformations(session_id)
+
+        # Test analytics
+        await test_analytics(session_id)
+
+        # Test validation
+        await test_validation(session_id)
+
+        # Test export
+        await test_export(session_id)
+
+        print(
+            f"\n{Colors.GREEN}{Colors.BOLD}═══════════════════════════════════════════{Colors.ENDC}"
+        )
+        print(f"{Colors.GREEN}{Colors.BOLD}    All tests completed successfully!{Colors.ENDC}")
+        print(
+            f"{Colors.GREEN}{Colors.BOLD}═══════════════════════════════════════════{Colors.ENDC}\n"
+        )
+
+    except Exception as e:
+        print_error(f"Test failed with error: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/test_server_boot.py

@@ -0,0 +1,50 @@
+"""Smoke tests for server boot, tool registry, and CLI argument handling."""
+
+import pytest
+
+
+def test_server_imports_clean():
+    """Importing the server module must not raise."""
+    import csv_editor.server  # noqa: F401
+
+
+def test_tool_registry_populated():
+    """After import, the FastMCP instance must have a populated tool registry.
+
+    Actual count as of FastMCP 3.2: 39 tools. The README claims "40+" as marketing
+    approximation; we assert >=35 to remain robust to small refactors.
+    """
+    from csv_editor.server import mcp
+
+    tool_count = _count_registered_tools(mcp)
+
+    assert tool_count >= 35, f"Expected at least 35 tools registered, got {tool_count}"
+
+
+def test_cli_rejects_sse_transport():
+    """The CLI must reject --transport sse with a non-zero exit."""
+    from csv_editor.server import main
+
+    with pytest.raises(SystemExit) as exc_info:
+        main(["--transport", "sse"])
+
+    assert exc_info.value.code == 2
+
+
+def _count_registered_tools(mcp) -> int:
+    """Robustly count registered tools across FastMCP 2.x/3.x attribute naming."""
+    for attr in ("_tool_manager", "tool_manager", "_tools", "tools"):
+        obj = getattr(mcp, attr, None)
+        if obj is None:
+            continue
+        tools = getattr(obj, "_tools", None) or getattr(obj, "tools", None) or obj
+        try:
+            return len(tools)
+        except TypeError:
+            continue
+    list_tools = getattr(mcp, "list_tools", None)
+    if callable(list_tools):
+        import asyncio
+        result = asyncio.run(list_tools())
+        return len(result)
+    raise RuntimeError("Could not locate FastMCP tool registry")

package/tests/test_settings.py

@@ -0,0 +1,184 @@
+"""Tests for CSV Editor settings functionality."""
+
+import os
+import tempfile
+from unittest.mock import patch
+
+from src.csv_editor.models.csv_session import CSVSession, CSVSettings, get_csv_settings
+
+
+class TestCSVSettings:
+    """Test CSV settings configuration."""
+
+    def test_default_settings(self):
+        """Test default settings configuration."""
+        settings = CSVSettings()
+        assert settings.csv_history_dir == ".csv_history"
+
+    def test_settings_with_custom_dir(self):
+        """Test settings with custom directory."""
+        with tempfile.TemporaryDirectory() as custom_dir:
+            settings = CSVSettings(csv_history_dir=custom_dir)
+            assert settings.csv_history_dir == custom_dir
+
+    def test_environment_variable_override(self):
+        """Test that environment variable overrides default."""
+        with tempfile.TemporaryDirectory() as test_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": test_dir}):
+                settings = CSVSettings()
+                assert settings.csv_history_dir == test_dir
+
+    def test_case_insensitive_env_var(self):
+        """Test that environment variable is case insensitive."""
+        with tempfile.TemporaryDirectory() as test_dir:
+            with patch.dict(os.environ, {"csv_editor_csv_history_dir": test_dir}):
+                settings = CSVSettings()
+                assert settings.csv_history_dir == test_dir
+
+
+class TestCSVSettingsIntegration:
+    """Test CSV settings integration with sessions."""
+
+    def test_get_csv_settings_singleton(self):
+        """Test that get_csv_settings returns singleton instance."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": temp_dir}):
+                # Reset global settings for clean test
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    settings1 = get_csv_settings()
+                    settings2 = get_csv_settings()
+                    assert settings1 is settings2
+                    assert settings1.csv_history_dir == temp_dir
+
+    def test_session_uses_default_settings(self):
+        """Test that CSVSession uses default settings."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": temp_dir}):
+                # Reset global settings to use temp directory
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    session = CSVSession()
+
+                    assert session.history_manager is not None
+                    assert session.history_manager.history_dir == temp_dir
+
+    def test_session_with_environment_variable(self):
+        """Test that CSVSession uses environment variable settings."""
+        with tempfile.TemporaryDirectory() as test_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": test_dir}):
+                # Reset global settings to force reload
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    session = CSVSession()
+                    assert session.history_manager is not None
+                    assert session.history_manager.history_dir == test_dir
+
+    def test_session_history_manager_initialization(self):
+        """Test that history manager is properly initialized with settings."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": temp_dir}):
+                # Reset global settings
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    session = CSVSession()
+
+                    # Verify history manager configuration
+                    assert session.history_manager is not None
+                    assert session.history_manager.history_dir == temp_dir
+                    assert session.history_manager.session_id == session.session_id
+                    assert session.history_manager.enable_snapshots is True
+                    assert session.history_manager.snapshot_interval == 5
+
+    def test_settings_are_configurable(self):
+        """Test that settings can be configured multiple ways."""
+        with tempfile.TemporaryDirectory() as temp_dir1, tempfile.TemporaryDirectory() as temp_dir2:
+            # Test 1: Direct instantiation
+            settings1 = CSVSettings(csv_history_dir=temp_dir1)
+            assert settings1.csv_history_dir == temp_dir1
+
+            # Test 2: Environment variable
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": temp_dir2}):
+                settings2 = CSVSettings()
+                assert settings2.csv_history_dir == temp_dir2
+
+            # Test 3: Default
+            with patch.dict(os.environ, {}, clear=True):
+                # Clear any existing env vars
+                if "CSV_EDITOR_CSV_HISTORY_DIR" in os.environ:
+                    del os.environ["CSV_EDITOR_CSV_HISTORY_DIR"]
+                settings3 = CSVSettings()
+                assert settings3.csv_history_dir == ".csv_history"
+
+    def test_session_history_disabled(self):
+        """Test that settings work even when history is disabled."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": temp_dir}):
+                # Reset global settings
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    session = CSVSession(enable_history=False)
+
+                    # History manager should be None when disabled
+                    assert session.history_manager is None
+                    # But settings should still be accessible
+                    settings = get_csv_settings()
+                    assert settings.csv_history_dir == temp_dir
+
+
+class TestSettingsDocumentation:
+    """Test that settings behavior matches documentation."""
+
+    def test_env_prefix_documentation(self):
+        """Test that CSV_EDITOR_ prefix works as documented."""
+        with tempfile.TemporaryDirectory() as test_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": test_dir}):
+                settings = CSVSettings()
+                assert settings.csv_history_dir == test_dir
+
+    def test_default_history_subdirectory(self):
+        """Test that default is the .csv_history subdirectory."""
+        # Clear environment and test default value without creating files
+        with patch.dict(os.environ, {}, clear=True):
+            if "CSV_EDITOR_CSV_HISTORY_DIR" in os.environ:
+                del os.environ["CSV_EDITOR_CSV_HISTORY_DIR"]
+
+            settings = CSVSettings()
+            assert (
+                settings.csv_history_dir == ".csv_history"
+            ), "Default should be .csv_history subdirectory"
+
+    def test_integration_with_history_manager(self):
+        """Test that HistoryManager receives the configured directory."""
+        with tempfile.TemporaryDirectory() as test_dir:
+            with patch.dict(os.environ, {"CSV_EDITOR_CSV_HISTORY_DIR": test_dir}):
+                # Reset global settings
+                with patch.object(
+                    __import__("src.csv_editor.models.csv_session", fromlist=["_settings"]),
+                    "_settings",
+                    None,
+                ):
+                    session = CSVSession()
+
+                    # Verify the directory was passed to HistoryManager
+                    assert session.history_manager.history_dir == test_dir
+
+                    # Verify other HistoryManager parameters are still correctly set
+                    assert session.history_manager.session_id == session.session_id
+                    assert hasattr(session.history_manager, "storage_type")
+                    assert hasattr(session.history_manager, "enable_snapshots")