onbuzz 3.4.0 → 3.6.2

package/src/tools/__tests__/agentDelayTool.test.js

@@ -0,0 +1,342 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock dependencies before importing
+jest.unstable_mockModule('../../utilities/tagParser.js', () => ({
+  default: {
+    extractContent: jest.fn((content, tag) => {
+      const regex = new RegExp(`<${tag}>(.*?)</${tag}>`, 'gs');
+      const matches = [];
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        matches.push(match[1]);
+      }
+      return matches;
+    })
+  }
+}));
+
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  TOOL_STATUS: { PENDING: 'pending', EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed' },
+  SYSTEM_DEFAULTS: { MAX_PAUSE_DURATION: 300, MAX_TOOL_EXECUTION_TIME: 300000 },
+  AGENT_STATUS: { ACTIVE: 'active', IDLE: 'idle', BUSY: 'busy', PAUSED: 'paused' },
+  OPERATION_STATUS: { EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed' },
+  ERROR_TYPES: {}
+}));
+
+const { default: AgentDelayTool } = await import('../agentDelayTool.js');
+
+describe('AgentDelayTool', () => {
+  let tool;
+  let logger;
+  let mockAgentPool;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    mockAgentPool = {
+      pauseAgent: jest.fn().mockResolvedValue({ success: true }),
+      getAgent: jest.fn().mockResolvedValue({ id: 'agent-1', delayEndTime: null }),
+      persistAgentState: jest.fn().mockResolvedValue(undefined)
+    };
+    tool = new AgentDelayTool({}, logger, mockAgentPool);
+  });
+
+  describe('constructor', () => {
+    test('should set default pause durations', () => {
+      expect(tool.maxPauseDuration).toBe(300);
+      expect(tool.minPauseDuration).toBe(1);
+      expect(tool.requiresProject).toBe(false);
+      expect(tool.isAsync).toBe(false);
+    });
+
+    test('should accept custom durations', () => {
+      const customTool = new AgentDelayTool({ maxDuration: 600, minDuration: 5 }, logger, null);
+      expect(customTool.maxPauseDuration).toBe(600);
+      expect(customTool.minPauseDuration).toBe(5);
+    });
+  });
+
+  describe('getDescription', () => {
+    test('should return description with pause range info', () => {
+      const desc = tool.getDescription();
+      expect(desc).toContain('Agent Delay Tool');
+      expect(desc).toContain('duration');
+    });
+  });
+
+  describe('getSupportedActions', () => {
+    test('should return pause and delay', () => {
+      const actions = tool.getSupportedActions();
+      expect(actions).toContain('pause');
+      expect(actions).toContain('delay');
+    });
+  });
+
+  describe('getRequiredParameters', () => {
+    test('should require duration', () => {
+      expect(tool.getRequiredParameters()).toContain('duration');
+    });
+  });
+
+  describe('parseParameters', () => {
+    test('should parse duration and reason from tags', () => {
+      const result = tool.parseParameters('<pause-duration>30</pause-duration><reason>Waiting</reason>');
+      expect(result.duration).toBe(30);
+      expect(result.reason).toBe('Waiting');
+    });
+
+    test('should default reason when not provided', () => {
+      const result = tool.parseParameters('<pause-duration>60</pause-duration>');
+      expect(result.duration).toBe(60);
+      expect(result.reason).toBe('Agent pause requested');
+    });
+
+    test('should return null duration when not provided', () => {
+      const result = tool.parseParameters('some content');
+      expect(result.duration).toBeNull();
+    });
+  });
+
+  describe('validateParameterTypes', () => {
+    test('should accept valid params', () => {
+      const result = tool.validateParameterTypes({ duration: 30, reason: 'test' });
+      expect(result.valid).toBe(true);
+    });
+
+    test('should reject non-number duration', () => {
+      const result = tool.validateParameterTypes({ duration: 'abc' });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('valid number');
+    });
+
+    test('should reject non-string reason', () => {
+      const result = tool.validateParameterTypes({ duration: 30, reason: 123 });
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('customValidateParameters', () => {
+    test('should reject null duration', () => {
+      const result = tool.customValidateParameters({ duration: null });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('required');
+    });
+
+    test('should reject duration below minimum', () => {
+      const result = tool.customValidateParameters({ duration: 0 });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('at least');
+    });
+
+    test('should reject duration above maximum', () => {
+      const result = tool.customValidateParameters({ duration: 999 });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('cannot exceed');
+    });
+
+    test('should reject non-integer duration', () => {
+      const result = tool.customValidateParameters({ duration: 10.5 });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('whole number');
+    });
+
+    test('should reject reason over 200 chars', () => {
+      const result = tool.customValidateParameters({ duration: 30, reason: 'x'.repeat(201) });
+      expect(result.valid).toBe(false);
+    });
+
+    test('should accept valid parameters', () => {
+      const result = tool.customValidateParameters({ duration: 60, reason: 'Valid reason' });
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('execute', () => {
+    test('should throw when agentId is missing', async () => {
+      await expect(tool.execute({ duration: 30, reason: 'test' }, {}))
+        .rejects.toThrow('Agent ID is required');
+    });
+
+    test('should throw when agentPool is not available', async () => {
+      tool.agentPool = null;
+      await expect(tool.execute({ duration: 30, reason: 'test' }, { agentId: 'agent-1' }))
+        .rejects.toThrow('Agent pool not available');
+    });
+
+    test('should successfully pause agent', async () => {
+      const result = await tool.execute(
+        { duration: 30, reason: 'npm install' },
+        { agentId: 'agent-1' }
+      );
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('agent-pause');
+      expect(result.agentId).toBe('agent-1');
+      expect(result.pauseDuration).toBe(30);
+      expect(result.reason).toBe('npm install');
+      expect(result.pausedUntil).toBeDefined();
+      expect(mockAgentPool.pauseAgent).toHaveBeenCalled();
+    });
+
+    test('should set delayEndTime on agent', async () => {
+      const mockAgent = { id: 'agent-1', delayEndTime: null };
+      mockAgentPool.getAgent.mockResolvedValue(mockAgent);
+
+      await tool.execute(
+        { duration: 60, reason: 'build' },
+        { agentId: 'agent-1' }
+      );
+      expect(mockAgent.delayEndTime).toBeDefined();
+      expect(mockAgentPool.persistAgentState).toHaveBeenCalledWith('agent-1');
+    });
+
+    test('should throw when pause fails', async () => {
+      mockAgentPool.pauseAgent.mockResolvedValue({ success: false, message: 'Agent not found' });
+
+      await expect(tool.execute(
+        { duration: 30, reason: 'test' },
+        { agentId: 'agent-1' }
+      )).rejects.toThrow('Failed to pause agent');
+    });
+
+    test('should format singular second correctly', async () => {
+      const result = await tool.execute(
+        { duration: 1, reason: 'brief' },
+        { agentId: 'agent-1' }
+      );
+      expect(result.message).toBe('Agent will resume activity in 1 second');
+    });
+
+    test('should format plural seconds correctly', async () => {
+      const result = await tool.execute(
+        { duration: 30, reason: 'brief' },
+        { agentId: 'agent-1' }
+      );
+      expect(result.message).toBe('Agent will resume activity in 30 seconds');
+    });
+  });
+
+  describe('getCapabilities', () => {
+    test('should include pause range info', () => {
+      const caps = tool.getCapabilities();
+      expect(caps.pauseRange).toBeDefined();
+      expect(caps.pauseRange.min).toBe(1);
+      expect(caps.pauseRange.max).toBe(300);
+      expect(caps.affects).toBe('agent-status');
+    });
+  });
+
+  describe('formatResumeTime', () => {
+    test('should format seconds', () => {
+      const futureDate = new Date(Date.now() + 30000);
+      const result = tool.formatResumeTime(futureDate);
+      expect(result).toMatch(/in \d+ seconds?/);
+    });
+
+    test('should format minutes', () => {
+      const futureDate = new Date(Date.now() + 120000);
+      const result = tool.formatResumeTime(futureDate);
+      expect(result).toMatch(/in \d+ minutes?/);
+    });
+
+    test('should format hours', () => {
+      const futureDate = new Date(Date.now() + 7200000);
+      const result = tool.formatResumeTime(futureDate);
+      expect(result).toMatch(/in \d+ hours?/);
+    });
+  });
+
+  describe('canPauseAgent', () => {
+    test('should return false when no agent pool', async () => {
+      tool.agentPool = null;
+      const result = await tool.canPauseAgent('agent-1');
+      expect(result.canPause).toBe(false);
+    });
+
+    test('should return false when agent not found', async () => {
+      mockAgentPool.getAgent.mockResolvedValue(null);
+      const result = await tool.canPauseAgent('agent-1');
+      expect(result.canPause).toBe(false);
+      expect(result.reason).toContain('not found');
+    });
+
+    test('should return false when agent already paused', async () => {
+      mockAgentPool.getAgent.mockResolvedValue({ status: 'paused', pausedUntil: 'sometime' });
+      const result = await tool.canPauseAgent('agent-1');
+      expect(result.canPause).toBe(false);
+      expect(result.reason).toContain('already paused');
+    });
+
+    test('should return true when agent can be paused', async () => {
+      mockAgentPool.getAgent.mockResolvedValue({ status: 'active' });
+      const result = await tool.canPauseAgent('agent-1');
+      expect(result.canPause).toBe(true);
+    });
+
+    test('should handle errors gracefully', async () => {
+      mockAgentPool.getAgent.mockRejectedValue(new Error('DB error'));
+      const result = await tool.canPauseAgent('agent-1');
+      expect(result.canPause).toBe(false);
+    });
+  });
+
+  describe('getPauseRecommendations', () => {
+    test('should recommend for npm install', () => {
+      const result = tool.getPauseRecommendations({ lastCommand: 'npm install' });
+      expect(result.suggested.length).toBeGreaterThan(0);
+      expect(result.suggested[0].duration).toBe(90);
+    });
+
+    test('should recommend for docker build', () => {
+      const result = tool.getPauseRecommendations({ lastCommand: 'docker build .' });
+      expect(result.suggested.length).toBeGreaterThan(0);
+    });
+
+    test('should warn about short pauses', () => {
+      const result = tool.getPauseRecommendations({ requestedDuration: 5 });
+      expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    test('should warn about long pauses', () => {
+      const result = tool.getPauseRecommendations({ requestedDuration: 250 });
+      expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    test('should return empty for no context', () => {
+      const result = tool.getPauseRecommendations({});
+      expect(result.suggested).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+  });
+
+  describe('setAgentPool', () => {
+    test('should enable tool when pool is provided', () => {
+      const newTool = new AgentDelayTool({}, logger, null);
+      newTool.setAgentPool(mockAgentPool);
+      expect(newTool.isEnabled).toBe(true);
+    });
+
+    test('should disable tool when pool is null', () => {
+      tool.setAgentPool(null);
+      expect(tool.isEnabled).toBe(false);
+    });
+  });
+
+  describe('getUsageExamples', () => {
+    test('should return array of examples', () => {
+      const examples = tool.getUsageExamples();
+      expect(Array.isArray(examples)).toBe(true);
+      expect(examples.length).toBeGreaterThan(0);
+      expect(examples[0].title).toBeDefined();
+      expect(examples[0].command).toBeDefined();
+    });
+  });
+
+  describe('getParameterSchema', () => {
+    test('should return schema with duration and reason', () => {
+      const schema = tool.getParameterSchema();
+      expect(schema.properties.duration).toBeDefined();
+      expect(schema.properties.reason).toBeDefined();
+      expect(schema.required).toContain('duration');
+    });
+  });
+});

package/src/tools/__tests__/asyncToolManager.test.js

@@ -0,0 +1,344 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  TOOL_STATUS: {
+    PENDING: 'pending',
+    EXECUTING: 'executing',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+    TIMEOUT: 'timeout'
+  },
+  SYSTEM_DEFAULTS: { MAX_TOOL_EXECUTION_TIME: 300000 },
+  OPERATION_STATUS: {},
+  ERROR_TYPES: {}
+}));
+
+const { default: AsyncToolManager } = await import('../asyncToolManager.js');
+
+describe('AsyncToolManager', () => {
+  let manager;
+  let logger;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    logger = createMockLogger();
+    manager = new AsyncToolManager({
+      maxConcurrentOperations: 5,
+      defaultTimeout: 10000,
+      cleanupInterval: 60000
+    }, logger);
+  });
+
+  afterEach(() => {
+    manager.stopMonitoring();
+    manager.removeAllListeners();
+    jest.useRealTimers();
+  });
+
+  describe('constructor', () => {
+    test('should set default config', () => {
+      expect(manager.maxConcurrentOperations).toBe(5);
+      expect(manager.defaultTimeout).toBe(10000);
+      expect(manager.operations).toBeInstanceOf(Map);
+      expect(manager.operationHistory).toEqual([]);
+    });
+
+    test('should start monitoring on creation', () => {
+      expect(manager.monitoringInterval).not.toBeNull();
+    });
+  });
+
+  describe('startOperation', () => {
+    test('should create and track a new operation', async () => {
+      const opId = await manager.startOperation('filesystem', 'agent-1', { path: '/test' });
+      expect(typeof opId).toBe('string');
+      expect(opId).toMatch(/^op-/);
+      expect(manager.operations.has(opId)).toBe(true);
+    });
+
+    test('should set pending status initially', async () => {
+      const opId = await manager.startOperation('filesystem', 'agent-1', {});
+      const op = manager.operations.get(opId);
+      expect(op.status).toBe('pending');
+    });
+
+    test('should throw when max concurrent operations reached', async () => {
+      // Fill up operations
+      for (let i = 0; i < 5; i++) {
+        await manager.startOperation('tool', `agent-${i}`, {});
+      }
+      await expect(manager.startOperation('tool', 'agent-extra', {}))
+        .rejects.toThrow('Maximum concurrent operations');
+    });
+
+    test('should use custom timeout from context', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {}, { timeout: 5000 });
+      const op = manager.operations.get(opId);
+      expect(op.timeout).toBe(5000);
+    });
+  });
+
+  describe('updateOperation', () => {
+    test('should update operation status', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      const result = manager.updateOperation(opId, 'executing');
+      expect(result).toBe(true);
+      expect(manager.operations.get(opId).status).toBe('executing');
+    });
+
+    test('should set startedAt on executing', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'executing');
+      expect(manager.operations.get(opId).startedAt).not.toBeNull();
+    });
+
+    test('should set completedAt on completed', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'completed', { result: 'done' });
+      expect(manager.operations.get(opId).completedAt).not.toBeNull();
+      expect(manager.operations.get(opId).result).toBe('done');
+    });
+
+    test('should return false for unknown operation', () => {
+      const result = manager.updateOperation('nonexistent', 'completed');
+      expect(result).toBe(false);
+    });
+
+    test('should store error data', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'failed', { error: 'Something broke' });
+      expect(manager.operations.get(opId).error).toBe('Something broke');
+    });
+
+    test('should store progress data', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'executing', { progress: 50 });
+      expect(manager.operations.get(opId).progress).toBe(50);
+    });
+  });
+
+  describe('getOperation', () => {
+    test('should return operation details', async () => {
+      const opId = await manager.startOperation('filesystem', 'agent-1', { path: '/test' });
+      const op = manager.getOperation(opId);
+      expect(op).not.toBeNull();
+      expect(op.toolId).toBe('filesystem');
+      expect(op.agentId).toBe('agent-1');
+      expect(op.status).toBe('pending');
+    });
+
+    test('should return null for unknown operation', () => {
+      expect(manager.getOperation('nonexistent')).toBeNull();
+    });
+
+    test('should include executionTime', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'executing');
+      const op = manager.getOperation(opId);
+      expect(op.executionTime).toBeDefined();
+    });
+  });
+
+  describe('getAgentOperations', () => {
+    test('should return only operations for specified agent', async () => {
+      await manager.startOperation('tool1', 'agent-1', {});
+      await manager.startOperation('tool2', 'agent-1', {});
+      await manager.startOperation('tool3', 'agent-2', {});
+
+      const ops = manager.getAgentOperations('agent-1');
+      expect(ops).toHaveLength(2);
+    });
+
+    test('returns all operations for agent', async () => {
+      const id1 = await manager.startOperation('tool1', 'agent-1', {});
+      const id2 = await manager.startOperation('tool2', 'agent-1', {});
+      const ops = manager.getAgentOperations('agent-1');
+      const ids = ops.map(op => op.id);
+      expect(ids).toContain(id1);
+      expect(ids).toContain(id2);
+    });
+  });
+
+  describe('cancelOperation', () => {
+    test('should cancel a pending operation', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      const result = await manager.cancelOperation(opId, 'No longer needed');
+      expect(result).toBe(true);
+    });
+
+    test('should return false for unknown operation', async () => {
+      const result = await manager.cancelOperation('nonexistent');
+      expect(result).toBe(false);
+    });
+
+    test('should not cancel completed operation', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'completed');
+      const result = await manager.cancelOperation(opId);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('retryOperation', () => {
+    test('should retry a failed operation with retries remaining', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {}, { maxRetries: 3 });
+      manager.updateOperation(opId, 'failed', { error: 'timeout' });
+      const result = await manager.retryOperation(opId);
+      expect(result).toBe(true);
+      expect(manager.operations.get(opId).retryCount).toBe(1);
+      expect(manager.operations.get(opId).status).toBe('pending');
+    });
+
+    test('should not retry when max retries exceeded', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {}, { maxRetries: 0 });
+      manager.updateOperation(opId, 'failed');
+      const result = await manager.retryOperation(opId);
+      expect(result).toBe(false);
+    });
+
+    test('should not retry non-failed operation', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      const result = await manager.retryOperation(opId);
+      expect(result).toBe(false);
+    });
+
+    test('should return false for unknown operation', async () => {
+      const result = await manager.retryOperation('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getStatistics', () => {
+    test('should return correct stats', async () => {
+      await manager.startOperation('filesystem', 'agent-1', {});
+      await manager.startOperation('terminal', 'agent-1', {});
+      await manager.startOperation('filesystem', 'agent-2', {});
+
+      const stats = manager.getStatistics();
+      expect(stats.total).toBe(3);
+      expect(stats.byTool.filesystem).toBe(2);
+      expect(stats.byTool.terminal).toBe(1);
+      expect(stats.byAgent['agent-1']).toBe(2);
+    });
+
+    test('should return empty stats when no operations', () => {
+      const stats = manager.getStatistics();
+      expect(stats.total).toBe(0);
+      expect(stats.averageExecutionTime).toBe(0);
+    });
+  });
+
+  describe('cleanupCompletedOperations', () => {
+    test('should clean up old completed operations', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'completed');
+
+      // Set completedAt to past
+      manager.operations.get(opId).completedAt = new Date(Date.now() - 7200000).toISOString();
+
+      const count = await manager.cleanupCompletedOperations(3600000);
+      expect(count).toBe(1);
+      expect(manager.operations.has(opId)).toBe(false);
+    });
+
+    test('should not clean up recent operations', async () => {
+      const opId = await manager.startOperation('tool', 'agent-1', {});
+      manager.updateOperation(opId, 'completed');
+
+      const count = await manager.cleanupCompletedOperations(3600000);
+      expect(count).toBe(0);
+    });
+  });
+
+  describe('shutdown', () => {
+    test('should cancel active operations and stop monitoring', async () => {
+      await manager.startOperation('tool1', 'agent-1', {});
+      await manager.startOperation('tool2', 'agent-1', {});
+
+      await manager.shutdown();
+      expect(manager.isShuttingDown).toBe(true);
+      expect(manager.operations.size).toBe(0);
+      expect(manager.monitoringInterval).toBeNull();
+    });
+  });
+
+  describe('getOperationHistory', () => {
+    test('should return empty history initially', () => {
+      const history = manager.getOperationHistory();
+      expect(history).toEqual([]);
+    });
+
+    test('should filter by agentId', async () => {
+      // Add to history manually
+      manager.operationHistory.push(
+        { agentId: 'agent-1', toolId: 'tool1', createdAt: new Date().toISOString() },
+        { agentId: 'agent-2', toolId: 'tool2', createdAt: new Date().toISOString() }
+      );
+      const history = manager.getOperationHistory({ agentId: 'agent-1' });
+      expect(history).toHaveLength(1);
+    });
+
+    test('should filter by toolId', () => {
+      manager.operationHistory.push(
+        { agentId: 'agent-1', toolId: 'filesystem', createdAt: new Date().toISOString() },
+        { agentId: 'agent-1', toolId: 'terminal', createdAt: new Date().toISOString() }
+      );
+      const history = manager.getOperationHistory({ toolId: 'filesystem' });
+      expect(history).toHaveLength(1);
+    });
+
+    test('should filter by status', () => {
+      manager.operationHistory.push(
+        { agentId: 'agent-1', status: 'completed', createdAt: new Date().toISOString() },
+        { agentId: 'agent-1', status: 'failed', createdAt: new Date().toISOString() }
+      );
+      const history = manager.getOperationHistory({ status: 'completed' });
+      expect(history).toHaveLength(1);
+    });
+
+    test('should respect limit', () => {
+      for (let i = 0; i < 10; i++) {
+        manager.operationHistory.push({
+          agentId: 'agent-1', createdAt: new Date().toISOString()
+        });
+      }
+      const history = manager.getOperationHistory({ limit: 3 });
+      expect(history).toHaveLength(3);
+    });
+  });
+
+  describe('generateOperationId', () => {
+    test('should generate unique IDs', () => {
+      const id1 = manager.generateOperationId();
+      const id2 = manager.generateOperationId();
+      expect(id1).not.toBe(id2);
+      expect(id1).toMatch(/^op-/);
+    });
+  });
+
+  describe('calculateExecutionTime', () => {
+    test('should return 0 when not started', () => {
+      const result = manager.calculateExecutionTime({ startedAt: null });
+      expect(result).toBe(0);
+    });
+
+    test('should calculate time for completed operation', () => {
+      const start = new Date('2024-01-01T00:00:00Z');
+      const end = new Date('2024-01-01T00:01:00Z');
+      const result = manager.calculateExecutionTime({
+        startedAt: start.toISOString(),
+        completedAt: end.toISOString()
+      });
+      expect(result).toBe(60000);
+    });
+  });
+
+  describe('stopMonitoring', () => {
+    test('should clear the interval', () => {
+      manager.stopMonitoring();
+      expect(manager.monitoringInterval).toBeNull();
+    });
+  });
+});