import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { mcpStatusTool } from '../../src/tools/mcp-status.js';
import { MCPClientManager } from '../../src/services/mcp-client-manager.js';
import { ApprovalService } from '../../src/services/approval.js';
import { FunctionBridge } from '../../src/services/function-bridge.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/services/mcp-client-manager.js');
jest.mock('../../src/services/approval.js');
jest.mock('../../src/services/function-bridge.js');
describe('mcpStatusTool', () => {
let mockMcpManager: jest.Mocked<MCPClientManager>;
let mockApprovalService: jest.Mocked<ApprovalService>;
let mockFunctionBridge: jest.Mocked<FunctionBridge>;
const mockServerStatus = {
filesystem: {
type: 'stdio',
status: 'connected',
},
database: {
type: 'sse',
status: 'connecting',
},
};
const mockTools = [
{ name: 'read_file', serverName: 'filesystem' },
{ name: 'write_file', serverName: 'filesystem' },
{ name: 'query', serverName: 'database' },
];
const mockApprovalStats = {
total: 10,
pending: 2,
approved: 5,
denied: 2,
expired: 1,
};
const mockBridgeStats = {
trustedToolCount: 5,
totalCalls: 100,
successfulCalls: 95,
};
beforeEach(() => {
mockMcpManager = {
getStatus: jest.fn().mockReturnValue(mockServerStatus),
getConnectedServers: jest.fn().mockReturnValue(['filesystem', 'database']),
listAllTools: jest.fn().mockResolvedValue(mockTools),
} as unknown as jest.Mocked<MCPClientManager>;
mockApprovalService = {
getStats: jest.fn().mockReturnValue(mockApprovalStats),
getPendingApprovals: jest.fn().mockReturnValue([]),
} as unknown as jest.Mocked<ApprovalService>;
mockFunctionBridge = {
getStats: jest.fn().mockReturnValue(mockBridgeStats),
} as unknown as jest.Mocked<FunctionBridge>;
});
describe('overview section', () => {
it('should display MCP Bridge status header', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('MCP Bridge Status');
});
it('should display connected servers count', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Connected Servers: 2');
});
it('should display available tools count', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Available Tools: 3');
});
it('should display trusted tools count', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Trusted Tools: 5');
});
});
describe('server details section', () => {
it('should display server status with icons', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('🟢'); // connected
expect(result.content[0].text).toContain('🟡'); // connecting
expect(result.content[0].text).toContain('filesystem');
expect(result.content[0].text).toContain('database');
});
it('should display server type and status', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('stdio');
expect(result.content[0].text).toContain('Status: connected');
expect(result.content[0].text).toContain('Status: connecting');
});
it('should display tool count per server', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Tools: 2'); // filesystem
expect(result.content[0].text).toContain('Tools: 1'); // database
});
it('should display tool names for small tool lists', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('read_file');
expect(result.content[0].text).toContain('write_file');
});
it('should truncate long tool lists with count', async () => {
mockMcpManager.listAllTools.mockResolvedValue([
{ name: 'tool1', serverName: 'server1' },
{ name: 'tool2', serverName: 'server1' },
{ name: 'tool3', serverName: 'server1' },
{ name: 'tool4', serverName: 'server1' },
{ name: 'tool5', serverName: 'server1' },
]);
mockMcpManager.getStatus.mockReturnValue({
server1: { type: 'stdio', status: 'connected' },
});
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('+2 more');
});
it('should handle disconnected server', async () => {
mockMcpManager.getStatus.mockReturnValue({
broken: { type: 'stdio', status: 'disconnected' },
});
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('🔴');
});
it('should show message when no servers configured', async () => {
mockMcpManager.getStatus.mockReturnValue({});
mockMcpManager.listAllTools.mockResolvedValue([]);
mockMcpManager.getConnectedServers.mockReturnValue([]);
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('No MCP servers configured');
});
});
describe('approval statistics section', () => {
it('should display all approval statistics', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Total Requests: 10');
expect(result.content[0].text).toContain('Pending: 2');
expect(result.content[0].text).toContain('Approved: 5');
expect(result.content[0].text).toContain('Denied: 2');
expect(result.content[0].text).toContain('Expired: 1');
});
});
describe('pending approvals section', () => {
it('should display pending approvals when they exist', async () => {
const now = Date.now();
mockApprovalService.getPendingApprovals.mockReturnValue([
{
id: 'approval-1',
duckName: 'TestDuck',
mcpServer: 'filesystem',
toolName: 'read_file',
arguments: {},
status: 'pending' as const,
timestamp: now - 30000,
expiresAt: now + 30000,
},
]);
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Pending Approvals');
expect(result.content[0].text).toContain('TestDuck');
expect(result.content[0].text).toContain('filesystem:read_file');
expect(result.content[0].text).toMatch(/\d+s ago/);
});
it('should not display pending section when no pending approvals', async () => {
mockApprovalService.getStats.mockReturnValue({
...mockApprovalStats,
pending: 0,
});
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).not.toContain('Pending Approvals:');
});
});
describe('commands section', () => {
it('should display available commands', async () => {
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.content[0].text).toContain('Commands');
expect(result.content[0].text).toContain('get_pending_approvals');
expect(result.content[0].text).toContain('approve_mcp_request');
expect(result.content[0].text).toContain('ask_duck');
});
});
describe('error handling', () => {
it('should handle exceptions gracefully', async () => {
mockMcpManager.getStatus.mockImplementation(() => {
throw new Error('Connection failed');
});
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Failed to get MCP status');
expect(result.content[0].text).toContain('Connection failed');
});
it('should handle non-Error exceptions', async () => {
mockMcpManager.getStatus.mockImplementation(() => {
throw 'Unknown failure';
});
const result = await mcpStatusTool(
mockMcpManager,
mockApprovalService,
mockFunctionBridge,
{}
);
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Unknown failure');
});
});
});
