| import { Command } from "commander"; |
| import { beforeEach, describe, expect, it, vi } from "vitest"; |
| import { defaultRuntime } from "../../runtime.js"; |
|
|
| const callGatewayFromCli = vi.fn(); |
|
|
| vi.mock("../gateway-rpc.js", async () => { |
| const actual = await vi.importActual<typeof import("../gateway-rpc.js")>("../gateway-rpc.js"); |
| return { |
| ...actual, |
| callGatewayFromCli: (...args: Parameters<typeof actual.callGatewayFromCli>) => |
| callGatewayFromCli(...args), |
| }; |
| }); |
|
|
| const { registerCronAddCommand } = await import("./register.cron-add.js"); |
| const { registerCronEditCommand } = await import("./register.cron-edit.js"); |
|
|
| function createMutationProgram(): Command { |
| const program = new Command(); |
| program.exitOverride(); |
| registerCronAddCommand(program); |
| registerCronEditCommand(program); |
| return program; |
| } |
|
|
| const topicMutationCases = [ |
| { |
| operation: "add", |
| method: "cron.add", |
| args: [ |
| "add", |
| "--name", |
| "topic-proof", |
| "--every", |
| "1m", |
| "--agent", |
| "main", |
| "--message", |
| "hello", |
| "--channel", |
| "telegram", |
| "--to", |
| "group-123", |
| ], |
| }, |
| { |
| operation: "edit", |
| method: "cron.update", |
| args: ["edit", "job-1", "--channel", "telegram", "--to", "group-123"], |
| }, |
| ] as const; |
|
|
| describe("shared automation mutation options", () => { |
| beforeEach(() => { |
| callGatewayFromCli.mockReset(); |
| callGatewayFromCli.mockResolvedValue({ ok: true }); |
| }); |
|
|
| it.each( |
| ["--at", "--every", "--cron", "--on-exit"].flatMap((flag) => |
| ["", " "].map((value) => ({ flag, value })), |
| ), |
| )("rejects explicit blank $flag=$value on edit before RPC", async ({ flag, value }) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync(["edit", "job-1", flag, value], { from: "user" }), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledExactlyOnceWith( |
| expect.stringContaining("Schedule values must not be blank"), |
| ); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }); |
|
|
| it.each( |
| ["add", "create"].flatMap((operation) => ["", " "].map((value) => ({ operation, value }))), |
| )("rejects a blank schedule mixed with --every on $operation", async ({ operation, value }) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync( |
| [ |
| operation, |
| "--name", |
| "blank-schedule", |
| "--agent", |
| "main", |
| "--message", |
| "hello", |
| "--every", |
| "1h", |
| "--cron", |
| value, |
| ], |
| { from: "user" }, |
| ), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledExactlyOnceWith( |
| expect.stringContaining("Schedule values must not be blank"), |
| ); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }); |
|
|
| it("rejects a blank schedule before mutation after a pacing read", async () => { |
| callGatewayFromCli.mockImplementation(async (method: string) => |
| method === "cron.get" |
| ? { |
| id: "job-1", |
| configRevision: "fixture-revision-1", |
| pacing: { min: "1m", max: "1h" }, |
| } |
| : { ok: true }, |
| ); |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync( |
| ["edit", "job-1", "--pacing-min", "30m", "--every", ""], |
| { from: "user" }, |
| ), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledExactlyOnceWith( |
| expect.stringContaining("Schedule values must not be blank"), |
| ); |
| expect(callGatewayFromCli).toHaveBeenCalledWith("cron.get", expect.anything(), { |
| id: "job-1", |
| }); |
| expect(callGatewayFromCli.mock.calls.map(([method]) => method)).not.toContain("cron.update"); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }); |
|
|
| it.each([ |
| { label: "omitted", args: [], rejects: false }, |
| { label: "blank", args: ["--every", ""], rejects: true }, |
| ])("distinguishes an $label schedule from a name-only edit", async ({ args, rejects }) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| const run = createMutationProgram().parseAsync( |
| ["edit", "job-1", "--name", "Renamed", ...args], |
| { from: "user" }, |
| ); |
| if (rejects) { |
| await expect(run).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledExactlyOnceWith( |
| expect.stringContaining("Schedule values must not be blank"), |
| ); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } else { |
| await run; |
| expect(callGatewayFromCli).toHaveBeenCalledWith("cron.update", expect.anything(), { |
| id: "job-1", |
| patch: { name: "Renamed" }, |
| }); |
| expect(errorSpy).not.toHaveBeenCalled(); |
| } |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }); |
|
|
| it.each([ |
| { operation: "add", flag: "--every" }, |
| { operation: "add", flag: "--stagger" }, |
| { operation: "edit", flag: "--every" }, |
| { operation: "edit", flag: "--stagger" }, |
| ])( |
| "rejects out-of-range configured duration precision for $operation $flag before RPC", |
| async ({ operation, flag }) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| const args = |
| operation === "add" |
| ? [ |
| "add", |
| "--name", |
| "Duration boundary", |
| "--agent", |
| "main", |
| "--system-event", |
| "test", |
| "--disabled", |
| ] |
| : ["edit", "job-1"]; |
| try { |
| await expect( |
| createMutationProgram().parseAsync( |
| [ |
| ...args, |
| ...(flag === "--stagger" ? ["--cron", "0 * * * *", "--tz", "UTC"] : []), |
| flag, |
| "8640000000000001ms", |
| ], |
| { from: "user" }, |
| ), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(`Invalid ${flag}`)); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }, |
| ); |
|
|
| it.each(["--every", "--stagger"])( |
| "accepts the inclusive configured duration precision limit for %s", |
| async (flag) => { |
| await createMutationProgram().parseAsync( |
| [ |
| "add", |
| "--name", |
| "Duration boundary", |
| "--agent", |
| "main", |
| "--system-event", |
| "test", |
| "--disabled", |
| ...(flag === "--stagger" ? ["--cron", "0 * * * *"] : []), |
| flag, |
| "8640000000000000ms", |
| ], |
| { from: "user" }, |
| ); |
|
|
| expect(callGatewayFromCli).toHaveBeenCalledWith( |
| "cron.add", |
| expect.anything(), |
| expect.objectContaining({ |
| enabled: false, |
| schedule: |
| flag === "--every" |
| ? { kind: "every", everyMs: 8_640_000_000_000_000 } |
| : { |
| kind: "cron", |
| expr: "0 * * * *", |
| tz: undefined, |
| staggerMs: 8_640_000_000_000_000, |
| }, |
| }), |
| ); |
| }, |
| ); |
|
|
| it("updates an existing automation to an exit-triggered schedule", async () => { |
| await createMutationProgram().parseAsync( |
| ["edit", "job-1", "--on-exit", "./watch.sh", "--on-exit-cwd", "/repo"], |
| { from: "user" }, |
| ); |
|
|
| expect(callGatewayFromCli).toHaveBeenCalledWith("cron.update", expect.anything(), { |
| id: "job-1", |
| patch: { schedule: { kind: "on-exit", command: "./watch.sh", cwd: "/repo" } }, |
| }); |
| }); |
|
|
| it.each([ |
| [["--on-exit-cwd", "/repo"], "--on-exit-cwd requires --on-exit"], |
| [["--on-exit", "./watch.sh", "--every", "5m"], "Choose at most one schedule change"], |
| ])("rejects invalid exit-triggered schedule options", async (args, message) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync(["edit", "job-1", ...args], { from: "user" }), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(message)); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }); |
|
|
| it.each( |
| topicMutationCases.flatMap((mutation) => |
| ["", " "].map((threadId) => ({ |
| operation: mutation.operation, |
| args: mutation.args, |
| threadId, |
| })), |
| ), |
| )( |
| "rejects blank thread id $threadId before automation $operation", |
| async ({ args, threadId }) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync([...args, "--thread-id", threadId], { |
| from: "user", |
| }), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledWith( |
| expect.stringContaining("--thread-id must be a positive integer"), |
| ); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }, |
| ); |
|
|
| it.each(topicMutationCases)( |
| "preserves omitted and maximum-safe topic ids on automation $operation", |
| async ({ operation, method, args }) => { |
| for (const threadId of [undefined, Number.MAX_SAFE_INTEGER]) { |
| callGatewayFromCli.mockClear(); |
| await createMutationProgram().parseAsync( |
| [...args, ...(threadId === undefined ? [] : ["--thread-id", String(threadId)])], |
| { from: "user" }, |
| ); |
| const call = callGatewayFromCli.mock.calls.find( |
| ([calledMethod]) => calledMethod === method, |
| ); |
| const request = call?.[2] as { |
| delivery?: { threadId?: number }; |
| patch?: { delivery?: { threadId?: number } }; |
| }; |
| const delivery = operation === "add" ? request.delivery : request.patch?.delivery; |
| expect(delivery?.threadId).toBe(threadId); |
| } |
| }, |
| ); |
|
|
| it.each(["", " ", "topic-42"])( |
| "rejects invalid thread id %j before loading an automation for a combined edit", |
| async (threadId) => { |
| const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => {}); |
| try { |
| await expect( |
| createMutationProgram().parseAsync( |
| [ |
| "edit", |
| "job-1", |
| "--pacing-min", |
| "30m", |
| "--channel", |
| "telegram", |
| "--to", |
| "group-123", |
| "--thread-id", |
| threadId, |
| ], |
| { from: "user" }, |
| ), |
| ).rejects.toMatchObject({ name: "ExitError", code: 1 }); |
| expect(errorSpy).toHaveBeenCalledWith( |
| expect.stringContaining("--thread-id must be a positive integer"), |
| ); |
| expect(callGatewayFromCli).not.toHaveBeenCalled(); |
| } finally { |
| errorSpy.mockRestore(); |
| } |
| }, |
| ); |
|
|
| it("keeps creation defaults out of automation edit patches", () => { |
| const program = createMutationProgram(); |
| const add = program.commands.find((command) => command.name() === "add")!; |
| const edit = program.commands.find((command) => command.name() === "edit")!; |
| const creationDefaults: Array<[string, string | boolean]> = [ |
| ["wake", "now"], |
| ["tz", ""], |
| ["exact", false], |
| ["lightContext", false], |
| ["announce", false], |
| ["channel", "last"], |
| ["bestEffortDeliver", false], |
| ]; |
|
|
| for (const [name, value] of creationDefaults) { |
| expect(add.getOptionValue(name)).toBe(value); |
| expect(edit.getOptionValue(name)).toBeUndefined(); |
| } |
| }); |
| }); |
|
|
