@sei-js/mcp-server/dist/esm/tests/core/helpers/tool-test-helpers.js

Model Context Protocol (MCP) server for interacting with EVM-compatible networks

import { jest } from '@jest/globals';
/**
 * Helper function to create a mock MCP server for testing tools
 * @returns A mock MCP server object with the tool method
 */
export function createMockServer() {
    const registeredTools = new Map();
    const server = {
        tool: jest.fn((name, description, schema, handler) => {
            registeredTools.set(name, { name, description, schema, handler });
        })
    };
    return { server, registeredTools };
}
/**
 * Helper function to test a tool's success path
 * @param tool The tool object from registeredTools
 * @param params The parameters to pass to the tool handler
 * @returns The result of the tool handler
 */
export async function testToolSuccess(tool, params) {
    return await tool.handler(params);
}
/**
 * Helper function to test a tool's error path
 * @param tool The tool object from registeredTools
 * @param params The parameters to pass to the tool handler
 * @param mockFn The mock function that should throw an error
 * @param error The error to throw
 * @returns The result of the tool handler
 */
export async function testToolError(tool, params, mockFn, error) {
    mockFn.mockImplementationOnce(() => {
        throw error;
    });
    return await tool.handler(params);
}
/**
 * Helper function to verify a successful tool response
 * @param response The response from the tool handler
 * @param expectedData The expected data in the response
 */
export function verifySuccessResponse(response, expectedData) {
    expect(response).toHaveProperty('content');
    expect(response.content).toBeInstanceOf(Array);
    expect(response.content[0]).toHaveProperty('type', 'text');
    // Parse the JSON response
    const responseData = JSON.parse(response.content[0].text);
    expect(responseData).toEqual(expectedData);
}
/**
 * Helper function to verify an error tool response
 * @param response The response from the tool handler
 * @param errorMessage The expected error message
 */
export function verifyErrorResponse(response, errorMessage) {
    expect(response).toHaveProperty('content');
    expect(response.content).toBeInstanceOf(Array);
    expect(response.content[0]).toHaveProperty('type', 'text');
    expect(response.content[0].text).toContain(errorMessage);
    expect(response).toHaveProperty('isError', true);
}
/**
 * Common mock setup for balance-related tests
 */
export function setupBalanceMocks() {
    const mockBalance = jest.fn().mockResolvedValue(BigInt(100));
    const mockTokenInfo = jest.fn().mockResolvedValue({
        name: 'Test Token',
        symbol: 'TEST',
        decimals: 18
    });
    const mockNftInfo = jest.fn().mockResolvedValue({
        name: 'Test NFT',
        symbol: 'TNFT'
    });
    return {
        mockBalance,
        mockTokenInfo,
        mockNftInfo
    };
}
/**
 * Common mock setup for transaction-related tests
 */
export function setupTransactionMocks() {
    const mockHash = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
    return {
        mockHash,
        mockTxReceipt: {
            transactionHash: mockHash,
            blockNumber: 12345678,
            status: 'success'
        },
        mockTransaction: {
            hash: mockHash,
            blockNumber: 12345678,
            from: '0x1234567890abcdef1234567890abcdef12345678',
            to: '0x1234567890abcdef1234567890abcdef12345679',
            value: BigInt(1000000000000000000),
            data: '0x',
            nonce: 1,
            gasLimit: BigInt(21000)
        },
        mockTransactionReceipt: {
            transactionHash: mockHash,
            blockNumber: 12345678,
            status: 'success',
            gasUsed: BigInt(21000),
            effectiveGasPrice: BigInt(1000000000),
            logs: []
        }
    };
}