- Polish import and initialization tests

- Expand the dev section on testing in README

Author: ndaelman-hu

README.md

@@ -245,10 +245,38 @@ Once the servers passes the checks, register the new MCP server:
 - to unified interface in `src/parse_patrol/`. **Only the central interface is exposed in `main` branch!** This allows agents and users to access all parsing tools via a single, clear server endpoint.
 - in this `README.md`, if this is a new tool.
 
-Testing is done 2 ways:
+### Testing
 
-- the agent attempts to generate pipeline scripts. Successful cases may be stored under in `.pipelines/scripts/`. The input to be processed is found in `.pipelines/data/`. Schema definitions and documentation resources are available in `.resources/`.
-- test the parser and server code in `tests/`.
+Testing is done in multiple ways to ensure both functionality and MCP server behavior:
+
+#### 1. Automated Unit Tests
+Run the comprehensive test suite using pytest:
+
+```bash
+# Run all tests with verbose output
+uv run python -m pytest tests/ -v
+
+# Run specific test file
+uv run python -m pytest tests/test_modular_mcp.py -v
+
+# Run tests with coverage (if coverage is installed)
+uv run python -m pytest tests/ --cov=parse_patrol
+```
+
+The test suite includes:
+
+- **MCP Server Initialization**: Tests that the unified MCP server loads correctly
+- **Parser Configuration**: Parametrized tests ensuring each parser has proper configuration
+- **Runtime Import Tests**: Validates that parsers work with their dependencies (gracefully skips if dependencies missing)
+- **Minimal Dependency Tests**: Tests core MCP functionality without optional parser dependencies
+
+#### 2. Agent Pipeline Testing
+Test end-to-end workflows:
+
+- The agent attempts to generate pipeline scripts using the MCP tools
+- Successful cases are stored in `.pipelines/scripts/`
+- Input data for processing is found in `.pipelines/data/`
+- Schema definitions and documentation resources are available in `.resources/`
 
 ## Online Resources
 

tests/test_modular_mcp.py

