@daghis/teamcity-mcp 0.1.2

package/tests/teamcity/errors.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Tests for TeamCity error handling
+ */
+import type { AxiosError } from 'axios';
+
+import {
+  TeamCityAPIError,
+  TeamCityAuthenticationError,
+  TeamCityAuthorizationError,
+  TeamCityNetworkError,
+  TeamCityNotFoundError,
+  TeamCityRateLimitError,
+  TeamCityRequestError,
+  TeamCityServerError,
+  TeamCityTimeoutError,
+  TeamCityValidationError,
+  getRetryDelay,
+  isRetryableError,
+} from '@/teamcity/errors';
+
+describe('TeamCity Error Classes', () => {
+  describe('TeamCityAPIError', () => {
+    it('should create error with all properties', () => {
+      const error = new TeamCityAPIError(
+        'Test error',
+        'TEST_ERROR',
+        500,
+        { detail: 'test' },
+        'req-123',
+        new Error('Original')
+      );
+
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe('TEST_ERROR');
+      expect(error.statusCode).toBe(500);
+      expect(error.details).toEqual({ detail: 'test' });
+      expect(error.requestId).toBe('req-123');
+      expect(error.originalError).toBeDefined();
+      expect(error.name).toBe('TeamCityAPIError');
+    });
+
+    it('should create from Axios error with response', () => {
+      const axiosError = {
+        response: {
+          status: 404,
+          data: {
+            code: 'NOT_FOUND',
+            message: 'Resource not found',
+          },
+        },
+        message: 'Not found',
+      } as AxiosError;
+
+      const error = TeamCityAPIError.fromAxiosError(axiosError, 'req-456');
+
+      expect(error.code).toBe('NOT_FOUND');
+      expect(error.message).toBe('Resource not found');
+      expect(error.statusCode).toBe(404);
+      expect(error.requestId).toBe('req-456');
+    });
+
+    it('should create from Axios error without response', () => {
+      const axiosError = {
+        request: {},
+        message: 'Network error',
+      } as AxiosError;
+
+      const error = TeamCityAPIError.fromAxiosError(axiosError, 'req-789');
+
+      expect(error).toBeInstanceOf(TeamCityNetworkError);
+      expect(error.message).toBe('Network error');
+      expect(error.requestId).toBe('req-789');
+    });
+
+    it('should create from Axios error without request', () => {
+      const axiosError = {
+        message: 'Config error',
+      } as AxiosError;
+
+      const error = TeamCityAPIError.fromAxiosError(axiosError, 'req-000');
+
+      expect(error).toBeInstanceOf(TeamCityRequestError);
+      expect(error.message).toBe('Config error');
+      expect(error.requestId).toBe('req-000');
+    });
+
+    it('should serialize to JSON', () => {
+      const error = new TeamCityAPIError('Test', 'TEST', 500, { foo: 'bar' }, 'req-123');
+      const json = error.toJSON();
+
+      expect(json).toHaveProperty('name', 'TeamCityAPIError');
+      expect(json).toHaveProperty('code', 'TEST');
+      expect(json).toHaveProperty('message', 'Test');
+      expect(json).toHaveProperty('statusCode', 500);
+      expect(json).toHaveProperty('details', { foo: 'bar' });
+      expect(json).toHaveProperty('requestId', 'req-123');
+      expect(json).toHaveProperty('stack');
+    });
+  });
+
+  describe('Specific Error Classes', () => {
+    it('should create TeamCityAuthenticationError', () => {
+      const error = new TeamCityAuthenticationError('Invalid token', 'req-123');
+
+      expect(error.name).toBe('TeamCityAuthenticationError');
+      expect(error.code).toBe('AUTHENTICATION_ERROR');
+      expect(error.statusCode).toBe(401);
+      expect(error.message).toBe('Invalid token');
+    });
+
+    it('should create TeamCityAuthorizationError', () => {
+      const error = new TeamCityAuthorizationError('Forbidden', 'req-123');
+
+      expect(error.name).toBe('TeamCityAuthorizationError');
+      expect(error.code).toBe('AUTHORIZATION_ERROR');
+      expect(error.statusCode).toBe(403);
+    });
+
+    it('should create TeamCityNotFoundError', () => {
+      const error = new TeamCityNotFoundError('Build', '123', 'req-123');
+
+      expect(error.name).toBe('TeamCityNotFoundError');
+      expect(error.code).toBe('NOT_FOUND');
+      expect(error.statusCode).toBe(404);
+      expect(error.message).toBe("Build with identifier '123' not found");
+    });
+
+    it('should create TeamCityValidationError', () => {
+      const validationErrors = [
+        { field: 'name', message: 'Name is required' },
+        { field: 'email', message: 'Invalid email' },
+      ];
+      const error = new TeamCityValidationError(validationErrors, 'req-123');
+
+      expect(error.name).toBe('TeamCityValidationError');
+      expect(error.code).toBe('VALIDATION_ERROR');
+      expect(error.statusCode).toBe(400);
+      expect(error.message).toBe('Validation failed: Name is required, Invalid email');
+      expect(error.validationErrors).toEqual(validationErrors);
+    });
+
+    it('should create TeamCityRateLimitError', () => {
+      const error = new TeamCityRateLimitError(60, 'req-123');
+
+      expect(error.name).toBe('TeamCityRateLimitError');
+      expect(error.code).toBe('RATE_LIMIT_ERROR');
+      expect(error.statusCode).toBe(429);
+      expect(error.message).toBe('Rate limit exceeded. Retry after 60 seconds');
+      expect(error.retryAfter).toBe(60);
+    });
+
+    it('should create TeamCityServerError', () => {
+      const error = new TeamCityServerError('Internal error', 503, 'req-123');
+
+      expect(error.name).toBe('TeamCityServerError');
+      expect(error.code).toBe('SERVER_ERROR');
+      expect(error.statusCode).toBe(503);
+    });
+
+    it('should create TeamCityTimeoutError', () => {
+      const error = new TeamCityTimeoutError(30000, 'req-123');
+
+      expect(error.name).toBe('TeamCityTimeoutError');
+      expect(error.code).toBe('TIMEOUT_ERROR');
+      expect(error.message).toBe('Request timed out after 30000ms');
+    });
+  });
+
+  describe('isRetryableError', () => {
+    it('should identify retryable errors', () => {
+      expect(isRetryableError(new TeamCityNetworkError())).toBe(true);
+      expect(isRetryableError(new TeamCityTimeoutError(30000))).toBe(true);
+      expect(isRetryableError(new TeamCityServerError())).toBe(true);
+      expect(isRetryableError(new TeamCityRateLimitError())).toBe(true);
+      expect(isRetryableError(new TeamCityAPIError('', '', 503))).toBe(true);
+    });
+
+    it('should identify non-retryable errors', () => {
+      expect(isRetryableError(new TeamCityAuthenticationError())).toBe(false);
+      expect(isRetryableError(new TeamCityAuthorizationError())).toBe(false);
+      expect(isRetryableError(new TeamCityNotFoundError('Build'))).toBe(false);
+      expect(isRetryableError(new TeamCityValidationError([]))).toBe(false);
+      expect(isRetryableError(new TeamCityRequestError())).toBe(false);
+      expect(isRetryableError(new Error('Generic error'))).toBe(false);
+    });
+  });
+
+  describe('getRetryDelay', () => {
+    it('should use retry-after for rate limit errors', () => {
+      const error = new TeamCityRateLimitError(120);
+      const delay = getRetryDelay(error, 1);
+
+      expect(delay).toBe(120000); // 120 seconds in ms
+    });
+
+    it('should use exponential backoff for other errors', () => {
+      const error = new TeamCityServerError();
+
+      const delay1 = getRetryDelay(error, 1, 1000);
+      const delay2 = getRetryDelay(error, 2, 1000);
+      const delay3 = getRetryDelay(error, 3, 1000);
+
+      // Base delays should be 1000, 2000, 4000 (plus jitter)
+      expect(delay1).toBeGreaterThanOrEqual(1000);
+      expect(delay1).toBeLessThanOrEqual(2000);
+
+      expect(delay2).toBeGreaterThanOrEqual(2000);
+      expect(delay2).toBeLessThanOrEqual(3000);
+
+      expect(delay3).toBeGreaterThanOrEqual(4000);
+      expect(delay3).toBeLessThanOrEqual(5000);
+    });
+
+    it('should cap delay at 30 seconds', () => {
+      const error = new TeamCityServerError();
+      const delay = getRetryDelay(error, 10, 1000); // Very high attempt number
+
+      expect(delay).toBeLessThanOrEqual(30000);
+    });
+  });
+});

