@daghis/teamcity-mcp 0.1.2

package/tests/unit/tools/list-pagination-all.test.ts

@@ -0,0 +1,259 @@
+// Dev mode is fine for list tools
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'dev',
+}));
+
+function parseCount(locator?: string): { count: number; start: number } {
+  const loc = locator ?? '';
+  const mCount = loc.match(/count:(\d+)/) as RegExpMatchArray | null;
+  const mStart = loc.match(/start:(\d+)/) as RegExpMatchArray | null;
+  return {
+    count: mCount ? parseInt(mCount[1] as string, 10) : 100,
+    start: mStart ? parseInt(mStart[1] as string, 10) : 0,
+  };
+}
+
+describe('tools: list pagination with all=true', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('list_projects fetches all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const total = 5;
+          const data = Array.from({ length: total }, (_, i) => ({ id: `P${i + 1}` }));
+          const getAllProjects = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = data.slice(start, start + count);
+            return { data: { project: slice, count: total } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ projects: { getAllProjects } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_projects').handler({
+            all: true,
+            pageSize: 2,
+            fields: '$short',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(total);
+          const gotIds = (payload.items as Array<{ id: string }>).map((p) => p.id).sort();
+          const expectedIds = data.map((p) => p.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_build_configs fetches all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const total = 5;
+          const data = Array.from({ length: total }, (_, i) => ({ id: `BT${i + 1}` }));
+          const getAllBuildTypes = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = data.slice(start, start + count);
+            return { data: { buildType: slice, count: total } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ buildTypes: { getAllBuildTypes } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_build_configs').handler({
+            all: true,
+            pageSize: 2,
+            fields: '$short',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(total);
+          const gotIds = (payload.items as Array<{ id: string }>).map((b) => b.id).sort();
+          const expectedIds = data.map((b) => b.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_builds fetches all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const total = 5;
+          const data = Array.from({ length: total }, (_, i) => ({ id: i + 1 }));
+          const getAllBuilds = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = data.slice(start, start + count);
+            return { data: { build: slice, count: total } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ builds: { getAllBuilds } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_builds').handler({
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(total);
+          const gotIds = (payload.items as Array<{ id: number }>).map((b) => b.id).sort();
+          const expectedIds = data.map((b) => b.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_agents and list_agent_pools fetch all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const totalAgents = 4;
+          const agentsData = Array.from({ length: totalAgents }, (_, i) => ({ id: `${i + 1}` }));
+          const getAllAgents = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = agentsData.slice(start, start + count);
+            return { data: { agent: slice, count: totalAgents } };
+          });
+          const totalPools = 3;
+          const poolsData = Array.from({ length: totalPools }, (_, i) => ({ id: `${i + 1}` }));
+          const getAllAgentPools = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = poolsData.slice(start, start + count);
+            return { data: { agentPool: slice, count: totalPools } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ agents: { getAllAgents }, agentPools: { getAllAgentPools } }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('list_agents').handler({
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(totalAgents);
+          let gotIds = (payload.items as Array<{ id: string }>).map((a) => a.id).sort();
+          let expectedIds = agentsData.map((a) => a.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+
+          res = await getRequiredTool('list_agent_pools').handler({
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(totalPools);
+          gotIds = (payload.items as Array<{ id: string }>).map((p) => p.id).sort();
+          expectedIds = poolsData.map((p) => p.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_vcs_roots and list_queued_builds fetch all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const totalRoots = 4;
+          const rootsData = Array.from({ length: totalRoots }, (_, i) => ({ id: `V${i + 1}` }));
+          const getAllVcsRoots = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = rootsData.slice(start, start + count);
+            return { data: { 'vcs-root': slice, count: totalRoots } };
+          });
+          const totalQueue = 5;
+          const queueData = Array.from({ length: totalQueue }, (_, i) => ({ id: i + 1 }));
+          const getAllQueuedBuilds = jest.fn(async (locator?: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = queueData.slice(start, start + count);
+            return { data: { build: slice, count: totalQueue } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                vcsRoots: { getAllVcsRoots },
+                buildQueue: { getAllQueuedBuilds },
+              }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('list_vcs_roots').handler({
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(totalRoots);
+          const gotIds = (payload.items as Array<{ id: string }>).map((v) => v.id).sort();
+          const expectedIds = rootsData.map((v) => v.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+
+          res = await getRequiredTool('list_queued_builds').handler({
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(totalQueue);
+          const gotBuildIds = (payload.items as Array<{ id: number }>).map((b) => b.id).sort();
+          const expectedBuildIds = queueData.map((b) => b.id).sort();
+          expect(gotBuildIds).toEqual(expectedBuildIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_test_failures fetches all pages', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const total = 5;
+          const data = Array.from({ length: total }, (_, i) => ({ id: `T${i + 1}` }));
+          const getAllTestOccurrences = jest.fn(async (locator: string) => {
+            const { count, start } = parseCount(locator);
+            const slice = data.slice(start, start + count);
+            return { data: { testOccurrence: slice, count: total } };
+          });
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ tests: { getAllTestOccurrences } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_test_failures').handler({
+            buildId: 'b1',
+            all: true,
+            pageSize: 2,
+            fields: 'id',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items.length).toBe(total);
+          const gotIds = (payload.items as Array<{ id: string }>).map((t) => t.id).sort();
+          const expectedIds = data.map((t) => t.id).sort();
+          expect(gotIds).toEqual(expectedIds);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/list-projects-pagination.test.ts

@@ -0,0 +1,39 @@
+import { getRequiredTool } from '@/tools';
+
+// Mock TeamCityAPI to simulate paginated project listings
+jest.mock('@/api-client', () => {
+  const getAllProjects = jest.fn((locator?: string) => {
+    const startMatch = locator?.match(/start:(\d+)/);
+    const countMatch = locator?.match(/count:(\d+)/);
+    const start = startMatch?.[1] ? parseInt(startMatch[1], 10) : 0;
+    const count = countMatch?.[1] ? parseInt(countMatch[1], 10) : 100;
+
+    const all = Array.from({ length: 5 }, (_, i) => ({ id: `p${i + 1}` }));
+    const slice = all.slice(start, Math.min(start + count, all.length));
+    return Promise.resolve({ data: { project: slice, count: all.length } });
+  });
+
+  return {
+    TeamCityAPI: {
+      getInstance: () => ({
+        projects: { getAllProjects },
+      }),
+    },
+  };
+});
+
+describe('list_projects pagination', () => {
+  it('returns first page with pageSize', async () => {
+    const res = await getRequiredTool('list_projects').handler({ pageSize: 2 });
+    const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+    expect(payload.items).toHaveLength(2);
+    expect(payload.pagination.page).toBe(1);
+  });
+
+  it('fetches all pages when all=true', async () => {
+    const res = await getRequiredTool('list_projects').handler({ pageSize: 2, all: true });
+    const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+    expect(payload.items).toHaveLength(5);
+    expect(payload.pagination.mode).toBe('all');
+  });
+});

package/tests/unit/tools/parameters-and-steps-triggers.test.ts

@@ -0,0 +1,176 @@
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: parameters, steps, triggers', () => {
+  it('add/update/delete parameter call respective endpoints', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const createBuildParameterOfBuildType = jest.fn(async () => ({}));
+          const updateBuildParameterOfBuildType = jest.fn(async () => ({}));
+          const deleteBuildParameterOfBuildType = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                buildTypes: {
+                  createBuildParameterOfBuildType,
+                  updateBuildParameterOfBuildType,
+                  deleteBuildParameterOfBuildType,
+                },
+              }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('add_parameter').handler({
+            buildTypeId: 'bt',
+            name: 'k',
+            value: 'v',
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'add_parameter',
+            buildTypeId: 'bt',
+            name: 'k',
+          });
+
+          res = await getRequiredTool('update_parameter').handler({
+            buildTypeId: 'bt',
+            name: 'k',
+            value: 'v2',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'update_parameter',
+            buildTypeId: 'bt',
+            name: 'k',
+          });
+
+          res = await getRequiredTool('delete_parameter').handler({ buildTypeId: 'bt', name: 'k' });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'delete_parameter',
+            buildTypeId: 'bt',
+            name: 'k',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('manage_build_steps add/update/delete', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const addBuildStepToBuildType = jest.fn(async () => ({}));
+          const setBuildStepParameter = jest.fn(async () => ({}));
+          const deleteBuildStep = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                buildTypes: { addBuildStepToBuildType, setBuildStepParameter, deleteBuildStep },
+              }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('manage_build_steps').handler({
+            buildTypeId: 'bt',
+            action: 'add',
+            name: 'Run',
+            type: 'simpleRunner',
+            properties: { 'script.content': 'echo hi' },
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'add_build_step',
+            buildTypeId: 'bt',
+          });
+
+          res = await getRequiredTool('manage_build_steps').handler({
+            buildTypeId: 'bt',
+            action: 'update',
+            stepId: 'S1',
+            properties: { a: 1, b: '2' },
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'update_build_step',
+            buildTypeId: 'bt',
+            stepId: 'S1',
+          });
+
+          res = await getRequiredTool('manage_build_steps').handler({
+            buildTypeId: 'bt',
+            action: 'delete',
+            stepId: 'S1',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'delete_build_step',
+            buildTypeId: 'bt',
+            stepId: 'S1',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('manage_build_triggers add/delete', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const addTriggerToBuildType = jest.fn(async () => ({}));
+          const deleteTrigger = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ buildTypes: { addTriggerToBuildType, deleteTrigger } }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('manage_build_triggers').handler({
+            buildTypeId: 'bt',
+            action: 'add',
+            type: 'vcsTrigger',
+            properties: { branchFilter: '+:*' },
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'add_build_trigger',
+            buildTypeId: 'bt',
+          });
+
+          res = await getRequiredTool('manage_build_triggers').handler({
+            buildTypeId: 'bt',
+            action: 'delete',
+            triggerId: 'T1',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'delete_build_trigger',
+            buildTypeId: 'bt',
+            triggerId: 'T1',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/project-build-crud.test.ts

@@ -0,0 +1,110 @@
+// Full mode for write tools
+// Use required tool helper to avoid undefined checks
+
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: project/build CRUD & updates', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('create_project and delete_project return structured JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const addProject = jest.fn(async () => ({ data: { id: 'P1' } }));
+          const deleteProject = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ projects: { addProject, deleteProject } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('create_project').handler({ name: 'Proj', id: 'P1' });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({ success: true, action: 'create_project', id: 'P1' });
+
+          res = await getRequiredTool('delete_project').handler({ projectId: 'P1' });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({ success: true, action: 'delete_project', id: 'P1' });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('create_build_config and clone_build_config return structured JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const createBuildType = jest.fn(async () => ({ data: { id: 'BT_NEW' } }));
+          const getBuildType = jest.fn(async () => ({ id: 'BT_SRC', project: { id: 'P1' } }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ buildTypes: { createBuildType }, getBuildType }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          let res = await getRequiredTool('create_build_config').handler({
+            projectId: 'P1',
+            name: 'Build',
+            id: 'BT_NEW',
+          });
+          let payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'create_build_config',
+            id: 'BT_NEW',
+          });
+
+          res = await getRequiredTool('clone_build_config').handler({
+            sourceBuildTypeId: 'BT_SRC',
+            name: 'Clone',
+            id: 'BT_CLONE',
+          });
+          payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'clone_build_config',
+            id: 'BT_NEW',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('update_build_config sets fields and returns structured JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const setBuildTypeField = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ buildTypes: { setBuildTypeField } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('update_build_config').handler({
+            buildTypeId: 'BT1',
+            name: 'New Name',
+            description: 'Desc',
+            paused: true,
+            artifactRules: 'artifacts/*.tgz',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'update_build_config',
+            id: 'BT1',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/project-hierarchy.test.ts

@@ -0,0 +1,46 @@
+import { getRequiredTool } from '@/tools';
+
+// Mock TeamCityAPI to simulate a small project tree
+jest.mock('@/api-client', () => {
+  type Project = {
+    id: string;
+    name: string;
+    projects: { project: Array<{ id: string; name: string }> };
+  };
+  const projects: Record<string, Project> = {
+    _Root: {
+      id: '_Root',
+      name: 'Root',
+      projects: {
+        project: [
+          { id: 'A', name: 'Alpha' },
+          { id: 'B', name: 'Beta' },
+        ],
+      },
+    },
+    A: { id: 'A', name: 'Alpha', projects: { project: [{ id: 'A1', name: 'Alpha One' }] } },
+    B: { id: 'B', name: 'Beta', projects: { project: [] } },
+    A1: { id: 'A1', name: 'Alpha One', projects: { project: [] } },
+  };
+
+  return {
+    TeamCityAPI: {
+      getInstance: () => ({
+        projects: {
+          getProject: async (id: string) => ({ data: projects[id] }),
+        },
+      }),
+    },
+  };
+});
+
+describe('list_project_hierarchy', () => {
+  it('walks the tree and returns children for root', async () => {
+    const res = await getRequiredTool('list_project_hierarchy').handler({});
+    const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+    expect(payload.children).toEqual([
+      { id: 'A', name: 'Alpha' },
+      { id: 'B', name: 'Beta' },
+    ]);
+  });
+});