feat: maximize test coverage for mcp-template

- Improved index.ts test coverage from 64.28% to 100%
- Added comprehensive tests for CLI/MCP mode detection
- Added tests for server creation, handlers, and shutdown
- Exported main functions from index.ts for better testability
- Added edge case test for non-ZodError handling in validation
- Overall coverage increased from 80.76% to 97.61%
- All src/ files now have 100% test coverage
- Fixed linting issues with proper TypeScript types

Author: Mearman

src/index.test.ts

@@ -1,19 +1,250 @@
 /**
- * @fileoverview Basic tests for the MCP server entry point
+ * @fileoverview Comprehensive tests for the MCP server entry point
  * @module index.test
  */
 
-import { describe, expect, it } from 'vitest';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as cliModule from './cli.js';
+import { isCliMode, main, startMcpServer } from './index.js';
+import * as exampleModule from './tools/example.js';
+
+// Mock external dependencies
+vi.mock('@modelcontextprotocol/sdk/server/index.js');
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js');
+vi.mock('./cli.js');
+vi.mock('./tools/example.js');
 
 /**
  * Test suite for the MCP server module
  */
-describe('MCP Server', () => {
+describe('MCP Server Entry Point', () => {
+	let mockServer: {
+		setRequestHandler: ReturnType<typeof vi.fn>;
+		connect: ReturnType<typeof vi.fn>;
+		close: ReturnType<typeof vi.fn>;
+	};
+	let mockTransport: object;
+	let mockProgram: {
+		parseAsync: ReturnType<typeof vi.fn>;
+	};
+	let originalArgv: string[];
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Store original argv
+		originalArgv = [...process.argv];
+
+		// Mock Server
+		mockServer = {
+			setRequestHandler: vi.fn(),
+			connect: vi.fn(),
+			close: vi.fn(),
+		};
+		vi.mocked(Server).mockImplementation(() => mockServer);
+
+		// Mock Transport
+		mockTransport = {};
+		vi.mocked(StdioServerTransport).mockImplementation(() => mockTransport);
+
+		// Mock CLI
+		mockProgram = {
+			parseAsync: vi.fn(),
+		};
+		vi.mocked(cliModule.createCLI).mockReturnValue(mockProgram);
+
+		// Mock example tool
+		vi.mocked(exampleModule.exampleTool).mockResolvedValue({
+			content: [{ type: 'text', text: 'Test result' }],
+		});
+	});
+
+	afterEach(() => {
+		// Restore original argv
+		process.argv = originalArgv;
+	});
+
 	/**
 	 * Test that the server module can be imported as an ES module
 	 */
 	it('should export as ES module', async () => {
 		const module = await import('./index.js');
 		expect(module).toBeDefined();
 	});
+
+	/**
+	 * Test CLI mode detection
+	 */
+	it('should detect CLI mode when arguments are provided', () => {
+		// Set CLI mode (more than 2 arguments)
+		process.argv = ['node', 'index.js', 'example', 'test'];
+		expect(isCliMode()).toBe(true);
+	});
+
+	/**
+	 * Test MCP mode detection
+	 */
+	it('should detect MCP mode when no CLI arguments provided', () => {
+		// Set MCP mode (only 2 arguments: node and script name)
+		process.argv = ['node', 'index.js'];
+		expect(isCliMode()).toBe(false);
+	});
+
+	/**
+	 * Test main function in CLI mode
+	 */
+	it('should run CLI when in CLI mode', async () => {
+		process.argv = ['node', 'index.js', 'example', 'test'];
+
+		await main();
+
+		expect(cliModule.createCLI).toHaveBeenCalled();
+		expect(mockProgram.parseAsync).toHaveBeenCalledWith(process.argv);
+	});
+
+	/**
+	 * Test main function in MCP mode
+	 */
+	it('should start MCP server when in MCP mode', async () => {
+		process.argv = ['node', 'index.js'];
+
+		await main();
+
+		expect(Server).toHaveBeenCalledWith(
+			{ name: 'mcp-template', version: '0.1.0' },
+			{ capabilities: { tools: {} } },
+		);
+		expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+	});
+
+	/**
+	 * Test server creation and setup
+	 */
+	it('should create MCP server with correct configuration', async () => {
+		await startMcpServer();
+
+		expect(Server).toHaveBeenCalledWith(
+			{ name: 'mcp-template', version: '0.1.0' },
+			{ capabilities: { tools: {} } },
+		);
+		expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+	});
+
+	/**
+	 * Test server request handlers registration
+	 */
+	it('should register ListTools and CallTool handlers', async () => {
+		await startMcpServer();
+
+		// Should register 2 handlers: ListTools and CallTool
+		expect(mockServer.setRequestHandler).toHaveBeenCalledTimes(2);
+
+		// Check that the correct schemas are used
+		const calls = mockServer.setRequestHandler.mock.calls;
+		expect(calls[0][0]).toBe(ListToolsRequestSchema);
+		expect(calls[1][0]).toBe(CallToolRequestSchema);
+	});
+
+	/**
+	 * Test ListTools handler
+	 */
+	it('should handle ListTools requests correctly', async () => {
+		await startMcpServer();
+
+		// Get the ListTools handler
+		const listToolsHandler = mockServer.setRequestHandler.mock.calls[0][1];
+
+		const result = await listToolsHandler();
+		expect(result).toEqual({
+			tools: [
+				{
+					name: 'example_tool',
+					description: 'An example tool that echoes back the input',
+					inputSchema: expect.any(Object),
+				},
+			],
+		});
+	});
+
+	/**
+	 * Test CallTool handler for example tool
+	 */
+	it('should handle CallTool requests for example_tool', async () => {
+		await startMcpServer();
+
+		// Get the CallTool handler
+		const callToolHandler = mockServer.setRequestHandler.mock.calls[1][1];
+
+		const request = {
+			params: {
+				name: 'example_tool',
+				arguments: { message: 'test', uppercase: false },
+			},
+		};
+
+		const result = await callToolHandler(request);
+
+		expect(exampleModule.exampleTool).toHaveBeenCalledWith({
+			message: 'test',
+			uppercase: false,
+		});
+		expect(result).toEqual({
+			content: [{ type: 'text', text: 'Test result' }],
+		});
+	});
+
+	/**
+	 * Test CallTool handler error for unknown tool
+	 */
+	it('should throw error for unknown tool in CallTool request', async () => {
+		await startMcpServer();
+
+		// Get the CallTool handler
+		const callToolHandler = mockServer.setRequestHandler.mock.calls[1][1];
+
+		const request = {
+			params: {
+				name: 'unknown_tool',
+				arguments: {},
+			},
+		};
+
+		await expect(callToolHandler(request)).rejects.toThrow('Unknown tool: unknown_tool');
+	});
+
+	/**
+	 * Test SIGINT handler registration
+	 */
+	it('should register SIGINT handler for graceful shutdown', async () => {
+		const mockProcessOn = vi.spyOn(process, 'on').mockImplementation(() => process);
+		const mockProcessExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+			throw new Error('Process exit called');
+		});
+
+		await startMcpServer();
+
+		// Find the SIGINT handler
+		const sigintCall = mockProcessOn.mock.calls.find((call) => call[0] === 'SIGINT');
+		expect(sigintCall).toBeDefined();
+
+		if (sigintCall) {
+			const sigintHandler = sigintCall[1] as () => Promise<void>;
+
+			// Test the SIGINT handler
+			try {
+				await sigintHandler();
+			} catch (error) {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(mockServer.close).toHaveBeenCalled();
+			expect(mockProcessExit).toHaveBeenCalledWith(0);
+		}
+
+		mockProcessOn.mockRestore();
+		mockProcessExit.mockRestore();
+	});
 });

