mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-10-23 17:33:51 +02:00
DottaandPaperclip
3a726e676f
Enforce private task and project access across direct reads, search, execution, files, plugins, live delivery, and sharing mutations. Preserve downward-only sharing, current responsible-user authorization, and audited emergency access. Bind historical draft assets with migration 0314. Co-Authored-By: Paperclip <noreply@paperclip.ing>
676 lines
23 KiB
TypeScript
676 lines
23 KiB
TypeScript
import express from "express";
|
|
import type { PluginWorkerManager } from "../services/plugin-worker-manager.js";
|
|
import { PgDialect } from "drizzle-orm/pg-core";
|
|
import request from "supertest";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const mockIssueService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
}));
|
|
|
|
const mockTreeControlService = vi.hoisted(() => ({
|
|
preview: vi.fn(),
|
|
createHold: vi.fn(),
|
|
cancelIssueStatusesForHold: vi.fn(),
|
|
restoreIssueStatusesForHold: vi.fn(),
|
|
getHold: vi.fn(),
|
|
releaseHold: vi.fn(),
|
|
cancelUnclaimedWakeupsForTree: vi.fn(),
|
|
}));
|
|
|
|
const mockReplayBlocks = vi.hoisted(() => vi.fn());
|
|
const mockReplayWhere = vi.hoisted(() => vi.fn());
|
|
const mockExecutionBlocker = vi.hoisted(() => vi.fn());
|
|
vi.mock("../services/execution-blocker.js", () => ({ getExecutionBlocker: mockExecutionBlocker }));
|
|
|
|
const mockLogActivity = vi.hoisted(() => vi.fn());
|
|
const mockHeartbeatService = vi.hoisted(() => ({
|
|
cancelRun: vi.fn(),
|
|
wakeup: vi.fn(),
|
|
}));
|
|
const mockAccessService = vi.hoisted(() => ({ decide: vi.fn() }));
|
|
|
|
const mockHeartbeatFactory = vi.hoisted(() => vi.fn());
|
|
|
|
vi.mock("../services/index.js", () => ({
|
|
accessService: () => mockAccessService,
|
|
heartbeatService: mockHeartbeatFactory,
|
|
issueService: () => mockIssueService,
|
|
issueTreeControlService: () => mockTreeControlService,
|
|
logActivity: mockLogActivity,
|
|
}));
|
|
|
|
async function createApp(
|
|
actor: Record<string, unknown>,
|
|
pluginWorkerManager?: PluginWorkerManager,
|
|
) {
|
|
const [{ errorHandler }, { issueTreeControlRoutes }] = await Promise.all([
|
|
import("../middleware/index.js"),
|
|
import("../routes/issue-tree-control.js"),
|
|
]);
|
|
const app = express();
|
|
app.use(express.json());
|
|
app.use((req, _res, next) => {
|
|
(req as any).actor = actor;
|
|
next();
|
|
});
|
|
const query = {
|
|
from: () => query,
|
|
innerJoin: () => query,
|
|
where: (predicate: unknown) => { mockReplayWhere(predicate); return mockReplayBlocks(); },
|
|
limit: mockReplayBlocks,
|
|
};
|
|
app.use("/api", issueTreeControlRoutes({ select: () => query } as any, { pluginWorkerManager }));
|
|
app.use(errorHandler);
|
|
return app;
|
|
}
|
|
|
|
describe("issue tree control routes", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mockHeartbeatFactory.mockReturnValue(mockHeartbeatService);
|
|
mockReplayBlocks.mockResolvedValue([]);
|
|
mockExecutionBlocker.mockResolvedValue(null);
|
|
mockTreeControlService.getHold.mockResolvedValue(null);
|
|
mockIssueService.getById.mockResolvedValue({
|
|
id: "11111111-1111-4111-8111-111111111111",
|
|
companyId: "company-2",
|
|
});
|
|
mockTreeControlService.cancelUnclaimedWakeupsForTree.mockResolvedValue([]);
|
|
mockTreeControlService.cancelIssueStatusesForHold.mockResolvedValue({
|
|
updatedIssueIds: [],
|
|
updatedIssues: [],
|
|
});
|
|
mockTreeControlService.restoreIssueStatusesForHold.mockResolvedValue({
|
|
updatedIssueIds: [],
|
|
updatedIssues: [],
|
|
releasedCancelHoldIds: [],
|
|
restoreHold: null,
|
|
});
|
|
mockHeartbeatService.cancelRun.mockResolvedValue(null);
|
|
mockHeartbeatService.wakeup.mockResolvedValue(null);
|
|
mockAccessService.decide.mockResolvedValue({ allowed: true });
|
|
});
|
|
|
|
it("conceals private roots from non-members before exposing tree state", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockAccessService.decide.mockResolvedValue({ allowed: false, reason: "deny_issue_private" });
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-control/preview")
|
|
.send({ mode: "pause" });
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(mockTreeControlService.preview).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each([false, true])(
|
|
"only wakes eligible current assignees when resume requests wakeAgents=%s",
|
|
async (wakeAgents) => {
|
|
const rootId = "11111111-1111-4111-8111-111111111111";
|
|
const holdId = "33333333-3333-4333-8333-333333333333";
|
|
const root = {
|
|
id: rootId,
|
|
companyId: "company-2",
|
|
status: "todo",
|
|
assigneeAgentId: "agent-parent",
|
|
};
|
|
const issues = [
|
|
root,
|
|
{
|
|
id: "child",
|
|
companyId: "company-2",
|
|
status: "in_progress",
|
|
assigneeAgentId: "agent-child",
|
|
},
|
|
{
|
|
id: "backlog-task",
|
|
companyId: "company-2",
|
|
status: "backlog",
|
|
assigneeAgentId: "parked-agent",
|
|
},
|
|
{
|
|
id: "blocked-task",
|
|
companyId: "company-2",
|
|
status: "blocked",
|
|
assigneeAgentId: "blocked-agent",
|
|
},
|
|
{
|
|
id: "done",
|
|
companyId: "company-2",
|
|
status: "done",
|
|
assigneeAgentId: "agent-done",
|
|
},
|
|
{
|
|
id: "cancelled",
|
|
companyId: "company-2",
|
|
status: "cancelled",
|
|
assigneeAgentId: "agent-cancelled",
|
|
},
|
|
{
|
|
id: "foreign",
|
|
companyId: "company-3",
|
|
status: "todo",
|
|
assigneeAgentId: "agent-foreign",
|
|
},
|
|
];
|
|
mockIssueService.getById.mockImplementation(async (id: string) =>
|
|
issues.find((issue) => issue.id === id),
|
|
);
|
|
mockTreeControlService.releaseHold.mockResolvedValue({
|
|
id: holdId,
|
|
mode: "pause",
|
|
status: "released",
|
|
members: issues.map((issue) => ({ issueId: issue.id })),
|
|
});
|
|
mockTreeControlService.getHold.mockResolvedValue({
|
|
id: holdId,
|
|
rootIssueId: rootId,
|
|
mode: "pause",
|
|
members: issues.map((issue) => ({ issueId: issue.id })),
|
|
});
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
const response = await request(app)
|
|
.post(`/api/issues/${rootId}/tree-holds/${holdId}/release`)
|
|
.send({ metadata: { wakeAgents } });
|
|
expect(response.status).toBe(200);
|
|
expect(mockHeartbeatService.wakeup.mock.calls.map(([id]) => id)).toEqual(
|
|
wakeAgents ? ["agent-parent", "agent-child"] : [],
|
|
);
|
|
if (wakeAgents) {
|
|
const { params } = new PgDialect().sqlToQuery(mockReplayWhere.mock.calls[0]![0]);
|
|
expect(params).toEqual(expect.arrayContaining(["todo", "in_progress", "in_review"]));
|
|
expect(params).not.toContain("blocked");
|
|
expect(params).not.toContain("backlog");
|
|
}
|
|
if (wakeAgents)
|
|
expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(
|
|
"agent-child",
|
|
expect.objectContaining({
|
|
reason: "issue_tree_resumed",
|
|
contextSnapshot: expect.objectContaining({
|
|
issueId: "child",
|
|
holdId,
|
|
}),
|
|
}),
|
|
);
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({ action: "issue.tree_hold_released" }),
|
|
);
|
|
},
|
|
);
|
|
|
|
it("resumes sandbox-backed work through the shared plugin worker manager", async () => {
|
|
const rootId = "11111111-1111-4111-8111-111111111111";
|
|
const holdId = "33333333-3333-4333-8333-333333333333";
|
|
const pluginWorkerManager = { isRunning: () => true } as unknown as PluginWorkerManager;
|
|
mockHeartbeatFactory.mockImplementation((_db, options) => ({
|
|
...mockHeartbeatService,
|
|
wakeup: async (...args: unknown[]) => {
|
|
// Lease acquisition needs the process's manager, even when its worker
|
|
// is already running. A service without it cannot dispatch this run.
|
|
expect(options?.pluginWorkerManager).toBe(pluginWorkerManager);
|
|
return mockHeartbeatService.wakeup(...args);
|
|
},
|
|
}));
|
|
mockIssueService.getById.mockResolvedValue({
|
|
id: rootId, companyId: "company-2", status: "todo", assigneeAgentId: "agent-parent",
|
|
});
|
|
mockTreeControlService.releaseHold.mockResolvedValue({
|
|
id: holdId, mode: "pause", status: "released", members: [{ issueId: rootId }],
|
|
});
|
|
const app = await createApp({
|
|
type: "board", userId: "user-1", companyIds: ["company-2"], source: "session",
|
|
}, pluginWorkerManager);
|
|
const response = await request(app)
|
|
.post(`/api/issues/${rootId}/tree-holds/${holdId}/release`)
|
|
.send({ metadata: { wakeAgents: true } });
|
|
expect(response.status).toBe(200);
|
|
expect(response.body.wakeFailures).toBeUndefined();
|
|
expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith("agent-parent", expect.objectContaining({
|
|
reason: "issue_tree_resumed",
|
|
contextSnapshot: expect.objectContaining({ issueId: rootId, source: "issue.tree_resume" }),
|
|
}));
|
|
});
|
|
|
|
it("reports wake failures without undoing release or skipping other assignees", async () => {
|
|
const rootId = "11111111-1111-4111-8111-111111111111";
|
|
const holdId = "33333333-3333-4333-8333-333333333333";
|
|
mockTreeControlService.releaseHold.mockResolvedValue({
|
|
id: holdId,
|
|
mode: "pause",
|
|
status: "released",
|
|
members: [{ issueId: rootId }, { issueId: "child" }],
|
|
});
|
|
mockIssueService.getById.mockImplementation(async (id) => ({
|
|
id,
|
|
companyId: "company-2",
|
|
status: "todo",
|
|
assigneeAgentId: id,
|
|
}));
|
|
mockHeartbeatService.wakeup.mockRejectedValueOnce(
|
|
new Error("Agent unavailable"),
|
|
);
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
const response = await request(app)
|
|
.post(`/api/issues/${rootId}/tree-holds/${holdId}/release`)
|
|
.send({ metadata: { wakeAgents: true } });
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toMatchObject({
|
|
status: "released",
|
|
wakeFailures: [{ issueId: rootId, message: "Agent unavailable" }],
|
|
});
|
|
expect(
|
|
mockHeartbeatService.wakeup.mock.calls.map(([agent]) => agent),
|
|
).toEqual([rootId, "child"]);
|
|
});
|
|
|
|
it("keeps the hold active when resume requests an unsafe execution replay", async () => {
|
|
const rootId = "11111111-1111-4111-8111-111111111111";
|
|
const holdId = "33333333-3333-4333-8333-333333333333";
|
|
mockTreeControlService.getHold.mockResolvedValue({
|
|
id: holdId,
|
|
rootIssueId: rootId,
|
|
mode: "pause",
|
|
members: [{ issueId: rootId }],
|
|
});
|
|
mockReplayBlocks.mockResolvedValue([{ id: rootId, identifier: "TEST-1" }]);
|
|
mockExecutionBlocker.mockResolvedValue({ nextAction: "Resume without waking agents until the previous execution stops.",
|
|
recoveryActionId: null, cause: "execution_owner_active", runId: "previous-run", agentId: "agent-1" });
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
const response = await request(app)
|
|
.post(`/api/issues/${rootId}/tree-holds/${holdId}/release`)
|
|
.send({ metadata: { wakeAgents: true } });
|
|
expect(response.status).toBe(409);
|
|
expect(response.body.error).toContain("Resume without waking agents");
|
|
expect(mockTreeControlService.releaseHold).not.toHaveBeenCalled();
|
|
expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects cross-company preview requests with a uniform 404 before calling the preview service", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-1"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-control/preview")
|
|
.send({ mode: "pause" });
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(mockTreeControlService.preview).not.toHaveBeenCalled();
|
|
expect(mockLogActivity).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("requires board access for hold creation", async () => {
|
|
const app = await createApp({
|
|
type: "agent",
|
|
agentId: "22222222-2222-4222-8222-222222222222",
|
|
companyId: "company-2",
|
|
runId: null,
|
|
source: "api_key",
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "pause" });
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(mockIssueService.getById).not.toHaveBeenCalled();
|
|
expect(mockTreeControlService.createHold).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects malformed tree hold IDs before querying the hold service", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
|
|
const getRes = await request(app)
|
|
.get("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds/null");
|
|
const releaseRes = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds/null/release")
|
|
.send({ reason: "bad hold id" });
|
|
|
|
expect(getRes.status).toBe(400);
|
|
expect(releaseRes.status).toBe(400);
|
|
expect(mockTreeControlService.getHold).not.toHaveBeenCalled();
|
|
expect(mockTreeControlService.releaseHold).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("cancels active descendant runs when creating a pause hold", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "33333333-3333-4333-8333-333333333333",
|
|
mode: "pause",
|
|
reason: "pause subtree",
|
|
},
|
|
preview: {
|
|
mode: "pause",
|
|
totals: { affectedIssues: 1 },
|
|
warnings: [],
|
|
activeRuns: [
|
|
{
|
|
id: "44444444-4444-4444-8444-444444444444",
|
|
issueId: "11111111-1111-4111-8111-111111111111",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "pause", reason: "pause subtree" });
|
|
|
|
expect(res.status).toBe(201);
|
|
expect(mockHeartbeatService.cancelRun).toHaveBeenCalledWith(
|
|
"44444444-4444-4444-8444-444444444444",
|
|
"Cancelled by a board operator's subtree pause",
|
|
{ resultJson: { cancelledByActorType: "user", cancelledByUserId: "user-1" } },
|
|
);
|
|
expect(mockTreeControlService.cancelUnclaimedWakeupsForTree).toHaveBeenCalledWith(
|
|
"company-2",
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"Cancelled because an active subtree pause hold was created",
|
|
);
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
action: "issue.tree_hold_run_interrupted",
|
|
entityId: "44444444-4444-4444-8444-444444444444",
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("marks affected issues cancelled when creating a cancel hold", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "33333333-3333-4333-8333-333333333333",
|
|
mode: "cancel",
|
|
reason: "cancel subtree",
|
|
},
|
|
preview: {
|
|
mode: "cancel",
|
|
totals: { affectedIssues: 2 },
|
|
warnings: [],
|
|
activeRuns: [],
|
|
},
|
|
});
|
|
mockTreeControlService.cancelIssueStatusesForHold.mockResolvedValue({
|
|
updatedIssueIds: [
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"55555555-5555-4555-8555-555555555555",
|
|
],
|
|
updatedIssues: [],
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "cancel", reason: "cancel subtree" });
|
|
|
|
expect(res.status).toBe(201);
|
|
expect(mockTreeControlService.cancelIssueStatusesForHold).toHaveBeenCalledWith(
|
|
"company-2",
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"33333333-3333-4333-8333-333333333333",
|
|
);
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
action: "issue.tree_cancel_status_updated",
|
|
details: expect.objectContaining({ cancelledIssueCount: 2 }),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("still marks affected issues cancelled when run interruption fails", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "33333333-3333-4333-8333-333333333333",
|
|
mode: "cancel",
|
|
reason: "cancel subtree",
|
|
},
|
|
preview: {
|
|
mode: "cancel",
|
|
totals: { affectedIssues: 1 },
|
|
warnings: [],
|
|
activeRuns: [
|
|
{
|
|
id: "44444444-4444-4444-8444-444444444444",
|
|
issueId: "11111111-1111-4111-8111-111111111111",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
mockTreeControlService.cancelIssueStatusesForHold.mockResolvedValue({
|
|
updatedIssueIds: ["11111111-1111-4111-8111-111111111111"],
|
|
updatedIssues: [],
|
|
});
|
|
mockHeartbeatService.cancelRun.mockRejectedValue(new Error("adapter process did not exit"));
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "cancel", reason: "cancel subtree" });
|
|
|
|
expect(res.status).toBe(201);
|
|
expect(mockHeartbeatService.cancelRun).toHaveBeenCalledWith(
|
|
"44444444-4444-4444-8444-444444444444",
|
|
"Cancelled by a board operator's subtree cancel",
|
|
{ resultJson: { cancelledByActorType: "user", cancelledByUserId: "user-1" } },
|
|
);
|
|
expect(mockTreeControlService.cancelIssueStatusesForHold).toHaveBeenCalledWith(
|
|
"company-2",
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"33333333-3333-4333-8333-333333333333",
|
|
);
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
action: "issue.tree_hold_run_interrupt_failed",
|
|
entityId: "44444444-4444-4444-8444-444444444444",
|
|
details: expect.objectContaining({
|
|
error: "adapter process did not exit",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("restores affected issues and can request explicit wakeups", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "66666666-6666-4666-8666-666666666666",
|
|
mode: "restore",
|
|
reason: "restore subtree",
|
|
},
|
|
preview: {
|
|
mode: "restore",
|
|
totals: { affectedIssues: 1 },
|
|
warnings: [],
|
|
activeRuns: [],
|
|
},
|
|
});
|
|
mockTreeControlService.restoreIssueStatusesForHold.mockResolvedValue({
|
|
updatedIssueIds: ["55555555-5555-4555-8555-555555555555"],
|
|
updatedIssues: [
|
|
{
|
|
id: "55555555-5555-4555-8555-555555555555",
|
|
status: "todo",
|
|
assigneeAgentId: "22222222-2222-4222-8222-222222222222",
|
|
},
|
|
],
|
|
releasedCancelHoldIds: ["33333333-3333-4333-8333-333333333333"],
|
|
restoreHold: {
|
|
id: "66666666-6666-4666-8666-666666666666",
|
|
mode: "restore",
|
|
status: "released",
|
|
},
|
|
});
|
|
mockHeartbeatService.wakeup.mockResolvedValue({
|
|
id: "77777777-7777-4777-8777-777777777777",
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "restore", reason: "restore subtree", metadata: { wakeAgents: true } });
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(mockTreeControlService.restoreIssueStatusesForHold).toHaveBeenCalledWith(
|
|
"company-2",
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"66666666-6666-4666-8666-666666666666",
|
|
expect.objectContaining({ reason: "restore subtree" }),
|
|
);
|
|
expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(
|
|
"22222222-2222-4222-8222-222222222222",
|
|
expect.objectContaining({
|
|
reason: "issue_tree_restored",
|
|
payload: expect.objectContaining({ issueId: "55555555-5555-4555-8555-555555555555" }),
|
|
}),
|
|
);
|
|
expect(res.body.hold.status).toBe("released");
|
|
});
|
|
|
|
it("releases a restore hold if the restore application fails", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "66666666-6666-4666-8666-666666666666",
|
|
mode: "restore",
|
|
reason: "restore subtree",
|
|
},
|
|
preview: {
|
|
mode: "restore",
|
|
totals: { affectedIssues: 1 },
|
|
warnings: [],
|
|
activeRuns: [],
|
|
},
|
|
});
|
|
mockTreeControlService.restoreIssueStatusesForHold.mockRejectedValue(new Error("restore failed"));
|
|
mockTreeControlService.releaseHold.mockResolvedValue({
|
|
id: "66666666-6666-4666-8666-666666666666",
|
|
mode: "restore",
|
|
status: "released",
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "restore", reason: "restore subtree" });
|
|
|
|
expect(res.status).toBe(500);
|
|
expect(mockTreeControlService.releaseHold).toHaveBeenCalledWith(
|
|
"company-2",
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"66666666-6666-4666-8666-666666666666",
|
|
expect.objectContaining({
|
|
reason: "Restore operation failed before subtree status updates completed",
|
|
metadata: { cleanup: "restore_failed_before_apply" },
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("returns resume operations as released holds and avoids cancellation side effects", async () => {
|
|
const app = await createApp({
|
|
type: "board",
|
|
userId: "user-1",
|
|
companyIds: ["company-2"],
|
|
source: "session",
|
|
isInstanceAdmin: false,
|
|
});
|
|
mockTreeControlService.createHold.mockResolvedValue({
|
|
hold: {
|
|
id: "77777777-7777-4777-8777-777777777777",
|
|
mode: "resume",
|
|
status: "released",
|
|
reason: "resume subtree",
|
|
},
|
|
preview: {
|
|
mode: "resume",
|
|
totals: {
|
|
affectedIssues: 1,
|
|
},
|
|
warnings: [],
|
|
activeRuns: [],
|
|
},
|
|
resumedPauseHoldIds: ["33333333-3333-4333-8333-333333333333"],
|
|
});
|
|
|
|
const res = await request(app)
|
|
.post("/api/issues/11111111-1111-4111-8111-111111111111/tree-holds")
|
|
.send({ mode: "resume", reason: "resume subtree" });
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.hold.mode).toBe("resume");
|
|
expect(res.body.hold.status).toBe("released");
|
|
expect(res.body.resumedPauseHoldIds).toEqual(["33333333-3333-4333-8333-333333333333"]);
|
|
expect(mockHeartbeatService.cancelRun).not.toHaveBeenCalled();
|
|
expect(mockTreeControlService.cancelUnclaimedWakeupsForTree).not.toHaveBeenCalled();
|
|
expect(mockTreeControlService.cancelIssueStatusesForHold).not.toHaveBeenCalled();
|
|
expect(mockTreeControlService.restoreIssueStatusesForHold).not.toHaveBeenCalled();
|
|
});
|
|
});
|