@herdctl/core 0.0.1 → 0.0.2

package/src/fleet-manager/__tests__/errors.test.ts

@@ -1,660 +0,0 @@
-/**
- * Tests for fleet-manager error classes
- *
- * Tests all error classes, their constructors, properties, and type guards.
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  FleetManagerErrorCode,
-  FleetManagerError,
-  ConfigurationError,
-  AgentNotFoundError,
-  JobNotFoundError,
-  ScheduleNotFoundError,
-  InvalidStateError,
-  FleetManagerStateError,
-  ConcurrencyLimitError,
-  FleetManagerConfigError,
-  FleetManagerStateDirError,
-  FleetManagerShutdownError,
-  JobCancelError,
-  JobForkError,
-  // Type guards
-  isFleetManagerError,
-  isConfigurationError,
-  isAgentNotFoundError,
-  isJobNotFoundError,
-  isScheduleNotFoundError,
-  isInvalidStateError,
-  isConcurrencyLimitError,
-  isJobCancelError,
-  isJobForkError,
-} from "../errors.js";
-
-describe("FleetManagerError classes", () => {
-  // ===========================================================================
-  // FleetManagerError (base class)
-  // ===========================================================================
-  describe("FleetManagerError", () => {
-    it("creates error with message", () => {
-      const error = new FleetManagerError("Test error");
-      expect(error.message).toBe("Test error");
-      expect(error.name).toBe("FleetManagerError");
-      expect(error.code).toBe(FleetManagerErrorCode.FLEET_MANAGER_ERROR);
-    });
-
-    it("creates error with custom code", () => {
-      const error = new FleetManagerError("Test error", {
-        code: FleetManagerErrorCode.CONFIGURATION_ERROR,
-      });
-      expect(error.code).toBe(FleetManagerErrorCode.CONFIGURATION_ERROR);
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Original error");
-      const error = new FleetManagerError("Wrapped error", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // ConfigurationError
-  // ===========================================================================
-  describe("ConfigurationError", () => {
-    it("creates error with message only", () => {
-      const error = new ConfigurationError("Config failed");
-      expect(error.message).toContain("Config failed");
-      expect(error.name).toBe("ConfigurationError");
-      expect(error.code).toBe(FleetManagerErrorCode.CONFIGURATION_ERROR);
-      expect(error.configPath).toBeUndefined();
-      expect(error.validationErrors).toEqual([]);
-    });
-
-    it("creates error with config path", () => {
-      const error = new ConfigurationError("Config failed", {
-        configPath: "/path/to/config.yaml",
-      });
-      expect(error.message).toContain("Config failed");
-      expect(error.message).toContain("/path/to/config.yaml");
-      expect(error.configPath).toBe("/path/to/config.yaml");
-    });
-
-    it("creates error with validation errors", () => {
-      const error = new ConfigurationError("Validation failed", {
-        validationErrors: [
-          { path: "agents[0].name", message: "Name is required" },
-          { path: "agents[0].model", message: "Invalid model", value: "unknown" },
-        ],
-      });
-      expect(error.message).toContain("Validation errors:");
-      expect(error.message).toContain("agents[0].name");
-      expect(error.message).toContain("Name is required");
-      expect(error.validationErrors).toHaveLength(2);
-    });
-
-    it("hasValidationErrors returns true when errors exist", () => {
-      const error = new ConfigurationError("Validation failed", {
-        validationErrors: [{ path: "test", message: "error" }],
-      });
-      expect(error.hasValidationErrors()).toBe(true);
-    });
-
-    it("hasValidationErrors returns false when no errors", () => {
-      const error = new ConfigurationError("Config failed");
-      expect(error.hasValidationErrors()).toBe(false);
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("YAML parse error");
-      const error = new ConfigurationError("Config failed", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // AgentNotFoundError
-  // ===========================================================================
-  describe("AgentNotFoundError", () => {
-    it("creates error with agent name", () => {
-      const error = new AgentNotFoundError("my-agent");
-      expect(error.message).toContain("my-agent");
-      expect(error.message).toContain("not found");
-      expect(error.name).toBe("AgentNotFoundError");
-      expect(error.code).toBe(FleetManagerErrorCode.AGENT_NOT_FOUND);
-      expect(error.agentName).toBe("my-agent");
-      expect(error.availableAgents).toBeUndefined();
-    });
-
-    it("creates error with available agents list", () => {
-      const error = new AgentNotFoundError("missing", {
-        availableAgents: ["agent-a", "agent-b", "agent-c"],
-      });
-      expect(error.message).toContain("Available agents:");
-      expect(error.message).toContain("agent-a");
-      expect(error.availableAgents).toEqual(["agent-a", "agent-b", "agent-c"]);
-    });
-
-    it("shows message for empty agents list", () => {
-      const error = new AgentNotFoundError("missing", {
-        availableAgents: [],
-      });
-      expect(error.message).toContain("No agents are configured");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Lookup failed");
-      const error = new AgentNotFoundError("my-agent", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // JobNotFoundError
-  // ===========================================================================
-  describe("JobNotFoundError", () => {
-    it("creates error with job ID", () => {
-      const error = new JobNotFoundError("job-2024-01-15-abc123");
-      expect(error.message).toContain("job-2024-01-15-abc123");
-      expect(error.message).toContain("not found");
-      expect(error.name).toBe("JobNotFoundError");
-      expect(error.code).toBe(FleetManagerErrorCode.JOB_NOT_FOUND);
-      expect(error.jobId).toBe("job-2024-01-15-abc123");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("File not found");
-      const error = new JobNotFoundError("job-123", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // ScheduleNotFoundError
-  // ===========================================================================
-  describe("ScheduleNotFoundError", () => {
-    it("creates error with agent and schedule names", () => {
-      const error = new ScheduleNotFoundError("my-agent", "hourly");
-      expect(error.message).toContain("hourly");
-      expect(error.message).toContain("my-agent");
-      expect(error.message).toContain("not found");
-      expect(error.name).toBe("ScheduleNotFoundError");
-      expect(error.code).toBe(FleetManagerErrorCode.SCHEDULE_NOT_FOUND);
-      expect(error.agentName).toBe("my-agent");
-      expect(error.scheduleName).toBe("hourly");
-      expect(error.availableSchedules).toBeUndefined();
-    });
-
-    it("creates error with available schedules list", () => {
-      const error = new ScheduleNotFoundError("my-agent", "missing", {
-        availableSchedules: ["hourly", "daily", "weekly"],
-      });
-      expect(error.message).toContain("Available schedules:");
-      expect(error.message).toContain("hourly");
-      expect(error.availableSchedules).toEqual(["hourly", "daily", "weekly"]);
-    });
-
-    it("shows message for empty schedules list", () => {
-      const error = new ScheduleNotFoundError("my-agent", "missing", {
-        availableSchedules: [],
-      });
-      expect(error.message).toContain("has no schedules configured");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Config error");
-      const error = new ScheduleNotFoundError("agent", "schedule", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // InvalidStateError
-  // ===========================================================================
-  describe("InvalidStateError", () => {
-    it("creates error with single expected state", () => {
-      const error = new InvalidStateError("start", "uninitialized", "initialized");
-      expect(error.message).toContain("Cannot start");
-      expect(error.message).toContain("uninitialized");
-      expect(error.message).toContain("initialized");
-      expect(error.name).toBe("InvalidStateError");
-      expect(error.code).toBe(FleetManagerErrorCode.INVALID_STATE);
-      expect(error.operation).toBe("start");
-      expect(error.currentState).toBe("uninitialized");
-      expect(error.expectedState).toBe("initialized");
-    });
-
-    it("creates error with multiple expected states", () => {
-      const error = new InvalidStateError("reload", "uninitialized", [
-        "initialized",
-        "running",
-        "stopped",
-      ]);
-      expect(error.message).toContain("initialized or running or stopped");
-      expect(error.expectedState).toEqual(["initialized", "running", "stopped"]);
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("State transition failed");
-      const error = new InvalidStateError("start", "error", "initialized", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // FleetManagerStateError (deprecated)
-  // ===========================================================================
-  describe("FleetManagerStateError (deprecated)", () => {
-    it("creates error with operation and states", () => {
-      const error = new FleetManagerStateError("start", "uninitialized", "initialized");
-      expect(error.message).toContain("Cannot start");
-      expect(error.name).toBe("FleetManagerStateError");
-      expect(error.operation).toBe("start");
-      expect(error.currentState).toBe("uninitialized");
-      expect(error.expectedState).toBe("initialized");
-    });
-
-    it("provides requiredState alias for backwards compatibility", () => {
-      const error = new FleetManagerStateError("stop", "starting", [
-        "running",
-        "initialized",
-      ]);
-      expect(error.requiredState).toEqual(["running", "initialized"]);
-      expect(error.requiredState).toBe(error.expectedState);
-    });
-  });
-
-  // ===========================================================================
-  // ConcurrencyLimitError
-  // ===========================================================================
-  describe("ConcurrencyLimitError", () => {
-    it("creates error with agent name and limits", () => {
-      const error = new ConcurrencyLimitError("my-agent", 3, 3);
-      expect(error.message).toContain("my-agent");
-      expect(error.message).toContain("concurrency limit");
-      expect(error.message).toContain("3/3");
-      expect(error.name).toBe("ConcurrencyLimitError");
-      expect(error.code).toBe(FleetManagerErrorCode.CONCURRENCY_LIMIT);
-      expect(error.agentName).toBe("my-agent");
-      expect(error.currentJobs).toBe(3);
-      expect(error.limit).toBe(3);
-    });
-
-    it("isAtLimit returns true when at capacity", () => {
-      const error = new ConcurrencyLimitError("agent", 5, 5);
-      expect(error.isAtLimit()).toBe(true);
-    });
-
-    it("isAtLimit returns true when over capacity", () => {
-      const error = new ConcurrencyLimitError("agent", 6, 5);
-      expect(error.isAtLimit()).toBe(true);
-    });
-
-    it("isAtLimit returns false when under capacity", () => {
-      const error = new ConcurrencyLimitError("agent", 2, 5);
-      expect(error.isAtLimit()).toBe(false);
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Queue full");
-      const error = new ConcurrencyLimitError("agent", 3, 3, { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // FleetManagerConfigError (deprecated)
-  // ===========================================================================
-  describe("FleetManagerConfigError (deprecated)", () => {
-    it("creates error with message only", () => {
-      const error = new FleetManagerConfigError("Config not found");
-      expect(error.message).toBe("Config not found");
-      expect(error.name).toBe("FleetManagerConfigError");
-      expect(error.code).toBe(FleetManagerErrorCode.CONFIG_LOAD_ERROR);
-      expect(error.configPath).toBeUndefined();
-    });
-
-    it("creates error with config path", () => {
-      const error = new FleetManagerConfigError(
-        "Failed to load",
-        "/path/to/config.yaml"
-      );
-      expect(error.configPath).toBe("/path/to/config.yaml");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("YAML parse error");
-      const error = new FleetManagerConfigError("Config invalid", undefined, {
-        cause,
-      });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // FleetManagerStateDirError
-  // ===========================================================================
-  describe("FleetManagerStateDirError", () => {
-    it("creates error with message and state directory", () => {
-      const error = new FleetManagerStateDirError(
-        "Failed to create directory",
-        "/path/to/.herdctl"
-      );
-      expect(error.message).toBe("Failed to create directory");
-      expect(error.name).toBe("FleetManagerStateDirError");
-      expect(error.code).toBe(FleetManagerErrorCode.STATE_DIR_ERROR);
-      expect(error.stateDir).toBe("/path/to/.herdctl");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Permission denied");
-      const error = new FleetManagerStateDirError("Access denied", "/tmp/state", {
-        cause,
-      });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // FleetManagerShutdownError
-  // ===========================================================================
-  describe("FleetManagerShutdownError", () => {
-    it("creates error with timedOut true", () => {
-      const error = new FleetManagerShutdownError("Shutdown timed out", {
-        timedOut: true,
-      });
-      expect(error.message).toBe("Shutdown timed out");
-      expect(error.name).toBe("FleetManagerShutdownError");
-      expect(error.code).toBe(FleetManagerErrorCode.SHUTDOWN_ERROR);
-      expect(error.timedOut).toBe(true);
-    });
-
-    it("creates error with timedOut false", () => {
-      const error = new FleetManagerShutdownError("Shutdown failed", {
-        timedOut: false,
-      });
-      expect(error.timedOut).toBe(false);
-    });
-
-    it("isTimeout returns correct value", () => {
-      const timedOutError = new FleetManagerShutdownError("Timeout", {
-        timedOut: true,
-      });
-      const normalError = new FleetManagerShutdownError("Error", {
-        timedOut: false,
-      });
-
-      expect(timedOutError.isTimeout()).toBe(true);
-      expect(normalError.isTimeout()).toBe(false);
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Jobs still running");
-      const error = new FleetManagerShutdownError("Shutdown failed", {
-        timedOut: true,
-        cause,
-      });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // JobCancelError
-  // ===========================================================================
-  describe("JobCancelError", () => {
-    it("creates error for not_running reason", () => {
-      const error = new JobCancelError("job-123", "not_running");
-      expect(error.message).toContain("not running");
-      expect(error.name).toBe("JobCancelError");
-      expect(error.code).toBe(FleetManagerErrorCode.JOB_CANCEL_ERROR);
-      expect(error.jobId).toBe("job-123");
-      expect(error.reason).toBe("not_running");
-    });
-
-    it("creates error for process_error reason", () => {
-      const error = new JobCancelError("job-456", "process_error");
-      expect(error.message).toContain("Failed to terminate");
-      expect(error.reason).toBe("process_error");
-    });
-
-    it("creates error for timeout reason", () => {
-      const error = new JobCancelError("job-789", "timeout");
-      expect(error.message).toContain("Timeout");
-      expect(error.reason).toBe("timeout");
-    });
-
-    it("creates error for unknown reason", () => {
-      const error = new JobCancelError("job-abc", "unknown");
-      expect(error.message).toContain("Unknown error");
-      expect(error.reason).toBe("unknown");
-    });
-
-    it("uses custom message when provided", () => {
-      const error = new JobCancelError("job-123", "process_error", {
-        message: "Custom cancellation message",
-      });
-      expect(error.message).toBe("Custom cancellation message");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("SIGKILL failed");
-      const error = new JobCancelError("job-123", "process_error", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // JobForkError
-  // ===========================================================================
-  describe("JobForkError", () => {
-    it("creates error for no_session reason", () => {
-      const error = new JobForkError("job-123", "no_session");
-      expect(error.message).toContain("no session ID");
-      expect(error.name).toBe("JobForkError");
-      expect(error.code).toBe(FleetManagerErrorCode.JOB_FORK_ERROR);
-      expect(error.originalJobId).toBe("job-123");
-      expect(error.reason).toBe("no_session");
-    });
-
-    it("creates error for job_not_found reason", () => {
-      const error = new JobForkError("job-456", "job_not_found");
-      expect(error.message).toContain("not found");
-      expect(error.reason).toBe("job_not_found");
-    });
-
-    it("creates error for agent_not_found reason", () => {
-      const error = new JobForkError("job-789", "agent_not_found");
-      expect(error.message).toContain("Agent");
-      expect(error.message).toContain("not found");
-      expect(error.reason).toBe("agent_not_found");
-    });
-
-    it("creates error for unknown reason", () => {
-      const error = new JobForkError("job-abc", "unknown");
-      expect(error.message).toContain("Unknown error");
-      expect(error.reason).toBe("unknown");
-    });
-
-    it("uses custom message when provided", () => {
-      const error = new JobForkError("job-123", "no_session", {
-        message: "Custom fork error message",
-      });
-      expect(error.message).toBe("Custom fork error message");
-    });
-
-    it("creates error with cause", () => {
-      const cause = new Error("Session lookup failed");
-      const error = new JobForkError("job-123", "no_session", { cause });
-      expect(error.cause).toBe(cause);
-    });
-  });
-
-  // ===========================================================================
-  // Type Guards
-  // ===========================================================================
-  describe("Type Guards", () => {
-    describe("isFleetManagerError", () => {
-      it("returns true for FleetManagerError", () => {
-        const error = new FleetManagerError("test");
-        expect(isFleetManagerError(error)).toBe(true);
-      });
-
-      it("returns true for all subclasses", () => {
-        expect(isFleetManagerError(new ConfigurationError("test"))).toBe(true);
-        expect(isFleetManagerError(new AgentNotFoundError("test"))).toBe(true);
-        expect(isFleetManagerError(new JobNotFoundError("test"))).toBe(true);
-        expect(isFleetManagerError(new ScheduleNotFoundError("a", "b"))).toBe(true);
-        expect(isFleetManagerError(new InvalidStateError("a", "b", "c"))).toBe(true);
-        expect(isFleetManagerError(new ConcurrencyLimitError("a", 1, 1))).toBe(true);
-        expect(isFleetManagerError(new FleetManagerShutdownError("test", { timedOut: false }))).toBe(true);
-        expect(isFleetManagerError(new JobCancelError("test", "unknown"))).toBe(true);
-        expect(isFleetManagerError(new JobForkError("test", "unknown"))).toBe(true);
-      });
-
-      it("returns false for regular Error", () => {
-        expect(isFleetManagerError(new Error("test"))).toBe(false);
-      });
-
-      it("returns false for non-error values", () => {
-        expect(isFleetManagerError(null)).toBe(false);
-        expect(isFleetManagerError(undefined)).toBe(false);
-        expect(isFleetManagerError("error")).toBe(false);
-        expect(isFleetManagerError({ message: "error" })).toBe(false);
-      });
-    });
-
-    describe("isConfigurationError", () => {
-      it("returns true for ConfigurationError", () => {
-        const error = new ConfigurationError("test");
-        expect(isConfigurationError(error)).toBe(true);
-      });
-
-      it("returns false for other FleetManagerError types", () => {
-        expect(isConfigurationError(new FleetManagerError("test"))).toBe(false);
-        expect(isConfigurationError(new AgentNotFoundError("test"))).toBe(false);
-      });
-
-      it("returns false for non-error values", () => {
-        expect(isConfigurationError(null)).toBe(false);
-        expect(isConfigurationError(new Error("test"))).toBe(false);
-      });
-    });
-
-    describe("isAgentNotFoundError", () => {
-      it("returns true for AgentNotFoundError", () => {
-        const error = new AgentNotFoundError("test");
-        expect(isAgentNotFoundError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isAgentNotFoundError(new FleetManagerError("test"))).toBe(false);
-        expect(isAgentNotFoundError(new JobNotFoundError("test"))).toBe(false);
-        expect(isAgentNotFoundError(null)).toBe(false);
-      });
-    });
-
-    describe("isJobNotFoundError", () => {
-      it("returns true for JobNotFoundError", () => {
-        const error = new JobNotFoundError("test");
-        expect(isJobNotFoundError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isJobNotFoundError(new FleetManagerError("test"))).toBe(false);
-        expect(isJobNotFoundError(new AgentNotFoundError("test"))).toBe(false);
-        expect(isJobNotFoundError(null)).toBe(false);
-      });
-    });
-
-    describe("isScheduleNotFoundError", () => {
-      it("returns true for ScheduleNotFoundError", () => {
-        const error = new ScheduleNotFoundError("agent", "schedule");
-        expect(isScheduleNotFoundError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isScheduleNotFoundError(new FleetManagerError("test"))).toBe(false);
-        expect(isScheduleNotFoundError(new AgentNotFoundError("test"))).toBe(false);
-        expect(isScheduleNotFoundError(null)).toBe(false);
-      });
-    });
-
-    describe("isInvalidStateError", () => {
-      it("returns true for InvalidStateError", () => {
-        const error = new InvalidStateError("op", "current", "expected");
-        expect(isInvalidStateError(error)).toBe(true);
-      });
-
-      it("returns true for FleetManagerStateError (deprecated subclass)", () => {
-        const error = new FleetManagerStateError("op", "current", "expected");
-        expect(isInvalidStateError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isInvalidStateError(new FleetManagerError("test"))).toBe(false);
-        expect(isInvalidStateError(new AgentNotFoundError("test"))).toBe(false);
-        expect(isInvalidStateError(null)).toBe(false);
-      });
-    });
-
-    describe("isConcurrencyLimitError", () => {
-      it("returns true for ConcurrencyLimitError", () => {
-        const error = new ConcurrencyLimitError("agent", 3, 3);
-        expect(isConcurrencyLimitError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isConcurrencyLimitError(new FleetManagerError("test"))).toBe(false);
-        expect(isConcurrencyLimitError(new AgentNotFoundError("test"))).toBe(false);
-        expect(isConcurrencyLimitError(null)).toBe(false);
-      });
-    });
-
-    describe("isJobCancelError", () => {
-      it("returns true for JobCancelError", () => {
-        const error = new JobCancelError("job-123", "not_running");
-        expect(isJobCancelError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isJobCancelError(new FleetManagerError("test"))).toBe(false);
-        expect(isJobCancelError(new JobNotFoundError("test"))).toBe(false);
-        expect(isJobCancelError(null)).toBe(false);
-      });
-    });
-
-    describe("isJobForkError", () => {
-      it("returns true for JobForkError", () => {
-        const error = new JobForkError("job-123", "no_session");
-        expect(isJobForkError(error)).toBe(true);
-      });
-
-      it("returns false for other error types", () => {
-        expect(isJobForkError(new FleetManagerError("test"))).toBe(false);
-        expect(isJobForkError(new JobNotFoundError("test"))).toBe(false);
-        expect(isJobForkError(new JobCancelError("test", "unknown"))).toBe(false);
-        expect(isJobForkError(null)).toBe(false);
-      });
-    });
-  });
-
-  // ===========================================================================
-  // Error Codes
-  // ===========================================================================
-  describe("FleetManagerErrorCode", () => {
-    it("contains all expected error codes", () => {
-      expect(FleetManagerErrorCode.FLEET_MANAGER_ERROR).toBe("FLEET_MANAGER_ERROR");
-      expect(FleetManagerErrorCode.CONFIGURATION_ERROR).toBe("CONFIGURATION_ERROR");
-      expect(FleetManagerErrorCode.CONFIG_LOAD_ERROR).toBe("CONFIG_LOAD_ERROR");
-      expect(FleetManagerErrorCode.AGENT_NOT_FOUND).toBe("AGENT_NOT_FOUND");
-      expect(FleetManagerErrorCode.JOB_NOT_FOUND).toBe("JOB_NOT_FOUND");
-      expect(FleetManagerErrorCode.SCHEDULE_NOT_FOUND).toBe("SCHEDULE_NOT_FOUND");
-      expect(FleetManagerErrorCode.INVALID_STATE).toBe("INVALID_STATE");
-      expect(FleetManagerErrorCode.STATE_DIR_ERROR).toBe("STATE_DIR_ERROR");
-      expect(FleetManagerErrorCode.CONCURRENCY_LIMIT).toBe("CONCURRENCY_LIMIT");
-      expect(FleetManagerErrorCode.SHUTDOWN_ERROR).toBe("SHUTDOWN_ERROR");
-      expect(FleetManagerErrorCode.JOB_CANCEL_ERROR).toBe("JOB_CANCEL_ERROR");
-      expect(FleetManagerErrorCode.JOB_FORK_ERROR).toBe("JOB_FORK_ERROR");
-    });
-  });
-});