@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/unit/mcp/server-lifecycle.test.ts

@@ -1,301 +0,0 @@
-/**
- * Tests for MCP Server Lifecycle Management
- * Verifies server initialization, start, stop, and restart functionality
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-
-import { getConfig } from '@/config';
-import { createMCPServer } from '@/server';
-
-describe('MCP Server Lifecycle', () => {
-  let server: Server | undefined;
-  let originalEnv: NodeJS.ProcessEnv;
-
-  beforeEach(() => {
-    // Save original environment
-    originalEnv = { ...process.env };
-
-    // Set test environment
-    process.env['TEAMCITY_URL'] = 'https://test.teamcity.com';
-    process.env['TEAMCITY_TOKEN'] = 'test-token';
-    process.env['MCP_MODE'] = 'dev';
-  });
-
-  afterEach(async () => {
-    // Restore original environment
-    process.env = originalEnv;
-
-    // Clean up server if it exists
-    if (server && typeof server.close === 'function') {
-      await server.close();
-    }
-  });
-
-  describe('Server Initialization', () => {
-    it('should create server with correct metadata', () => {
-      server = createMCPServer();
-
-      expect(server).toBeDefined();
-      expect(server).toBeInstanceOf(Server);
-
-      // Check server info
-      const serverInfo = (server as unknown as { serverInfo?: { name?: string; version?: string } })
-        .serverInfo;
-      expect(serverInfo).toEqual({
-        name: 'teamcity-mcp',
-        version: expect.any(String),
-      });
-    });
-
-    it('should initialize with configured capabilities', () => {
-      const config = getConfig();
-      server = createMCPServer();
-
-      // Server should be created with capabilities from config
-      expect(server).toBeDefined();
-
-      // Verify capabilities are set based on config
-      const capabilities = (server as unknown as { _capabilities?: Record<string, unknown> })
-        ._capabilities;
-      if (config.mcp.capabilities.tools) {
-        expect(capabilities?.['tools']).toBeDefined();
-      }
-      if (config.mcp.capabilities.prompts) {
-        expect(capabilities?.['prompts']).toBeDefined();
-      }
-      if (config.mcp.capabilities.resources) {
-        expect(capabilities?.['resources']).toBeDefined();
-      }
-    });
-
-    it('should expose public lifecycle methods', () => {
-      server = createMCPServer();
-
-      expect(typeof server.connect).toBe('function');
-      expect(typeof server.close).toBe('function');
-    });
-
-    it('should handle server creation errors gracefully', () => {
-      // Test with invalid configuration
-      process.env['TEAMCITY_URL'] = '';
-
-      expect(() => createMCPServer()).not.toThrow();
-      server = createMCPServer();
-      expect(server).toBeDefined();
-    });
-  });
-
-  describe('Server Start/Stop', () => {
-    it('should connect with transport', async () => {
-      server = createMCPServer();
-      const transport = new StdioServerTransport();
-
-      // Mock stdin/stdout for testing
-      const mockStdin = {
-        on: jest.fn(),
-        once: jest.fn(),
-        removeListener: jest.fn(),
-        setEncoding: jest.fn(),
-        pause: jest.fn(),
-        resume: jest.fn(),
-      };
-
-      const mockStdout = {
-        write: jest.fn((_: unknown, callback?: () => void) => {
-          if (typeof callback === 'function') callback();
-          return true;
-        }),
-        on: jest.fn(),
-      };
-
-      (transport as unknown as { input: unknown; output: unknown }).input = mockStdin;
-      (transport as unknown as { input: unknown; output: unknown }).output = mockStdout;
-
-      await expect(server.connect(transport)).resolves.not.toThrow();
-    });
-
-    it('should handle graceful shutdown', async () => {
-      server = createMCPServer();
-
-      // Server should close without errors
-      await expect(server.close()).resolves.not.toThrow();
-    });
-
-    it('should handle multiple start attempts', async () => {
-      server = createMCPServer();
-      const transport = new StdioServerTransport();
-
-      // Mock transport
-      const mockStdin = {
-        on: jest.fn(),
-        once: jest.fn(),
-        removeListener: jest.fn(),
-        setEncoding: jest.fn(),
-        pause: jest.fn(),
-        resume: jest.fn(),
-      };
-
-      const mockStdout = {
-        write: jest.fn((_: unknown, callback?: () => void) => {
-          if (typeof callback === 'function') callback();
-          return true;
-        }),
-        on: jest.fn(),
-      };
-
-      (transport as unknown as { input: unknown; output: unknown }).input = mockStdin;
-      (transport as unknown as { input: unknown; output: unknown }).output = mockStdout;
-
-      // First connection should succeed
-      await server.connect(transport);
-
-      // Second connection attempt should be handled
-      const transport2 = new StdioServerTransport();
-      (transport2 as unknown as { input: unknown; output: unknown }).input = mockStdin;
-      (transport2 as unknown as { input: unknown; output: unknown }).output = mockStdout;
-
-      // This might throw or be ignored depending on implementation
-      // Accept either resolution or rejection
-      await server.connect(transport2).catch(() => undefined);
-    });
-  });
-
-  describe('Server Lifecycle Events', () => {
-    it('should handle connection lifecycle', async () => {
-      server = createMCPServer();
-
-      // Test server lifecycle management
-      // The server should be created and ready for connections
-      expect(server).toBeDefined();
-      const meta = (server as unknown as { serverInfo?: { name?: string } }).serverInfo;
-      expect(meta).toBeDefined();
-      expect(meta?.name).toBe('teamcity-mcp');
-
-      // Server should have proper methods for lifecycle management
-      expect(typeof server.connect).toBe('function');
-      expect(typeof server.close).toBe('function');
-
-      // Server close should work without errors (even without connection)
-      await expect(server.close()).resolves.not.toThrow();
-
-      // Should be able to close multiple times without issues
-      await expect(server.close()).resolves.not.toThrow();
-    });
-
-    it('should maintain server state correctly', () => {
-      server = createMCPServer();
-
-      // Check initial state
-      expect((server as unknown as { serverInfo?: unknown }).serverInfo).toBeDefined();
-
-      // Server should have proper structure
-      expect(server.setRequestHandler).toBeDefined();
-      expect(server.connect).toBeDefined();
-      expect(server.close).toBeDefined();
-    });
-  });
-
-  describe('Error Recovery', () => {
-    it('should recover from transport errors', async () => {
-      server = createMCPServer();
-      const transport = new StdioServerTransport();
-
-      // Mock transport with error simulation
-      const mockStdin = {
-        on: jest.fn((event: string, handler: (err: Error) => void) => {
-          if (event === 'error') {
-            // Simulate error after connection
-            setTimeout(() => handler(new Error('Transport error')), 10);
-          }
-        }),
-        once: jest.fn(),
-        removeListener: jest.fn(),
-        setEncoding: jest.fn(),
-        pause: jest.fn(),
-        resume: jest.fn(),
-      };
-
-      const mockStdout = {
-        write: jest.fn((_: unknown, callback?: () => void) => {
-          if (typeof callback === 'function') callback();
-          return true;
-        }),
-        on: jest.fn(),
-      };
-
-      (transport as unknown as { input: unknown; output: unknown }).input = mockStdin;
-      (transport as unknown as { input: unknown; output: unknown }).output = mockStdout;
-
-      // Connection should handle errors gracefully
-      await server.connect(transport);
-
-      // Wait for error to be triggered
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      // Server should still be functional
-      expect(server.close).toBeDefined();
-      await server.close();
-    });
-
-    it('should handle server restart', async () => {
-      // Create and start server
-      server = createMCPServer();
-      const transport1 = new StdioServerTransport();
-
-      // Mock first transport
-      const mockStdin1 = {
-        on: jest.fn(),
-        once: jest.fn(),
-        removeListener: jest.fn(),
-        setEncoding: jest.fn(),
-        pause: jest.fn(),
-        resume: jest.fn(),
-      };
-
-      const mockStdout1 = {
-        write: jest.fn((_: unknown, callback?: () => void) => {
-          if (typeof callback === 'function') callback();
-          return true;
-        }),
-        on: jest.fn(),
-      };
-
-      (transport1 as unknown as { input: unknown; output: unknown }).input = mockStdin1;
-      (transport1 as unknown as { input: unknown; output: unknown }).output = mockStdout1;
-
-      await server.connect(transport1);
-
-      // Stop server
-      await server.close();
-
-      // Create new server instance
-      server = createMCPServer();
-      const transport2 = new StdioServerTransport();
-
-      // Mock second transport
-      const mockStdin2 = {
-        on: jest.fn(),
-        once: jest.fn(),
-        removeListener: jest.fn(),
-        setEncoding: jest.fn(),
-        pause: jest.fn(),
-        resume: jest.fn(),
-      };
-
-      const mockStdout2 = {
-        write: jest.fn((_: unknown, callback?: () => void) => {
-          if (typeof callback === 'function') callback();
-          return true;
-        }),
-        on: jest.fn(),
-      };
-
-      (transport2 as unknown as { input: unknown; output: unknown }).input = mockStdin2;
-      (transport2 as unknown as { input: unknown; output: unknown }).output = mockStdout2;
-
-      // Should be able to start again
-      await expect(server.connect(transport2)).resolves.not.toThrow();
-    });
-  });
-});

package/tests/unit/middleware/error.test.ts

@@ -1,283 +0,0 @@
-/**
- * Tests for error handling middleware
- */
-import { z } from 'zod';
-
-import {
-  MCPAuthError,
-  MCPNotFoundError,
-  MCPToolError,
-  MCPValidationError,
-  asyncHandler,
-  formatError,
-  retry,
-  safeJsonParse,
-} from '@/middleware/error';
-
-describe('Error Classes', () => {
-  describe('MCPToolError', () => {
-    it('should create error with default values', () => {
-      const error = new MCPToolError('Test error');
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe('TOOL_ERROR');
-      expect(error.statusCode).toBe(500);
-      expect(error.name).toBe('MCPToolError');
-    });
-
-    it('should create error with custom values', () => {
-      const error = new MCPToolError('Custom error', 'CUSTOM_CODE', 400, { foo: 'bar' });
-      expect(error.message).toBe('Custom error');
-      expect(error.code).toBe('CUSTOM_CODE');
-      expect(error.statusCode).toBe(400);
-      expect(error.data).toEqual({ foo: 'bar' });
-    });
-  });
-
-  describe('MCPValidationError', () => {
-    it('should create validation error', () => {
-      const zodError = new z.ZodError([
-        {
-          path: ['field'],
-          message: 'Invalid value',
-          code: 'custom',
-        },
-      ]);
-      const error = new MCPValidationError('Validation failed', zodError);
-      expect(error.message).toBe('Validation failed');
-      expect(error.code).toBe('VALIDATION_ERROR');
-      expect(error.statusCode).toBe(400);
-      expect(error.errors).toBe(zodError);
-      expect(error.name).toBe('MCPValidationError');
-    });
-  });
-
-  describe('MCPAuthError', () => {
-    it('should create auth error', () => {
-      const error = new MCPAuthError('Unauthorized');
-      expect(error.message).toBe('Unauthorized');
-      expect(error.code).toBe('AUTH_ERROR');
-      expect(error.statusCode).toBe(401);
-      expect(error.name).toBe('MCPAuthError');
-    });
-  });
-
-  describe('MCPNotFoundError', () => {
-    it('should create not found error', () => {
-      const error = new MCPNotFoundError('Tool');
-      expect(error.message).toBe('Tool not found');
-      expect(error.code).toBe('NOT_FOUND');
-      expect(error.statusCode).toBe(404);
-      expect(error.name).toBe('MCPNotFoundError');
-    });
-  });
-});
-
-describe('formatError', () => {
-  it('should format MCPToolError', () => {
-    const error = new MCPToolError('Test error', 'TEST_CODE', 500, { detail: 'test' });
-    const result = formatError(error);
-    expect(result).toEqual({
-      success: false,
-      error: {
-        message: 'Test error',
-        code: 'TEST_CODE',
-        data: { detail: 'test' },
-      },
-    });
-  });
-
-  it('should format ZodError', () => {
-    const zodError = new z.ZodError([
-      {
-        path: ['field'],
-        message: 'Invalid value',
-        code: 'custom',
-      },
-    ]);
-    const result = formatError(zodError);
-    expect(result).toEqual({
-      success: false,
-      error: {
-        message: 'Validation failed',
-        code: 'VALIDATION_ERROR',
-        data: zodError.errors,
-      },
-    });
-  });
-
-  it('should format generic Error', () => {
-    const error = new Error('Generic error');
-    const result = formatError(error);
-    expect(result).toEqual({
-      success: false,
-      error: {
-        message: 'Generic error',
-        code: 'INTERNAL_ERROR',
-      },
-    });
-  });
-
-  it('should format unknown error', () => {
-    const result = formatError('string error');
-    expect(result).toEqual({
-      success: false,
-      error: {
-        message: 'An unknown error occurred',
-        code: 'UNKNOWN_ERROR',
-      },
-    });
-  });
-});
-
-describe('asyncHandler', () => {
-  it('should handle successful async function', async () => {
-    const handler = asyncHandler(async () => {
-      return 'success';
-    });
-    const result = await handler();
-    expect(result).toBe('success');
-  });
-
-  it('should handle async function with parameters', async () => {
-    const handler = asyncHandler<number>(async (...args: unknown[]) => {
-      const [a, b] = args as [number, number];
-      return a + b;
-    });
-    const result = await handler(2, 3);
-    expect(result).toBe(5);
-  });
-
-  it('should propagate errors', async () => {
-    const handler = asyncHandler(async () => {
-      throw new Error('Test error');
-    });
-    await expect(handler()).rejects.toThrow('Test error');
-  });
-});
-
-describe('safeJsonParse', () => {
-  it('should parse valid JSON', () => {
-    const result = safeJsonParse('{"key": "value"}');
-    expect(result).toEqual({ key: 'value' });
-  });
-
-  it('should return null for invalid JSON', () => {
-    const result = safeJsonParse('invalid json');
-    expect(result).toBeNull();
-  });
-
-  it('should parse complex JSON structures', () => {
-    const json = JSON.stringify({
-      array: [1, 2, 3],
-      nested: { foo: 'bar' },
-      bool: true,
-      null: null,
-    });
-    const result = safeJsonParse(json);
-    expect(result).toEqual({
-      array: [1, 2, 3],
-      nested: { foo: 'bar' },
-      bool: true,
-      null: null,
-    });
-  });
-});
-
-describe('retry', () => {
-  it('should succeed on first try', async () => {
-    let attempts = 0;
-    const result = await retry(async () => {
-      attempts++;
-      return 'success';
-    });
-    expect(result).toBe('success');
-    expect(attempts).toBe(1);
-  });
-
-  it('should retry on failure and eventually succeed', async () => {
-    let attempts = 0;
-    const result = await retry(
-      async () => {
-        attempts++;
-        if (attempts < 3) {
-          throw new Error('Fail');
-        }
-        return 'success';
-      },
-      { retries: 3, delay: 10 }
-    );
-    expect(result).toBe('success');
-    expect(attempts).toBe(3);
-  });
-
-  it('should throw after max retries', async () => {
-    let attempts = 0;
-    await expect(
-      retry(
-        async () => {
-          attempts++;
-          throw new Error('Always fails');
-        },
-        { retries: 3, delay: 10 }
-      )
-    ).rejects.toThrow('Always fails');
-    expect(attempts).toBe(3);
-  });
-
-  it('should use exponential backoff', async () => {
-    const delays: number[] = [];
-    let lastTime = Date.now();
-
-    await retry(
-      async () => {
-        const now = Date.now();
-        if (lastTime !== now) {
-          delays.push(now - lastTime);
-        }
-        lastTime = now;
-        if (delays.length < 2) {
-          throw new Error('Retry');
-        }
-        return 'success';
-      },
-      { retries: 3, delay: 10, exponentialBackoff: true }
-    );
-
-    // Second retry should have longer delay than first
-    expect(delays.length).toBeGreaterThanOrEqual(2);
-    if (delays.length >= 2) {
-      const first = delays[0] as number;
-      const second = delays[1] as number;
-      expect(second).toBeGreaterThanOrEqual(first);
-    }
-  });
-
-  it('should use fixed delay without exponential backoff', async () => {
-    const delays: number[] = [];
-    let lastTime = Date.now();
-
-    await retry(
-      async () => {
-        const now = Date.now();
-        if (lastTime !== now) {
-          delays.push(now - lastTime);
-        }
-        lastTime = now;
-        if (delays.length < 2) {
-          throw new Error('Retry');
-        }
-        return 'success';
-      },
-      { retries: 3, delay: 10, exponentialBackoff: false }
-    );
-
-    // All delays should be similar (within reasonable tolerance)
-    expect(delays.length).toBeGreaterThanOrEqual(2);
-    if (delays.length >= 2) {
-      const avgDelay = delays.reduce((a, b) => a + b, 0) / delays.length;
-      delays.forEach((delay) => {
-        expect(Math.abs(delay - avgDelay)).toBeLessThan(50); // Allow 50ms tolerance
-      });
-    }
-  });
-});

