@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/teamcity/errors.test.ts

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

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

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