| |
| import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; |
| import { createDeferred } from "../../../test/helpers/promise.js"; |
| import { createProcessSupervisor } from "./supervisor.js"; |
| import type { |
| ProcessSupervisor, |
| SpawnInput, |
| SpawnProcessAdapter, |
| TerminationReason, |
| } from "./types.js"; |
|
|
| const { createChildAdapterMock, createPtyAdapterMock } = vi.hoisted(() => ({ |
| createChildAdapterMock: vi.fn(), |
| createPtyAdapterMock: vi.fn(), |
| })); |
|
|
| vi.mock("./adapters/child.js", () => ({ |
| createChildAdapter: async ( |
| ...args: Parameters<typeof import("./adapters/child.js").createChildAdapter> |
| ) => ({ |
| adapter: await createChildAdapterMock(...args), |
| ready: Promise.resolve(), |
| }), |
| })); |
|
|
| vi.mock("./adapters/pty.js", () => ({ |
| createPtyAdapter: createPtyAdapterMock, |
| })); |
|
|
| type CancellationTestAdapter = SpawnProcessAdapter<NodeJS.Signals | null> & { |
| killMock: ReturnType<typeof vi.fn>; |
| disposeMock: ReturnType<typeof vi.fn>; |
| settle: (signal: NodeJS.Signals) => void; |
| }; |
|
|
| function createCancellationTestAdapter(): CancellationTestAdapter { |
| const completion = createDeferred<{ code: number | null; signal: NodeJS.Signals | null }>(); |
| const killMock = vi.fn(); |
| const disposeMock = vi.fn(); |
|
|
| return { |
| pid: 4321, |
| supportsRawOutput: false, |
| onStdout: () => undefined, |
| onStderr: () => undefined, |
| wait: async () => completion.promise, |
| kill: (signal) => killMock(signal), |
| dispose: disposeMock, |
| killMock, |
| disposeMock, |
| settle: (signal) => completion.resolve({ code: null, signal }), |
| }; |
| } |
|
|
| type CancellationPath = "run-id" | "scope"; |
|
|
| function cancelThrough( |
| supervisor: ProcessSupervisor, |
| path: CancellationPath, |
| runId: string, |
| scopeKey: string, |
| reason: TerminationReason, |
| ): void { |
| if (path === "scope") { |
| supervisor.cancelScope(scopeKey, reason); |
| return; |
| } |
| supervisor.cancel(runId, reason); |
| } |
|
|
| const cancellationPaths = [ |
| { label: "run ID", first: "run-id", later: "run-id" }, |
| { label: "scope", first: "scope", later: "scope" }, |
| { label: "run ID followed by scope", first: "run-id", later: "scope" }, |
| { label: "scope followed by run ID", first: "scope", later: "run-id" }, |
| ] as const satisfies ReadonlyArray<{ |
| label: string; |
| first: CancellationPath; |
| later: CancellationPath; |
| }>; |
|
|
| const cancellationReasons = [ |
| { |
| firstReason: "manual-cancel", |
| laterReasons: ["overall-timeout", "no-output-timeout", "manual-cancel"], |
| }, |
| { |
| firstReason: "overall-timeout", |
| laterReasons: ["manual-cancel", "no-output-timeout", "overall-timeout"], |
| }, |
| { |
| firstReason: "no-output-timeout", |
| laterReasons: ["manual-cancel", "overall-timeout", "no-output-timeout"], |
| }, |
| ] as const satisfies ReadonlyArray<{ |
| firstReason: TerminationReason; |
| laterReasons: ReadonlyArray<TerminationReason>; |
| }>; |
|
|
| describe("process supervisor first cancellation reason", () => { |
| beforeEach(() => { |
| createChildAdapterMock.mockReset(); |
| createPtyAdapterMock.mockReset(); |
| vi.useFakeTimers(); |
| }); |
|
|
| it("keeps the first manual-cancel when a later construction deadline fires", async () => { |
| const startup = createDeferred<CancellationTestAdapter>(); |
| createChildAdapterMock.mockReturnValueOnce(startup.promise); |
| const supervisor = createProcessSupervisor(); |
| const runId = "manual-cancel-then-timeout"; |
| const pendingRun = supervisor.spawn({ |
| runId, |
| mode: "child", |
| argv: [process.execPath, "-e", "setInterval(() => {}, 1_000)"], |
| timeoutMs: 25, |
| stdinMode: "pipe-closed", |
| }); |
|
|
| expect(createChildAdapterMock).toHaveBeenCalledOnce(); |
| supervisor.cancel(runId, "manual-cancel"); |
|
|
| await vi.advanceTimersByTimeAsync(25); |
| const constructionState = await Promise.race([ |
| pendingRun.then( |
| () => "settled" as const, |
| () => "rejected" as const, |
| ), |
| Promise.resolve().then(() => "pending" as const), |
| ]); |
| expect(constructionState).toBe("settled"); |
|
|
| const run = await pendingRun; |
| await expect(run.wait()).resolves.toMatchObject({ |
| reason: "manual-cancel", |
| timedOut: false, |
| noOutputTimedOut: false, |
| }); |
| expect(run.activity.resultSettled).toBe(true); |
|
|
| const lateAdapter = createCancellationTestAdapter(); |
| const killed = createDeferred(); |
| lateAdapter.killMock.mockImplementation(() => killed.resolve()); |
| startup.resolve(lateAdapter); |
| await killed.promise; |
| expect(lateAdapter.killMock).toHaveBeenCalledWith("SIGKILL"); |
| expect(lateAdapter.disposeMock).not.toHaveBeenCalled(); |
| lateAdapter.settle("SIGKILL"); |
| await run.waitForExtinction?.(); |
| expect(lateAdapter.disposeMock).toHaveBeenCalled(); |
| }); |
|
|
| afterEach(() => { |
| vi.clearAllTimers(); |
| vi.useRealTimers(); |
| vi.restoreAllMocks(); |
| }); |
|
|
| for (const mode of ["child", "pty"] as const) { |
| describe(`${mode} processes`, () => { |
| for (const path of cancellationPaths) { |
| describe(path.label, () => { |
| it.each(cancellationReasons)( |
| "keeps $firstReason after repeated overlapping cancellation", |
| async ({ firstReason, laterReasons }) => { |
| const adapter = createCancellationTestAdapter(); |
| const adapterMock = mode === "child" ? createChildAdapterMock : createPtyAdapterMock; |
| adapterMock.mockResolvedValueOnce(adapter); |
|
|
| const supervisor = createProcessSupervisor(); |
| const runId = `first-cancellation-${mode}`; |
| const scopeKey = `scope:first-cancellation-${mode}`; |
| const input: SpawnInput = { |
| runId, |
| scopeKey, |
| mode, |
| argv: [process.execPath, "-e", ""], |
| }; |
| const run = await supervisor.spawn(input); |
| const exitPromise = run.wait(); |
|
|
| cancelThrough(supervisor, path.first, runId, scopeKey, firstReason); |
| for (const laterReason of laterReasons) { |
| cancelThrough(supervisor, path.later, runId, scopeKey, laterReason); |
| expect(run.activity.resultSettled, `after ${laterReason}`).toBe(false); |
| } |
|
|
| expect(adapter.killMock).toHaveBeenCalledTimes(1); |
|
|
| const signal = |
| process.platform === "win32" && firstReason !== "manual-cancel" |
| ? "SIGKILL" |
| : "SIGTERM"; |
| expect(adapter.killMock).toHaveBeenCalledWith(signal); |
| adapter.settle(signal); |
|
|
| await expect(exitPromise).resolves.toMatchObject({ |
| reason: firstReason, |
| exitSignal: signal, |
| timedOut: firstReason !== "manual-cancel", |
| noOutputTimedOut: firstReason === "no-output-timeout", |
| }); |
| expect(run.activity.resultSettled).toBe(true); |
| expect(adapter.disposeMock).toHaveBeenCalledTimes(1); |
| expect(vi.getTimerCount()).toBe(0); |
| }, |
| ); |
| }); |
| } |
| }); |
| } |
| }); |
|
|
