@northflare/runner 0.0.12 → 0.0.13

package/tests/retry-strategies.test.ts

@@ -1,410 +0,0 @@
-/**
- * Tests for runner registration retry strategies
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { RunnerApp } from "../src/runner-sse";
-import { RunnerConfig } from "../src/types";
-
-// Mock dependencies
-vi.mock('simple-git', () => ({
-  default: vi.fn(() => ({
-    init: vi.fn().mockResolvedValue(undefined),
-    addConfig: vi.fn().mockResolvedValue(undefined),
-  }))
-}));
-
-vi.mock('fs/promises', () => ({
-  default: {
-    mkdir: vi.fn().mockResolvedValue(undefined),
-    access: vi.fn().mockRejectedValue(new Error('Not found')),
-    readFile: vi.fn().mockResolvedValue('{}'),
-    writeFile: vi.fn().mockResolvedValue(undefined),
-  }
-}));
-
-vi.mock('../src/components/message-handler-sse', () => ({
-  MessageHandler: vi.fn().mockImplementation(() => ({
-    startProcessing: vi.fn().mockResolvedValue(undefined),
-    stopProcessing: vi.fn().mockResolvedValue(undefined),
-    initializeCollectionAfterRegistration: vi.fn(),
-  }))
-}));
-
-vi.mock('../src/components/claude-sdk-manager', () => ({
-  ClaudeManager: vi.fn().mockImplementation(() => ({
-    stopConversation: vi.fn().mockResolvedValue(undefined),
-  }))
-}));
-
-vi.mock('../src/components/enhanced-repository-manager', () => ({
-  EnhancedRepositoryManager: vi.fn().mockImplementation(() => ({
-    createLocalTaskHandle: vi.fn(),
-    createTaskWorktree: vi.fn(),
-    checkoutRepository: vi.fn(),
-    getWorkspacePath: vi.fn(),
-  }))
-}));
-
-vi.mock('../src/utils/logger', () => ({
-  createLogger: vi.fn(() => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }))
-}));
-
-vi.mock('../src/utils/status-line', () => ({
-  statusLineManager: {
-    dispose: vi.fn(),
-  }
-}));
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-  vi.clearAllTimers();
-});
-
-describe("Runner Registration Retry Strategies", () => {
-  const baseConfig: RunnerConfig = {
-    orchestratorUrl: "http://orchestrator.test",
-    dataDir: "./test-data",
-    heartbeatInterval: 120000,
-    retryStrategy: "none",
-    retryIntervalSecs: 60,
-    retryDurationSecs: 900,
-    workspaceDir: "/test/workspace",
-  };
-
-  describe("No Retry Strategy", () => {
-    it("should fail immediately if registration fails", async () => {
-      const config = { ...baseConfig, retryStrategy: "none" as const };
-      const runner = new RunnerApp(config);
-      
-      // Mock sendToOrchestrator to fail
-      runner.sendToOrchestrator = vi.fn().mockRejectedValue(new Error("Connection refused"));
-
-      await expect(runner.start()).rejects.toThrow("Connection refused");
-      expect(runner.sendToOrchestrator).toHaveBeenCalledTimes(1);
-    });
-
-    it("should succeed on first attempt", async () => {
-      const config = { ...baseConfig, retryStrategy: "none" as const };
-      const runner = new RunnerApp(config);
-
-      // Mock successful registration
-      runner.sendToOrchestrator = vi.fn().mockResolvedValue({ 
-        jsonrpc: "2.0",
-        result: { 
-          success: true, 
-          runnerId: "runner-123" 
-        }
-      });
-
-      await runner.start();
-      expect(runner.getRunnerId()).toBe("runner-123");
-      expect(runner.sendToOrchestrator).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("Interval Retry Strategy", () => {
-
-    it("should retry at fixed intervals until success", async () => {
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "interval" as const,
-        retryIntervalSecs: 2, // 2 seconds for testing
-      };
-      const runner = new RunnerApp(config);
-
-      // Mock delay function to resolve immediately
-      let delayCallCount = 0;
-      runner.setDelayFunction(async (ms: number) => {
-        delayCallCount++;
-        expect(ms).toBe(2000); // Should always be 2 seconds
-      });
-
-      // Mock: fail 2 times, then succeed
-      const mock = vi.fn()
-        .mockRejectedValueOnce(new Error("Connection refused"))
-        .mockRejectedValueOnce(new Error("Server error"))
-        .mockResolvedValueOnce({ 
-          jsonrpc: "2.0",
-          result: { 
-            success: true, 
-            runnerId: "runner-456" 
-          }
-        });
-      runner.sendToOrchestrator = mock;
-
-      await runner.start();
-
-      expect(mock).toHaveBeenCalledTimes(3);
-      expect(delayCallCount).toBe(2); // Two delays between three attempts
-      expect(runner.getRunnerId()).toBe("runner-456");
-    });
-
-    it("should keep retrying indefinitely with interval strategy", async () => {
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "interval" as const,
-        retryIntervalSecs: 1,
-      };
-      const runner = new RunnerApp(config);
-
-      // Track attempts
-      let attemptCount = 0;
-      const mock = vi.fn().mockImplementation(() => {
-        attemptCount++;
-        if (attemptCount <= 10) {
-          return Promise.reject(new Error("Connection refused"));
-        }
-        return Promise.resolve({
-          jsonrpc: "2.0",
-          result: { success: true, runnerId: "runner-stopped" }
-        });
-      });
-      runner.sendToOrchestrator = mock;
-
-      // Mock delay to resolve immediately but track calls
-      let delayCallCount = 0;
-      runner.setDelayFunction(async (ms: number) => {
-        delayCallCount++;
-        expect(ms).toBe(1000);
-      });
-
-      await runner.start();
-
-      expect(mock).toHaveBeenCalledTimes(11); // Initial + 10 retries
-      expect(delayCallCount).toBe(10);
-      await runner.stop();
-    });
-  });
-
-  describe("Exponential Retry Strategy", () => {
-
-    it("should retry with exponential backoff", async () => {
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "exponential" as const,
-        retryDurationSecs: 120, // 2 minutes for testing
-      };
-      const runner = new RunnerApp(config);
-
-      // Track delay calls
-      const delayCalls: number[] = [];
-      runner.setDelayFunction(async (ms: number) => {
-        delayCalls.push(ms);
-      });
-
-      // Mock: fail 3 times, then succeed
-      const mock = vi.fn()
-        .mockRejectedValueOnce(new Error("Error 1"))
-        .mockRejectedValueOnce(new Error("Error 2"))
-        .mockRejectedValueOnce(new Error("Error 3"))
-        .mockResolvedValueOnce({ 
-          jsonrpc: "2.0",
-          result: { 
-            success: true, 
-            runnerId: "runner-789" 
-          }
-        });
-      runner.sendToOrchestrator = mock;
-
-      await runner.start();
-
-      expect(mock).toHaveBeenCalledTimes(4);
-      expect(delayCalls).toEqual([8000, 16000, 32000]); // Exponential backoff
-      expect(runner.getRunnerId()).toBe("runner-789");
-    });
-
-    it("should stop retrying after max duration", async () => {
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "exponential" as const,
-        retryDurationSecs: 30, // 30 seconds max
-      };
-      const runner = new RunnerApp(config);
-
-      // Mock Date.now() for precise time control
-      let currentTime = 0;
-      vi.spyOn(Date, 'now').mockImplementation(() => currentTime);
-
-      // Track delay calls
-      const delayCalls: number[] = [];
-      runner.setDelayFunction(async (ms: number) => {
-        delayCalls.push(ms);
-        currentTime += ms;
-      });
-
-      // Always fail
-      runner.sendToOrchestrator = vi.fn().mockRejectedValue(new Error("Connection refused"));
-
-      await expect(runner.start()).rejects.toThrow("Failed to register after 30 seconds");
-
-      // Should have attempted: immediate, +8s, +16s, then final at 30s
-      expect(runner.sendToOrchestrator).toHaveBeenCalledTimes(4);
-      expect(delayCalls).toEqual([8000, 16000, 6000]); // Last delay is 6s to reach 30s total
-      
-      vi.spyOn(Date, 'now').mockRestore();
-      await runner.stop();
-    });
-
-    it("should handle final retry at max duration", async () => {
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "exponential" as const,
-        retryDurationSecs: 60, // 1 minute
-      };
-      const runner = new RunnerApp(config);
-
-      // Mock Date.now() for precise time control
-      let currentTime = 0;
-      vi.spyOn(Date, 'now').mockImplementation(() => currentTime);
-
-      // Track delay calls
-      const delayCalls: number[] = [];
-      runner.setDelayFunction(async (ms: number) => {
-        delayCalls.push(ms);
-        currentTime += ms;
-      });
-
-      // Fail until the final retry
-      let callCount = 0;
-      runner.sendToOrchestrator = vi.fn().mockImplementation(() => {
-        callCount++;
-        if (callCount < 4) {
-          return Promise.reject(new Error("Still failing"));
-        }
-        return Promise.resolve({ 
-          jsonrpc: "2.0",
-          result: { 
-            success: true, 
-            runnerId: "runner-final" 
-          }
-        });
-      });
-
-      await runner.start();
-
-      expect(runner.sendToOrchestrator).toHaveBeenCalledTimes(4);
-      // First delay is 8s, second is 16s, third would be 32s but gets limited to remaining time
-      // After 8+16=24s, only 36s remain to 60s total, but next delay would be 32s, so it's min(32, 36) = 32
-      expect(delayCalls).toEqual([8000, 16000, 32000]);
-      expect(runner.getRunnerId()).toBe("runner-final");
-      
-      vi.spyOn(Date, 'now').mockRestore();
-    });
-  });
-
-  describe("Registration Response Handling", () => {
-    it("should handle missing runnerId in response", async () => {
-      const config = { ...baseConfig, retryStrategy: "none" as const };
-      const runner = new RunnerApp(config);
-
-      // Mock response without runnerId
-      runner.sendToOrchestrator = vi.fn().mockResolvedValue({ 
-        jsonrpc: "2.0",
-        result: { 
-          success: true 
-        } // Missing runnerId
-      });
-
-      await expect(runner.start()).rejects.toThrow("Registration response did not include runnerId");
-    });
-
-    it("should store runnerId from successful registration", async () => {
-      const config = { ...baseConfig, retryStrategy: "none" as const };
-      const runner = new RunnerApp(config);
-
-      runner.sendToOrchestrator = vi.fn().mockResolvedValue({ 
-        jsonrpc: "2.0",
-        result: { 
-          success: true, 
-          runnerId: "runner-abc-123" 
-        }
-      });
-
-      await runner.start();
-      expect(runner.getRunnerId()).toBe("runner-abc-123");
-    });
-  });
-
-  describe("Heartbeat Behavior", () => {
-
-    it("should not start heartbeat if registration fails", async () => {
-      vi.useFakeTimers();
-      
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "none" as const,
-        heartbeatInterval: 5000,
-      };
-      const runner = new RunnerApp(config);
-
-      // Mock failed registration
-      const mock = vi.fn().mockRejectedValue(new Error("Registration failed"));
-      runner.sendToOrchestrator = mock;
-
-      await expect(runner.start()).rejects.toThrow("Registration failed");
-
-      // Advance time to check if heartbeat was started
-      await vi.advanceTimersByTimeAsync(10000);
-
-      // Should only have the registration attempt, no heartbeat calls
-      expect(mock).toHaveBeenCalledTimes(1);
-      
-      vi.useRealTimers();
-    });
-
-    it("should start heartbeat after successful registration", async () => {
-      vi.useFakeTimers();
-      
-      const config = { 
-        ...baseConfig, 
-        retryStrategy: "none" as const,
-        heartbeatInterval: 5000,
-      };
-      const runner = new RunnerApp(config);
-
-      // Mock successful registration and heartbeat
-      const mock = vi.fn()
-        .mockResolvedValueOnce({ 
-          jsonrpc: "2.0",
-          result: { 
-            success: true, 
-            runnerId: "runner-heartbeat" 
-          }
-        })
-        .mockResolvedValue({ 
-          jsonrpc: "2.0",
-          result: { 
-            success: true 
-          }
-        });
-      runner.sendToOrchestrator = mock;
-
-      await runner.start();
-
-      // Initial registration call
-      expect(mock).toHaveBeenCalledTimes(1);
-
-      // Advance time for heartbeat
-      await vi.advanceTimersByTimeAsync(5000);
-      expect(mock).toHaveBeenCalledTimes(2);
-
-      // Check heartbeat was called with correct params
-      const heartbeatCall = mock.mock.calls[1];
-      expect(heartbeatCall![0].method).toBe("runner.heartbeat");
-      expect(heartbeatCall![0].params.runnerId).toBe("runner-heartbeat");
-
-      await runner.stop();
-      vi.useRealTimers();
-    });
-  });
-});