package/tests/unit/server.test.ts

@@ -1,102 +0,0 @@
-/**
- * Unit tests for MCP server
- */
-import { type ToolDefinition, getAvailableTools } from '../../src/tools';
-
-describe('MCP Server', () => {
-  describe('Server Creation', () => {
-    test('should create MCP server instance', async () => {
-      const { createMCPServer } = await import('../../src/server');
-      const server = createMCPServer();
-
-      expect(server).toBeDefined();
-      // Server class from @modelcontextprotocol/sdk/server has specific methods
-      expect(typeof server.setRequestHandler).toBe('function');
-    });
-
-    test('should have proper server configuration', async () => {
-      const { getConfig } = await import('../../src/config');
-      const config = getConfig();
-
-      expect(config.mcp).toBeDefined();
-      expect(config.mcp.name).toBe('teamcity-mcp');
-      expect(config.mcp.version).toBeDefined();
-    });
-
-    // Removed env-var dependent test: MCP_MODE handling
-  });
-
-  describe('Tool Registration', () => {
-    test('should have ping tool available', () => {
-      const tools = getAvailableTools();
-      const pingTool = tools.find((t: ToolDefinition) => t.name === 'ping');
-
-      expect(pingTool).toBeDefined();
-      expect(pingTool?.description).toContain('connectivity');
-      expect(pingTool?.inputSchema).toBeDefined();
-    });
-
-    test('should have list_projects tool available', () => {
-      const tools = getAvailableTools();
-      const listProjectsTool = tools.find((t: ToolDefinition) => t.name === 'list_projects');
-
-      expect(listProjectsTool).toBeDefined();
-      expect(listProjectsTool?.description).toContain('TeamCity projects');
-    });
-
-    test('should have proper number of tools registered', () => {
-      const tools = getAvailableTools();
-
-      expect(tools.length).toBeGreaterThan(0);
-      expect(
-        tools.every(
-          (t: ToolDefinition) =>
-            Boolean(t.name) && Boolean(t.description) && typeof t.handler === 'function'
-        )
-      ).toBe(true);
-    });
-  });
-
-  describe('Configuration', () => {
-    // Removed env-var dependent test: configuration from environment
-    // Removed env-var dependent test: default values when env vars missing
-    // Removed env-var dependent test: TeamCity configuration via environment
-  });
-
-  describe('Logging', () => {
-    test('should create logger instance', async () => {
-      const { createLogger } = await import('../../src/utils/logger');
-      const logger = createLogger();
-
-      expect(logger).toBeDefined();
-      expect(logger).toHaveProperty('info');
-      expect(logger).toHaveProperty('error');
-      expect(logger).toHaveProperty('warn');
-      expect(logger).toHaveProperty('debug');
-    });
-
-    // Removed env-var dependent test: log level via environment
-  });
-
-  describe('Error Handling', () => {
-    test('should handle MCP errors properly', async () => {
-      const { MCPError } = await import('../../src/types');
-
-      const error = new MCPError('Test error', 'TEST_ERROR', 400);
-      expect(error).toBeInstanceOf(Error);
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe('TEST_ERROR');
-      expect(error.statusCode).toBe(400);
-    });
-
-    test('should handle TeamCity API errors', async () => {
-      const { TeamCityAPIError } = await import('../../src/types');
-
-      const error = new TeamCityAPIError('API error', 500, { detail: 'Server error' });
-      expect(error).toBeInstanceOf(Error);
-      expect(error.message).toBe('API error');
-      expect(error.statusCode).toBe(500);
-      expect(error.response).toEqual({ detail: 'Server error' });
-    });
-  });
-});