/**
* MCP Server Startup Integration Tests
* Tests server initialization, module registration, and basic functionality
*
* @author nich
* @github github.com/nirholas
* @license Apache-2.0
*/
import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"
import { MockMcpServer, createMockMcpServer } from "../mocks/mcp"
// Mock @/evm to register test tools instead of loading real modules
vi.mock("@/evm", () => ({
registerEVM: vi.fn((server: any) => {
// Register mock tools for testing
server.tool("get_block", "Get block by number", { blockNumber: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_balance", "Get native balance", { address: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_token_balance", "Get ERC20 token balance", { address: {}, token: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("estimate_gas", "Estimate gas for transaction", { to: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_gas_price", "Get current gas price", {}, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_chain_id", "Get current chain ID", {}, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_transaction", "Get transaction by hash", { txHash: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("call_contract", "Call a contract function", { address: {}, abi: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
})
}))
// Mock @/server/base to use mock server
const mockRegisterEVM = vi.fn((server: any) => {
server.tool("get_block", "Get block by number", { blockNumber: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_balance", "Get native balance", { address: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_token_balance", "Get ERC20 token balance", { address: {}, token: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("estimate_gas", "Estimate gas for transaction", { to: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_gas_price", "Get current gas price", {}, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_chain_id", "Get current chain ID", {}, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("get_transaction", "Get transaction by hash", { txHash: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
server.tool("call_contract", "Call a contract function", { address: {}, abi: {} }, async () => ({ content: [{ type: "text", text: "{}" }] }))
})
vi.mock("@/server/base", () => ({
startServer: vi.fn(() => {
const mockServer = createMockMcpServer()
mockRegisterEVM(mockServer)
return mockServer
})
}))
describe("MCP Server Startup Tests", () => {
let mockServer: MockMcpServer
beforeEach(() => {
mockServer = createMockMcpServer()
})
afterEach(() => {
mockServer.clear()
vi.clearAllMocks()
})
describe("Server Initialization", () => {
it("should initialize server correctly", async () => {
const { startServer } = await import("@/server/base")
const server = startServer()
expect(server).toBeDefined()
expect(server).toHaveProperty("tool")
})
it("should have correct server metadata", async () => {
const { startServer } = await import("@/server/base")
const server = startServer()
// The server should be created with proper configuration
expect(server).toBeDefined()
})
it("should not throw during initialization", async () => {
const { startServer } = await import("@/server/base")
expect(() => startServer()).not.toThrow()
})
})
describe("Module Registration", () => {
it("should register all EVM modules without errors", async () => {
const { registerEVM } = await import("@/evm")
expect(() => registerEVM(mockServer as any)).not.toThrow()
})
it("should register tools after EVM registration", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const tools = mockServer.getAllTools()
expect(tools.length).toBeGreaterThan(0)
})
it("should register multiple tool categories", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const toolNames = mockServer.getToolNames()
// Should have tools from various categories
const hasBlockTools = toolNames.some(name => name.includes("block"))
const hasTokenTools = toolNames.some(name =>
name.includes("token") || name.includes("erc20") || name.includes("balance")
)
const hasNetworkTools = toolNames.some(name =>
name.includes("chain") || name.includes("network") || name.includes("gas")
)
expect(hasBlockTools || hasTokenTools || hasNetworkTools).toBe(true)
})
it("should register prompts along with tools", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
// Prompts may or may not be registered depending on modules
// This test verifies the registration process completes
expect(mockServer.getAllTools().length).toBeGreaterThan(0)
})
})
describe("List Tools Request", () => {
it("should return all registered tools", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const tools = mockServer.getAllTools()
expect(Array.isArray(tools)).toBe(true)
expect(tools.length).toBeGreaterThan(0)
})
it("should return tools with required properties", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const tools = mockServer.getAllTools()
for (const tool of tools) {
expect(tool).toHaveProperty("name")
expect(tool).toHaveProperty("description")
expect(tool).toHaveProperty("inputSchema")
expect(tool).toHaveProperty("handler")
expect(typeof tool.name).toBe("string")
expect(typeof tool.description).toBe("string")
expect(typeof tool.handler).toBe("function")
}
})
it("should return tool names as strings", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const toolNames = mockServer.getToolNames()
expect(Array.isArray(toolNames)).toBe(true)
for (const name of toolNames) {
expect(typeof name).toBe("string")
expect(name.length).toBeGreaterThan(0)
}
})
})
describe("Unknown Tool Handling", () => {
it("should throw error for unknown tool", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
await expect(
mockServer.executeTool("nonexistent_tool", {})
).rejects.toThrow("Tool not found: nonexistent_tool")
})
it("should return undefined when getting unknown tool", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
const tool = mockServer.getTool("unknown_tool_xyz")
expect(tool).toBeUndefined()
})
it("should handle tool names with special characters gracefully", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
await expect(
mockServer.executeTool("tool@#$%", {})
).rejects.toThrow("Tool not found")
})
it("should handle empty tool name", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
await expect(
mockServer.executeTool("", {})
).rejects.toThrow("Tool not found")
})
})
describe("Server Connection Lifecycle", () => {
it("should support connect method", () => {
expect(mockServer.connect).toBeDefined()
expect(typeof mockServer.connect).toBe("function")
})
it("should support close method", () => {
expect(mockServer.close).toBeDefined()
expect(typeof mockServer.close).toBe("function")
})
it("should clear all registrations", async () => {
const { registerEVM } = await import("@/evm")
registerEVM(mockServer as any)
expect(mockServer.getAllTools().length).toBeGreaterThan(0)
mockServer.clear()
expect(mockServer.getAllTools().length).toBe(0)
})
})
describe("Concurrent Registration", () => {
it("should handle multiple registration calls", async () => {
const { registerEVM } = await import("@/evm")
// First registration
registerEVM(mockServer as any)
const firstCount = mockServer.getAllTools().length
// Second registration (tools will be added again)
registerEVM(mockServer as any)
const secondCount = mockServer.getAllTools().length
// Map-based storage means same tool names overwrite
// so counts should be equal if all names are unique
expect(secondCount).toBeGreaterThanOrEqual(firstCount)
})
})
describe("Error Handling During Registration", () => {
it("should continue registration even if individual modules have issues", async () => {
const { registerEVM } = await import("@/evm")
// This tests the robustness of the registration process
registerEVM(mockServer as any)
// If registration completes, tools should be available
const tools = mockServer.getAllTools()
expect(tools.length).toBeGreaterThan(0)
})
})
})
