test: improve coverage for leader identification feature

- Add test for health check exception handling when is_leader() fails
- Add tests for GatewayService initialization with invalid/None port values
- Add comprehensive tests for is_leader() method covering JSON metadata, legacy UUID, and edge cases
- Fix is_leader() to return False when Redis is unavailable (was incorrectly returning True)
- All tests passing: 15,833 passed (9 new tests added)

Addresses coverage gaps identified in diff-cover report for lines:
- mcpgateway/main.py: 10346, 10348 (exception handling)
- mcpgateway/services/gateway_service.py: 478-479 (port conversion), 4133-4152 (is_leader logic)

Signed-off-by: Bogdan-Marius-Catanus <bogdan-marius.catanus@ibm.com>

Author: Bogdan-Marius-Catanus

.secrets.baseline

@@ -3,7 +3,7 @@
     "files": "^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2026-04-01T14:06:09Z",
+  "generated_at": "2026-04-01T14:37:32Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"

mcpgateway/services/gateway_service.py

@@ -478,12 +478,7 @@ def __init__(self) -> None:
         except (ValueError, TypeError):
             port_value = 0
 
-        self._instance_metadata = {
-            "instance_id": str(uuid.uuid4()),
-            "port": port_value,
-            "pid": os.getpid(),
-            "hostname": socket.gethostname()
-        }
+        self._instance_metadata = {"instance_id": str(uuid.uuid4()), "port": port_value, "pid": os.getpid(), "hostname": socket.gethostname()}
         self._instance_id = self._instance_metadata["instance_id"]
 
         # Leader election settings from config