@@ -5,151 +5,113 @@
 """
 
 import sys
-import pytest
-from unittest.mock import patch
+import pytest  # pyright: ignore[reportMissingImports]
 
 
-def test_mcp_server_with_all_dependencies():
-    """Test MCP server loads successfully when all dependencies are available."""
+# Test configurations - moved to top for easy maintenance
+PARSER_TEST_CONFIGS = [
+    ("cclib parser", "parse_patrol.parsers.cclib.__main__", "cclib_parse_file_to_model"),
+    ("gaussian parser", "parse_patrol.parsers.gaussian.__main__", "gauss_parse_file_to_model"),
+    ("iodata parser", "parse_patrol.parsers.iodata.__main__", "iodata_parse_file_to_model"),
+    ("NOMAD database", "parse_patrol.databases.nomad.__main__", "search_nomad_entries"),
+]
+
+
+def test_mcp_server_initialization():
+    """Test MCP server loads successfully and basic structure is correct.
+    
+    This test validates the core MCP server setup:
+    - MCP server object is created with correct name
+    - Parser configuration list exists and is properly structured
+    
+    NOTE: This tests the basic server initialization, not individual parser configs.
+    Individual parser configs are tested separately with parametrize.
+    """
     # Add src to path for imports
     import os
     src_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src')
     if src_path not in sys.path:
         sys.path.insert(0, src_path)
 
-    # Import and initialize MCP server
+    # Import and initialize MCP server (parsers register automatically)
     from parse_patrol.__main__ import mcp
 
     # Test that MCP server was created successfully
     assert mcp is not None
     assert mcp.name == "Parse Patrol - Unified Chemistry Parser"
-
-
-def test_mcp_server_dynamic_registration():
-    """Test that parsers are registered dynamically based on available dependencies."""
-    import os
-    src_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src')
-    if src_path not in sys.path:
-        sys.path.insert(0, src_path)
-    
-    # Capture output from registration process
-    import io
-    import contextlib
-    
-    captured_output = io.StringIO()
-    
-    # Import with captured output
-    with contextlib.redirect_stdout(captured_output):
-        from parse_patrol.__main__ import mcp
 
-    output = captured_output.getvalue()
-    
-    # Check that registration messages were printed
-    assert "Registered cclib parser" in output or "cclib parser not available" in output
-    assert "Registered gaussian parser" in output or "gaussian parser not available" in output
-    assert "Registered iodata parser" in output or "iodata parser not available" in output
-    assert "Registered NOMAD database" in output or "NOMAD database not available" in output
+    # Test that we can access the parser configs (shows modular design works)
+    from parse_patrol.__main__ import parser_configs
+    assert len(parser_configs) > 0
+    assert isinstance(parser_configs, list)
+    # Individual parser configs are tested in test_parser_config_exists
 
 
-def test_mcp_server_handles_missing_dependencies():
-    """Test that MCP server handles missing dependencies gracefully."""
+@pytest.mark.parametrize(
+        "expected_parser_name",
+        [config[0] for config in PARSER_TEST_CONFIGS]
+    )
+def test_parser_config_exists(expected_parser_name):
+    """Test that each expected parser has a configuration entry.
+    
+    This test validates STATIC CONFIGURATION for individual parsers:
+    - Each parser has an entry in the parser_configs list
+    - The configuration has the expected name
+    
+    NOTE: This tests configuration PRESENCE, not functionality.
+    The config can exist even if the parser's dependencies are missing.
+    """
     import os
     src_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src')
     if src_path not in sys.path:
         sys.path.insert(0, src_path)
 
-    # Mock missing cclib dependency
-    with patch.dict('sys.modules', {'cclib': None}):
-        with patch('builtins.__import__', side_effect=lambda name, *args, **kwargs: 
-                   __import__(name, *args, **kwargs) if name != 'cclib' 
-                   else (_ for _ in ()).throw(ImportError(f"No module named '{name}'"))):
-            
-            # This should work even with cclib missing
-            from mcp.server.fastmcp import FastMCP
-            test_mcp = FastMCP("Test Parse Patrol")
-            
-            # Test that we can create MCP server without all dependencies
-            assert test_mcp is not None
+    from parse_patrol.__main__ import parser_configs
+    assert any(config["name"] == expected_parser_name for config in parser_configs), \
+           f"Parser config for '{expected_parser_name}' not found"
 
 
-def test_individual_parser_imports():
-    """Test importing individual parsers to ensure they work independently."""
+@pytest.mark.parametrize("parser_name,module_path,function_name", PARSER_TEST_CONFIGS)
+def test_individual_parser_imports(parser_name, module_path, function_name):
+    """Test importing individual parsers to ensure they work at RUNTIME.
+    
+    This test validates ACTUAL FUNCTIONALITY for each parser:
+    - Parser module can be imported successfully
+    - Required dependencies are available (cclib, iodata, etc.)
+    - Expected functions exist and are callable
+    
+    NOTE: This tests RUNTIME functionality, not just configuration.
+    This test will fail/skip if dependencies are missing, even if 
+    the parser configuration exists and is correct.
+    
+    Contrast with test_parser_config_exists which only tests static config.
+    """
     import os
     src_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src')
     if src_path not in sys.path:
         sys.path.insert(0, src_path)
 
-    # Test cclib parser
     try:
-        from parse_patrol.parsers.cclib.__main__ import cclib_parse_file_to_model
-        assert callable(cclib_parse_file_to_model)
-        print("✓ cclib parser imports successfully")
+        module = __import__(module_path, fromlist=[function_name])
+        func = getattr(module, function_name)
+        assert callable(func)
+        print(f"✓ {parser_name} imports successfully")
     except ImportError as e:
-        print(f"⚠ cclib parser not available: {e}")
-    
-    # Test gaussian parser  
-    try:
-        from parse_patrol.parsers.gaussian.__main__ import gauss_parse_file_to_model
-        assert callable(gauss_parse_file_to_model)
-        print("✓ gaussian parser imports successfully")
-    except ImportError as e:
-        print(f"⚠ gaussian parser not available: {e}")
-    
-    # Test iodata parser
-    try:
-        from parse_patrol.parsers.iodata.__main__ import iodata_parse_file_to_model
-        assert callable(iodata_parse_file_to_model)
-        print("✓ iodata parser imports successfully")
-    except ImportError as e:
-        print(f"⚠ iodata parser not available: {e}")
-    
-    # Test NOMAD database
-    try:
-        from parse_patrol.databases.nomad.__main__ import search_nomad_entries
-        assert callable(search_nomad_entries)
-        print("✓ NOMAD database imports successfully")
-    except ImportError as e:
-        print(f"⚠ NOMAD database not available: {e}")
+        print(f"⚠ {parser_name} not available: {e}")
+        pytest.skip(f"Skipping {parser_name} test due to missing dependencies")
 
 
 def test_mcp_server_without_optional_deps():
-    """Test MCP server with minimal dependencies (only MCP core)."""
+    """Test MCP server core functionality without parser dependencies."""
     import os
     src_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src')
     if src_path not in sys.path:
         sys.path.insert(0, src_path)
 
     # Test that we can at least import the MCP framework
-    from mcp.server.fastmcp import FastMCP
+    from mcp.server.fastmcp import FastMCP # pyright: ignore[reportMissingImports]
 
     # Create a minimal MCP server
     minimal_mcp = FastMCP("Minimal Parse Patrol")
     assert minimal_mcp is not None
-    assert minimal_mcp.name == "Minimal Parse Patrol"
-
-
-if __name__ == "__main__":
-    # Run tests directly if script is executed
-    print("=== Testing Modular MCP Server ===\n")
-    
-    print("1. Testing MCP server with all dependencies...")
-    test_mcp_server_with_all_dependencies()
-    print("✓ Passed\n")
-    
-    print("2. Testing dynamic registration...")
-    test_mcp_server_dynamic_registration()
-    print("✓ Passed\n")
-    
-    print("3. Testing individual parser imports...")
-    test_individual_parser_imports()
-    print("✓ Passed\n")
-    
-    print("4. Testing MCP server with minimal dependencies...")
-    test_mcp_server_without_optional_deps()
-    print("✓ Passed\n")
-    
-    print("5. Testing graceful handling of missing dependencies...")
-    test_mcp_server_handles_missing_dependencies()
-    print("✓ Passed\n")
-    
-    print("🎉 All tests passed!")
+    assert minimal_mcp.name == "Minimal Parse Patrol"