@daghis/teamcity-mcp 0.9.0 → 0.9.2

package/src/utils/async/index.test.ts

@@ -1,664 +0,0 @@
-/**
- * Tests for async utilities
- */
-import {
-  AsyncResult,
-  CircuitBreaker,
-  asyncHandler,
-  asyncUtils,
-  batchProcess,
-  circuitBreaker,
-  debounce,
-  measureTime,
-  parallelLimit,
-  retry,
-  safeAsyncHandler,
-  sleep,
-  throttle,
-  withTimeout,
-} from './index';
-
-// Helper to create a function that fails N times then succeeds
-const createFlakeyFunction = <T>(failCount: number, result: T) => {
-  let attempts = 0;
-  return jest.fn(async () => {
-    attempts++;
-    if (attempts <= failCount) {
-      throw new Error(`Attempt ${attempts} failed`);
-    }
-    return result;
-  });
-};
-
-// Helper to create a function that always fails
-const createFailingFunction = (message = 'Always fails') => {
-  return jest.fn(async () => {
-    throw new Error(message);
-  });
-};
-
-describe('asyncHandler', () => {
-  it('should return result for successful function', async () => {
-    const fn = jest.fn(async (x: number) => x * 2);
-    const wrapped = asyncHandler(fn);
-
-    const result = await wrapped(5);
-
-    expect(result).toBe(10);
-    expect(fn).toHaveBeenCalledWith(5);
-  });
-
-  it('should re-throw Error instances', async () => {
-    const error = new Error('Test error');
-    const fn = jest.fn(async () => {
-      throw error;
-    });
-    const wrapped = asyncHandler(fn);
-
-    await expect(wrapped()).rejects.toBe(error);
-  });
-
-  it('should wrap non-Error values in Error', async () => {
-    const fn = jest.fn(async () => {
-      // eslint-disable-next-line no-throw-literal
-      throw 'string error'; // Throw a string, not an Error
-    });
-    const wrapped = asyncHandler(fn);
-
-    await expect(wrapped()).rejects.toThrow('Async operation failed: string error');
-  });
-});
-
-describe('safeAsyncHandler', () => {
-  it('should return success result for successful function', async () => {
-    const fn = jest.fn(async (x: string) => x.toUpperCase());
-    const wrapped = safeAsyncHandler(fn);
-
-    const result = await wrapped('test');
-
-    expect(result).toEqual({ success: true, data: 'TEST' });
-  });
-
-  it('should return error result for failing function', async () => {
-    const error = new Error('Test error');
-    const fn = jest.fn(async () => {
-      throw error;
-    });
-    const wrapped = safeAsyncHandler(fn);
-
-    const result = await wrapped();
-
-    expect(result).toEqual({ success: false, error });
-  });
-
-  it('should wrap non-Error values in Error', async () => {
-    const fn = jest.fn(async () => {
-      throw new Error('string error');
-    });
-    const wrapped = safeAsyncHandler(fn);
-
-    const result = await wrapped();
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toBe('string error');
-    }
-  });
-});
-
-describe('retry', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it('should succeed on first attempt', async () => {
-    const fn = jest.fn(async () => 'success');
-
-    const result = await retry(fn);
-
-    expect(result).toBe('success');
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should retry failed attempts and eventually succeed', async () => {
-    jest.useRealTimers(); // Need real timers for this async test
-    const fn = createFlakeyFunction(2, 'success');
-
-    const result = await retry(fn, { maxAttempts: 3, delay: 10 });
-
-    expect(result).toBe('success');
-    expect(fn).toHaveBeenCalledTimes(3);
-  }, 15000);
-
-  it('should throw last error after max attempts', async () => {
-    jest.useRealTimers(); // Need real timers for this async test
-    const fn = createFailingFunction();
-
-    await expect(retry(fn, { maxAttempts: 3, delay: 10 })).rejects.toThrow('Always fails');
-    expect(fn).toHaveBeenCalledTimes(3);
-  }, 15000);
-
-  it('should use exponential backoff', async () => {
-    jest.useRealTimers(); // Need real timers for timing test
-    const fn = createFailingFunction();
-    const startTime = Date.now();
-
-    try {
-      await retry(fn, { maxAttempts: 3, delay: 50, backoff: 2 });
-    } catch (error) {
-      // Expected to fail
-    }
-
-    const elapsed = Date.now() - startTime;
-    // Should wait roughly 50 + 100 = 150ms; allow small scheduler jitter
-    expect(elapsed).toBeGreaterThanOrEqual(140);
-  }, 15000);
-
-  it('should respect maxDelay option', async () => {
-    jest.useRealTimers(); // Need real timers for timing test
-    const fn = createFailingFunction();
-    const startTime = Date.now();
-
-    try {
-      await retry(fn, { maxAttempts: 3, delay: 1000, backoff: 2, maxDelay: 100 });
-    } catch (error) {
-      // Expected to fail
-    }
-
-    const elapsed = Date.now() - startTime;
-    // Should not exceed 100 + 100 = 200ms significantly
-    expect(elapsed).toBeLessThan(300);
-  });
-
-  it('should call onRetry callback', async () => {
-    jest.useRealTimers(); // Need real timers for this async test
-    const fn = createFlakeyFunction(2, 'success');
-    const onRetry = jest.fn();
-
-    await retry(fn, { maxAttempts: 3, delay: 10, onRetry });
-
-    expect(onRetry).toHaveBeenCalledTimes(2);
-    expect(onRetry).toHaveBeenNthCalledWith(1, expect.any(Error), 1);
-    expect(onRetry).toHaveBeenNthCalledWith(2, expect.any(Error), 2);
-  }, 15000);
-
-  it('should respect shouldRetry option', async () => {
-    const fn = createFailingFunction('Specific error');
-    const shouldRetry = jest.fn((error: unknown) => {
-      return error instanceof Error && !error.message.includes('Specific');
-    });
-
-    await expect(retry(fn, { shouldRetry })).rejects.toThrow('Specific error');
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(shouldRetry).toHaveBeenCalledWith(expect.any(Error), 1);
-  });
-});
-
-describe('withTimeout', () => {
-  it('should resolve normally if promise completes within timeout', async () => {
-    const promise = Promise.resolve('success');
-
-    const result = await withTimeout(promise, { timeout: 100 });
-
-    expect(result).toBe('success');
-  });
-
-  it('should reject with timeout error if promise takes too long', async () => {
-    const promise = new Promise((resolve) => setTimeout(resolve, 200));
-
-    await expect(withTimeout(promise, { timeout: 50 })).rejects.toThrow(
-      'Operation timed out after 50ms'
-    );
-  });
-
-  it('should use custom timeout message', async () => {
-    const promise = new Promise((resolve) => setTimeout(resolve, 200));
-
-    await expect(withTimeout(promise, { timeout: 50, message: 'Custom timeout' })).rejects.toThrow(
-      'Custom timeout'
-    );
-  });
-});
-
-describe('sleep', () => {
-  it('should sleep for specified duration', async () => {
-    const startTime = Date.now();
-
-    await sleep(50);
-
-    const elapsed = Date.now() - startTime;
-    expect(elapsed).toBeGreaterThanOrEqual(45);
-    expect(elapsed).toBeLessThan(120); // Allow variance on shared runners
-  }, 15000);
-});
-
-describe('debounce', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.clearAllTimers();
-    jest.useRealTimers();
-  });
-
-  it('should debounce function calls', () => {
-    const fn = jest.fn();
-    const debouncedFn = debounce(fn, 100);
-
-    debouncedFn('arg1');
-    debouncedFn('arg2');
-    debouncedFn('arg3');
-
-    expect(fn).not.toHaveBeenCalled();
-
-    jest.advanceTimersByTime(100);
-
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith('arg3');
-  });
-
-  it('should reset timer on subsequent calls', () => {
-    const fn = jest.fn();
-    const debouncedFn = debounce(fn, 100);
-
-    debouncedFn('arg1');
-    jest.advanceTimersByTime(50);
-
-    debouncedFn('arg2');
-    jest.advanceTimersByTime(50);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    jest.advanceTimersByTime(50);
-
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith('arg2');
-  });
-});
-
-describe('throttle', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.clearAllTimers();
-    jest.useRealTimers();
-  });
-
-  it('should throttle function calls', () => {
-    const fn = jest.fn();
-    const throttledFn = throttle(fn, 100);
-
-    throttledFn('arg1');
-    throttledFn('arg2');
-    throttledFn('arg3');
-
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith('arg1');
-
-    jest.advanceTimersByTime(100);
-
-    throttledFn('arg4');
-
-    expect(fn).toHaveBeenCalledTimes(2);
-    expect(fn).toHaveBeenLastCalledWith('arg4');
-  });
-});
-
-describe('parallelLimit', () => {
-  it('should execute all items with concurrency limit', async () => {
-    const items = [1, 2, 3, 4, 5];
-    const results: number[] = [];
-    const fn = jest.fn(async (item: number) => {
-      await sleep(50);
-      results.push(item);
-    });
-
-    await parallelLimit(items, fn, 2);
-
-    expect(fn).toHaveBeenCalledTimes(5);
-    expect(results).toHaveLength(5);
-    expect(results.sort()).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('should respect concurrency limit', async () => {
-    const items = [1, 2, 3, 4];
-    let activeCount = 0;
-    let maxActiveCount = 0;
-
-    const fn = async () => {
-      activeCount++;
-      maxActiveCount = Math.max(maxActiveCount, activeCount);
-      await sleep(50);
-      activeCount--;
-    };
-
-    await parallelLimit(items, fn, 2);
-
-    expect(maxActiveCount).toBe(2);
-  });
-});
-
-describe('CircuitBreaker', () => {
-  it('should execute function normally when circuit is closed', async () => {
-    const fn = jest.fn(async (x: number) => x * 2);
-    const breaker = new CircuitBreaker(fn);
-
-    const result = await breaker.execute(5);
-
-    expect(result).toBe(10);
-    expect(breaker.getState()).toBe('CLOSED');
-  });
-
-  it('should open circuit after failure threshold', async () => {
-    const fn = createFailingFunction();
-    const onStateChange = jest.fn();
-    const breaker = new CircuitBreaker(fn, { failureThreshold: 2, onStateChange });
-
-    await expect(breaker.execute()).rejects.toThrow();
-    expect(breaker.getState()).toBe('CLOSED');
-
-    await expect(breaker.execute()).rejects.toThrow();
-    expect(breaker.getState()).toBe('OPEN');
-    expect(onStateChange).toHaveBeenCalledWith('OPEN', expect.any(Error));
-  });
-
-  it('should reject immediately when circuit is open', async () => {
-    const fn = createFailingFunction();
-    const breaker = new CircuitBreaker(fn, { failureThreshold: 1 });
-
-    // Fail to open circuit
-    await expect(breaker.execute()).rejects.toThrow();
-
-    // Should reject immediately
-    await expect(breaker.execute()).rejects.toThrow('Circuit breaker is OPEN');
-    expect(fn).toHaveBeenCalledTimes(1); // Only called once
-  });
-
-  it('should transition to half-open after reset timeout', async () => {
-    const fn = createFailingFunction();
-    const breaker = new CircuitBreaker(fn, {
-      failureThreshold: 1,
-      resetTimeout: 100,
-    });
-
-    // Open circuit
-    await expect(breaker.execute()).rejects.toThrow();
-    expect(breaker.getState()).toBe('OPEN');
-
-    // Wait for reset timeout
-    await sleep(150);
-
-    // Should attempt execution (will fail but state changes to HALF_OPEN first)
-    await expect(breaker.execute()).rejects.toThrow();
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-
-  it('should reset circuit after successful executions in half-open state', async () => {
-    const fn = createFlakeyFunction(1, 'success');
-    const onStateChange = jest.fn();
-    const breaker = new CircuitBreaker(fn, {
-      failureThreshold: 1,
-      resetTimeout: 100,
-      onStateChange,
-    });
-
-    // Open circuit
-    await expect(breaker.execute()).rejects.toThrow();
-    expect(breaker.getState()).toBe('OPEN');
-
-    await sleep(150);
-
-    // Execute successfully 3 times to close circuit
-    await breaker.execute();
-    await breaker.execute();
-    await breaker.execute();
-
-    expect(breaker.getState()).toBe('CLOSED');
-    expect(onStateChange).toHaveBeenLastCalledWith('CLOSED');
-  });
-
-  it('should reset state manually', () => {
-    const fn = createFailingFunction();
-    const breaker = new CircuitBreaker(fn, { failureThreshold: 1 });
-
-    // Open circuit would normally require async execution
-    // For test, we'll manipulate state directly through multiple executions
-    expect(breaker.getFailures()).toBe(0);
-
-    breaker.reset();
-    expect(breaker.getState()).toBe('CLOSED');
-    expect(breaker.getFailures()).toBe(0);
-  });
-});
-
-describe('circuitBreaker factory', () => {
-  it('should create circuit breaker instance', () => {
-    const fn = async () => 'test';
-    const breaker = circuitBreaker(fn);
-
-    expect(breaker).toBeInstanceOf(CircuitBreaker);
-  });
-});
-
-describe('batchProcess', () => {
-  it('should process all items in batches', async () => {
-    const items = [1, 2, 3, 4, 5, 6, 7];
-    const processor = jest.fn(async (batch: number[]) => batch.map((x) => x * 2));
-
-    const results = await batchProcess(items, processor, 3);
-
-    expect(results).toEqual([2, 4, 6, 8, 10, 12, 14]);
-    expect(processor).toHaveBeenCalledTimes(3);
-    expect(processor).toHaveBeenNthCalledWith(1, [1, 2, 3]);
-    expect(processor).toHaveBeenNthCalledWith(2, [4, 5, 6]);
-    expect(processor).toHaveBeenNthCalledWith(3, [7]);
-  });
-
-  it('should call onBatchComplete callback', async () => {
-    const items = [1, 2, 3, 4];
-    const processor = async (batch: number[]) => batch.map((x) => x * 2);
-    const onBatchComplete = jest.fn();
-
-    await batchProcess(items, processor, 2, { onBatchComplete });
-
-    expect(onBatchComplete).toHaveBeenCalledTimes(2);
-    expect(onBatchComplete).toHaveBeenNthCalledWith(1, [1, 2], [2, 4]);
-    expect(onBatchComplete).toHaveBeenNthCalledWith(2, [3, 4], [6, 8]);
-  });
-
-  it('should call onError callback and still throw', async () => {
-    const items = [1, 2, 3, 4];
-    const processor = async (batch: number[]) => {
-      if (batch.includes(3)) {
-        throw new Error('Batch contains 3');
-      }
-      return batch.map((x) => x * 2);
-    };
-    const onError = jest.fn();
-
-    await expect(batchProcess(items, processor, 2, { onError })).rejects.toThrow(
-      'Batch contains 3'
-    );
-
-    expect(onError).toHaveBeenCalledWith([3, 4], expect.any(Error));
-  });
-
-  it('should process batches with concurrency control', async () => {
-    const items = [1, 2, 3, 4, 5, 6];
-    let activeCount = 0;
-    let maxActiveCount = 0;
-
-    const processor = async (batch: number[]) => {
-      activeCount++;
-      maxActiveCount = Math.max(maxActiveCount, activeCount);
-      await sleep(50);
-      activeCount--;
-      return batch.map((x) => x * 2);
-    };
-
-    await batchProcess(items, processor, 2, { concurrency: 2 });
-
-    expect(maxActiveCount).toBe(2); // Should not exceed concurrency limit
-  });
-});
-
-describe('measureTime', () => {
-  it('should measure execution time', async () => {
-    const operation = async () => {
-      await sleep(50);
-      return 'result';
-    };
-
-    const { result, duration } = await measureTime(operation);
-
-    expect(result).toBe('result');
-    // Allow small timer scheduling jitter on some systems / CI runners
-    expect(duration).toBeGreaterThanOrEqual(40);
-    expect(duration).toBeLessThan(120);
-  });
-
-  it('should measure time even if operation fails', async () => {
-    const operation = async () => {
-      await sleep(50);
-      throw new Error('Operation failed');
-    };
-
-    await expect(measureTime(operation)).rejects.toThrow('Operation failed');
-  });
-
-  it('should log with label', async () => {
-    // Mock the logger module
-    const mockDebug = jest.fn();
-    jest.mock('../logger', () => ({
-      getLogger: () => ({ debug: mockDebug }),
-    }));
-
-    const operation = async () => {
-      await sleep(50);
-      return 'result';
-    };
-
-    await measureTime(operation, 'Test Operation');
-
-    // Since we can't easily mock the logger import, skip this test
-    // The functionality is tested indirectly through other tests
-    expect(true).toBe(true); // Placeholder assertion
-  });
-});
-
-describe('asyncUtils', () => {
-  describe('promisify', () => {
-    it('should convert callback-style function to Promise', async () => {
-      const callbackFn = (
-        value: string,
-        callback: (err: Error | null, result?: string) => void
-      ) => {
-        setTimeout(() => callback(null, value.toUpperCase()), 10);
-      };
-
-      const promisified = asyncUtils.promisify(callbackFn);
-      const result = await promisified('test');
-
-      expect(result).toBe('TEST');
-    });
-
-    it('should reject on callback error', async () => {
-      const callbackFn = (callback: (err: Error | null, result?: string) => void) => {
-        setTimeout(() => callback(new Error('Callback error')), 10);
-      };
-
-      const promisified = asyncUtils.promisify(callbackFn);
-
-      await expect(promisified()).rejects.toThrow('Callback error');
-    });
-  });
-
-  describe('raceToSuccess', () => {
-    it('should resolve with first successful promise', async () => {
-      const promises = [
-        Promise.reject(new Error('Error 1')),
-        Promise.resolve('Success'),
-        Promise.reject(new Error('Error 2')),
-      ];
-
-      const result = await asyncUtils.raceToSuccess(promises);
-
-      expect(result).toBe('Success');
-    });
-
-    it('should reject if all promises fail', async () => {
-      const promises = [
-        Promise.reject(new Error('Error 1')),
-        Promise.reject(new Error('Error 2')),
-        Promise.reject(new Error('Error 3')),
-      ];
-
-      await expect(asyncUtils.raceToSuccess(promises)).rejects.toThrow('All promises rejected');
-    });
-  });
-
-  describe('cancellable', () => {
-    it('should resolve normally if not cancelled', async () => {
-      const promise = Promise.resolve('success');
-      const { promise: cancellable } = asyncUtils.cancellable(promise);
-
-      const result = await cancellable;
-
-      expect(result).toBe('success');
-    });
-
-    it('should not resolve if cancelled before completion', async () => {
-      const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 100));
-      const { promise: cancellable, cancel } = asyncUtils.cancellable(promise);
-
-      cancel();
-
-      // Promise should not resolve/reject
-      let resolved = false;
-      cancellable
-        .then(() => {
-          resolved = true;
-        })
-        .catch(() => {
-          resolved = true;
-        });
-
-      await sleep(150);
-      expect(resolved).toBe(false);
-    });
-  });
-});
-
-describe('type definitions', () => {
-  it('should properly type AsyncResult', () => {
-    const successResult: AsyncResult<string> = { success: true, data: 'test' };
-    const errorResult: AsyncResult<string, CustomError> = {
-      success: false,
-      error: new CustomError('test'),
-    };
-
-    expect(successResult.success).toBe(true);
-    if (successResult.success) {
-      expect(successResult.data).toBe('test');
-    }
-
-    expect(errorResult.success).toBe(false);
-    if (!errorResult.success) {
-      expect(errorResult.error).toBeInstanceOf(CustomError);
-    }
-  });
-});
-
-class CustomError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'CustomError';
-  }
-}