@@ -4131,8 +4126,8 @@ async def is_leader(self) -> bool:
             bool: True if this instance holds the leader lock, False otherwise.
         """
         if not self._redis_client or not hasattr(self, "_leader_key"):
-            # Fallback to file lock for non-Redis setups
-            return True
+            # Redis unavailable - cannot verify leadership in cluster mode
+            return False
 
         try:
             current_leader_raw = await self._redis_client.get(self._leader_key)

tests/unit/mcpgateway/services/test_gateway_service_redis_leadership.py

@@ -380,3 +380,129 @@ async def test_skips_cancel_when_old_task_done(self):
                     await service._run_follower_election("test@example.com")  # pylint: disable=protected-access
 
         done_task.cancel.assert_not_called()
+
+
+
+class TestGatewayServiceInitialization:
+    """Tests for GatewayService initialization with instance metadata."""
+
+    def test_init_with_invalid_port(self):
+        """Test GatewayService initialization with invalid port value."""
+        with patch("mcpgateway.services.gateway_service.settings") as mock_settings:
+            mock_settings.port = "invalid"
+            mock_settings.platform_admin_email = "admin@test.com"
+            
+            service = GatewayService()
+            
+            # Should default to 0 when port conversion fails
+            assert service._instance_metadata["port"] == 0
+            assert "instance_id" in service._instance_metadata
+            assert "pid" in service._instance_metadata
+            assert "hostname" in service._instance_metadata
+
+    def test_init_with_none_port(self):
+        """Test GatewayService initialization with None port value."""
+        with patch("mcpgateway.services.gateway_service.settings") as mock_settings:
+            mock_settings.port = None
+            mock_settings.platform_admin_email = "admin@test.com"
+            
+            service = GatewayService()
+            
+            # Should default to 0 when port is None
+            assert service._instance_metadata["port"] == 0
+            assert "instance_id" in service._instance_metadata
+            assert "pid" in service._instance_metadata
+            assert "hostname" in service._instance_metadata
+
+    def test_init_with_valid_port(self):
+        """Test GatewayService initialization with valid port value."""
+        with patch("mcpgateway.services.gateway_service.settings") as mock_settings:
+            mock_settings.port = "8080"
+            mock_settings.platform_admin_email = "admin@test.com"
+            
+            service = GatewayService()
+            
+            # Should convert port to int
+            assert service._instance_metadata["port"] == 8080
+            assert "instance_id" in service._instance_metadata
+            assert "pid" in service._instance_metadata
+            assert "hostname" in service._instance_metadata
+
+
+class TestIsLeaderMethod:
+    """Tests for is_leader() method."""
+
+    @pytest.mark.asyncio
+    async def test_is_leader_with_json_metadata(self):
+        """Test is_leader() correctly parses JSON metadata from Redis."""
+        import json
+        
+        redis_mock = AsyncMock()
+        metadata = {
+            "instance_id": "test-id-123",
+            "port": 8001,
+            "pid": 12345,
+            "hostname": "test-host"
+        }
+        redis_mock.get = AsyncMock(return_value=json.dumps(metadata))
+        
+        service = _make_service(redis_client=redis_mock, instance_id="test-id-123")
+        
+        result = await service.is_leader()
+        
+        assert result is True
+        redis_mock.get.assert_called_once_with("test:leader")
+
+    @pytest.mark.asyncio
+    async def test_is_leader_with_legacy_uuid(self):
+        """Test is_leader() handles legacy UUID-only format."""
+        redis_mock = AsyncMock()
+        redis_mock.get = AsyncMock(return_value="test-id-123")  # Plain UUID string
+        
+        service = _make_service(redis_client=redis_mock, instance_id="test-id-123")
+        
+        result = await service.is_leader()
+        
+        assert result is True
+        redis_mock.get.assert_called_once_with("test:leader")
+
+    @pytest.mark.asyncio
+    async def test_is_leader_returns_false_when_not_leader(self):
+        """Test is_leader() returns False when instance is not the leader."""
+        import json
+        
+        redis_mock = AsyncMock()
+        metadata = {
+            "instance_id": "other-id-456",
+            "port": 8002,
+            "pid": 67890,
+            "hostname": "other-host"
+        }
+        redis_mock.get = AsyncMock(return_value=json.dumps(metadata))
+        
+        service = _make_service(redis_client=redis_mock, instance_id="test-id-123")
+        
+        result = await service.is_leader()
+        
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_is_leader_returns_false_when_no_leader(self):
+        """Test is_leader() returns False when no leader exists in Redis."""
+        redis_mock = AsyncMock()
+        redis_mock.get = AsyncMock(return_value=None)
+        
+        service = _make_service(redis_client=redis_mock, instance_id="test-id-123")
+        
+        result = await service.is_leader()
+        
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_is_leader_returns_false_when_redis_unavailable(self):
+        """Test is_leader() returns False when Redis client is unavailable."""
+        service = _make_service(redis_client=None, instance_id="test-id-123")
+        
+        result = await service.is_leader()
+        
+        assert result is False

tests/unit/mcpgateway/test_main.py

@@ -499,6 +499,33 @@ def close(self):
         assert response["status"] == "unhealthy"
         assert session.invalidate_called is True
 
+    @pytest.mark.asyncio
+    async def test_health_check_leader_exception(self):
+        """Test health check when is_leader() raises an exception."""
+        # First-Party
+        from mcpgateway import main as mcpgateway_main
+
+        class DummySession:
+            def execute(self, *_args, **_kwargs):
+                pass
+
+            def commit(self):
+                pass
+
+            def close(self):
+                pass
+
+        session = DummySession()
+        
+        # Mock gateway_service to raise exception on is_leader()
+        with patch("mcpgateway.main.SessionLocal", return_value=session):
+            with patch("mcpgateway.main.gateway_service") as mock_gateway:
+                mock_gateway.is_leader.side_effect = Exception("Redis connection failed")
+                response = await mcpgateway_main.healthcheck()
+        
+        assert response["status"] == "healthy"
+        assert response["is_leader"] is False  # Should fallback to False on exception
+
     @pytest.mark.asyncio
     async def test_ready_check_db_error(self):
         """Test readiness check error path with rollback failure."""