335 lines
11 KiB
TypeScript
335 lines
11 KiB
TypeScript
import express from "express";
|
|
import request from "supertest";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { StorageService } from "../storage/types.js";
|
|
|
|
const ISSUE_ID = "11111111-1111-4111-8111-111111111111";
|
|
const WORK_PRODUCT_ID = "22222222-2222-4222-8222-222222222222";
|
|
|
|
const mockIssueService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
getByIdentifier: vi.fn(),
|
|
getAttachmentById: vi.fn(),
|
|
}));
|
|
const mockCompanyService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
}));
|
|
const mockWorkProductService = vi.hoisted(() => ({
|
|
createForIssue: vi.fn(),
|
|
getById: vi.fn(),
|
|
update: vi.fn(),
|
|
}));
|
|
const mockAccessService = vi.hoisted(() => ({
|
|
decide: vi.fn(async () => ({
|
|
allowed: true,
|
|
explanation: "Allowed by test mock",
|
|
})),
|
|
canUser: vi.fn(),
|
|
hasPermission: vi.fn(),
|
|
}));
|
|
const mockLogActivity = vi.hoisted(() => vi.fn(async () => undefined));
|
|
const mockEnsureForWorkProduct = vi.hoisted(() => vi.fn());
|
|
const mockSyncDocumentSafely = vi.hoisted(() => vi.fn(async () => undefined));
|
|
|
|
function registerRouteMocks() {
|
|
vi.doMock("@paperclipai/shared/telemetry", () => ({
|
|
trackAgentTaskCompleted: vi.fn(),
|
|
trackErrorHandlerCrash: vi.fn(),
|
|
}));
|
|
|
|
vi.doMock("../telemetry.js", () => ({
|
|
getTelemetryClient: vi.fn(() => ({ track: vi.fn() })),
|
|
}));
|
|
|
|
vi.doMock("../services/issues.js", () => ({
|
|
issueService: () => mockIssueService,
|
|
}));
|
|
|
|
vi.doMock("../services/activity-log.js", () => ({
|
|
logActivity: mockLogActivity,
|
|
}));
|
|
|
|
vi.doMock("../services/artifact-review-documents.js", () => ({
|
|
artifactReviewDocumentService: () => ({
|
|
ensureForWorkProduct: mockEnsureForWorkProduct,
|
|
}),
|
|
}));
|
|
|
|
vi.doMock("../services/external-objects.js", () => ({
|
|
externalObjectService: () => ({
|
|
syncDocumentSafely: mockSyncDocumentSafely,
|
|
}),
|
|
}));
|
|
|
|
vi.doMock("../services/index.js", () => ({
|
|
accessService: () => mockAccessService,
|
|
agentService: () => ({
|
|
getById: vi.fn(),
|
|
}),
|
|
companySkillService: () => ({}),
|
|
companyService: () => mockCompanyService,
|
|
documentAnnotationService: () => ({ remapOpenThreadsForDocument: async () => [] }),
|
|
documentService: () => ({}),
|
|
executionWorkspaceService: () => ({}),
|
|
feedbackService: () => ({
|
|
listIssueVotesForUser: vi.fn(async () => []),
|
|
saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })),
|
|
}),
|
|
goalService: () => ({}),
|
|
heartbeatService: () => ({
|
|
wakeup: vi.fn(async () => undefined),
|
|
reportRunActivity: vi.fn(async () => undefined),
|
|
getRun: vi.fn(async () => null),
|
|
getActiveRunForAgent: vi.fn(async () => null),
|
|
cancelRun: vi.fn(async () => null),
|
|
}),
|
|
instanceSettingsService: () => ({
|
|
get: vi.fn(async () => ({
|
|
id: "instance-settings-1",
|
|
general: {
|
|
censorUsernameInLogs: false,
|
|
feedbackDataSharingPreference: "prompt",
|
|
},
|
|
})),
|
|
listCompanyIds: vi.fn(async () => ["company-1"]),
|
|
}),
|
|
issueApprovalService: () => ({}),
|
|
issueReferenceService: () => ({
|
|
deleteDocumentSource: async () => undefined,
|
|
diffIssueReferenceSummary: () => ({
|
|
addedReferencedIssues: [],
|
|
removedReferencedIssues: [],
|
|
currentReferencedIssues: [],
|
|
}),
|
|
emptySummary: () => ({ outbound: [], inbound: [] }),
|
|
listIssueReferenceSummary: async () => ({ outbound: [], inbound: [] }),
|
|
syncComment: async () => undefined,
|
|
syncDocument: async () => undefined,
|
|
syncIssue: async () => undefined,
|
|
}),
|
|
issueThreadInteractionService: () => ({
|
|
listForIssue: vi.fn(async () => []),
|
|
expireRequestConfirmationsSupersededByComment: vi.fn(async () => []),
|
|
expireStaleRequestConfirmationsForIssueDocument: vi.fn(async () => []),
|
|
}),
|
|
issueRecoveryActionService: () => ({
|
|
getActiveForIssue: vi.fn(async () => null),
|
|
listActiveForIssues: vi.fn(async () => new Map()),
|
|
}),
|
|
issueService: () => mockIssueService,
|
|
logActivity: mockLogActivity,
|
|
projectService: () => ({}),
|
|
routineService: () => ({
|
|
syncRunStatusForIssue: vi.fn(async () => undefined),
|
|
}),
|
|
workProductService: () => mockWorkProductService,
|
|
}));
|
|
}
|
|
|
|
function createStorageService(): StorageService {
|
|
return {
|
|
provider: "local_disk",
|
|
putFile: vi.fn(),
|
|
getObject: vi.fn(),
|
|
headObject: vi.fn(),
|
|
deleteObject: vi.fn(),
|
|
} as unknown as StorageService;
|
|
}
|
|
|
|
async function createApp(options?: { companyIds?: string[] }) {
|
|
const [{ errorHandler }, { issueRoutes }] = await Promise.all([
|
|
vi.importActual<typeof import("../middleware/index.js")>("../middleware/index.js"),
|
|
vi.importActual<typeof import("../routes/issues.js")>("../routes/issues.js"),
|
|
]);
|
|
const app = express();
|
|
app.use(express.json());
|
|
app.use((req, _res, next) => {
|
|
(req as any).actor = {
|
|
type: "board",
|
|
userId: "local-board",
|
|
companyIds: options?.companyIds ?? ["company-1"],
|
|
source: "local_implicit",
|
|
isInstanceAdmin: false,
|
|
};
|
|
next();
|
|
});
|
|
app.use("/api", issueRoutes({} as any, createStorageService()));
|
|
app.use(errorHandler);
|
|
return app;
|
|
}
|
|
|
|
function makeIssue() {
|
|
return {
|
|
id: ISSUE_ID,
|
|
companyId: "company-1",
|
|
identifier: "PAP-1",
|
|
projectId: null,
|
|
status: "in_progress",
|
|
assigneeAgentId: null,
|
|
};
|
|
}
|
|
|
|
function makeWorkProduct(overrides: Record<string, unknown> = {}) {
|
|
const attachmentId = "55555555-5555-4555-8555-555555555555";
|
|
const contentPath = `/api/attachments/${attachmentId}/content`;
|
|
return {
|
|
id: WORK_PRODUCT_ID,
|
|
companyId: "company-1",
|
|
issueId: ISSUE_ID,
|
|
type: "artifact",
|
|
provider: "paperclip",
|
|
title: "Verification report",
|
|
metadata: {
|
|
attachmentId,
|
|
contentType: "text/markdown",
|
|
byteSize: 128,
|
|
contentPath,
|
|
openPath: contentPath,
|
|
downloadPath: `${contentPath}?download=1`,
|
|
originalFilename: "verification-report.md",
|
|
},
|
|
createdByRunId: null,
|
|
sourceTrust: null,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeDocument(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "33333333-3333-4333-8333-333333333333",
|
|
companyId: "company-1",
|
|
issueId: ISSUE_ID,
|
|
key: `artifact-review-${WORK_PRODUCT_ID}`,
|
|
title: "Verification report",
|
|
format: "markdown",
|
|
body: "# Report",
|
|
latestRevisionId: "44444444-4444-4444-8444-444444444444",
|
|
latestRevisionNumber: 1,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("work product review-document route", () => {
|
|
beforeEach(() => {
|
|
vi.resetModules();
|
|
vi.clearAllMocks();
|
|
registerRouteMocks();
|
|
mockIssueService.getById.mockResolvedValue(makeIssue());
|
|
mockWorkProductService.getById.mockResolvedValue(makeWorkProduct());
|
|
});
|
|
|
|
it("returns 404 when the work product belongs to another issue", async () => {
|
|
mockWorkProductService.getById.mockResolvedValue(
|
|
makeWorkProduct({ issueId: "55555555-5555-4555-8555-555555555555" }),
|
|
);
|
|
|
|
const app = await createApp();
|
|
const res = await request(app).post(
|
|
`/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
|
|
);
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(mockEnsureForWorkProduct).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns 404 when the work product does not exist", async () => {
|
|
mockWorkProductService.getById.mockResolvedValue(null);
|
|
|
|
const app = await createApp();
|
|
const res = await request(app).post(
|
|
`/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
|
|
);
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(mockEnsureForWorkProduct).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("materializes the review document and logs document creation", async () => {
|
|
mockEnsureForWorkProduct.mockResolvedValue({
|
|
document: makeDocument(),
|
|
created: true,
|
|
revisionChanged: true,
|
|
remappedAnnotations: [],
|
|
});
|
|
|
|
const app = await createApp();
|
|
const res = await request(app).post(
|
|
`/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
|
|
);
|
|
|
|
expect(res.status).toBe(201);
|
|
expect(res.body.key).toBe(`artifact-review-${WORK_PRODUCT_ID}`);
|
|
expect(mockEnsureForWorkProduct).toHaveBeenCalledWith({
|
|
issue: { id: ISSUE_ID, companyId: "company-1" },
|
|
workProduct: expect.objectContaining({ id: WORK_PRODUCT_ID }),
|
|
});
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
action: "issue.document_created",
|
|
details: expect.objectContaining({
|
|
workProductId: WORK_PRODUCT_ID,
|
|
artifactReviewDocument: true,
|
|
}),
|
|
}),
|
|
);
|
|
expect(mockSyncDocumentSafely).toHaveBeenCalledWith(makeDocument().id);
|
|
});
|
|
|
|
it("returns 200 without side effects when the document is already current", async () => {
|
|
mockEnsureForWorkProduct.mockResolvedValue({
|
|
document: makeDocument(),
|
|
created: false,
|
|
revisionChanged: false,
|
|
remappedAnnotations: [],
|
|
});
|
|
|
|
const app = await createApp();
|
|
const res = await request(app).post(
|
|
`/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
|
|
);
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.id).toBe(makeDocument().id);
|
|
expect(mockLogActivity).not.toHaveBeenCalled();
|
|
expect(mockSyncDocumentSafely).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("passes typed materialization errors through to the response", async () => {
|
|
const { HttpError } = await vi.importActual<typeof import("../errors.js")>("../errors.js");
|
|
mockEnsureForWorkProduct.mockRejectedValue(
|
|
new HttpError(415, "Work product attachment is not Markdown"),
|
|
);
|
|
|
|
const app = await createApp();
|
|
const res = await request(app).post(
|
|
`/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
|
|
);
|
|
|
|
expect(res.status).toBe(415);
|
|
expect(res.body.error).toBe("Work product attachment is not Markdown");
|
|
});
|
|
|
|
it("resynchronizes an eligible review document after a title-only work product update", async () => {
|
|
const renamed = makeWorkProduct({ title: "Renamed verification report" });
|
|
mockWorkProductService.update.mockResolvedValue(renamed);
|
|
mockEnsureForWorkProduct.mockResolvedValue({
|
|
document: makeDocument({ title: "Renamed verification report", latestRevisionNumber: 2 }),
|
|
created: false,
|
|
revisionChanged: true,
|
|
remappedAnnotations: [],
|
|
});
|
|
|
|
const app = await createApp();
|
|
const res = await request(app)
|
|
.patch(`/api/work-products/${WORK_PRODUCT_ID}`)
|
|
.send({ title: "Renamed verification report" });
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(mockEnsureForWorkProduct).toHaveBeenCalledWith({
|
|
issue: { id: ISSUE_ID, companyId: "company-1" },
|
|
workProduct: renamed,
|
|
});
|
|
});
|
|
});
|