@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/teamcity/auth.test.ts

@@ -1,276 +0,0 @@
-/**
- * Tests for TeamCity authentication utilities
- */
-import {
-  type AxiosError,
-  type AxiosResponse,
-  AxiosHeaders as Headers,
-  type InternalAxiosRequestConfig,
-} from 'axios';
-
-import {
-  addRequestId,
-  extractErrorDetails,
-  generateRequestId,
-  logAndTransformError,
-  logResponse,
-  validateConfiguration,
-  validateServerUrl,
-  validateToken,
-} from '@/teamcity/auth';
-import * as logger from '@/utils/logger';
-
-// Mock the logger
-jest.mock('@/utils/logger', () => ({
-  info: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-}));
-
-describe('TeamCity Authentication Utilities', () => {
-  describe('generateRequestId', () => {
-    it('should generate a unique UUID', () => {
-      const id1 = generateRequestId();
-      const id2 = generateRequestId();
-
-      expect(id1).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-      expect(id2).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-      expect(id1).not.toBe(id2);
-    });
-  });
-
-  describe('addRequestId', () => {
-    it('should add request ID to headers and config', () => {
-      const config: InternalAxiosRequestConfig = {
-        url: '/test',
-        method: 'get',
-        headers: new Headers(),
-      };
-
-      const result = addRequestId(config);
-
-      expect(result.headers['X-Request-ID']).toBeDefined();
-      expect(result.headers['X-Request-ID']).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-      );
-      expect((result as unknown as { requestId?: string }).requestId).toBe(
-        result.headers['X-Request-ID']
-      );
-    });
-
-    it('should log request with redacted authorization', () => {
-      const { info } = logger;
-      const headers = new Headers();
-      headers.set('Authorization', 'Bearer secret-token');
-      const config: InternalAxiosRequestConfig = {
-        url: '/test',
-        method: 'get',
-        headers,
-      };
-
-      addRequestId(config);
-
-      expect(info).toHaveBeenCalledWith(
-        'Starting TeamCity API request',
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: '[REDACTED]',
-          }),
-        })
-      );
-    });
-  });
-
-  describe('extractErrorDetails', () => {
-    it('should extract details from response error', () => {
-      const error = {
-        config: { requestId: 'test-123' },
-        response: {
-          status: 404,
-          data: {
-            code: 'NOT_FOUND',
-            message: 'Resource not found',
-            details: 'Build with ID 123 not found',
-          },
-        },
-        message: 'Not Found',
-      } as unknown as AxiosError;
-
-      const result = extractErrorDetails(error);
-
-      expect(result).toEqual({
-        code: 'NOT_FOUND',
-        message: 'Resource not found',
-        details: 'Build with ID 123 not found',
-        requestId: 'test-123',
-        statusCode: 404,
-        originalError: error,
-      });
-    });
-
-    it('should handle network errors', () => {
-      const error = {
-        config: { requestId: 'test-456' },
-        request: {},
-        message: 'Network Error',
-      } as unknown as AxiosError;
-
-      const result = extractErrorDetails(error);
-
-      expect(result).toEqual({
-        code: 'NO_RESPONSE',
-        message: 'No response received from TeamCity server',
-        details: 'Network Error',
-        requestId: 'test-456',
-        originalError: error,
-      });
-    });
-
-    it('should handle request setup errors', () => {
-      const error = {
-        config: { requestId: 'test-789' },
-        message: 'Invalid URL',
-      } as unknown as AxiosError;
-
-      const result = extractErrorDetails(error);
-
-      expect(result).toEqual({
-        code: 'REQUEST_SETUP_ERROR',
-        message: 'Error setting up the request',
-        details: 'Invalid URL',
-        requestId: 'test-789',
-        originalError: error,
-      });
-    });
-  });
-
-  describe('validateToken', () => {
-    it('should accept valid tokens', () => {
-      expect(validateToken('abc123')).toBe(true);
-      expect(validateToken('ABC-123_456')).toBe(true);
-      expect(validateToken('dXNlcjpwYXNzd29yZA==')).toBe(true); // Base64
-    });
-
-    it('should reject invalid tokens', () => {
-      expect(validateToken('')).toBe(false);
-      expect(validateToken('token with spaces')).toBe(false);
-      expect(validateToken('token@with#invalid$chars')).toBe(false);
-    });
-  });
-
-  describe('validateServerUrl', () => {
-    it('should accept valid URLs', () => {
-      expect(validateServerUrl('https://teamcity.example.com')).toBe(true);
-      expect(validateServerUrl('http://localhost:8111')).toBe(true);
-      expect(validateServerUrl('https://tc.company.net:8443')).toBe(true);
-    });
-
-    it('should reject invalid URLs', () => {
-      expect(validateServerUrl('')).toBe(false);
-      expect(validateServerUrl('not-a-url')).toBe(false);
-      expect(validateServerUrl('ftp://teamcity.com')).toBe(false);
-      expect(validateServerUrl('teamcity.com')).toBe(false); // Missing protocol
-    });
-  });
-
-  describe('validateConfiguration', () => {
-    it('should validate correct configuration', () => {
-      const result = validateConfiguration('https://teamcity.example.com', 'valid-token-123');
-
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should report invalid URL', () => {
-      const result = validateConfiguration('invalid-url', 'valid-token-123');
-
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toContain('Invalid TeamCity server URL');
-    });
-
-    it('should report invalid token', () => {
-      const result = validateConfiguration('https://teamcity.example.com', '');
-
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toContain('Invalid TeamCity authentication token');
-    });
-
-    it('should report multiple errors', () => {
-      const result = validateConfiguration('invalid-url', 'invalid token with spaces');
-
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toHaveLength(2);
-      expect(result.errors).toContain('Invalid TeamCity server URL');
-      expect(result.errors).toContain('Invalid TeamCity authentication token');
-    });
-  });
-
-  describe('logResponse', () => {
-    it('should log response details and return unchanged', () => {
-      const { info } = logger;
-      const response: AxiosResponse = {
-        config: {
-          requestId: 'test-123',
-          method: 'get',
-          url: '/test',
-        } as unknown as InternalAxiosRequestConfig,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          'x-response-time': '123ms',
-        },
-        data: { result: 'success' },
-      };
-
-      const result = logResponse(response);
-
-      expect(result).toBe(response);
-      expect(info).toHaveBeenCalledWith(
-        'TeamCity API request completed',
-        expect.objectContaining({
-          requestId: 'test-123',
-          method: 'GET',
-          url: '/test',
-          status: 200,
-          duration: '123ms',
-        })
-      );
-    });
-  });
-
-  describe('logAndTransformError', () => {
-    it('should log error and reject with TeamCityAPIError', async () => {
-      const { error } = logger;
-      const axiosError = {
-        config: { requestId: 'test-456' },
-        response: {
-          status: 500,
-          data: {
-            code: 'SERVER_ERROR',
-            message: 'Internal server error',
-          },
-        },
-        message: 'Request failed',
-      } as unknown as AxiosError;
-
-      await expect(logAndTransformError(axiosError)).rejects.toEqual(
-        expect.objectContaining({
-          code: 'SERVER_ERROR',
-          message: 'Internal server error',
-          requestId: 'test-456',
-          statusCode: 500,
-        })
-      );
-
-      expect(error).toHaveBeenCalledWith(
-        'TeamCity API request failed',
-        undefined,
-        expect.objectContaining({
-          requestId: 'test-456',
-          code: 'SERVER_ERROR',
-          statusCode: 500,
-        })
-      );
-    });
-  });
-});

