mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 03:31:44 +01:00
The task routes that filter several rows for one actor (summaries, lists, blockers, relation edges and the chat bootstrap) asked for one authorization decision per task, all at the same time. Each decision sent a task-row read and a copy of the task-privacy statement, which is more than 1 KB of SQL, so a request for 50 summaries sent 127 to 279 statements on every pool connection at once. The routes now ask the authorization service for all decisions in one batched read. It reads the task rows and applies the same privacy predicate to all of them in one statement, and reads membership, agent and run policy once. Within a batch, the authorizing user's membership is read once, and the boundary checks of a low-trust agent, which stay per task, run at most eight at a time. A request for 50 summaries now sends 22 to 28 statements (65 for a low-trust agent). Tests compare the batch with one check per task for 24 actors. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
577 lines
20 KiB
TypeScript
577 lines
20 KiB
TypeScript
import express from "express";
|
|
import request from "supertest";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { errorHandler } from "../middleware/index.js";
|
|
import { issueRoutes } from "../routes/issues.js";
|
|
|
|
const mockIssueService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
getAncestors: vi.fn(),
|
|
getRelationSummaries: vi.fn(),
|
|
findMentionedProjectIds: vi.fn(),
|
|
getCommentCursor: vi.fn(),
|
|
getComment: vi.fn(),
|
|
listBlockerAttention: vi.fn(),
|
|
listReviewAttention: vi.fn(),
|
|
getCurrentScheduledRetry: vi.fn(),
|
|
getActiveInboxArchiveFields: vi.fn(),
|
|
listAttachments: vi.fn(),
|
|
}));
|
|
|
|
const mockProjectService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
listByIds: vi.fn(),
|
|
}));
|
|
|
|
const mockGoalService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
getDefaultCompanyGoal: vi.fn(),
|
|
}));
|
|
|
|
const mockDocumentsService = vi.hoisted(() => ({
|
|
getIssueDocumentPayload: vi.fn(),
|
|
getIssueDocumentByKey: vi.fn(),
|
|
}));
|
|
|
|
const mockExecutionWorkspaceService = vi.hoisted(() => ({
|
|
getById: vi.fn(() => { throw new Error("Task routes must not inspect a workspace"); }),
|
|
getStoredById: vi.fn(),
|
|
}));
|
|
|
|
const mockAccessService = vi.hoisted(() => {
|
|
const decide = vi.fn();
|
|
return {
|
|
canUser: vi.fn(),
|
|
decide,
|
|
// The batched read asks the mocked decision once per task.
|
|
decideReads: async (actor: unknown, resources: unknown[]) =>
|
|
Promise.all(resources.map((resource) => decide({ actor, action: "issue:read", resource }))),
|
|
hasPermission: vi.fn(),
|
|
};
|
|
});
|
|
|
|
const mockAgentService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
}));
|
|
|
|
const mockFeedbackService = vi.hoisted(() => ({
|
|
listIssueVotesForUser: vi.fn(async () => []),
|
|
saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })),
|
|
}));
|
|
|
|
const mockHeartbeatService = vi.hoisted(() => ({
|
|
wakeup: vi.fn(async () => undefined),
|
|
reportRunActivity: vi.fn(async () => undefined),
|
|
}));
|
|
|
|
const mockInstanceSettingsService = vi.hoisted(() => ({
|
|
get: vi.fn(async () => ({
|
|
id: "instance-settings-1",
|
|
general: {
|
|
censorUsernameInLogs: false,
|
|
feedbackDataSharingPreference: "prompt",
|
|
},
|
|
})),
|
|
listCompanyIds: vi.fn(async () => ["company-1"]),
|
|
}));
|
|
|
|
const mockIssueReferenceService = vi.hoisted(() => ({
|
|
deleteDocumentSource: vi.fn(async () => undefined),
|
|
diffIssueReferenceSummary: vi.fn(() => ({
|
|
addedReferencedIssues: [],
|
|
removedReferencedIssues: [],
|
|
currentReferencedIssues: [],
|
|
})),
|
|
emptySummary: vi.fn(() => ({ outbound: [], inbound: [] })),
|
|
listIssueReferenceSummary: vi.fn(async () => ({ outbound: [], inbound: [] })),
|
|
syncComment: vi.fn(async () => undefined),
|
|
syncDocument: vi.fn(async () => undefined),
|
|
syncIssue: vi.fn(async () => undefined),
|
|
}));
|
|
|
|
const mockLogActivity = vi.hoisted(() => vi.fn(async () => undefined));
|
|
|
|
const mockRoutineService = vi.hoisted(() => ({
|
|
syncRunStatusForIssue: vi.fn(async () => undefined),
|
|
}));
|
|
|
|
const mockWorkProductService = vi.hoisted(() => ({
|
|
listForIssue: vi.fn(async () => []),
|
|
}));
|
|
|
|
const mockEnvironmentService = vi.hoisted(() => ({}));
|
|
|
|
const mockDb = vi.hoisted(() => ({
|
|
select: vi.fn(),
|
|
execute: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../services/task-interruption-presentation.js", () => ({
|
|
taskInterruptionPresentation: vi.fn(async () => null),
|
|
taskInterruptionPresentations: vi.fn(async () => new Map()),
|
|
}));
|
|
|
|
vi.mock("../services/index.js", () => ({
|
|
companyService: () => ({
|
|
getById: vi.fn(async () => ({ id: "company-1" })),
|
|
}),
|
|
accessService: () => mockAccessService,
|
|
agentService: () => mockAgentService,
|
|
companySkillService: () => ({
|
|
completeTestRunForIssue: vi.fn(async () => null),
|
|
}),
|
|
documentAnnotationService: () => ({ remapOpenThreadsForDocument: async () => [] }),
|
|
documentService: () => mockDocumentsService,
|
|
environmentService: () => mockEnvironmentService,
|
|
executionWorkspaceService: () => mockExecutionWorkspaceService,
|
|
feedbackService: () => mockFeedbackService,
|
|
goalService: () => mockGoalService,
|
|
heartbeatService: () => mockHeartbeatService,
|
|
instanceSettingsService: () => mockInstanceSettingsService,
|
|
issueApprovalService: () => ({}),
|
|
issueRecoveryActionService: () => ({
|
|
getActiveForIssue: vi.fn(async () => null),
|
|
listActiveForIssues: vi.fn(async () => new Map()),
|
|
}),
|
|
issueThreadInteractionService: () => ({
|
|
listForIssue: vi.fn(async () => []),
|
|
expireRequestConfirmationsSupersededByComment: vi.fn(async () => []),
|
|
expireStaleRequestConfirmationsForIssueDocument: vi.fn(async () => []),
|
|
}),
|
|
issueReferenceService: () => mockIssueReferenceService,
|
|
issueService: () => mockIssueService,
|
|
logActivity: mockLogActivity,
|
|
projectService: () => mockProjectService,
|
|
routineService: () => mockRoutineService,
|
|
workProductService: () => mockWorkProductService,
|
|
}));
|
|
|
|
vi.mock("../services/execution-workspaces.js", () => ({
|
|
executionWorkspaceService: () => mockExecutionWorkspaceService,
|
|
STALE_REOPEN_PENDING_CONSUMPTION_GRACE_MS: 5 * 60 * 1000,
|
|
}));
|
|
|
|
function createApp() {
|
|
const app = express();
|
|
app.use(express.json());
|
|
app.use((req, _res, next) => {
|
|
(req as any).actor = {
|
|
type: "board",
|
|
userId: "local-board",
|
|
companyIds: ["company-1"],
|
|
source: "local_implicit",
|
|
isInstanceAdmin: false,
|
|
};
|
|
next();
|
|
});
|
|
app.use("/api", issueRoutes(mockDb as any, {} as any));
|
|
app.use(errorHandler);
|
|
return app;
|
|
}
|
|
|
|
const legacyProjectLinkedIssue = {
|
|
id: "11111111-1111-4111-8111-111111111111",
|
|
companyId: "company-1",
|
|
identifier: "PAP-581",
|
|
title: "Legacy onboarding task",
|
|
description: "Seed the first CEO task",
|
|
status: "todo",
|
|
workMode: "planning",
|
|
priority: "medium",
|
|
projectId: "22222222-2222-4222-8222-222222222222",
|
|
goalId: null,
|
|
parentId: null,
|
|
assigneeAgentId: "33333333-3333-4333-8333-333333333333",
|
|
assigneeUserId: null,
|
|
updatedAt: new Date("2026-03-24T12:00:00Z"),
|
|
executionWorkspaceId: null,
|
|
labels: [],
|
|
labelIds: [],
|
|
};
|
|
|
|
const projectGoal = {
|
|
id: "44444444-4444-4444-8444-444444444444",
|
|
companyId: "company-1",
|
|
title: "Launch the company",
|
|
description: null,
|
|
level: "company",
|
|
status: "active",
|
|
parentId: null,
|
|
ownerAgentId: null,
|
|
createdAt: new Date("2026-03-20T00:00:00Z"),
|
|
updatedAt: new Date("2026-03-20T00:00:00Z"),
|
|
};
|
|
|
|
describe("issue goal context routes", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mockAccessService.decide.mockResolvedValue({
|
|
allowed: true,
|
|
action: "issue:read",
|
|
reason: "allow_test",
|
|
explanation: "Allowed by test mock.",
|
|
});
|
|
mockIssueService.getById.mockResolvedValue(legacyProjectLinkedIssue);
|
|
mockIssueService.getAncestors.mockResolvedValue([]);
|
|
mockIssueService.getRelationSummaries.mockResolvedValue({ blockedBy: [], blocks: [] });
|
|
mockIssueService.findMentionedProjectIds.mockResolvedValue([]);
|
|
mockIssueService.getCommentCursor.mockResolvedValue({
|
|
totalComments: 0,
|
|
latestCommentId: null,
|
|
latestCommentAt: null,
|
|
});
|
|
mockIssueService.getComment.mockResolvedValue(null);
|
|
mockIssueService.listBlockerAttention.mockResolvedValue(new Map());
|
|
mockIssueService.listReviewAttention.mockResolvedValue(new Map());
|
|
mockIssueService.getCurrentScheduledRetry.mockResolvedValue(null);
|
|
mockIssueService.getActiveInboxArchiveFields.mockResolvedValue({});
|
|
mockIssueService.listAttachments.mockResolvedValue([]);
|
|
mockDocumentsService.getIssueDocumentPayload.mockResolvedValue({});
|
|
mockDocumentsService.getIssueDocumentByKey.mockResolvedValue(null);
|
|
mockExecutionWorkspaceService.getStoredById.mockResolvedValue(null);
|
|
const emptyQuery: any = {};
|
|
emptyQuery.from = vi.fn(() => emptyQuery);
|
|
emptyQuery.innerJoin = vi.fn(() => emptyQuery);
|
|
emptyQuery.leftJoin = vi.fn(() => emptyQuery);
|
|
emptyQuery.where = vi.fn(() => emptyQuery);
|
|
emptyQuery.orderBy = vi.fn(() => emptyQuery);
|
|
emptyQuery.limit = vi.fn(async () => []);
|
|
emptyQuery.then = (resolve: (rows: unknown[]) => unknown, reject?: (error: unknown) => unknown) =>
|
|
Promise.resolve([]).then(resolve, reject);
|
|
mockDb.select.mockReturnValue(emptyQuery);
|
|
mockDb.execute.mockResolvedValue([]);
|
|
mockProjectService.getById.mockResolvedValue({
|
|
id: legacyProjectLinkedIssue.projectId,
|
|
companyId: "company-1",
|
|
urlKey: "onboarding",
|
|
goalId: projectGoal.id,
|
|
goalIds: [projectGoal.id],
|
|
goals: [{ id: projectGoal.id, title: projectGoal.title }],
|
|
name: "Onboarding",
|
|
description: null,
|
|
status: "in_progress",
|
|
leadAgentId: null,
|
|
targetDate: null,
|
|
color: null,
|
|
pauseReason: null,
|
|
pausedAt: null,
|
|
executionWorkspacePolicy: null,
|
|
codebase: {
|
|
workspaceId: null,
|
|
repoUrl: null,
|
|
repoRef: null,
|
|
defaultRef: null,
|
|
repoName: null,
|
|
localFolder: null,
|
|
managedFolder: "/tmp/company-1/project-1",
|
|
effectiveLocalFolder: "/tmp/company-1/project-1",
|
|
origin: "managed_checkout",
|
|
},
|
|
workspaces: [],
|
|
primaryWorkspace: null,
|
|
archivedAt: null,
|
|
createdAt: new Date("2026-03-20T00:00:00Z"),
|
|
updatedAt: new Date("2026-03-20T00:00:00Z"),
|
|
});
|
|
mockProjectService.listByIds.mockResolvedValue([]);
|
|
mockGoalService.getById.mockImplementation(async (id: string) =>
|
|
id === projectGoal.id ? projectGoal : null,
|
|
);
|
|
mockGoalService.getDefaultCompanyGoal.mockResolvedValue(null);
|
|
});
|
|
|
|
it.each(["", "/heartbeat-context"])("reads historical review tasks without computed productivity fields: %s", async (suffix) => {
|
|
mockIssueService.getById.mockResolvedValue({
|
|
...legacyProjectLinkedIssue,
|
|
originKind: "issue_productivity_review",
|
|
originId: "historical-source",
|
|
});
|
|
const res = await request(createApp()).get(`/api/issues/${legacyProjectLinkedIssue.id}${suffix}`);
|
|
expect(res.status).toBe(200);
|
|
const issue = suffix ? res.body.issue : res.body;
|
|
expect(issue).toMatchObject({
|
|
originKind: "issue_productivity_review",
|
|
originId: "historical-source",
|
|
assigneeAgentId: legacyProjectLinkedIssue.assigneeAgentId,
|
|
status: legacyProjectLinkedIssue.status,
|
|
});
|
|
expect(issue).not.toHaveProperty("productivityReview");
|
|
});
|
|
|
|
it("surfaces the project goal from GET /issues/:id when the issue has no direct goal", async () => {
|
|
const res = await request(createApp()).get("/api/issues/11111111-1111-4111-8111-111111111111");
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.goalId).toBe(projectGoal.id);
|
|
expect(res.body.goal).toEqual(
|
|
expect.objectContaining({
|
|
id: projectGoal.id,
|
|
title: projectGoal.title,
|
|
}),
|
|
);
|
|
expect(mockIssueService.findMentionedProjectIds).toHaveBeenCalledWith(
|
|
"11111111-1111-4111-8111-111111111111",
|
|
{ includeCommentBodies: false },
|
|
);
|
|
expect(mockGoalService.getDefaultCompanyGoal).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps GET /issues/:id project and workspace embeds compact for fast detail loads", async () => {
|
|
const workspaceId = "55555555-5555-4555-8555-555555555555";
|
|
const runtimeServiceBase = {
|
|
companyId: "company-1",
|
|
projectId: legacyProjectLinkedIssue.projectId,
|
|
projectWorkspaceId: "workspace-primary",
|
|
executionWorkspaceId: workspaceId,
|
|
issueId: legacyProjectLinkedIssue.id,
|
|
scopeType: "execution_workspace",
|
|
scopeId: workspaceId,
|
|
serviceName: "Dev server",
|
|
lifecycle: "shared",
|
|
reuseKey: "dev-server",
|
|
command: "pnpm dev",
|
|
cwd: "/tmp/company-1/project-1",
|
|
port: 3100,
|
|
url: "http://localhost:3100",
|
|
provider: "local_process",
|
|
providerRef: "pid:123",
|
|
ownerAgentId: null,
|
|
startedByRunId: null,
|
|
lastUsedAt: new Date("2026-03-24T12:00:00Z"),
|
|
startedAt: new Date("2026-03-24T12:00:00Z"),
|
|
stoppedAt: null,
|
|
healthStatus: "healthy",
|
|
configIndex: 0,
|
|
metadata: { huge: "runtime metadata should not be embedded" },
|
|
};
|
|
mockIssueService.getById.mockResolvedValueOnce({
|
|
...legacyProjectLinkedIssue,
|
|
executionWorkspaceId: workspaceId,
|
|
});
|
|
mockProjectService.getById.mockResolvedValueOnce({
|
|
...(await mockProjectService.getById()),
|
|
env: { API_KEY: { type: "plain", value: "should-not-ship" } },
|
|
workspaces: [
|
|
{
|
|
id: "workspace-primary",
|
|
companyId: "company-1",
|
|
projectId: legacyProjectLinkedIssue.projectId,
|
|
name: "Main",
|
|
sourceType: "local_path",
|
|
cwd: "/tmp/company-1/project-1",
|
|
repoUrl: null,
|
|
repoRef: "master",
|
|
defaultRef: "master",
|
|
visibility: "default",
|
|
setupCommand: null,
|
|
cleanupCommand: null,
|
|
remoteProvider: null,
|
|
remoteWorkspaceRef: null,
|
|
sharedWorkspaceKey: null,
|
|
metadata: { huge: "project workspace metadata should not be embedded" },
|
|
runtimeConfig: { services: [{ name: "Dev server", command: "pnpm dev" }] },
|
|
runtimeServices: [{ ...runtimeServiceBase, id: "project-service-stopped", status: "stopped" }],
|
|
isPrimary: true,
|
|
createdAt: new Date("2026-03-20T00:00:00Z"),
|
|
updatedAt: new Date("2026-03-20T00:00:00Z"),
|
|
},
|
|
],
|
|
primaryWorkspace: {
|
|
id: "workspace-primary",
|
|
companyId: "company-1",
|
|
projectId: legacyProjectLinkedIssue.projectId,
|
|
name: "Main",
|
|
sourceType: "local_path",
|
|
cwd: "/tmp/company-1/project-1",
|
|
repoUrl: null,
|
|
repoRef: "master",
|
|
defaultRef: "master",
|
|
visibility: "default",
|
|
setupCommand: null,
|
|
cleanupCommand: null,
|
|
remoteProvider: null,
|
|
remoteWorkspaceRef: null,
|
|
sharedWorkspaceKey: null,
|
|
metadata: { huge: "primary workspace metadata should not be embedded" },
|
|
runtimeConfig: { services: [{ name: "Dev server", command: "pnpm dev" }] },
|
|
runtimeServices: [{ ...runtimeServiceBase, id: "primary-service-stopped", status: "stopped" }],
|
|
isPrimary: true,
|
|
createdAt: new Date("2026-03-20T00:00:00Z"),
|
|
updatedAt: new Date("2026-03-20T00:00:00Z"),
|
|
},
|
|
});
|
|
mockExecutionWorkspaceService.getStoredById.mockResolvedValueOnce({
|
|
id: workspaceId,
|
|
companyId: "company-1",
|
|
projectId: legacyProjectLinkedIssue.projectId,
|
|
projectWorkspaceId: "workspace-primary",
|
|
sourceIssueId: legacyProjectLinkedIssue.id,
|
|
mode: "isolated_workspace",
|
|
strategyType: "git_worktree",
|
|
name: "PAP-581-workspace",
|
|
status: "active",
|
|
cwd: "/tmp/company-1/project-1",
|
|
repoUrl: null,
|
|
baseRef: "master",
|
|
branchName: "PAP-581-workspace",
|
|
providerType: "local",
|
|
providerRef: "/tmp/company-1/project-1",
|
|
derivedFromExecutionWorkspaceId: null,
|
|
lastUsedAt: new Date("2026-03-24T12:00:00Z"),
|
|
openedAt: new Date("2026-03-24T12:00:00Z"),
|
|
closedAt: null,
|
|
cleanupEligibleAt: null,
|
|
cleanupReason: null,
|
|
config: {
|
|
environmentId: "env-1",
|
|
provisionCommand: "bash setup.sh",
|
|
teardownCommand: null,
|
|
cleanupCommand: null,
|
|
workspaceRuntime: { services: [{ name: "Dev server", command: "pnpm dev" }] },
|
|
desiredState: null,
|
|
serviceStates: null,
|
|
},
|
|
metadata: { huge: "execution workspace metadata should not be embedded" },
|
|
runtimeServices: [
|
|
{ ...runtimeServiceBase, id: "service-running", status: "running" },
|
|
{ ...runtimeServiceBase, id: "service-stopped", status: "stopped" },
|
|
],
|
|
createdAt: new Date("2026-03-24T12:00:00Z"),
|
|
updatedAt: new Date("2026-03-24T12:00:00Z"),
|
|
});
|
|
|
|
const res = await request(createApp()).get("/api/issues/11111111-1111-4111-8111-111111111111");
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.project.env).toBeNull();
|
|
expect(res.body.project.workspaces[0]).not.toHaveProperty("metadata");
|
|
expect(res.body.project.workspaces[0]).not.toHaveProperty("runtimeServices");
|
|
expect(res.body.project.primaryWorkspace).not.toHaveProperty("metadata");
|
|
expect(res.body.project.primaryWorkspace).not.toHaveProperty("runtimeServices");
|
|
expect(res.body.currentExecutionWorkspace.metadata).toBeNull();
|
|
expect(res.body.currentExecutionWorkspace.runtimeServices).toHaveLength(1);
|
|
expect(res.body.currentExecutionWorkspace.runtimeServices[0]).toMatchObject({
|
|
id: "service-running",
|
|
status: "running",
|
|
url: "http://localhost:3100",
|
|
});
|
|
expect(res.body.currentExecutionWorkspace.runtimeServices[0]).not.toHaveProperty("metadata");
|
|
});
|
|
|
|
it("surfaces the project goal from GET /issues/:id/heartbeat-context", async () => {
|
|
const res = await request(createApp()).get(
|
|
"/api/issues/11111111-1111-4111-8111-111111111111/heartbeat-context",
|
|
);
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.issue.goalId).toBe(projectGoal.id);
|
|
expect(res.body.issue.workMode).toBe("planning");
|
|
expect(res.body.goal).toEqual(
|
|
expect.objectContaining({
|
|
id: projectGoal.id,
|
|
title: projectGoal.title,
|
|
}),
|
|
);
|
|
expect(mockGoalService.getDefaultCompanyGoal).not.toHaveBeenCalled();
|
|
expect(res.body.attachments).toEqual([]);
|
|
expect(res.body.taskQuestionContext).toEqual({
|
|
questions: [], truncated: false, guidance: expect.stringContaining("Historical questions remain answerable"),
|
|
});
|
|
});
|
|
|
|
it("preserves direct continuation summary lookup in GET /issues/:id/heartbeat-context", async () => {
|
|
mockDocumentsService.getIssueDocumentByKey.mockResolvedValue({
|
|
key: "continuation-summary",
|
|
title: "Continuation Summary",
|
|
body: "# Handoff",
|
|
latestRevisionId: "revision-1",
|
|
latestRevisionNumber: 1,
|
|
updatedAt: new Date("2026-04-19T12:00:00.000Z"),
|
|
});
|
|
|
|
const res = await request(createApp()).get(
|
|
"/api/issues/11111111-1111-4111-8111-111111111111/heartbeat-context",
|
|
);
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(mockDocumentsService.getIssueDocumentByKey).toHaveBeenCalledWith(
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"continuation-summary",
|
|
);
|
|
expect(res.body.continuationSummary).toEqual(expect.objectContaining({
|
|
key: "continuation-summary",
|
|
body: "# Handoff",
|
|
}));
|
|
});
|
|
|
|
it("surfaces blocker summaries on GET /issues/:id/heartbeat-context", async () => {
|
|
mockIssueService.getRelationSummaries.mockResolvedValue({
|
|
blockedBy: [
|
|
{
|
|
id: "55555555-5555-4555-8555-555555555555",
|
|
identifier: "PAP-580",
|
|
title: "Finish wakeup plumbing",
|
|
status: "done",
|
|
priority: "medium",
|
|
assigneeAgentId: null,
|
|
assigneeUserId: null,
|
|
},
|
|
],
|
|
blocks: [],
|
|
});
|
|
|
|
const res = await request(createApp()).get(
|
|
"/api/issues/11111111-1111-4111-8111-111111111111/heartbeat-context",
|
|
);
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.issue.blockedBy).toEqual([
|
|
expect.objectContaining({
|
|
id: "55555555-5555-4555-8555-555555555555",
|
|
identifier: "PAP-580",
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it.each(["", "/heartbeat-context"])("reads stored workspace context without Git inspection: %s", async (suffix) => {
|
|
mockIssueService.getById.mockResolvedValue({
|
|
...legacyProjectLinkedIssue,
|
|
executionWorkspaceId: "55555555-5555-4555-8555-555555555555",
|
|
});
|
|
mockExecutionWorkspaceService.getStoredById.mockResolvedValue({
|
|
id: "55555555-5555-4555-8555-555555555555",
|
|
name: "PAP-581 workspace",
|
|
mode: "isolated_workspace",
|
|
status: "active",
|
|
cwd: "/tmp/pap-581",
|
|
runtimeServices: [
|
|
{
|
|
id: "service-1",
|
|
serviceName: "web",
|
|
status: "running",
|
|
url: "http://127.0.0.1:5173",
|
|
healthStatus: "healthy",
|
|
},
|
|
],
|
|
});
|
|
|
|
const res = await request(createApp()).get(
|
|
`/api/issues/11111111-1111-4111-8111-111111111111${suffix}`,
|
|
);
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(mockExecutionWorkspaceService.getById).not.toHaveBeenCalled();
|
|
expect(mockExecutionWorkspaceService.getStoredById).toHaveBeenCalledWith("company-1", "55555555-5555-4555-8555-555555555555", { includeRuntimeServices: true });
|
|
expect(res.body.currentExecutionWorkspace).toEqual(expect.objectContaining({
|
|
id: "55555555-5555-4555-8555-555555555555",
|
|
mode: "isolated_workspace",
|
|
runtimeServices: [
|
|
expect.objectContaining({
|
|
serviceName: "web",
|
|
url: "http://127.0.0.1:5173",
|
|
}),
|
|
],
|
|
}));
|
|
});
|
|
});
|