@daghis/teamcity-mcp 0.1.2

package/tests/integration/triggers-scenario.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type { ActionResult, BuildTypeSummary, ListResult } from '../types/tool-results';
+import { callTool } from './lib/mcp-runner';
+
+const ts = Date.now();
+const PROJECT_ID = `E2E_TRIG_${ts}`;
+const PROJECT_NAME = `E2E Triggers ${ts}`;
+const BT_ID = `E2E_TRIG_BT_${ts}`;
+const BT_NAME = `E2E Trigger BuildType ${ts}`;
+
+const hasTeamCityEnv = Boolean(
+  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
+    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
+);
+
+describe('Build triggers: add and delete (full) with dev verification', () => {
+  afterAll(async () => {
+    if (!hasTeamCityEnv) return;
+    try {
+      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    } catch (_e) {
+      expect(true).toBe(true);
+    }
+  });
+  it('creates project and build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const cproj = await callTool<ActionResult>('full', 'create_project', {
+      id: PROJECT_ID,
+      name: PROJECT_NAME,
+    });
+    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
+    const cbt = await callTool<ActionResult>('full', 'create_build_config', {
+      projectId: PROJECT_ID,
+      id: BT_ID,
+      name: BT_NAME,
+    });
+    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
+  }, 60000);
+
+  it('adds a vcs trigger (full) and verifies via list_build_configs (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    try {
+      const addTrig = await callTool<ActionResult>('full', 'manage_build_triggers', {
+        buildTypeId: BT_ID,
+        action: 'add',
+        type: 'vcsTrigger',
+        properties: { quietPeriodMode: 'DO_NOT_USE' },
+      });
+      expect(addTrig).toMatchObject({ success: true, action: 'add_build_trigger' });
+    } catch (e) {
+      // Non-fatal; some servers may have policy restrictions
+      // eslint-disable-next-line no-console
+      console.warn('add trigger failed (non-fatal):', e);
+      return expect(true).toBe(true);
+    }
+
+    const cfgs = await callTool<ListResult<BuildTypeSummary>>('dev', 'list_build_configs', {
+      projectId: PROJECT_ID,
+      fields: 'buildType(id,triggers(trigger(id,type)))',
+    });
+    const entry = (cfgs.items ?? []).find((b) => b.id === BT_ID);
+    if (!entry?.triggers?.trigger?.length) return expect(true).toBe(true);
+    const triggerId = entry.triggers.trigger[0]?.id as string | undefined;
+    expect(typeof triggerId).toBe('string');
+
+    const del = await callTool('full', 'manage_build_triggers', {
+      buildTypeId: BT_ID,
+      action: 'delete',
+      triggerId,
+    });
+    expect(del).toMatchObject({ success: true, action: 'delete_build_trigger' });
+  }, 90000);
+
+  it('deletes project (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const res = await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    expect(res).toMatchObject({ success: true, action: 'delete_project' });
+  }, 60000);
+});

package/tests/integration/vcs-scenario.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type { ActionResult, ListResult, VcsRootRef } from '../types/tool-results';
+import { callTool } from './lib/mcp-runner';
+
+const hasTeamCityEnv = Boolean(
+  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
+    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
+);
+
+const ts = Date.now();
+const PROJECT_ID = `E2E_VCS_${ts}`;
+const PROJECT_NAME = `E2E VCS ${ts}`;
+const VCS_ID = `E2E_VCS_ROOT_${ts}`;
+const VCS_NAME = `E2E VCS Root ${ts}`;
+const BT_ID = `E2E_VCS_BT_${ts}`;
+const BT_NAME = `E2E VCS BuildType ${ts}`;
+
+describe('VCS roots: full writes + dev reads', () => {
+  afterAll(async () => {
+    try {
+      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    } catch (_e) {
+      expect(true).toBe(true);
+    }
+  });
+  it('creates project and build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const cproj = await callTool<ActionResult>('full', 'create_project', {
+      id: PROJECT_ID,
+      name: PROJECT_NAME,
+    });
+    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
+    const cbt = await callTool<ActionResult>('full', 'create_build_config', {
+      projectId: PROJECT_ID,
+      id: BT_ID,
+      name: BT_NAME,
+    });
+    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
+  }, 60000);
+
+  it('creates VCS root and verifies with get/list (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const createVcs = await callTool<ActionResult>('full', 'create_vcs_root', {
+      projectId: PROJECT_ID,
+      id: VCS_ID,
+      name: VCS_NAME,
+      vcsName: 'jetbrains.git',
+      url: 'https://example.com/repo.git',
+      branch: 'refs/heads/main',
+    });
+    expect(createVcs).toMatchObject({ success: true, action: 'create_vcs_root' });
+
+    const get = await callTool<VcsRootRef>('dev', 'get_vcs_root', { id: VCS_ID });
+    expect(get.id).toBe(VCS_ID);
+    const list = await callTool<ListResult<VcsRootRef>>('dev', 'list_vcs_roots', {
+      projectId: PROJECT_ID,
+    });
+    const found = (list.items ?? []).some((r) => r.id === VCS_ID);
+    expect(found).toBe(true);
+  }, 60000);
+
+  it('attaches VCS root to build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const attach = await callTool<ActionResult>('full', 'add_vcs_root_to_build', {
+      buildTypeId: BT_ID,
+      vcsRootId: VCS_ID,
+      checkoutRules: '+:refs/heads/*',
+    });
+    expect(attach).toMatchObject({ success: true, action: 'add_vcs_root_to_build' });
+  }, 60000);
+
+  it('deletes project (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const res = await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    expect(res).toMatchObject({ success: true, action: 'delete_project' });
+  }, 60000);
+});

