Nexus/packages/api/src/__tests__/assistant-tools-comments-create-errors.test.ts

import { beforeEach, describe, expect, it, vi } from "vitest";
import { SystemRole } from "@nexus/shared";

import { createToolContext, executeTool } from "./assistant-tools-comments-test-helpers.js";

describe("assistant comment tools create errors", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("returns a stable assistant error when creating a comment with an empty body", async () => {
    const ctx = createToolContext(
      {
        estimate: {
          findUnique: vi.fn(),
        },
        comment: {
          create: vi.fn(),
        },
      },
      { userRole: SystemRole.CONTROLLER },
    );

    const result = await executeTool(
      "create_comment",
      JSON.stringify({
        entityType: "estimate",
        entityId: "est_1",
        body: "",
      }),
      ctx,
    );

    expect(JSON.parse(result.content)).toEqual({
      error: "Comment body is required.",
    });
    expect(ctx.db.comment.create).not.toHaveBeenCalled();
  });

  it("returns a stable assistant error when creating a comment with a body that is too long", async () => {
    const ctx = createToolContext(
      {
        estimate: {
          findUnique: vi.fn(),
        },
        comment: {
          create: vi.fn(),
        },
      },
      { userRole: SystemRole.CONTROLLER },
    );

    const result = await executeTool(
      "create_comment",
      JSON.stringify({
        entityType: "estimate",
        entityId: "est_1",
        body: "x".repeat(10_001),
      }),
      ctx,
    );

    expect(JSON.parse(result.content)).toEqual({
      error: "Comment body must be at most 10000 characters.",
    });
    expect(ctx.db.comment.create).not.toHaveBeenCalled();
  });

  it("returns a stable assistant error when the comment author disappears during creation", async () => {
    const ctx = createToolContext(
      {
        estimate: {
          findUnique: vi.fn().mockResolvedValue({ id: "est_1" }),
        },
        comment: {
          create: vi.fn().mockRejectedValue({
            code: "P2003",
            message: "Foreign key constraint failed",
            meta: { field_name: "Comment_authorId_fkey" },
          }),
        },
      },
      { userRole: SystemRole.CONTROLLER },
    );

    const result = await executeTool(
      "create_comment",
      JSON.stringify({
        entityType: "estimate",
        entityId: "est_1",
        body: "Please review this estimate.",
      }),
      ctx,
    );

    expect(JSON.parse(result.content)).toEqual({
      error: "Comment author not found with the given criteria.",
    });
  });

  it("returns a stable assistant error when a mentioned user disappears during comment creation", async () => {
    const ctx = createToolContext(
      {
        estimate: {
          findUnique: vi.fn().mockResolvedValue({ id: "est_1" }),
        },
        comment: {
          create: vi.fn().mockResolvedValue({
            id: "comment_created",
            body: "Hello @[Peter Parker](user_missing)",
            resolved: false,
            createdAt: new Date("2026-03-29T11:00:00.000Z"),
            author: {
              id: "user_1",
              name: "Assistant User",
              email: "assistant@example.com",
              image: null,
            },
          }),
        },
        notification: {
          create: vi.fn().mockRejectedValue({
            code: "P2003",
            message: "Foreign key constraint failed",
            meta: { field_name: "Notification_userId_fkey" },
          }),
        },
        auditLog: {
          create: vi.fn(),
        },
      },
      { userRole: SystemRole.CONTROLLER },
    );

    const result = await executeTool(
      "create_comment",
      JSON.stringify({
        entityType: "estimate",
        entityId: "est_1",
        body: "Hello @[Peter Parker](user_missing)",
      }),
      ctx,
    );

    expect(JSON.parse(result.content)).toEqual({
      error: "Mentioned user not found with the given criteria.",
    });
  });
});