feat(tests): add pytest configuration and tests package for LinkedIn MCP server

chore(dependencies): add pytest-asyncio to development dependencies
chore(smithery): update main server to handle query parameter configuration and improve logging
chore(vscode): add task for running pytest tests in VSCode

Author: stickerdaniel

.vscode/tasks.json

@@ -1,6 +1,28 @@
 {
     "version": "2.0.0",
     "tasks": [
+        {
+            "label": "uv run pytest tests/",
+            "detail": "Run pytest tests for LinkedIn MCP server",
+            "type": "shell",
+            "command": "uv",
+            "args": [
+                "run",
+                "pytest",
+                "tests/",
+                "-v"
+            ],
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new",
+                "focus": true
+            },
+            "problemMatcher": []
+        },
         {
             "label": "uv run pre-commit run --all-files",
             "detail": "Run pre-commit hooks on all files",
@@ -14,7 +36,7 @@
             ],
             "group": {
                 "kind": "test",
-                "isDefault": true
+                "isDefault": false
             },
             "presentation": {
                 "reveal": "never",

pyproject.toml

@@ -22,6 +22,7 @@ linkedin-scraper = { git = "https://github.com/joeyism/linkedin_scraper.git" }
 dev = [
     "pre-commit>=4.2.0",
     "pytest>=8.3.5",
+    "pytest-asyncio>=1.0.0",
     "pytest-cov>=6.1.1",
     "ruff>=0.11.11",
     "ty>=0.0.1a12",

smithery.yaml

@@ -1,10 +1,10 @@
 runtime: "container"
 build:
-  dockerfile: "Dockerfile.smithery"           # Smithery-specific Dockerfile
-  dockerBuildPath: "."                        # Docker build context
+  dockerfile: "Dockerfile.smithery"
+  dockerBuildPath: "."
 startCommand:
   type: "http"
-  configSchema:                               # JSON Schema for configuration
+  configSchema:
     type: "object"
     properties:
       linkedin_email:

smithery_main.py

@@ -51,52 +51,59 @@ def main() -> None:
     Main entry point for Smithery deployment.
 
     Starts HTTP server listening on PORT environment variable.
-    Uses existing lazy initialization system.
+    Handles query parameter configuration as required by Smithery Custom Deploy.
     """
     print("🔗 LinkedIn MCP Server (Smithery) 🔗")
     print("=" * 40)
 
     # Get PORT from environment (Smithery requirement)
     port = int(os.environ.get("PORT", 8000))
 
-    # Set up environment for Smithery (can be called with query params later)
-    # For now, just ensure we're in the right mode
-    os.environ["DEBUG"] = os.environ.get("DEBUG", "false")
-
-    # Force HTTP transport and container-friendly settings
+    # Force settings for Smithery compatibility
+    os.environ["DEBUG"] = "false"  # No debug logs in production
     os.environ.setdefault("TRANSPORT", "streamable-http")
 
-    # Get configuration (will use lazy_init=True by default)
-    config = get_config()
+    # Ensure we don't try to use keyring in containers
+    os.environ.setdefault("LINKEDIN_EMAIL", "")
+    os.environ.setdefault("LINKEDIN_PASSWORD", "")
+
+    # Initialize configuration (will use lazy_init=True by default)
+    get_config()
 
-    # Configure logging
-    log_level = logging.DEBUG if config.server.debug else logging.ERROR
+    # Configure minimal logging for containers
     logging.basicConfig(
-        level=log_level,
+        level=logging.ERROR,  # Only errors, no debug/info spam
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )
 
     logger = logging.getLogger("linkedin_mcp_server")
-    logger.info(f"Starting Smithery MCP server on port {port}")
+    logger.error(f"Starting Smithery MCP server on port {port}")
 
-    # Initialize driver (will use lazy init by default - perfect for Smithery!)
+    # Initialize driver with lazy loading (no immediate credentials needed)
     initialize_driver()
 
-    # Create MCP server (tools will be available for discovery)
+    # Create MCP server (tools will be registered and available for discovery)
     mcp = create_mcp_server()
 
     # Start HTTP server
     print("\n🚀 Running LinkedIn MCP server (Smithery HTTP mode)...")
     print(f"📡 HTTP server listening on http://0.0.0.0:{port}/mcp")
-    print("🔧 Tools available for discovery - credentials validated on use")
+    print("🔧 Tools available for discovery - no credentials required")
+    print("⚙️  Configure linkedin_email and linkedin_password to use tools")
 
     try:
+        # Add a startup delay to ensure everything is ready
+        import time
+
+        time.sleep(1)
+
         mcp.run(transport="streamable-http", host="0.0.0.0", port=port, path="/mcp")
     except KeyboardInterrupt:
         print("\n👋 Shutting down LinkedIn MCP server...")
         shutdown_handler()
     except Exception as e:
         print(f"❌ Error running MCP server: {e}")
+        print(f"Stack trace: {e.__class__.__name__}: {str(e)}")
         shutdown_handler()
         raise
 

tests/__init__.py

@@ -0,0 +1 @@
+# tests package

tests/conftest.py

@@ -0,0 +1,39 @@
+# tests/conftest.py
+"""
+Simple pytest configuration for LinkedIn MCP server tests.
+"""
+
+import os
+import pytest
+from linkedin_mcp_server.config import reset_config
+
+
+@pytest.fixture(autouse=True)
+def clean_environment():
+    """Clean environment before each test."""
+    # Reset configuration singleton
+    reset_config()
+
+    # Clear environment variables that might affect tests
+    env_vars_to_clear = [
+        "LINKEDIN_EMAIL",
+        "LINKEDIN_PASSWORD",
+        "DEBUG",
+        "CHROMEDRIVER",
+        "HEADLESS",
+        "TRANSPORT",
+    ]
+    original_env = {}
+    for var in env_vars_to_clear:
+        original_env[var] = os.environ.get(var)
+        if var in os.environ:
+            del os.environ[var]
+
+    yield
+
+    # Restore environment variables
+    for var, value in original_env.items():
+        if value is not None:
+            os.environ[var] = value
+        elif var in os.environ:
+            del os.environ[var]

tests/test_mcp_http.py

@@ -0,0 +1,153 @@
+# tests/test_mcp_http.py
+"""
+Test that the MCP server HTTP transport works and tools are accessible.
+"""
+
+import pytest
+import asyncio
+from unittest.mock import patch
+from fastmcp.client import Client
+from linkedin_mcp_server.server import create_mcp_server
+
+
+@pytest.mark.asyncio
+async def test_mcp_server_tools_accessible():
+    """Test that MCP server tools are accessible via in-memory client."""
+    # Mock sys.argv to avoid pytest argument parsing conflicts
+    with patch("sys.argv", ["main.py"]):
+        # Create MCP server
+        mcp = create_mcp_server()
+
+        # Connect client directly to server (in-memory)
+        async with Client(mcp) as client:
+            # Test that we can list tools
+            tools = await client.list_tools()
+
+            # Verify expected LinkedIn tools are present
+            tool_names = [tool.name for tool in tools]
+            expected_tools = [
+                "get_person_profile",
+                "get_company_profile",
+                "get_job_details",
+                "close_session",
+            ]
+
+            for expected_tool in expected_tools:
+                assert expected_tool in tool_names, (
+                    f"Tool '{expected_tool}' not found in {tool_names}"
+                )
+
+            print(f"✅ Found {len(tools)} tools: {tool_names}")
+
+
+@pytest.mark.asyncio
+async def test_tools_have_proper_schemas():
+    """Test that tools have proper input schemas."""
+    with patch("sys.argv", ["main.py"]):
+        mcp = create_mcp_server()
+
+        async with Client(mcp) as client:
+            tools = await client.list_tools()
+
+            # Check each tool has required properties
+            for tool in tools:
+                assert tool.name is not None
+                assert tool.description is not None
+                assert len(tool.description) > 0
+
+                if tool.name in [
+                    "get_person_profile",
+                    "get_company_profile",
+                    "get_job_details",
+                ]:
+                    # These tools should have input schemas
+                    assert tool.inputSchema is not None
+                    assert "properties" in tool.inputSchema
+
+            print(f"✅ All {len(tools)} tools have proper schemas")
+
+
+@pytest.mark.asyncio
+async def test_close_session_tool_works():
+    """Test that close_session tool can be called successfully."""
+    with patch("sys.argv", ["main.py"]):
+        mcp = create_mcp_server()
+
+        async with Client(mcp) as client:
+            # Call close_session tool (should work without credentials)
+            result = await client.call_tool("close_session")
+
+            assert result.content is not None
+            assert len(result.content) > 0
+
+            response = result.content[0]
+            assert response.type == "text"
+            assert len(response.text) > 0
+
+            print(f"✅ close_session tool response: {response.text[:100]}...")
+
+
+@pytest.mark.asyncio
+async def test_tools_fail_gracefully_without_credentials():
+    """Test that LinkedIn tools fail gracefully when no credentials provided."""
+    # Mock sys.argv to avoid pytest argument parsing conflicts
+    with patch("sys.argv", ["main.py"]):
+        # Mock the driver creation to avoid WebDriver initialization
+        with patch(
+            "linkedin_mcp_server.drivers.chrome.get_or_create_driver"
+        ) as mock_driver:
+            mock_driver.return_value = None  # Simulate no driver available
+
+            mcp = create_mcp_server()
+
+            async with Client(mcp) as client:
+                # Try to call a LinkedIn tool without credentials
+                # This should either return an error message or raise an exception gracefully
+                try:
+                    result = await client.call_tool(
+                        "get_person_profile",
+                        {"linkedin_url": "https://www.linkedin.com/in/test-user/"},
+                    )
+
+                    # If no exception, check that result indicates missing credentials
+                    assert result.content is not None
+                    response = result.content[0]
+
+                    # Should mention credentials, driver, or login issues
+                    error_keywords = [
+                        "credential",
+                        "driver",
+                        "login",
+                        "error",
+                        "failed",
+                    ]
+                    assert any(
+                        keyword in response.text.lower() for keyword in error_keywords
+                    ), f"Expected error message about credentials, got: {response.text}"
+
+                    print(f"✅ Tool failed gracefully: {response.text[:100]}...")
+
+                except Exception as e:
+                    # Exception is also acceptable - means proper error handling
+                    print(f"✅ Tool raised exception (acceptable): {str(e)[:100]}...")
+
+
+def test_mcp_server_creation():
+    """Test that MCP server can be created successfully."""
+    with patch("sys.argv", ["main.py"]):
+        mcp = create_mcp_server()
+
+        assert mcp is not None
+        assert mcp.name == "linkedin_scraper"
+
+        print("✅ MCP server created successfully")
+
+
+if __name__ == "__main__":
+    # Run tests manually if executed directly
+    asyncio.run(test_mcp_server_tools_accessible())
+    asyncio.run(test_tools_have_proper_schemas())
+    asyncio.run(test_close_session_tool_works())
+    asyncio.run(test_tools_fail_gracefully_without_credentials())
+    test_mcp_server_creation()
+    print("🎉 All tests passed!")