@herdctl/core 0.0.1 → 0.1.0

package/dist/fleet-manager/__tests__/coverage.test.js

@@ -10,11 +10,15 @@
  * - Configuration error paths
  */
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+// Mock the Claude SDK to prevent real API calls during tests
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+    query: vi.fn(),
+}));
 import { mkdtemp, rm, mkdir, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { FleetManager } from "../fleet-manager.js";
-import { ConcurrencyLimitError, FleetManagerConfigError, AgentNotFoundError, ScheduleNotFoundError, } from "../errors.js";
+import { ConcurrencyLimitError, ConfigurationError, AgentNotFoundError, ScheduleNotFoundError, InvalidStateError, } from "../errors.js";
 describe("FleetManager Coverage Tests", () => {
     let tempDir;
     let configDir;
@@ -139,15 +143,15 @@ describe("FleetManager Coverage Tests", () => {
     // Configuration Error Handling
     // ===========================================================================
     describe("Configuration error handling", () => {
-        it("wraps ConfigNotFoundError in FleetManagerConfigError", async () => {
+        it("wraps ConfigNotFoundError in ConfigurationError", async () => {
             const manager = new FleetManager({
                 configPath: "/nonexistent/path/config.yaml",
                 stateDir,
                 logger: createSilentLogger(),
             });
-            await expect(manager.initialize()).rejects.toThrow(FleetManagerConfigError);
+            await expect(manager.initialize()).rejects.toThrow(ConfigurationError);
         });
-        it("wraps ConfigError in FleetManagerConfigError", async () => {
+        it("wraps ConfigError in ConfigurationError", async () => {
             const configPath = join(configDir, "herdctl.yaml");
             // Invalid YAML
             await writeFile(configPath, "invalid: yaml: content: [:");
@@ -156,9 +160,9 @@ describe("FleetManager Coverage Tests", () => {
                 stateDir,
                 logger: createSilentLogger(),
             });
-            await expect(manager.initialize()).rejects.toThrow(FleetManagerConfigError);
+            await expect(manager.initialize()).rejects.toThrow(ConfigurationError);
         });
-        it("wraps unknown errors in FleetManagerConfigError", async () => {
+        it("wraps unknown errors in ConfigurationError", async () => {
             // Create a config that will cause an unexpected error
             const configPath = join(configDir, "herdctl.yaml");
             await writeFile(configPath, "version: 1\nagents: 'not-an-array'");
@@ -167,7 +171,7 @@ describe("FleetManager Coverage Tests", () => {
                 stateDir,
                 logger: createSilentLogger(),
             });
-            await expect(manager.initialize()).rejects.toThrow(FleetManagerConfigError);
+            await expect(manager.initialize()).rejects.toThrow(ConfigurationError);
         });
     });
     // ===========================================================================
@@ -317,7 +321,7 @@ describe("FleetManager Coverage Tests", () => {
     // handleScheduleTrigger Error Handling
     // ===========================================================================
     describe("Schedule trigger error handling", () => {
-        it("emits schedule:trigger and schedule:complete events", async () => {
+        it("emits schedule:triggered event", async () => {
             await createAgentConfig("trigger-event-agent", {
                 name: "trigger-event-agent",
                 schedules: {
@@ -338,21 +342,15 @@ describe("FleetManager Coverage Tests", () => {
                 checkInterval: 50,
                 logger: createSilentLogger(),
             });
-            const triggerHandler = vi.fn();
             const triggeredHandler = vi.fn();
-            const completeHandler = vi.fn();
-            manager.on("schedule:trigger", triggerHandler);
             manager.on("schedule:triggered", triggeredHandler);
-            manager.on("schedule:complete", completeHandler);
             await manager.initialize();
             await manager.start();
             // Wait for schedule to trigger
             await new Promise((resolve) => setTimeout(resolve, 200));
             await manager.stop();
-            // Both legacy and new events should be emitted
-            expect(triggerHandler).toHaveBeenCalled();
+            // The schedule:triggered event should be emitted
             expect(triggeredHandler).toHaveBeenCalled();
-            expect(completeHandler).toHaveBeenCalled();
         });
     });
     // ===========================================================================
@@ -1499,320 +1497,6 @@ describe("FleetManager Coverage Tests", () => {
         });
     });
     // ===========================================================================
-    // FleetManagerStateError tests
-    // ===========================================================================
-    describe("FleetManagerStateError", () => {
-        it("has requiredState alias for backwards compatibility", async () => {
-            const { FleetManagerStateError } = await import("../errors.js");
-            const error = new FleetManagerStateError("test", "current", "required");
-            expect(error.requiredState).toBe("required");
-        });
-    });
-    // ===========================================================================
-    // Event emission helper methods
-    // ===========================================================================
-    describe("Event emission helpers", () => {
-        it("emitConfigReloaded emits config:reloaded event", async () => {
-            await createAgentConfig("emit-config-agent", {
-                name: "emit-config-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-config-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("config:reloaded", handler);
-            manager.emitConfigReloaded({
-                agentCount: 1,
-                agentNames: ["emit-config-agent"],
-                configPath,
-                changes: [],
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitAgentStarted emits agent:started event", async () => {
-            await createAgentConfig("emit-start-agent", {
-                name: "emit-start-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-start-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("agent:started", handler);
-            const agent = manager.getAgents().find(a => a.name === "emit-start-agent");
-            manager.emitAgentStarted({
-                agent,
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitAgentStopped emits agent:stopped event", async () => {
-            await createAgentConfig("emit-stop-agent", {
-                name: "emit-stop-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-stop-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("agent:stopped", handler);
-            manager.emitAgentStopped({
-                agentName: "emit-stop-agent",
-                reason: "test",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitScheduleSkipped emits schedule:skipped event", async () => {
-            await createAgentConfig("emit-skip-agent", {
-                name: "emit-skip-agent",
-                schedules: {
-                    test: { type: "interval", interval: "1h" },
-                },
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-skip-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("schedule:skipped", handler);
-            manager.emitScheduleSkipped({
-                agentName: "emit-skip-agent",
-                scheduleName: "test",
-                reason: "max_concurrent",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobCreated emits job:created event", async () => {
-            await createAgentConfig("emit-job-create-agent", {
-                name: "emit-job-create-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-job-create-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:created", handler);
-            manager.emitJobCreated({
-                job: {
-                    id: "test-job-id",
-                    agent: "emit-job-create-agent",
-                    trigger_type: "manual",
-                    status: "pending",
-                    started_at: new Date().toISOString(),
-                    schedule: null,
-                    prompt: null,
-                    forked_from: null,
-                },
-                agentName: "emit-job-create-agent",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobOutput emits job:output event", async () => {
-            await createAgentConfig("emit-output-agent", {
-                name: "emit-output-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-output-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:output", handler);
-            manager.emitJobOutput({
-                jobId: "test-job-id",
-                agentName: "emit-output-agent",
-                output: "test output",
-                outputType: "stdout",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobCompleted emits job:completed event", async () => {
-            await createAgentConfig("emit-complete-agent", {
-                name: "emit-complete-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-complete-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:completed", handler);
-            manager.emitJobCompleted({
-                job: {
-                    id: "test-job-id",
-                    agent: "emit-complete-agent",
-                    trigger_type: "manual",
-                    status: "completed",
-                    started_at: new Date().toISOString(),
-                    schedule: null,
-                    prompt: null,
-                    forked_from: null,
-                },
-                agentName: "emit-complete-agent",
-                exitReason: "success",
-                durationSeconds: 10,
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobFailed emits job:failed event", async () => {
-            await createAgentConfig("emit-fail-agent", {
-                name: "emit-fail-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-fail-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:failed", handler);
-            manager.emitJobFailed({
-                job: {
-                    id: "test-job-id",
-                    agent: "emit-fail-agent",
-                    trigger_type: "manual",
-                    status: "failed",
-                    started_at: new Date().toISOString(),
-                    schedule: null,
-                    prompt: null,
-                    forked_from: null,
-                },
-                agentName: "emit-fail-agent",
-                error: new Error("Test error"),
-                exitReason: "error",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobCancelled emits job:cancelled event", async () => {
-            await createAgentConfig("emit-cancel-agent", {
-                name: "emit-cancel-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-cancel-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:cancelled", handler);
-            manager.emitJobCancelled({
-                job: {
-                    id: "test-job-id",
-                    agent: "emit-cancel-agent",
-                    trigger_type: "manual",
-                    status: "cancelled",
-                    started_at: new Date().toISOString(),
-                    schedule: null,
-                    prompt: null,
-                    forked_from: null,
-                },
-                agentName: "emit-cancel-agent",
-                terminationType: "graceful",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it("emitJobForked emits job:forked event", async () => {
-            await createAgentConfig("emit-fork-agent", {
-                name: "emit-fork-agent",
-            });
-            const configPath = await createConfig({
-                version: 1,
-                agents: [{ path: "./agents/emit-fork-agent.yaml" }],
-            });
-            const manager = new FleetManager({
-                configPath,
-                stateDir,
-                logger: createSilentLogger(),
-            });
-            await manager.initialize();
-            const handler = vi.fn();
-            manager.on("job:forked", handler);
-            const originalJob = {
-                id: "original-job-id",
-                agent: "emit-fork-agent",
-                trigger_type: "manual",
-                status: "completed",
-                started_at: new Date().toISOString(),
-                schedule: null,
-                prompt: null,
-                forked_from: null,
-            };
-            manager.emitJobForked({
-                job: {
-                    id: "forked-job-id",
-                    agent: "emit-fork-agent",
-                    trigger_type: "fork",
-                    status: "pending",
-                    started_at: new Date().toISOString(),
-                    schedule: null,
-                    prompt: null,
-                    forked_from: "original-job-id",
-                },
-                originalJob,
-                agentName: "emit-fork-agent",
-                timestamp: new Date().toISOString(),
-            });
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-    });
-    // ===========================================================================
     // getAgentInfoByName tests
     // ===========================================================================
     describe("getAgentInfoByName", () => {
@@ -2120,8 +1804,7 @@ describe("FleetManager Coverage Tests", () => {
                 stateDir,
                 logger: createSilentLogger(),
             });
-            const { FleetManagerStateError } = await import("../errors.js");
-            await expect(manager.start()).rejects.toThrow(FleetManagerStateError);
+            await expect(manager.start()).rejects.toThrow(InvalidStateError);
         });
     });
     // ===========================================================================