@daghis/teamcity-mcp 0.1.2

package/tests/teamcity/auth.test.ts

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

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