/**
* Unit tests for MCPServer business logic (src/server.ts)
*
* These tests focus on testable business logic without complex SDK mocking
*/
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import {
mockCensusResponses,
expectedFormattedOutputs,
createMockFetchResponse,
} from '../fixtures/mock-data.js';
// Mock global fetch
global.fetch = vi.fn();
describe('Census API Logic', () => {
beforeEach(() => {
vi.clearAllMocks();
});
afterEach(() => {
vi.restoreAllMocks();
});
describe('makeCensusRequest helper', () => {
// We'll test the logic by importing and testing the actual function indirectly
// through the tool handler
it('should fetch data from Census API', async () => {
(global.fetch as any).mockResolvedValue(
createMockFetchResponse(mockCensusResponses.california)
);
const url = 'https://api.census.gov/data/2020/dec/pl?get=NAME,P1_001N&for=state:6';
const response = await fetch(url);
const data = await response.json();
expect(global.fetch).toHaveBeenCalledWith(url);
expect(data).toEqual(mockCensusResponses.california);
});
it('should handle HTTP errors', async () => {
(global.fetch as any).mockResolvedValue(
createMockFetchResponse(null, false, 500)
);
const url = 'https://api.census.gov/data/2020/dec/pl?get=NAME,P1_001N&for=state:1';
const response = await fetch(url);
expect(response.ok).toBe(false);
expect(response.status).toBe(500);
});
it('should handle network errors', async () => {
(global.fetch as any).mockRejectedValue(new Error('Network error'));
await expect(fetch('https://api.census.gov/data/2020/dec/pl')).rejects.toThrow(
'Network error'
);
});
});
describe('Census Data Formatting', () => {
it('should format data with headers and rows', () => {
const censusData = mockCensusResponses.california;
const headers = censusData[0];
const rows = censusData.slice(1);
let formattedData = `Census Population Data:\n\n`;
formattedData += `${headers.join('\t')}\n`;
formattedData += '---\n';
for (const row of rows) {
formattedData += `${row.join('\t')}\n`;
}
expect(formattedData).toBe(expectedFormattedOutputs.california);
});
it('should format multiple states correctly', () => {
const censusData = mockCensusResponses.multipleStates;
const headers = censusData[0];
const rows = censusData.slice(1);
let formattedData = `Census Population Data:\n\n`;
formattedData += `${headers.join('\t')}\n`;
formattedData += '---\n';
for (const row of rows) {
formattedData += `${row.join('\t')}\n`;
}
expect(formattedData).toBe(expectedFormattedOutputs.multipleStates);
});
it('should handle empty data sets', () => {
const censusData = mockCensusResponses.empty;
expect(censusData.length).toBe(0);
});
});
describe('Census URL Construction', () => {
const CENSUS_API_BASE = 'https://api.census.gov/data/2020/dec/pl';
it('should construct URL for all states', () => {
const states = [0];
let stateQuery = '*';
if (states && states.length > 0 && states[0] !== 0) {
stateQuery = states.join(',');
}
const url = `${CENSUS_API_BASE}?get=NAME,P1_001N&for=state:${stateQuery}`;
expect(url).toBe('https://api.census.gov/data/2020/dec/pl?get=NAME,P1_001N&for=state:*');
});
it('should construct URL for single state', () => {
const states = [6];
let stateQuery = '*';
if (states && states.length > 0 && states[0] !== 0) {
stateQuery = states.join(',');
}
const url = `${CENSUS_API_BASE}?get=NAME,P1_001N&for=state:${stateQuery}`;
expect(url).toBe('https://api.census.gov/data/2020/dec/pl?get=NAME,P1_001N&for=state:6');
});
it('should construct URL for multiple states', () => {
const states = [1, 6, 36];
let stateQuery = '*';
if (states && states.length > 0 && states[0] !== 0) {
stateQuery = states.join(',');
}
const url = `${CENSUS_API_BASE}?get=NAME,P1_001N&for=state:${stateQuery}`;
expect(url).toBe(
'https://api.census.gov/data/2020/dec/pl?get=NAME,P1_001N&for=state:1,6,36'
);
});
});
describe('Error Response Creation', () => {
it('should create JSON-RPC error with correct structure', () => {
const createErrorResponse = (message: string) => {
return {
jsonrpc: '2.0',
error: {
code: -32000,
message: message,
},
id: expect.any(String),
};
};
const error = createErrorResponse('Test error');
expect(error).toMatchObject({
jsonrpc: '2.0',
error: {
code: -32000,
message: 'Test error',
},
});
});
});
describe('Initialize Request Detection', () => {
it('should detect valid initialize request', () => {
const validInitRequest = {
jsonrpc: '2.0',
id: 1,
method: 'initialize',
params: {
protocolVersion: '2024-11-05',
capabilities: {},
clientInfo: { name: 'test', version: '1.0.0' },
},
};
// Simple check for initialize method
expect(validInitRequest.method).toBe('initialize');
expect(validInitRequest.params.protocolVersion).toBeDefined();
});
it('should detect non-initialize request', () => {
const nonInitRequest = {
jsonrpc: '2.0',
id: 2,
method: 'tools/list',
params: {},
};
expect(nonInitRequest.method).not.toBe('initialize');
});
it('should handle initialize request in array', () => {
const requests = [
{
jsonrpc: '2.0',
id: 1,
method: 'initialize',
params: {
protocolVersion: '2024-11-05',
capabilities: {},
clientInfo: { name: 'test', version: '1.0.0' },
},
},
];
const hasInitialize = requests.some((req) => req.method === 'initialize');
expect(hasInitialize).toBe(true);
});
});
describe('Tool Configuration', () => {
it('should define get-population tool schema', () => {
const getPopulationTool = {
name: 'get-population',
description:
'Get population data for US states by FIPS state code. Pass an array of state codes (e.g., [1, 6, 36] for Alabama, California, New York) or use [0] to get all states.',
inputSchema: {
type: 'object',
properties: {
states: {
type: 'array',
items: {
type: 'number',
},
description: 'Array of FIPS state codes (e.g., [1, 6, 36]). Use [0] for all states.',
},
},
required: ['states'],
},
};
expect(getPopulationTool.name).toBe('get-population');
expect(getPopulationTool.inputSchema.required).toContain('states');
expect(getPopulationTool.inputSchema.properties.states.type).toBe('array');
});
it('should validate tool input schema', () => {
const schema = {
type: 'object',
properties: {
states: {
type: 'array',
items: {
type: 'number',
},
},
},
required: ['states'],
};
expect(schema.required).toContain('states');
expect(schema.properties.states.items.type).toBe('number');
});
});
describe('Notification Format', () => {
it('should create tool list changed notification', () => {
const notification = {
method: 'notifications/tools/list_changed',
};
expect(notification.method).toBe('notifications/tools/list_changed');
});
it('should create logging message notification', () => {
const notification = {
method: 'notifications/message',
params: { level: 'info', data: 'Test message' },
};
expect(notification.method).toBe('notifications/message');
expect(notification.params.level).toBe('info');
expect(notification.params.data).toBe('Test message');
});
it('should create JSON-RPC notification', () => {
const baseNotification = {
method: 'notifications/message',
params: { level: 'info', data: 'Test' },
};
const rpcNotification = {
...baseNotification,
jsonrpc: '2.0',
};
expect(rpcNotification.jsonrpc).toBe('2.0');
expect(rpcNotification.method).toBe('notifications/message');
});
});
describe('Session Management Logic', () => {
it('should generate unique session IDs', () => {
const sessionIds = new Set();
for (let i = 0; i < 100; i++) {
const id = `session-${Math.random().toString(36).substring(7)}`;
sessionIds.add(id);
}
// All should be unique
expect(sessionIds.size).toBe(100);
});
it('should track multiple transports', () => {
const transports: Record<string, any> = {};
transports['session-1'] = { id: '1' };
transports['session-2'] = { id: '2' };
transports['session-3'] = { id: '3' };
expect(Object.keys(transports).length).toBe(3);
expect(transports['session-1']).toBeDefined();
expect(transports['session-2']).toBeDefined();
});
});
});
