@daghis/teamcity-mcp 0.1.2 → 0.1.3

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

@@ -1,80 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,122 +0,0 @@
-/**
- * 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

@@ -1,378 +0,0 @@
-/**
- * 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);
-    });
-  });
-});