@daghis/teamcity-mcp 0.1.2 → 0.1.3

package/tests/unit/teamcity/build-progress-tracker.test.ts

@@ -1,1030 +0,0 @@
-/**
- * Tests for BuildProgressTracker
- */
-import { EventEmitter } from 'events';
-
-import { BuildProgressTracker, type ProgressUpdate } from '@/teamcity/build-progress-tracker';
-import { BuildStatusManager } from '@/teamcity/build-status-manager';
-
-describe('BuildProgressTracker', () => {
-  let tracker: BuildProgressTracker;
-  let mockStatusManager: jest.Mocked<BuildStatusManager>;
-  let _eventEmitter: EventEmitter;
-
-  beforeEach(() => {
-    // Set up fake timers
-    jest.useFakeTimers();
-
-    // Create mock status manager
-    mockStatusManager = {
-      getBuildStatus: jest.fn(),
-      getBuildStatusByLocator: jest.fn(),
-      clearCache: jest.fn(),
-    } as unknown as jest.Mocked<BuildStatusManager>;
-
-    _eventEmitter = new EventEmitter();
-    tracker = new BuildProgressTracker(mockStatusManager);
-  });
-
-  afterEach(() => {
-    // Clean up any active tracking
-    tracker.stopAllTracking();
-    jest.clearAllTimers();
-    // Restore real timers
-    jest.useRealTimers();
-  });
-
-  describe('trackBuildProgress', () => {
-    describe('Progress Updates', () => {
-      // Note: We don't use global fake timers because the initial poll
-      // happens with delay 0 which needs to complete before we can control timing
-
-      it('should emit progress updates for running builds', async () => {
-        const buildId = '12345';
-        const progressUpdates: ProgressUpdate[] = [];
-
-        // Mock build status responses
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 25,
-            currentStageText: 'Compiling sources',
-            elapsedSeconds: 30,
-            estimatedTotalSeconds: 120,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 50,
-            currentStageText: 'Running tests',
-            elapsedSeconds: 60,
-            estimatedTotalSeconds: 120,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 75,
-            currentStageText: 'Publishing artifacts',
-            elapsedSeconds: 90,
-            estimatedTotalSeconds: 120,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'finished',
-            status: 'SUCCESS',
-            percentageComplete: 100,
-            elapsedSeconds: 115,
-          });
-
-        // Start tracking with immediate initial poll
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 5000,
-        });
-
-        emitter.on('progress', (update: ProgressUpdate) => {
-          progressUpdates.push(update);
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll (immediate)
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Advance timers for subsequent polls
-        jest.advanceTimersByTime(5000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(5000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(5000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Verify progress updates
-        expect(progressUpdates).toHaveLength(4);
-        expect(progressUpdates[0]).toMatchObject({
-          buildId,
-          state: 'running',
-          percentageComplete: 25,
-          currentStageText: 'Compiling sources',
-        });
-        expect(progressUpdates[3]).toMatchObject({
-          state: 'finished',
-          status: 'SUCCESS',
-          percentageComplete: 100,
-        });
-      });
-
-      it('should calculate progress velocity', async () => {
-        const buildId = '12346';
-        let lastUpdate: ProgressUpdate | undefined;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 20,
-            elapsedSeconds: 20,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 40,
-            elapsedSeconds: 35,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 5000,
-          calculateVelocity: true,
-        });
-
-        emitter.on('progress', (update: ProgressUpdate) => {
-          lastUpdate = update;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll (immediate)
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Advance timers for subsequent polls
-        jest.advanceTimersByTime(5000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Velocity = (40 - 20) / 5s polling interval = 20 / 5 = 4% per second
-        expect(lastUpdate).toBeDefined();
-        if (lastUpdate == null) {
-          throw new Error('Expected lastUpdate to be defined');
-        }
-        expect(lastUpdate.velocity).toBeCloseTo(4, 1);
-        expect(lastUpdate.estimatedTimeRemaining).toBeDefined();
-      });
-
-      it('should handle stalled builds', async () => {
-        const buildId = '12347';
-        let stalledEventFired = false;
-
-        // First poll shows progress
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 30,
-            elapsedSeconds: 60,
-          })
-          // Subsequent polls show no progress (same percentage)
-          .mockResolvedValue({
-            buildId,
-            state: 'running',
-            percentageComplete: 30,
-            elapsedSeconds: 60,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          stallThreshold: 3000, // 3 seconds
-        });
-
-        emitter.on('stalled', () => {
-          stalledEventFired = true;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll (establishes lastProgress)
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Now advance time and do polls with no progress
-        // Intentional sequential timer advancement to simulate ticks
-        /* eslint-disable no-await-in-loop */
-        for (let i = 0; i < 4; i++) {
-          jest.advanceTimersByTime(1000);
-          await jest.runOnlyPendingTimers();
-          await Promise.resolve();
-        }
-        /* eslint-enable no-await-in-loop */
-
-        expect(stalledEventFired).toBe(true);
-      });
-    });
-
-    describe('Build State Transitions', () => {
-      it('should emit queued event when build is queued', async () => {
-        const buildId = '12348';
-        let queuedEventData: unknown;
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          state: 'queued',
-          percentageComplete: 0,
-          queuePosition: 3,
-          estimatedStartTime: new Date('2025-08-29T10:30:00Z'),
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId);
-
-        emitter.on('queued', (data: unknown) => {
-          queuedEventData = data;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Trigger initial poll
-        await tracker.pollOnce(buildId);
-
-        expect(queuedEventData as Record<string, unknown>).toMatchObject({
-          buildId,
-          queuePosition: 3,
-          estimatedStartTime: expect.any(Date),
-        });
-      });
-
-      it('should emit started event when build starts', async () => {
-        const buildId = '12349';
-        let startedEventData: unknown;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'queued',
-            percentageComplete: 0,
-            queuePosition: 1,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 0,
-            startDate: new Date('2025-08-29T10:31:00Z'),
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-        });
-
-        emitter.on('started', (data: unknown) => {
-          startedEventData = data;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        expect(startedEventData as Record<string, unknown>).toMatchObject({
-          buildId,
-          startDate: expect.any(Date),
-        });
-      });
-
-      it('should emit completed event when build finishes', async () => {
-        const buildId = '12350';
-        let completedEventData: unknown;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 95,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'finished',
-            status: 'SUCCESS',
-            percentageComplete: 100,
-            elapsedSeconds: 120,
-            finishDate: new Date('2025-08-29T10:33:00Z'),
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-        });
-
-        emitter.on('completed', (data: unknown) => {
-          completedEventData = data;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        expect(completedEventData as Record<string, unknown>).toMatchObject({
-          buildId,
-          status: 'SUCCESS',
-          elapsedSeconds: 120,
-          finishDate: expect.any(Date),
-        });
-      });
-
-      it('should emit failed event when build fails', async () => {
-        const buildId = '12351';
-        let failedEventData: unknown;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 60,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'finished',
-            status: 'FAILURE',
-            statusText: 'Tests failed',
-            failureReason: '5 tests failed',
-            percentageComplete: 60,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-        });
-
-        emitter.on('failed', (data: unknown) => {
-          failedEventData = data;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        expect(failedEventData as Record<string, unknown>).toMatchObject({
-          buildId,
-          status: 'FAILURE',
-          statusText: 'Tests failed',
-          failureReason: '5 tests failed',
-        });
-      });
-
-      it('should emit canceled event when build is canceled', async () => {
-        const buildId = '12352';
-        let canceledEventData: unknown;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 30,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'canceled',
-            percentageComplete: 30,
-            canceledBy: 'john.doe',
-            canceledDate: new Date('2025-08-29T10:35:00Z'),
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-        });
-
-        emitter.on('canceled', (data: unknown) => {
-          canceledEventData = data;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        expect(canceledEventData as Record<string, unknown>).toMatchObject({
-          buildId,
-          canceledBy: 'john.doe',
-          canceledDate: expect.any(Date),
-        });
-      });
-    });
-
-    describe('Error Handling', () => {
-      it('should emit error event on API failures', async () => {
-        const buildId = '12353';
-        let errorEventData: unknown;
-
-        mockStatusManager.getBuildStatus.mockRejectedValue(new Error('Network error'));
-
-        const emitter = tracker.trackBuildProgress(buildId);
-
-        emitter.on('error', (error) => {
-          errorEventData = error;
-        });
-
-        // Wait for initial poll to complete
-        await jest.runOnlyPendingTimers();
-
-        expect(errorEventData).toBeInstanceOf(Error);
-        const err = errorEventData as Error;
-        expect(err.message).toBe('Network error');
-      });
-
-      it('should retry on transient errors', async () => {
-        const buildId = '12354';
-
-        mockStatusManager.getBuildStatus
-          .mockRejectedValueOnce(new Error('Temporary failure'))
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'finished',
-            status: 'SUCCESS',
-            percentageComplete: 100,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          maxRetries: 3,
-        });
-
-        let progressUpdate: ProgressUpdate | undefined;
-        emitter.on('progress', (update) => {
-          progressUpdate = update;
-        });
-        emitter.on('error', () => {
-          // Expected error on first attempt
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Wait a bit more to ensure no additional calls are made
-        await jest.advanceTimersByTime(1000);
-        await Promise.resolve();
-
-        expect(progressUpdate).toBeDefined();
-        if (progressUpdate == null) {
-          throw new Error('Expected progressUpdate to be defined');
-        }
-        expect(progressUpdate).toMatchObject({
-          percentageComplete: 100,
-        });
-        // Should have initial failure + retry success + possible completion check
-        expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(3);
-      });
-
-      it('should stop tracking after max retries exceeded', async () => {
-        const buildId = '12355';
-        let stopEventFired = false;
-
-        mockStatusManager.getBuildStatus.mockRejectedValue(new Error('Persistent failure'));
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          maxRetries: 2,
-        });
-
-        emitter.on('stopped', () => {
-          stopEventFired = true;
-        });
-        emitter.on('error', () => {
-          // Expected errors
-        });
-
-        // Wait for initial poll (counts as first attempt)
-        await jest.runOnlyPendingTimers();
-
-        // Retry 1
-        jest.advanceTimersByTime(1000);
-        await Promise.resolve();
-
-        // Should stop after max retries
-
-        // Give time for async operations
-        await jest.runOnlyPendingTimers();
-
-        expect(stopEventFired).toBe(true);
-        expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(2);
-      });
-    });
-
-    describe('Progress Estimation', () => {
-      it('should estimate completion time based on velocity', async () => {
-        const buildId = '12356';
-        let lastUpdate: ProgressUpdate | undefined;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 30,
-            elapsedSeconds: 30,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            percentageComplete: 50,
-            elapsedSeconds: 50,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          calculateVelocity: true,
-        });
-
-        emitter.on('progress', (update) => {
-          lastUpdate = update;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        jest.advanceTimersByTime(1000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Velocity = 20% in 1s polling interval = 20% per second
-        // Remaining = 50% at 20% per second = 2.5 seconds
-        expect(lastUpdate).toBeDefined();
-        if (lastUpdate == null) {
-          throw new Error('Expected lastUpdate to be defined');
-        }
-        expect(lastUpdate.estimatedTimeRemaining).toBeCloseTo(2.5, 1);
-      });
-
-      it('should use historical data for initial estimates', async () => {
-        const buildId = '12357';
-        const buildTypeId = 'Build_Config_1';
-        let progressUpdate: ProgressUpdate | undefined;
-
-        // Set historical average
-        tracker.setHistoricalAverage(buildTypeId, 180); // 3 minutes average
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          buildTypeId,
-          state: 'running',
-          percentageComplete: 33,
-          elapsedSeconds: 60,
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          useHistoricalData: true,
-        });
-
-        emitter.on('progress', (update) => {
-          progressUpdate = update;
-        });
-
-        await tracker.pollOnce(buildId);
-
-        // At 33% with 180s average = ~120s remaining
-        expect(progressUpdate).toBeDefined();
-        if (progressUpdate == null) {
-          throw new Error('Expected progressUpdate to be defined');
-        }
-        expect(progressUpdate.estimatedTotalSeconds).toBeCloseTo(180, -1);
-      });
-
-      it('should handle builds running longer than estimated', async () => {
-        const buildId = '12358';
-        let progressUpdate: ProgressUpdate | undefined;
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          state: 'running',
-          percentageComplete: 95,
-          elapsedSeconds: 300,
-          estimatedTotalSeconds: 200, // Original estimate was 200s
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId);
-
-        emitter.on('progress', (update) => {
-          progressUpdate = update;
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        await tracker.pollOnce(buildId);
-
-        // Should show build is overdue
-        expect(progressUpdate).toBeDefined();
-        if (progressUpdate == null) {
-          throw new Error('Expected progressUpdate to be defined');
-        }
-        expect(progressUpdate.isOverdue).toBe(true);
-        expect(progressUpdate.overdueSeconds).toBe(100);
-      });
-    });
-
-    describe('Stage Tracking', () => {
-      it('should track build stage changes', async () => {
-        const buildId = '12359';
-        const stageChanges: string[] = [];
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Checkout',
-            percentageComplete: 10,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Compile',
-            percentageComplete: 30,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Test',
-            percentageComplete: 60,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Package',
-            percentageComplete: 90,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          trackStages: true,
-        });
-
-        emitter.on('stageChanged', (stage) => {
-          stageChanges.push(stage);
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Intentional sequential timer advancement for stage progression
-        /* eslint-disable no-await-in-loop */
-        for (let i = 0; i < 3; i++) {
-          jest.advanceTimersByTime(1000);
-          await jest.runOnlyPendingTimers();
-          await Promise.resolve();
-        }
-        /* eslint-enable no-await-in-loop */
-
-        expect(stageChanges).toEqual(['Checkout', 'Compile', 'Test', 'Package']);
-      });
-
-      it('should calculate stage duration', async () => {
-        const buildId = '12360';
-        let stageMetrics: Record<string, unknown> | undefined;
-
-        mockStatusManager.getBuildStatus
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Tests',
-            percentageComplete: 50,
-            elapsedSeconds: 60,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Tests',
-            percentageComplete: 70,
-            elapsedSeconds: 90,
-          })
-          .mockResolvedValueOnce({
-            buildId,
-            state: 'running',
-            currentStageText: 'Deploy',
-            percentageComplete: 80,
-            elapsedSeconds: 100,
-          });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          trackStages: true,
-          calculateStageMetrics: true,
-        });
-
-        emitter.on('stageCompleted', (metrics) => {
-          stageMetrics = metrics;
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Intentional sequential timer advancement for metrics
-        /* eslint-disable no-await-in-loop */
-        for (let i = 0; i < 2; i++) {
-          jest.advanceTimersByTime(1000);
-          await jest.runOnlyPendingTimers();
-          await Promise.resolve();
-        }
-        /* eslint-enable no-await-in-loop */
-
-        expect(stageMetrics).toMatchObject({
-          stageName: 'Tests',
-          duration: 2, // Time between polls in seconds
-          percentageOfBuild: 30, // 80 - 50
-        });
-      });
-    });
-
-    describe('Multiple Build Tracking', () => {
-      it('should track multiple builds simultaneously', async () => {
-        const buildIds = ['12361', '12362', '12363'];
-        const progressUpdates: Map<string, ProgressUpdate> = new Map();
-
-        buildIds.forEach((id, index) => {
-          mockStatusManager.getBuildStatus.mockResolvedValueOnce({
-            buildId: id,
-            state: 'running',
-            percentageComplete: (index + 1) * 25,
-          });
-        });
-
-        buildIds.forEach((id) => {
-          const emitter = tracker.trackBuildProgress(id);
-          emitter.on('progress', (update) => {
-            progressUpdates.set(id, update);
-          });
-        });
-
-        await Promise.all(buildIds.map((id) => tracker.pollOnce(id)));
-
-        expect(progressUpdates.size).toBe(3);
-        expect(progressUpdates.get('12361')?.percentageComplete).toBe(25);
-        expect(progressUpdates.get('12362')?.percentageComplete).toBe(50);
-        expect(progressUpdates.get('12363')?.percentageComplete).toBe(75);
-      });
-
-      it('should stop tracking specific build', () => {
-        const buildIds = ['12364', '12365'];
-
-        buildIds.forEach((id) => {
-          tracker.trackBuildProgress(id);
-        });
-
-        expect(tracker.getActiveTracking()).toHaveLength(2);
-
-        tracker.stopTracking('12364');
-
-        expect(tracker.getActiveTracking()).toHaveLength(1);
-        expect(tracker.getActiveTracking()).toContain('12365');
-      });
-
-      it('should stop all tracking', () => {
-        const buildIds = ['12366', '12367', '12368'];
-
-        buildIds.forEach((id) => {
-          tracker.trackBuildProgress(id);
-        });
-
-        expect(tracker.getActiveTracking()).toHaveLength(3);
-
-        tracker.stopAllTracking();
-
-        expect(tracker.getActiveTracking()).toHaveLength(0);
-      });
-    });
-
-    describe('Options and Configuration', () => {
-      it('should respect custom polling intervals', async () => {
-        const buildId = '12369';
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          state: 'running',
-          percentageComplete: 50,
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 10000, // 10 seconds
-        });
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-        expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(1); // Initial poll
-
-        jest.advanceTimersByTime(10000);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-        expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(2); // Second poll at 10s
-      });
-
-      it('should stop tracking when maxDuration exceeded', async () => {
-        const buildId = '12370';
-        let stoppedEventFired = false;
-        let _stoppedReason = '';
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          state: 'running',
-          percentageComplete: 50,
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          pollingInterval: 1000,
-          maxDuration: 2000, // Stop after 2 seconds
-        });
-
-        const stopPromise = new Promise<string>((resolve) => {
-          emitter.on('stopped', (reason) => {
-            stoppedEventFired = true;
-            _stoppedReason = reason;
-            resolve(reason);
-          });
-        });
-
-        emitter.on('error', () => {
-          /* ignore */
-        });
-
-        // Wait for initial poll
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Advance time to exceed maxDuration (2000ms)
-        jest.advanceTimersByTime(2001);
-        await jest.runOnlyPendingTimers();
-        await Promise.resolve();
-
-        // Wait for the stopped event
-        const reason = await stopPromise;
-
-        expect(stoppedEventFired).toBe(true);
-        expect(reason).toBe('maxDurationExceeded');
-      });
-
-      it('should include optional data when requested', async () => {
-        const buildId = '12371';
-        let progressUpdate: ProgressUpdate | undefined;
-
-        mockStatusManager.getBuildStatus.mockResolvedValue({
-          buildId,
-          state: 'running',
-          percentageComplete: 50,
-          testSummary: {
-            total: 100,
-            passed: 45,
-            failed: 0,
-            ignored: 5,
-          },
-          problems: [],
-        });
-
-        const emitter = tracker.trackBuildProgress(buildId, {
-          includeTests: true,
-          includeProblems: true,
-        });
-
-        emitter.on('progress', (update) => {
-          progressUpdate = update;
-        });
-
-        await tracker.pollOnce(buildId);
-
-        expect(progressUpdate).toBeDefined();
-        if (progressUpdate == null) {
-          throw new Error('Expected progressUpdate to be defined');
-        }
-        expect(progressUpdate.testSummary).toBeDefined();
-        expect(progressUpdate.testSummary?.passed).toBe(45);
-        expect(progressUpdate.problems).toBeDefined();
-      });
-    });
-  });
-
-  describe('pollOnce', () => {
-    it('should perform a single poll without scheduling next', async () => {
-      const buildId = '12372';
-
-      mockStatusManager.getBuildStatus.mockResolvedValue({
-        buildId,
-        state: 'running',
-        percentageComplete: 75,
-      });
-
-      const result = await tracker.pollOnce(buildId);
-
-      expect(result).toMatchObject({
-        buildId,
-        state: 'running',
-        percentageComplete: 75,
-      });
-      expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(1);
-
-      // Verify no additional polls are scheduled
-      jest.advanceTimersByTime(10000);
-      await jest.runOnlyPendingTimers();
-      await Promise.resolve();
-
-      expect(mockStatusManager.getBuildStatus).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('getTrackingInfo', () => {
-    it('should return current tracking information', async () => {
-      const buildId = '12373';
-
-      mockStatusManager.getBuildStatus.mockResolvedValue({
-        buildId,
-        state: 'running',
-        percentageComplete: 60,
-        elapsedSeconds: 120,
-      });
-
-      tracker.trackBuildProgress(buildId);
-      await tracker.pollOnce(buildId);
-
-      const info = tracker.getTrackingInfo(buildId);
-
-      expect(info).toMatchObject({
-        buildId,
-        isTracking: true,
-        lastUpdate: expect.any(Object),
-        pollCount: 1,
-        startTime: expect.any(Date),
-      });
-    });
-
-    it('should return null for untracked builds', () => {
-      const info = tracker.getTrackingInfo('unknown');
-      expect(info).toBeNull();
-    });
-  });
-
-  describe('setHistoricalAverage', () => {
-    it('should store and use historical build duration', async () => {
-      const buildId = '12374';
-      const buildTypeId = 'Build_Config_2';
-
-      tracker.setHistoricalAverage(buildTypeId, 240); // 4 minutes average
-
-      mockStatusManager.getBuildStatus.mockResolvedValue({
-        buildId,
-        buildTypeId,
-        state: 'running',
-        percentageComplete: 25,
-        elapsedSeconds: 60,
-      });
-
-      const emitter = tracker.trackBuildProgress(buildId, {
-        useHistoricalData: true,
-      });
-
-      let progressUpdate: ProgressUpdate | undefined;
-      emitter.on('progress', (update) => {
-        progressUpdate = update;
-      });
-
-      await tracker.pollOnce(buildId);
-
-      // Should estimate based on historical average
-      expect(progressUpdate).toBeDefined();
-      if (progressUpdate == null) {
-        throw new Error('Expected progressUpdate to be defined');
-      }
-      expect(progressUpdate.estimatedTotalSeconds).toBe(240);
-      expect(progressUpdate.estimatedTimeRemaining).toBeCloseTo(180, -1);
-    });
-  });
-});