test-mcp-tools.js•12.9 kB
#!/usr/bin/env tsx
/**
* Comprehensive MCP Tools Test Suite
* Tests all 10 MCP tools with ATXP payment integration
*/
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ErrorCode,
McpError,
ListToolsRequestSchema
} from "@modelcontextprotocol/sdk/types.js";
import { AgentService } from "./src/core/agent-service.ts";
import { PaymentManager } from "./src/payments/payment-manager.ts";
import { createAgentTools, validateToolArguments } from "./src/tools/agent-tools.ts";
console.log("🧪 MCP Tools Comprehensive Test Suite");
console.log("=====================================\n");
// Test configuration
const TEST_USER_ID = "test-user-123";
const TEST_AGENT_NAME = "Test Agent";
const TEST_AGENT_DESCRIPTION = "Test agent for MCP tool testing";
const TEST_INSTRUCTIONS = "You are a helpful test agent";
let createdAgentId = null;
let testResults = {
passed: 0,
failed: 0,
errors: []
};
// Import database utilities
import { db, users, agents } from "./src/core/database.ts";
import { eq } from "drizzle-orm";
async function createTestUser() {
try {
// Check if test user already exists
const [existingUser] = await db.select().from(users).where(eq(users.id, TEST_USER_ID));
if (existingUser) {
console.log(` 👤 Test user already exists: ${TEST_USER_ID}`);
return existingUser;
}
// Create test user
const [user] = await db.insert(users).values({
id: TEST_USER_ID,
email: "test@example.com",
firstName: "Test",
lastName: "User",
profileImageUrl: null
}).returning();
console.log(` 👤 Created test user: ${TEST_USER_ID}`);
return user;
} catch (error) {
console.log(` 👤 Test user creation failed, continuing anyway: ${error.message}`);
return null;
}
}
async function runTest(testName, testFunction) {
try {
console.log(`🔬 Testing: ${testName}`);
await testFunction();
testResults.passed++;
console.log(` ✅ PASSED: ${testName}\n`);
} catch (error) {
testResults.failed++;
testResults.errors.push({ test: testName, error: error.message });
console.log(` ❌ FAILED: ${testName}`);
console.log(` Error: ${error.message}\n`);
}
}
async function simulateToolCall(toolName, args, agentService, paymentManager) {
// Validate arguments
validateToolArguments(toolName, args);
// Validate payment (in test mode, this will use mock validation)
const userId = args?.userId || args?.ownerId;
if (userId && !(await paymentManager.validatePayment(userId, toolName))) {
throw new Error(`Payment validation failed for ${toolName}`);
}
// Execute the tool
switch (toolName) {
case "create_agent":
return await agentService.createAgent({
name: args.name,
description: args.description,
instructions: args.instructions,
userId: args.userId,
});
case "list_agents":
return await agentService.listAgents(args.userId, args.limit, args.offset);
case "get_agent":
return await agentService.getAgent(args.agentId, args.userId);
case "update_agent":
return await agentService.updateAgent(args.agentId, {
name: args.name,
description: args.description,
instructions: args.instructions,
}, args.userId);
case "delete_agent":
return await agentService.deleteAgent(args.agentId, args.userId);
case "prompt_agent":
return await agentService.promptAgent(args.agentId, args.message, args.userId);
case "add_user_to_agent":
return await agentService.addUserToAgent(args.agentId, args.userId, args.ownerId);
case "remove_user_from_agent":
return await agentService.removeUserFromAgent(args.agentId, args.userId, args.ownerId);
case "get_usage_report":
return await agentService.getUsageReport(args.userId, args.startDate, args.endDate);
case "get_pricing":
return {
pricing: {
create_agent: 0.05,
prompt_agent: 0.01,
update_agent: 0.02,
delete_agent: 0.01,
list_agents: 0.001,
get_agent: 0.001,
add_user_to_agent: 0.005,
remove_user_from_agent: 0.005,
get_usage_report: 0.002,
get_pricing: 0.001
}
};
default:
throw new Error(`Unknown tool: ${toolName}`);
}
}
async function testCreateAgent(agentService, paymentManager) {
// First create a test user
await createTestUser();
const result = await simulateToolCall("create_agent", {
name: TEST_AGENT_NAME,
description: TEST_AGENT_DESCRIPTION,
instructions: TEST_INSTRUCTIONS,
userId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.id || !result.name) {
throw new Error("Agent creation failed - missing required fields");
}
createdAgentId = result.id;
console.log(` 📝 Created agent with ID: ${createdAgentId}`);
}
async function testListAgents(agentService, paymentManager) {
const result = await simulateToolCall("list_agents", {
userId: TEST_USER_ID,
limit: 10,
offset: 0
}, agentService, paymentManager);
if (!Array.isArray(result.agents)) {
throw new Error("List agents failed - result is not an array");
}
console.log(` 📋 Found ${result.agents.length} agents`);
}
async function testGetAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const result = await simulateToolCall("get_agent", {
agentId: createdAgentId,
userId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.id || result.id !== createdAgentId) {
throw new Error("Get agent failed - incorrect agent returned");
}
console.log(` 🔍 Retrieved agent: ${result.name}`);
}
async function testUpdateAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const updatedName = "Updated Test Agent";
const result = await simulateToolCall("update_agent", {
agentId: createdAgentId,
name: updatedName,
description: "Updated description",
instructions: "Updated instructions",
userId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.name || result.name !== updatedName) {
throw new Error("Update agent failed - name not updated");
}
console.log(` ✏️ Updated agent name to: ${updatedName}`);
}
async function testPromptAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const result = await simulateToolCall("prompt_agent", {
agentId: createdAgentId,
message: "Hello, test message!",
userId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.response) {
throw new Error("Prompt agent failed - no response received");
}
console.log(` 💬 Agent responded: ${result.response.substring(0, 50)}...`);
}
async function testAddUserToAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const result = await simulateToolCall("add_user_to_agent", {
agentId: createdAgentId,
userId: "test-user-456",
ownerId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.success) {
throw new Error("Add user to agent failed");
}
console.log(` 👥 Added user to agent successfully`);
}
async function testRemoveUserFromAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const result = await simulateToolCall("remove_user_from_agent", {
agentId: createdAgentId,
userId: "test-user-456",
ownerId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.success) {
throw new Error("Remove user from agent failed");
}
console.log(` 👤 Removed user from agent successfully`);
}
async function testGetUsageReport(agentService, paymentManager) {
const result = await simulateToolCall("get_usage_report", {
userId: TEST_USER_ID,
startDate: "2024-01-01",
endDate: "2024-12-31"
}, agentService, paymentManager);
if (!result.report || typeof result.report.totalCost !== 'number') {
throw new Error("Get usage report failed - invalid report structure");
}
console.log(` 📊 Usage report: $${result.report.totalCost.toFixed(4)} total cost`);
}
async function testGetPricing(agentService, paymentManager) {
const result = await simulateToolCall("get_pricing", {}, agentService, paymentManager);
if (!result.pricing) {
throw new Error("Get pricing failed - no pricing data returned");
}
console.log(` 💰 Pricing data returned successfully`);
}
async function testDeleteAgent(agentService, paymentManager) {
if (!createdAgentId) {
throw new Error("No agent ID available for testing");
}
const result = await simulateToolCall("delete_agent", {
agentId: createdAgentId,
userId: TEST_USER_ID
}, agentService, paymentManager);
if (!result.success) {
throw new Error("Delete agent failed");
}
console.log(` 🗑️ Deleted agent successfully`);
createdAgentId = null;
}
async function testPaymentValidation(paymentManager) {
// Test that payment validation works for different actions
const actions = ["create_agent", "prompt_agent", "list_agents"];
for (const action of actions) {
const isValid = await paymentManager.validatePayment(TEST_USER_ID, action);
if (!isValid) {
throw new Error(`Payment validation failed for ${action}`);
}
}
console.log(` 💳 Payment validation passed for all actions`);
}
async function testPricingStructure(paymentManager) {
// Test basic provider info instead since getPricingInfo doesn't exist
const providerInfo = paymentManager.getProviderInfo();
if (!providerInfo.name || !providerInfo.mode) {
throw new Error("Payment provider info incomplete");
}
console.log(` 💵 Payment provider: ${providerInfo.name}, Mode: ${providerInfo.mode}`);
}
async function runAllTests() {
console.log("Initializing test environment...\n");
// Initialize services with test payment mode
const originalPaymentMode = process.env.PAYMENT_MODE;
process.env.PAYMENT_MODE = "none"; // Use free tier for testing
const paymentManager = new PaymentManager("none");
const agentService = new AgentService();
try {
await paymentManager.initialize();
console.log("✅ Payment manager initialized\n");
// Test payment system
await runTest("Payment Validation", () => testPaymentValidation(paymentManager));
await runTest("Pricing Structure", () => testPricingStructure(paymentManager));
// Test all MCP tools in order
await runTest("Create Agent", () => testCreateAgent(agentService, paymentManager));
await runTest("List Agents", () => testListAgents(agentService, paymentManager));
await runTest("Get Agent", () => testGetAgent(agentService, paymentManager));
await runTest("Update Agent", () => testUpdateAgent(agentService, paymentManager));
await runTest("Prompt Agent", () => testPromptAgent(agentService, paymentManager));
await runTest("Add User to Agent", () => testAddUserToAgent(agentService, paymentManager));
await runTest("Remove User from Agent", () => testRemoveUserFromAgent(agentService, paymentManager));
await runTest("Get Usage Report", () => testGetUsageReport(agentService, paymentManager));
await runTest("Get Pricing", () => testGetPricing(agentService, paymentManager));
await runTest("Delete Agent", () => testDeleteAgent(agentService, paymentManager));
} finally {
// Restore original payment mode
if (originalPaymentMode) {
process.env.PAYMENT_MODE = originalPaymentMode;
}
}
// Print test results
console.log("=====================================");
console.log("🎯 TEST RESULTS SUMMARY");
console.log("=====================================");
console.log(`✅ Tests Passed: ${testResults.passed}`);
console.log(`❌ Tests Failed: ${testResults.failed}`);
console.log(`📊 Total Tests: ${testResults.passed + testResults.failed}`);
if (testResults.failed > 0) {
console.log("\n🔍 FAILED TESTS:");
testResults.errors.forEach(({ test, error }) => {
console.log(` ❌ ${test}: ${error}`);
});
}
if (testResults.failed === 0) {
console.log("\n🎉 ALL TESTS PASSED! Your MCP server is working perfectly!");
console.log("💰 Ready for production with ATXP payments!");
} else {
console.log(`\n⚠️ ${testResults.failed} test(s) failed. Please review and fix issues.`);
process.exit(1);
}
}
// Run the test suite
runAllTests().catch(error => {
console.error("💥 Test suite failed:", error);
process.exit(1);
});