package/tests/teamcity/circuit-breaker.test.ts

@@ -1,304 +0,0 @@
-/**
- * Tests for Circuit Breaker implementation
- */
-import { CircuitBreaker, CircuitBreakerManager, CircuitState } from '@/teamcity/circuit-breaker';
-
-// Mock the logger
-jest.mock('@/utils/logger', () => ({
-  info: jest.fn(),
-  warn: jest.fn(),
-}));
-
-describe('CircuitBreaker', () => {
-  let breaker: CircuitBreaker;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    breaker = new CircuitBreaker('test-endpoint', {
-      failureThreshold: 3,
-      resetTimeout: 100, // 100ms for testing
-      successThreshold: 2,
-    });
-  });
-
-  describe('CLOSED state', () => {
-    it('should start in CLOSED state', () => {
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should execute function successfully in CLOSED state', async () => {
-      const result = await breaker.execute(async () => 'success');
-      expect(result).toBe('success');
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should count failures and stay CLOSED below threshold', async () => {
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-
-      // First failure
-      await expect(breaker.execute(failingFn)).rejects.toThrow('failure');
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-
-      // Second failure
-      await expect(breaker.execute(failingFn)).rejects.toThrow('failure');
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should transition to OPEN after reaching failure threshold', async () => {
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-
-      // Fail 3 times (threshold)
-      /* eslint-disable no-await-in-loop */
-      for (let i = 0; i < 3; i++) {
-        await expect(breaker.execute(failingFn)).rejects.toThrow('failure');
-      }
-      /* eslint-enable no-await-in-loop */
-
-      expect(breaker.getState()).toBe(CircuitState.OPEN);
-    });
-
-    it('should reset failure count on success', async () => {
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-      const successFn = async () => 'success';
-
-      // Two failures
-      await expect(breaker.execute(failingFn)).rejects.toThrow();
-      await expect(breaker.execute(failingFn)).rejects.toThrow();
-
-      // Success should reset count
-      await breaker.execute(successFn);
-
-      const stats = breaker.getStats();
-      expect(stats.failureCount).toBe(0);
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-    });
-  });
-
-  describe('OPEN state', () => {
-    beforeEach(async () => {
-      // Open the circuit
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-      /* eslint-disable no-await-in-loop */
-      for (let i = 0; i < 3; i++) {
-        await expect(breaker.execute(failingFn)).rejects.toThrow();
-      }
-      /* eslint-enable no-await-in-loop */
-    });
-
-    it('should reject immediately in OPEN state', async () => {
-      const fn = jest.fn(async () => 'success');
-
-      await expect(breaker.execute(fn)).rejects.toThrow('Circuit breaker is OPEN');
-      expect(fn).not.toHaveBeenCalled();
-    });
-
-    it('should transition to HALF_OPEN after reset timeout', async () => {
-      expect(breaker.getState()).toBe(CircuitState.OPEN);
-
-      // Wait for reset timeout
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      // Next execution should transition to HALF_OPEN
-      const fn = async () => 'success';
-      await breaker.execute(fn);
-
-      // After one success, still HALF_OPEN
-      expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
-    });
-  });
-
-  describe('HALF_OPEN state', () => {
-    beforeEach(async () => {
-      // Open the circuit
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-      /* eslint-disable no-await-in-loop */
-      for (let i = 0; i < 3; i++) {
-        // eslint-disable-next-line no-await-in-loop
-        await expect(breaker.execute(failingFn)).rejects.toThrow();
-      }
-      /* eslint-enable no-await-in-loop */
-
-      // Wait for reset timeout
-      await new Promise((resolve) => setTimeout(resolve, 150));
-    });
-
-    it('should transition to CLOSED after success threshold', async () => {
-      const successFn = async () => 'success';
-
-      // First success - transitions to HALF_OPEN
-      await breaker.execute(successFn);
-      expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
-
-      // Second success - should transition to CLOSED
-      await breaker.execute(successFn);
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should transition back to OPEN on failure in HALF_OPEN', async () => {
-      const successFn = async () => 'success';
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-
-      // First execution transitions to HALF_OPEN
-      await breaker.execute(successFn);
-      expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
-
-      // Failure should transition back to OPEN
-      await expect(breaker.execute(failingFn)).rejects.toThrow('failure');
-      expect(breaker.getState()).toBe(CircuitState.OPEN);
-    });
-  });
-
-  describe('getStats', () => {
-    it('should return circuit statistics', async () => {
-      const stats = breaker.getStats();
-
-      expect(stats).toHaveProperty('state', CircuitState.CLOSED);
-      expect(stats).toHaveProperty('failureCount', 0);
-      expect(stats).toHaveProperty('successCount', 0);
-      expect(stats).toHaveProperty('lastFailureTime', undefined);
-    });
-
-    it('should track failure statistics', async () => {
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-
-      await expect(breaker.execute(failingFn)).rejects.toThrow();
-
-      const stats = breaker.getStats();
-      expect(stats.failureCount).toBe(1);
-      expect(stats.lastFailureTime).toBeDefined();
-    });
-  });
-
-  describe('reset', () => {
-    it('should reset circuit to CLOSED state', async () => {
-      // Open the circuit
-      const failingFn = async () => {
-        throw new Error('failure');
-      };
-      /* eslint-disable no-await-in-loop */
-      for (let i = 0; i < 3; i++) {
-        await expect(breaker.execute(failingFn)).rejects.toThrow();
-      }
-      /* eslint-enable no-await-in-loop */
-
-      expect(breaker.getState()).toBe(CircuitState.OPEN);
-
-      // Reset
-      breaker.reset();
-
-      expect(breaker.getState()).toBe(CircuitState.CLOSED);
-      const stats = breaker.getStats();
-      expect(stats.failureCount).toBe(0);
-      expect(stats.successCount).toBe(0);
-      expect(stats.lastFailureTime).toBeUndefined();
-    });
-  });
-});
-
-describe('CircuitBreakerManager', () => {
-  let manager: CircuitBreakerManager;
-
-  beforeEach(() => {
-    manager = new CircuitBreakerManager({
-      failureThreshold: 2,
-      resetTimeout: 100,
-    });
-  });
-
-  it('should create breakers for different endpoints', () => {
-    const breaker1 = manager.getBreaker('/api/builds');
-    const breaker2 = manager.getBreaker('/api/projects');
-
-    expect(breaker1).toBeDefined();
-    expect(breaker2).toBeDefined();
-    expect(breaker1).not.toBe(breaker2);
-  });
-
-  it('should reuse breaker for same endpoint', () => {
-    const breaker1 = manager.getBreaker('/api/builds');
-    const breaker2 = manager.getBreaker('/api/builds');
-
-    expect(breaker1).toBe(breaker2);
-  });
-
-  it('should execute with circuit breaker', async () => {
-    const result = await manager.execute('/api/builds', async () => 'success');
-    expect(result).toBe('success');
-  });
-
-  it('should track stats for all breakers', async () => {
-    // Create some breakers with activity
-    await manager.execute('/api/builds', async () => 'success');
-    await manager
-      .execute('/api/projects', async () => {
-        throw new Error('failure');
-      })
-      .catch(() => {});
-
-    const stats = manager.getAllStats();
-
-    expect(stats).toHaveProperty('/api/builds');
-    expect(stats).toHaveProperty('/api/projects');
-    expect(stats['/api/builds']?.state).toBe(CircuitState.CLOSED);
-    expect(stats['/api/projects']?.failureCount).toBe(1);
-  });
-
-  it('should reset all breakers', async () => {
-    // Open some circuits
-    const failingFn = async () => {
-      throw new Error('failure');
-    };
-
-    /* eslint-disable no-await-in-loop */
-    for (let i = 0; i < 2; i++) {
-      await manager.execute('/api/builds', failingFn).catch(() => {});
-      await manager.execute('/api/projects', failingFn).catch(() => {});
-    }
-    /* eslint-enable no-await-in-loop */
-
-    const statsBefore = manager.getAllStats();
-    expect(statsBefore['/api/builds']?.state).toBe(CircuitState.OPEN);
-    expect(statsBefore['/api/projects']?.state).toBe(CircuitState.OPEN);
-
-    // Reset all
-    manager.resetAll();
-
-    const statsAfter = manager.getAllStats();
-    expect(statsAfter['/api/builds']?.state).toBe(CircuitState.CLOSED);
-    expect(statsAfter['/api/projects']?.state).toBe(CircuitState.CLOSED);
-  });
-
-  it('should reset specific breaker', async () => {
-    // Open a circuit
-    const failingFn = async () => {
-      throw new Error('failure');
-    };
-
-    /* eslint-disable no-await-in-loop */
-    for (let i = 0; i < 2; i++) {
-      await manager.execute('/api/builds', failingFn).catch(() => {});
-    }
-    /* eslint-enable no-await-in-loop */
-
-    expect(manager.getBreaker('/api/builds').getState()).toBe(CircuitState.OPEN);
-
-    // Reset specific
-    manager.reset('/api/builds');
-
-    expect(manager.getBreaker('/api/builds').getState()).toBe(CircuitState.CLOSED);
-  });
-});