package/tests/test-utils/mock-logger.ts

@@ -0,0 +1,15 @@
+import type { Logger } from 'winston';
+
+export function createMockLogger(): Logger {
+  return {
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+    http: jest.fn(),
+    verbose: jest.fn(),
+    debug: jest.fn(),
+    silly: jest.fn(),
+    log: jest.fn(),
+    // Add other Logger methods as needed
+  } as unknown as Logger;
+}

package/tests/test-utils/mock-teamcity-client.ts

@@ -0,0 +1,403 @@
+/**
+ * Type-safe mock utilities for TeamCity client testing
+ *
+ * Provides properly typed mock implementations that match the real TeamCityClient
+ * structure, eliminating the need for dangerous type assertions.
+ */
+import type { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+
+import type { BuildApi } from '@/teamcity-client/api/build-api';
+import type { BuildQueueApi } from '@/teamcity-client/api/build-queue-api';
+import type { BuildTypeApi } from '@/teamcity-client/api/build-type-api';
+import type { ProjectApi } from '@/teamcity-client/api/project-api';
+import type { TestOccurrenceApi } from '@/teamcity-client/api/test-occurrence-api';
+import type { VcsRootApi } from '@/teamcity-client/api/vcs-root-api';
+import type {
+  TeamCityBuildTypeResponse,
+  TeamCityProjectResponse,
+  TeamCityStepsResponse,
+  TeamCityTriggersResponse,
+} from '@/teamcity/api-types';
+import type { TeamCityClient } from '@/teamcity/client';
+
+/**
+ * Mock interface for BuildTypeApi with commonly used methods
+ */
+export interface MockBuildTypeApi extends Partial<InstanceType<typeof BuildTypeApi>> {
+  getAllBuildTypes: jest.Mock;
+  getBuildType: jest.Mock;
+  createBuildType: jest.Mock;
+  updateBuildType: jest.Mock;
+  deleteBuildType: jest.Mock;
+  setBuildTypeField: jest.Mock;
+  deleteBuildParameterOfBuildType: jest.Mock;
+}
+
+/**
+ * Mock interface for ProjectApi with commonly used methods
+ */
+export interface MockProjectApi extends Partial<InstanceType<typeof ProjectApi>> {
+  getAllProjects: jest.Mock;
+  getProject: jest.Mock;
+  createProject: jest.Mock;
+  updateProject: jest.Mock;
+  deleteProject: jest.Mock;
+}
+
+/**
+ * Mock interface for BuildApi with commonly used methods
+ */
+export interface MockBuildApi extends Partial<InstanceType<typeof BuildApi>> {
+  getAllBuilds: jest.Mock;
+  getMultipleBuilds: jest.Mock;
+  getBuild: jest.Mock;
+  triggerBuild: jest.Mock;
+  cancelBuild: jest.Mock;
+}
+
+/**
+ * Mock interface for BuildQueueApi with commonly used methods
+ */
+export interface MockBuildQueueApi extends Partial<InstanceType<typeof BuildQueueApi>> {
+  addBuildToQueue: jest.Mock;
+  getBuildQueue: jest.Mock;
+  cancelQueuedBuild: jest.Mock;
+}
+
+/**
+ * Mock interface for VcsRootApi with commonly used methods
+ */
+export interface MockVcsRootApi extends Partial<InstanceType<typeof VcsRootApi>> {
+  getAllVcsRoots: jest.Mock;
+  getVcsRoot: jest.Mock;
+}
+
+/**
+ * Mock interface for TestOccurrenceApi with commonly used methods
+ */
+export interface MockTestOccurrenceApi extends Partial<InstanceType<typeof TestOccurrenceApi>> {
+  getAllTestOccurrences: jest.Mock;
+  getTestOccurrence: jest.Mock;
+}
+
+/**
+ * Properly typed mock TeamCityClient class that matches the real client structure
+ */
+export class MockTeamCityClient {
+  public buildTypes: MockBuildTypeApi;
+  public projects: MockProjectApi;
+  public builds: MockBuildApi;
+  public buildQueue: MockBuildQueueApi;
+  public vcsRoots: MockVcsRootApi;
+  public changes: unknown;
+  public tests: unknown;
+  public testOccurrences: MockTestOccurrenceApi;
+  public users: unknown;
+  public agents: unknown;
+  public agentPools: unknown;
+
+  constructor() {
+    // Initialize BuildTypeApi mock
+    this.buildTypes = {
+      getAllBuildTypes: jest.fn(),
+      getBuildType: jest.fn(),
+      createBuildType: jest.fn(),
+      updateBuildType: jest.fn(),
+      deleteBuildType: jest.fn(),
+      setBuildTypeField: jest.fn(),
+      deleteBuildParameterOfBuildType: jest.fn(),
+    } as MockBuildTypeApi;
+
+    // Initialize ProjectApi mock
+    this.projects = {
+      getAllProjects: jest.fn(),
+      getProject: jest.fn(),
+      createProject: jest.fn(),
+      updateProject: jest.fn(),
+      deleteProject: jest.fn(),
+    } as MockProjectApi;
+
+    // Initialize BuildApi mock
+    this.builds = {
+      getAllBuilds: jest.fn(),
+      getMultipleBuilds: jest.fn(),
+      getBuild: jest.fn(),
+      triggerBuild: jest.fn(),
+      cancelBuild: jest.fn(),
+    } as MockBuildApi;
+
+    // Initialize BuildQueueApi mock
+    this.buildQueue = {
+      addBuildToQueue: jest.fn(),
+      getBuildQueue: jest.fn(),
+      cancelQueuedBuild: jest.fn(),
+    } as MockBuildQueueApi;
+
+    // Initialize VcsRootApi mock
+    this.vcsRoots = {
+      getAllVcsRoots: jest.fn(),
+      getVcsRoot: jest.fn(),
+    } as MockVcsRootApi;
+
+    // Initialize TestOccurrenceApi mock
+    this.testOccurrences = {
+      getAllTestOccurrences: jest.fn(),
+      getTestOccurrence: jest.fn(),
+    } as MockTestOccurrenceApi;
+
+    // Initialize other APIs as empty objects (can be extended as needed)
+    this.changes = {};
+    this.tests = {};
+    this.users = {};
+    this.agents = {};
+    this.agentPools = {};
+  }
+
+  /**
+   * Mock testConnection method
+   */
+  async testConnection(): Promise<boolean> {
+    return true;
+  }
+
+  /**
+   * Reset all mock functions
+   */
+  resetAllMocks(): void {
+    Object.values(this).forEach((api) => {
+      if (typeof api === 'object' && api !== null) {
+        Object.values(api).forEach((method) => {
+          if (typeof method === 'function' && 'mockReset' in method) {
+            (method as jest.Mock).mockReset();
+          }
+        });
+      }
+    });
+  }
+
+  /**
+   * Clear all mock calls but keep implementations
+   */
+  clearAllMocks(): void {
+    Object.values(this).forEach((api) => {
+      if (typeof api === 'object' && api !== null) {
+        Object.values(api).forEach((method) => {
+          if (typeof method === 'function' && 'mockClear' in method) {
+            (method as jest.Mock).mockClear();
+          }
+        });
+      }
+    });
+  }
+}
+
+/**
+ * Create a fully typed mock TeamCity client
+ * This returns both MockTeamCityClient and TeamCityClient types for flexibility
+ */
+export function createMockTeamCityClient(): MockTeamCityClient & TeamCityClient {
+  return new MockTeamCityClient() as MockTeamCityClient & TeamCityClient;
+}
+
+/**
+ * Create a type-safe mock Axios instance (kept for backward compatibility)
+ */
+export function createMockAxiosInstance(): jest.Mocked<AxiosInstance> {
+  return {
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+    patch: jest.fn(),
+    head: jest.fn(),
+    options: jest.fn(),
+    request: jest.fn(),
+    getUri: jest.fn(),
+    defaults: {
+      headers: {
+        common: {},
+        delete: {},
+        get: {},
+        head: {},
+        post: {},
+        put: {},
+        patch: {},
+      },
+      baseURL: 'http://teamcity.example.com',
+      timeout: 30000,
+      transformRequest: [],
+      transformResponse: [],
+      validateStatus: jest.fn(),
+    },
+    interceptors: {
+      request: {
+        use: jest.fn(),
+        eject: jest.fn(),
+        clear: jest.fn(),
+      },
+      response: {
+        use: jest.fn(),
+        eject: jest.fn(),
+        clear: jest.fn(),
+      },
+    },
+  } as unknown as jest.Mocked<AxiosInstance>;
+}
+
+/**
+ * Create a mock Axios response with proper typing
+ */
+export function createMockAxiosResponse<T>(data: T, status = 200): AxiosResponse<T> {
+  return {
+    data,
+    status,
+    statusText: 'OK',
+    headers: {},
+    config: {} as InternalAxiosRequestConfig,
+  };
+}
+
+/**
+ * Type-safe mock factory for build triggers
+ */
+export function createMockTriggerResponse(
+  overrides?: Partial<TeamCityTriggersResponse>
+): TeamCityTriggersResponse {
+  return {
+    count: 0,
+    trigger: [],
+    ...overrides,
+  };
+}
+
+/**
+ * Type-safe mock factory for build steps
+ */
+export function createMockStepsResponse(
+  overrides?: Partial<TeamCityStepsResponse>
+): TeamCityStepsResponse {
+  return {
+    count: 0,
+    step: [],
+    ...overrides,
+  };
+}
+
+/**
+ * Type-safe mock factory for build types
+ */
+export function createMockBuildTypeResponse(
+  overrides?: Partial<TeamCityBuildTypeResponse>
+): TeamCityBuildTypeResponse {
+  return {
+    id: 'MockProject_Build',
+    name: 'Mock Build',
+    projectId: 'MockProject',
+    ...overrides,
+  };
+}
+
+/**
+ * Type-safe mock factory for projects
+ */
+export function createMockProjectResponse(
+  overrides?: Partial<TeamCityProjectResponse>
+): TeamCityProjectResponse {
+  return {
+    id: 'MockProject',
+    name: 'Mock Project',
+    ...overrides,
+  };
+}
+
+/**
+ * Helper to setup common mock responses
+ */
+export function setupCommonMockResponses(mockClient: MockTeamCityClient): void {
+  // Setup default successful responses
+  mockClient.buildTypes.getAllBuildTypes.mockResolvedValue(
+    createMockAxiosResponse({
+      count: 0,
+      buildType: [],
+    })
+  );
+
+  mockClient.projects.getAllProjects.mockResolvedValue(
+    createMockAxiosResponse({
+      count: 0,
+      project: [],
+    })
+  );
+
+  mockClient.builds.getAllBuilds.mockResolvedValue(
+    createMockAxiosResponse({
+      count: 0,
+      build: [],
+    })
+  );
+}
+
+/**
+ * Helper to setup error responses
+ */
+export function setupErrorResponse(mockFn: jest.Mock, status: number, message = 'API Error'): void {
+  mockFn.mockRejectedValue({
+    response: {
+      status,
+      data: { message },
+    },
+  });
+}
+
+/**
+ * Type guard for checking if a value is a mock function
+ */
+export function isMockFunction<T extends (...args: never[]) => unknown>(
+  fn: T | jest.MockedFunction<T>
+): fn is jest.MockedFunction<T> {
+  return 'mockClear' in fn && typeof fn.mockClear === 'function';
+}
+
+/**
+ * Assertion helper for verifying API calls
+ */
+export function expectApiCall(
+  mockFn: jest.Mock,
+  expectedPath: string,
+  expectedParams?: Record<string, unknown>
+): void {
+  expect(mockFn).toHaveBeenCalledWith(
+    expectedPath,
+    expectedParams ? expect.objectContaining({ params: expectedParams }) : undefined
+  );
+}
+
+/**
+ * Type assertion helper that validates a mock client has the TeamCityClient shape
+ * This provides runtime validation that our mock matches the interface
+ */
+export function assertIsValidTeamCityClient(client: unknown): asserts client is TeamCityClient {
+  const c = client as Record<string, unknown>;
+
+  // Check for required API properties
+  const requiredApis = ['buildTypes', 'projects', 'builds', 'buildQueue', 'vcsRoots'] as const;
+  for (const api of requiredApis) {
+    if (!(api in c)) {
+      throw new Error(`Mock client missing required API: ${api}`);
+    }
+  }
+
+  // Check for required methods on buildTypes
+  const buildTypesVal = c['buildTypes'];
+  if (typeof buildTypesVal !== 'object' || buildTypesVal === null) {
+    throw new Error('Mock client buildTypes must be an object');
+  }
+  const bt = buildTypesVal as Record<string, unknown>;
+  const requiredBuildTypeMethods = ['getAllBuildTypes', 'getBuildType'] as const;
+  for (const method of requiredBuildTypeMethods) {
+    const m = bt[method];
+    if (typeof m !== 'function') {
+      throw new Error(`Mock buildTypes missing required method: ${method}`);
+    }
+  }
+}