package/tests/jest.test.js

@@ -0,0 +1,122 @@
+/**
+ * Meta-tests for Jest testing framework setup
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+describe('Jest Testing Framework', () => {
+  const rootDir = path.resolve(__dirname, '..');
+
+  describe('Jest Configuration', () => {
+    let jestConfig;
+
+    beforeAll(() => {
+      const configPath = path.join(rootDir, 'jest.config.js');
+      if (fs.existsSync(configPath)) {
+        // Clear require cache and reload config
+        delete require.cache[require.resolve(configPath)];
+        jestConfig = require(configPath);
+      }
+    });
+
+    test('jest.config.js should exist', () => {
+      const configPath = path.join(rootDir, 'jest.config.js');
+      expect(fs.existsSync(configPath)).toBe(true);
+    });
+
+    test('should have TypeScript preset configured', () => {
+      expect(jestConfig).toBeDefined();
+      expect(jestConfig.preset).toBe('ts-jest');
+    });
+
+    test('should have correct test environment', () => {
+      expect(jestConfig.testEnvironment).toBe('node');
+    });
+
+    test('should have proper test file patterns', () => {
+      expect(jestConfig.testMatch).toBeDefined();
+      expect(jestConfig.testMatch).toEqual(
+        expect.arrayContaining([expect.stringContaining('test'), expect.stringContaining('spec')])
+      );
+    });
+
+    test('should have coverage collection configured', () => {
+      expect(jestConfig.collectCoverageFrom).toBeDefined();
+      expect(jestConfig.collectCoverageFrom).toEqual(
+        expect.arrayContaining([expect.stringContaining('src/**/*.{ts,tsx}')])
+      );
+    });
+
+    test('should have coverage thresholds set', () => {
+      expect(jestConfig.coverageThreshold).toBeDefined();
+      expect(jestConfig.coverageThreshold.global).toBeDefined();
+      // Ensure thresholds are numeric and present; exact values are a team policy
+      const g = jestConfig.coverageThreshold.global;
+      expect(typeof g.branches).toBe('number');
+      expect(typeof g.functions).toBe('number');
+      expect(typeof g.lines).toBe('number');
+      expect(typeof g.statements).toBe('number');
+    });
+
+    test('should have module path mappings', () => {
+      expect(jestConfig.moduleNameMapper).toBeDefined();
+      expect(jestConfig.moduleNameMapper['^@/(.*)$']).toBeDefined();
+    });
+  });
+
+  describe('Test Directory Structure', () => {
+    test('tests directory should exist', () => {
+      const testsDir = path.join(rootDir, 'tests');
+      expect(fs.existsSync(testsDir)).toBe(true);
+    });
+
+    test('tests/unit directory should exist', () => {
+      const unitDir = path.join(rootDir, 'tests', 'unit');
+      expect(fs.existsSync(unitDir)).toBe(true);
+    });
+
+    // Integration tests directory check removed per project decision
+  });
+
+  describe('Test Scripts', () => {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+
+    test('should have test script', () => {
+      expect(packageJson.scripts.test).toBeDefined();
+      expect(packageJson.scripts.test).toContain('jest');
+    });
+
+    test('should have test:watch script', () => {
+      expect(packageJson.scripts['test:watch']).toBeDefined();
+      expect(packageJson.scripts['test:watch']).toContain('--watch');
+    });
+
+    test('should have test:coverage script', () => {
+      expect(packageJson.scripts['test:coverage']).toBeDefined();
+      expect(packageJson.scripts['test:coverage']).toContain('--coverage');
+    });
+  });
+
+  describe('Test Execution', () => {
+    test('should run tests successfully', () => {
+      try {
+        const output = execSync('npm test -- --listTests', {
+          cwd: rootDir,
+          encoding: 'utf8',
+        });
+        expect(output).toBeTruthy();
+      } catch (error) {
+        // If test listing fails, the test should fail
+        expect(error).toBeNull();
+      }
+    });
+
+    test('should generate coverage report', () => {
+      // Check if coverage can be generated (we don't run it fully to save time)
+      const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+      expect(packageJson.scripts['test:coverage']).toBeDefined();
+    });
+  });
+});