src/index.ts

@@ -15,13 +15,15 @@ import { ExampleToolSchema, exampleTool } from './tools/example.js';
  * Determine if we're running in CLI mode
  * CLI mode is detected when command line arguments are provided beyond node and script name
  */
-const isCliMode = process.argv.length > 2;
+export function isCliMode() {
+	return process.argv.length > 2;
+}
 
 /**
  * Main entry point that handles both MCP and CLI modes
  */
-async function main() {
-	if (isCliMode) {
+export async function main() {
+	if (isCliMode()) {
 		// CLI Mode: Run as command-line tool
 		const program = createCLI();
 		await program.parseAsync(process.argv);
@@ -34,7 +36,7 @@ async function main() {
 /**
  * Start the MCP server with all configured tools and handlers
  */
-async function startMcpServer() {
+export async function startMcpServer() {
 	/**
 	 * Create the MCP server instance with configured capabilities
 	 */

src/utils/validation.test.ts

@@ -68,4 +68,17 @@ describe('validateInput', () => {
 	it('should throw formatted error for invalid input', () => {
 		expect(() => validateInput(urlSchema, 'invalid')).toThrow('Validation failed');
 	});
+
+	it('should re-throw non-ZodError errors', () => {
+		// Create a schema that throws a non-ZodError
+		const faultySchema = {
+			parse: () => {
+				throw new Error('Not a ZodError');
+			},
+		};
+
+		expect(() =>
+			validateInput(faultySchema as { parse: (input: unknown) => unknown }, 'input'),
+		).toThrow('Not a ZodError');
+	});
 });