package/tests/mcp-server.test.ts

@@ -0,0 +1,378 @@
+/**
+ * Tests for MCP Server Initialization
+ * Verifies that the MCP server starts correctly and handles tools
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+import { getConfig } from '@/config';
+import { createMCPServer } from '@/server';
+
+import { type ToolDefinition, getAvailableTools, getTool } from '../src/tools';
+
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/server/index.js');
+jest.mock('@modelcontextprotocol/sdk/server/stdio.js');
+jest.mock('@modelcontextprotocol/sdk/types.js', () => ({
+  ErrorCode: {
+    MethodNotFound: -32601,
+    InternalError: -32603,
+  },
+  McpError: class McpError extends Error {
+    constructor(
+      public code: number,
+      message: string
+    ) {
+      super(message);
+      this.name = 'McpError';
+    }
+  },
+  ListToolsRequestSchema: { method: 'tools/list' },
+  CallToolRequestSchema: { method: 'tools/call' },
+}));
+jest.mock('@/config');
+jest.mock('../src/tools', () => ({
+  getAvailableTools: jest.fn(),
+  getTool: jest.fn(),
+  getMCPMode: jest.fn(() => 'dev'),
+}));
+jest.mock('@/utils/logger');
+
+describe('MCP Server Initialization', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Setup default mocks
+    (getConfig as jest.Mock).mockReturnValue({
+      mcp: {
+        name: 'teamcity-mcp',
+        version: '0.1.0',
+        capabilities: {
+          tools: true,
+          prompts: false,
+          resources: false,
+        },
+      },
+      server: {
+        mode: 'dev',
+      },
+      teamcity: {
+        url: 'https://teamcity.example.com',
+        token: 'test-token',
+      },
+    });
+
+    const defaultTools = [
+      {
+        name: 'ping',
+        description: 'Test connectivity',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            message: { type: 'string' },
+          },
+        },
+        handler: jest.fn(),
+      },
+    ];
+
+    (getAvailableTools as jest.Mock).mockReturnValue(defaultTools);
+
+    // Mock getTool to find tools from the available tools
+    (getTool as jest.Mock).mockImplementation((name: string) => {
+      const tools = (getAvailableTools as jest.Mock)() as ToolDefinition[];
+      return tools.find((tool: ToolDefinition) => tool.name === name);
+    });
+  });
+
+  describe('createMCPServer', () => {
+    it('should create an MCP server instance', () => {
+      const mockServer = {
+        setRequestHandler: jest.fn(),
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      const server = createMCPServer();
+
+      expect(server).toBeDefined();
+    });
+
+    // Removed implementation-detail assertions about handler registration and tool loading
+
+    it('should handle ListToolsRequest', async () => {
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      // Get the list tools handler
+      const listToolsHandler = mockSetRequestHandler.mock.calls[0][1];
+
+      // Call the handler
+      const result = await listToolsHandler();
+
+      expect(result).toEqual({
+        tools: [
+          {
+            name: 'ping',
+            description: 'Test connectivity',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                message: { type: 'string' },
+              },
+            },
+          },
+        ],
+      });
+    });
+
+    it('should handle CallToolRequest for existing tool', async () => {
+      const mockHandler = jest.fn().mockResolvedValue({ success: true, data: { result: 'pong' } });
+      const toolMock = {
+        name: 'ping',
+        description: 'Test connectivity',
+        inputSchema: {},
+        handler: mockHandler,
+      };
+
+      (getAvailableTools as jest.Mock).mockReturnValue([toolMock]);
+      (getTool as jest.Mock).mockImplementation((name: string) => {
+        return name === 'ping' ? toolMock : undefined;
+      });
+
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      // Get the call tool handler
+      const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+
+      // Call the handler
+      const result = await callToolHandler({
+        params: {
+          name: 'ping',
+          arguments: { message: 'test' },
+        },
+      });
+
+      expect(mockHandler).toHaveBeenCalledWith({ message: 'test' });
+      expect(result).toEqual({
+        content: [
+          {
+            type: 'text',
+            text: 'Tool executed successfully',
+          },
+        ],
+      });
+    });
+
+    it('should handle CallToolRequest for non-existing tool', async () => {
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      // Get the call tool handler
+      const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+
+      // Call the handler for non-existing tool
+      await expect(
+        callToolHandler({
+          params: {
+            name: 'non-existing-tool',
+            arguments: {},
+          },
+        })
+      ).rejects.toThrow('Unknown tool: non-existing-tool');
+    });
+  });
+
+  describe('Server Configuration', () => {
+    it('should initialize using configuration without errors', () => {
+      const mockServer = {
+        setRequestHandler: jest.fn(),
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      expect(() => createMCPServer()).not.toThrow();
+    });
+
+    it('should handle disabled capabilities', () => {
+      (getConfig as jest.Mock).mockReturnValue({
+        mcp: {
+          name: 'teamcity-mcp',
+          version: '0.1.0',
+          capabilities: {
+            tools: false,
+            prompts: false,
+            resources: false,
+          },
+        },
+        server: {
+          mode: 'dev',
+        },
+      });
+
+      const mockServer = {
+        setRequestHandler: jest.fn(),
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      expect(() => createMCPServer()).not.toThrow();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle errors in tool execution', async () => {
+      const mockHandler = jest.fn().mockResolvedValue({ success: false, error: 'Tool error' });
+      const toolMock = {
+        name: 'failing-tool',
+        description: 'A tool that fails',
+        inputSchema: {},
+        handler: mockHandler,
+      };
+
+      (getAvailableTools as jest.Mock).mockReturnValue([toolMock]);
+      (getTool as jest.Mock).mockImplementation((name: string) => {
+        return name === 'failing-tool' ? toolMock : undefined;
+      });
+
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+
+      const result = await callToolHandler({
+        params: {
+          name: 'failing-tool',
+          arguments: {},
+        },
+      });
+
+      expect(result).toEqual({
+        content: [
+          {
+            type: 'text',
+            text: 'Tool error',
+          },
+        ],
+      });
+    });
+
+    it('should validate tool input against schema', async () => {
+      const mockHandler = jest.fn();
+      const toolMock = {
+        name: 'validated-tool',
+        description: 'A tool with validation',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            required_field: { type: 'string' },
+          },
+          required: ['required_field'],
+        },
+        handler: mockHandler,
+      };
+
+      (getAvailableTools as jest.Mock).mockReturnValue([toolMock]);
+      (getTool as jest.Mock).mockImplementation((name: string) => {
+        return name === 'validated-tool' ? toolMock : undefined;
+      });
+
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+
+      // Call with invalid input
+      await expect(
+        callToolHandler({
+          params: {
+            name: 'validated-tool',
+            arguments: { wrong_field: 'value' },
+          },
+        })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('Tool Registration', () => {
+    it('should register multiple tools', async () => {
+      (getAvailableTools as jest.Mock).mockReturnValue([
+        {
+          name: 'tool1',
+          description: 'First tool',
+          inputSchema: {},
+          handler: jest.fn(),
+        },
+        {
+          name: 'tool2',
+          description: 'Second tool',
+          inputSchema: {},
+          handler: jest.fn(),
+        },
+        {
+          name: 'tool3',
+          description: 'Third tool',
+          inputSchema: {},
+          handler: jest.fn(),
+        },
+      ]);
+
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      const listToolsHandler = mockSetRequestHandler.mock.calls[0][1];
+      const result = await listToolsHandler();
+
+      expect(result.tools).toHaveLength(3);
+      expect(result.tools.map((t: { name: string }) => t.name)).toEqual([
+        'tool1',
+        'tool2',
+        'tool3',
+      ]);
+    });
+
+    it('should handle empty tool list', async () => {
+      (getAvailableTools as jest.Mock).mockReturnValue([]);
+
+      const mockSetRequestHandler = jest.fn();
+      const mockServer = {
+        setRequestHandler: mockSetRequestHandler,
+      };
+      (Server as jest.Mock).mockImplementation(() => mockServer);
+
+      createMCPServer();
+
+      const listToolsHandler = mockSetRequestHandler.mock.calls[0][1];
+      const result = await listToolsHandler();
+
+      expect(result.tools).toHaveLength(0);
+    });
+  });
+});