Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

76.4 KB
Raw Blame
const express = require('express');
const request = require('supertest');
const mongoose = require('mongoose');
const { ObjectId } = require('mongodb');
const { MongoMemoryServer } = require('mongodb-memory-server');
const {
  SystemRoles,
  ResourceType,
  AccessRoleIds,
  PrincipalType,
  PrincipalModel,
  PermissionBits,
} = require('librechat-data-provider');
const { SystemCapabilities, BASE_CONFIG_PRINCIPAL_ID } = require('@librechat/data-schemas');

let mockAppConfig = {};

// Mock modules before importing
jest.mock('~/server/services/Config', () => ({
  getCachedTools: jest.fn().mockResolvedValue({}),
  getAppConfig: jest.fn().mockResolvedValue({}),
}));

jest.mock('~/models', () => {
  const mongoose = require('mongoose');
  const { createMethods } = require('@librechat/data-schemas');
  const methods = createMethods(mongoose, {
    removeAllPermissions: async ({ resourceType, resourceId }) => {
      const AclEntry = mongoose.models.AclEntry;
      if (AclEntry) {
        await AclEntry.deleteMany({ resourceType, resourceId });
      }
    },
  });
  return {
    ...methods,
    getRoleByName: jest.fn(),
  };
});

jest.mock('~/server/middleware', () => ({
  requireJwtAuth: (req, res, next) => next(),
  configMiddleware: jest.fn((req, res, next) => {
    req.config = mockAppConfig;
    next();
  }),
  promptUsageLimiter: (req, res, next) => next(),
  promptResolveLimiter: (req, res, next) => next(),
  canAccessPromptViaGroup: jest.requireActual('~/server/middleware').canAccessPromptViaGroup,
  canAccessPromptGroupResource:
    jest.requireActual('~/server/middleware').canAccessPromptGroupResource,
  checkBan: (_req, _res, next) => next(),
  uaParser: (_req, _res, next) => next(),
  canAccessResource: jest.requireActual('~/server/middleware').canAccessResource,
}));

const { configMiddleware } = require('~/server/middleware');

let app;
let mongoServer;
let promptRoutes;
let accessPermissionsRoutes;
let Prompt, PromptGroup, AclEntry, AccessRole, User, SystemGrant, Config;
let testUsers, testRoles;
let grantPermission;
let db;
let currentTestUser; // Track current user for middleware

// Helper function to set user in middleware
function setTestUser(app, user) {
  currentTestUser = user;
}

beforeAll(async () => {
  mongoServer = await MongoMemoryServer.create();
  const mongoUri = mongoServer.getUri();
  await mongoose.connect(mongoUri);

  // Initialize models
  const dbModels = require('~/db/models');
  Prompt = dbModels.Prompt;
  PromptGroup = dbModels.PromptGroup;
  AclEntry = dbModels.AclEntry;
  AccessRole = dbModels.AccessRole;
  User = dbModels.User;
  SystemGrant = dbModels.SystemGrant;
  Config = dbModels.Config;
  db = require('~/models');

  // Import permission service
  const permissionService = require('~/server/services/PermissionService');
  grantPermission = permissionService.grantPermission;

  // Create test data
  await setupTestData();

  // Setup Express app
  app = express();
  app.use(express.json());

  // Add user middleware before routes
  app.use((req, res, next) => {
    if (currentTestUser) {
      req.user = {
        ...(currentTestUser.toObject ? currentTestUser.toObject() : currentTestUser),
        id: currentTestUser._id.toString(),
        _id: currentTestUser._id,
        name: currentTestUser.name,
        role: currentTestUser.role,
      };
    }
    next();
  });

  // Set default user
  currentTestUser = testUsers.owner;

  // Import routes after middleware is set up
  promptRoutes = require('./prompts');
  app.use('/api/prompts', promptRoutes);

  // Mounted so the sharing test below can call the real access-permissions router
  // (and its real `updateResourcePermissions` controller) instead of the service layer.
  accessPermissionsRoutes = require('./accessPermissions');
  app.use('/api/permissions', accessPermissionsRoutes);
});

afterEach(() => {
  mockAppConfig = {};
  // Always reset to owner user after each test for isolation
  if (currentTestUser !== testUsers.owner) {
    currentTestUser = testUsers.owner;
  }
});

afterAll(async () => {
  await mongoose.disconnect();
  await mongoServer.stop();
  jest.clearAllMocks();
});

async function setupTestData() {
  // Create access roles for promptGroups
  testRoles = {
    viewer: await AccessRole.create({
      accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
      name: 'Viewer',
      resourceType: ResourceType.PROMPTGROUP,
      permBits: PermissionBits.VIEW,
    }),
    editor: await AccessRole.create({
      accessRoleId: AccessRoleIds.PROMPTGROUP_EDITOR,
      name: 'Editor',
      resourceType: ResourceType.PROMPTGROUP,
      permBits: PermissionBits.VIEW | PermissionBits.EDIT,
    }),
    owner: await AccessRole.create({
      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
      name: 'Owner',
      resourceType: ResourceType.PROMPTGROUP,
      permBits:
        PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,
    }),
  };

  // Create test users
  testUsers = {
    owner: await User.create({
      name: 'Prompt Owner',
      email: '[email protected]',
      role: SystemRoles.USER,
    }),
    viewer: await User.create({
      name: 'Prompt Viewer',
      email: '[email protected]',
      role: SystemRoles.USER,
    }),
    editor: await User.create({
      name: 'Prompt Editor',
      email: '[email protected]',
      role: SystemRoles.USER,
    }),
    noAccess: await User.create({
      name: 'No Access',
      email: '[email protected]',
      role: SystemRoles.USER,
    }),
    admin: await User.create({
      name: 'Admin',
      email: '[email protected]',
      role: SystemRoles.ADMIN,
    }),
  };

  // Seed capabilities for the ADMIN role
  await SystemGrant.create([
    {
      principalType: PrincipalType.ROLE,
      principalId: SystemRoles.ADMIN,
      capability: SystemCapabilities.MANAGE_PROMPTS,
      grantedAt: new Date(),
    },
    {
      principalType: PrincipalType.ROLE,
      principalId: SystemRoles.ADMIN,
      capability: SystemCapabilities.READ_PROMPTS,
      grantedAt: new Date(),
    },
  ]);

  // Mock getRoleByName
  const { getRoleByName } = require('~/models');
  getRoleByName.mockImplementation((roleName) => {
    switch (roleName) {
      case SystemRoles.USER:
        return { permissions: { PROMPTS: { USE: true, CREATE: true, SHARE: true } } };
      case SystemRoles.ADMIN:
        return { permissions: { PROMPTS: { USE: true, CREATE: true, SHARE: true } } };
      default:
        return null;
    }
  });
}

async function createAccessiblePromptGroup({
  name,
  prompt,
  production = true,
  groupId,
  type = 'text',
}) {
  let group;
  if (groupId) {
    group = await PromptGroup.findById(groupId);
  } else {
    group = await PromptGroup.create({
      name,
      category: 'stored-filter-test',
      author: testUsers.owner._id,
      authorName: testUsers.owner.name,
      productionId: new ObjectId(),
    });

    await grantPermission({
      principalType: PrincipalType.USER,
      principalId: testUsers.owner._id,
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
      grantedBy: testUsers.owner._id,
    });
  }

  const promptRecord = await Prompt.create({
    prompt,
    author: testUsers.owner._id,
    type,
    groupId: group._id,
  });

  if (production) {
    group.productionId = promptRecord._id;
    await group.save();
  }

  return { group, prompt: promptRecord };
}

describe('Prompt Routes - ACL Permissions', () => {
  let consoleErrorSpy;

  beforeEach(() => {
    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
  });

  afterEach(() => {
    consoleErrorSpy.mockRestore();
  });

  // Simple test to verify route is loaded
  it('should have routes loaded', async () => {
    // This should at least not crash
    const response = await request(app).get('/api/prompts/test-404');

    // We expect a 401 or 404, not 500
    expect(response.status).not.toBe(500);
  });

  describe('POST /api/prompts - Create Prompt', () => {
    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should block configured prompt content before persistence', async () => {
      mockAppConfig = {
        filters: {
          prompts: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const response = await request(app)
        .post('/api/prompts')
        .send({
          prompt: {
            prompt: 'Use sk-private-token for requests',
            type: 'text',
          },
          group: {
            name: 'Filtered Prompt Group',
          },
        });

      expect(response.status).toBe(400);
      expect(response.body).toEqual(
        expect.objectContaining({
          error: 'content_filter_block',
          source: 'prompt',
          field: 'text',
        }),
      );
      await expect(Prompt.countDocuments()).resolves.toBe(0);
      await expect(PromptGroup.countDocuments()).resolves.toBe(0);
    });

    it('should create a prompt and grant owner permissions', async () => {
      const promptData = {
        prompt: {
          prompt: 'Test prompt content',
          type: 'text',
        },
        group: {
          name: 'Test Prompt Group',
        },
      };

      const response = await request(app).post('/api/prompts').send(promptData);

      expect(response.status).toBe(200);
      expect(response.body.prompt).toBeDefined();
      expect(response.body.prompt.prompt).toBe(promptData.prompt.prompt);

      // Check ACL entry was created
      const aclEntry = await AclEntry.findOne({
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: response.body.prompt.groupId,
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
      });

      expect(aclEntry).toBeTruthy();
      expect(aclEntry.roleId.toString()).toBe(testRoles.owner._id.toString());
    });

    it('should create a prompt group with prompt and grant owner permissions', async () => {
      const promptData = {
        prompt: {
          prompt: 'Group prompt content',
          type: 'text',
        },
        group: {
          name: 'Test Group',
          category: 'testing',
        },
      };

      const response = await request(app).post('/api/prompts').send(promptData).expect(200);

      expect(response.body.prompt).toBeDefined();
      expect(response.body.group).toBeDefined();
      expect(response.body.group.name).toBe(promptData.group.name);

      // Check ACL entry was created for the promptGroup
      const aclEntry = await AclEntry.findOne({
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: response.body.group._id,
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
      });

      expect(aclEntry).toBeTruthy();
    });
  });

  describe('GET /api/prompts/:promptId - Get Prompt', () => {
    let testPrompt;
    let testGroup;

    beforeEach(async () => {
      // Create a prompt group first
      testGroup = await PromptGroup.create({
        name: 'Test Group',
        category: 'testing',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      // Create a prompt
      testPrompt = await Prompt.create({
        prompt: 'Test prompt for retrieval',
        name: 'Get Test',
        author: testUsers.owner._id,
        type: 'text',
        groupId: testGroup._id,
      });
    });

    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should retrieve prompt when user has view permissions', async () => {
      // Grant view permissions on the promptGroup
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.owner._id,
      });

      const response = await request(app).get(`/api/prompts/${testPrompt._id}`);
      expect(response.status).toBe(200);
      expect(response.body._id).toBe(testPrompt._id.toString());
      expect(response.body.prompt).toBe(testPrompt.prompt);
    });

    it('should deny access when user has no permissions', async () => {
      // Change the user to one without access
      setTestUser(app, testUsers.noAccess);

      const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(403);

      // Verify error response
      expect(response.body.error).toBe('Forbidden');
      expect(response.body.message).toBe('Insufficient permissions to access this promptGroup');
    });

    it('should allow admin access without explicit permissions', async () => {
      // Set admin user
      setTestUser(app, testUsers.admin);

      const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(200);

      expect(response.body._id).toBe(testPrompt._id.toString());
    });

    it('should re-inspect an older stored prompt under prompt-only policy', async () => {
      const privateValue = 'sk-stored-prompt-value';
      testPrompt.prompt = `Use ${privateValue} for this request`;
      await testPrompt.save();
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.owner._id,
      });
      mockAppConfig = {
        filters: {
          prompts: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(400);

      expect(response.body).toEqual(
        expect.objectContaining({
          error: 'content_filter_block',
          source: 'prompt',
          field: 'text',
        }),
      );
      expect(JSON.stringify(response.body)).not.toContain(privateValue);
    });
  });

  describe('Stored prompt policy enforcement', () => {
    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should omit filtered variable and non-variable production prompts from reuse results', async () => {
      const safe = await createAccessiblePromptGroup({
        name: 'Safe prompt',
        prompt: 'Summarize this document',
      });
      const blockedPlain = await createAccessiblePromptGroup({
        name: 'Blocked plain prompt',
        prompt: 'Use sk-plain-stored-value for the request',
      });
      const blockedVariable = await createAccessiblePromptGroup({
        name: 'Blocked variable prompt',
        prompt: 'Use sk-variable-stored-value for {{customer}}',
      });
      mockAppConfig = {
        filters: {
          prompts: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const response = await request(app).get('/api/prompts/all').expect(200);
      const responseIds = response.body.map((group) => group._id);

      expect(responseIds).toContain(safe.group._id.toString());
      expect(responseIds).not.toContain(blockedPlain.group._id.toString());
      expect(responseIds).not.toContain(blockedVariable.group._id.toString());
      expect(JSON.stringify(response.body)).not.toContain('sk-plain-stored-value');
      expect(JSON.stringify(response.body)).not.toContain('sk-variable-stored-value');
    });

    it('should keep prompt filtering disabled when the prompt scope is omitted', async () => {
      const stored = await createAccessiblePromptGroup({
        name: 'Stored prompt',
        prompt: 'Use sk-allowed-by-omission for the request',
      });
      mockAppConfig = {
        filters: {
          messages: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const response = await request(app).get('/api/prompts/all').expect(200);

      expect(response.body).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            _id: stored.group._id.toString(),
            productionPrompt: expect.objectContaining({
              prompt: 'Use sk-allowed-by-omission for the request',
            }),
          }),
        ]),
      );
    });

    it('should redact blocked versions while preserving safe records for remediation', async () => {
      const blocked = await createAccessiblePromptGroup({
        name: 'Prompt with history',
        prompt: 'Use sk-blocked-version for this request',
      });
      const safe = await createAccessiblePromptGroup({
        groupId: blocked.group._id,
        prompt: 'A safe replacement prompt',
        production: false,
      });
      mockAppConfig = {
        filters: {
          prompts: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const [groupResponse, groupsResponse, promptsResponse] = await Promise.all([
        request(app).get(`/api/prompts/groups/${blocked.group._id}`).expect(200),
        request(app).get('/api/prompts/groups').query({ limit: '10' }).expect(200),
        request(app)
          .get('/api/prompts')
          .query({ groupId: blocked.group._id.toString() })
          .expect(200),
      ]);

      expect(groupResponse.body.productionPrompt).toEqual(
        expect.objectContaining({
          prompt: '',
          contentFilterBlocked: true,
        }),
      );
      const listedGroup = groupsResponse.body.promptGroups.find(
        (group) => group._id === blocked.group._id.toString(),
      );
      expect(listedGroup.productionPrompt).toEqual(
        expect.objectContaining({
          prompt: '',
          contentFilterBlocked: true,
        }),
      );
      const blockedVersion = promptsResponse.body.find(
        (prompt) => prompt._id === blocked.prompt._id.toString(),
      );
      const safeVersion = promptsResponse.body.find(
        (prompt) => prompt._id === safe.prompt._id.toString(),
      );
      expect(blockedVersion).toEqual(
        expect.objectContaining({
          prompt: '',
          contentFilterBlocked: true,
        }),
      );
      expect(safeVersion.prompt).toBe('A safe replacement prompt');
      expect(
        JSON.stringify([groupResponse.body, groupsResponse.body, promptsResponse.body]),
      ).not.toContain('sk-blocked-version');
    });

    it('should reject promoting an older blocked prompt without changing production', async () => {
      const safe = await createAccessiblePromptGroup({
        name: 'Production prompt',
        prompt: 'Current safe production prompt',
      });
      const blocked = await createAccessiblePromptGroup({
        groupId: safe.group._id,
        prompt: 'Use sk-blocked-production for this request',
        production: false,
      });
      mockAppConfig = {
        filters: {
          prompts: {
            pii: {
              starterPatterns: ['sk_prefix'],
            },
          },
        },
      };

      const response = await request(app)
        .patch(`/api/prompts/${blocked.prompt._id}/tags/production`)
        .expect(400);

      expect(response.body).toEqual(
        expect.objectContaining({
          error: 'content_filter_block',
          source: 'prompt',
          field: 'text',
        }),
      );
      expect(JSON.stringify(response.body)).not.toContain('sk-blocked-production');
      const unchangedGroup = await PromptGroup.findById(safe.group._id).lean();
      expect(unchangedGroup.productionId.toString()).toBe(safe.prompt._id.toString());
    });
  });

  describe('DELETE /api/prompts/:promptId - Delete Prompt', () => {
    let testPrompt;
    let testGroup;

    beforeEach(async () => {
      // Create group with prompt
      testGroup = await PromptGroup.create({
        name: 'Delete Test Group',
        category: 'testing',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      testPrompt = await Prompt.create({
        prompt: 'Test prompt for deletion',
        name: 'Delete Test',
        author: testUsers.owner._id,
        type: 'text',
        groupId: testGroup._id,
      });

      // Add prompt to group
      testGroup.productionId = testPrompt._id;
      testGroup.promptIds = [testPrompt._id];
      await testGroup.save();

      // Grant owner permissions on the promptGroup
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
        grantedBy: testUsers.owner._id,
      });
    });

    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should delete prompt when user has delete permissions', async () => {
      const response = await request(app)
        .delete(`/api/prompts/${testPrompt._id}`)
        .query({ groupId: testGroup._id.toString() })
        .expect(200);

      expect(response.body.prompt).toBe('Prompt deleted successfully');

      // Verify prompt was deleted
      const deletedPrompt = await Prompt.findById(testPrompt._id);
      expect(deletedPrompt).toBeNull();

      // Verify ACL entries were removed
      const aclEntries = await AclEntry.find({
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
      });
      expect(aclEntries).toHaveLength(0);
    });

    it('should deny deletion when user lacks delete permissions', async () => {
      // Create a prompt as a different user (not the one trying to delete)
      const authorPrompt = await Prompt.create({
        prompt: 'Test prompt by another user',
        name: 'Another User Prompt',
        author: testUsers.editor._id, // Different author
        type: 'text',
        groupId: testGroup._id,
      });

      // Grant only viewer permissions to viewer user on the promptGroup
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.viewer._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.editor._id,
      });

      // Set viewer user
      setTestUser(app, testUsers.viewer);

      await request(app)
        .delete(`/api/prompts/${authorPrompt._id}`)
        .query({ groupId: testGroup._id.toString() })
        .expect(403);

      // Verify prompt still exists
      const prompt = await Prompt.findById(authorPrompt._id);
      expect(prompt).toBeTruthy();
    });

    it('should run configMiddleware so the handler receives the configured value', async () => {
      configMiddleware.mockClear();

      await request(app)
        .delete(`/api/prompts/${testPrompt._id}`)
        .query({ groupId: testGroup._id.toString() })
        .expect(200);

      expect(configMiddleware).toHaveBeenCalledTimes(1);
    });
  });

  describe('DELETE /api/prompts/groups/:groupId - Delete Prompt Group', () => {
    let testGroup;

    beforeEach(async () => {
      testGroup = await PromptGroup.create({
        name: 'Delete Group Test Group',
        category: 'testing',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
        grantedBy: testUsers.owner._id,
      });
    });

    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should run configMiddleware so the handler receives the configured value', async () => {
      configMiddleware.mockClear();

      await request(app).delete(`/api/prompts/groups/${testGroup._id}`).expect(200);

      expect(configMiddleware).toHaveBeenCalledTimes(1);
    });
  });

  describe('PATCH /api/prompts/:promptId/tags/production - Make Production', () => {
    let testPrompt;
    let testGroup;

    beforeEach(async () => {
      // Create group
      testGroup = await PromptGroup.create({
        name: 'Production Test Group',
        category: 'testing',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      testPrompt = await Prompt.create({
        prompt: 'Test prompt for production',
        name: 'Production Test',
        author: testUsers.owner._id,
        type: 'text',
        groupId: testGroup._id,
      });
    });

    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should make prompt production when user has edit permissions', async () => {
      // Grant edit permissions on the promptGroup
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_EDITOR,
        grantedBy: testUsers.owner._id,
      });

      // Ensure owner user
      setTestUser(app, testUsers.owner);

      const response = await request(app)
        .patch(`/api/prompts/${testPrompt._id}/tags/production`)
        .expect(200);

      expect(response.body.message).toBe('Prompt production made successfully');

      // Verify the group was updated
      const updatedGroup = await PromptGroup.findById(testGroup._id);
      expect(updatedGroup.productionId.toString()).toBe(testPrompt._id.toString());
    });

    it('should deny making production when user lacks edit permissions', async () => {
      // Grant only view permissions to viewer on the promptGroup
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.viewer._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.owner._id,
      });

      // Set viewer user
      setTestUser(app, testUsers.viewer);

      await request(app).patch(`/api/prompts/${testPrompt._id}/tags/production`).expect(403);

      // Verify prompt hasn't changed
      const unchangedGroup = await PromptGroup.findById(testGroup._id);
      expect(unchangedGroup.productionId.toString()).not.toBe(testPrompt._id.toString());
    });
  });

  describe('Public Access', () => {
    let publicPrompt;
    let publicGroup;

    beforeEach(async () => {
      // Create a prompt group
      publicGroup = await PromptGroup.create({
        name: 'Public Test Group',
        category: 'testing',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      // Create a public prompt
      publicPrompt = await Prompt.create({
        prompt: 'Public prompt content',
        name: 'Public Test',
        author: testUsers.owner._id,
        type: 'text',
        groupId: publicGroup._id,
      });

      // Grant public viewer access on the promptGroup
      await grantPermission({
        principalType: PrincipalType.PUBLIC,
        principalId: null,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: publicGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.owner._id,
      });
    });

    afterEach(async () => {
      await Prompt.deleteMany({});
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should allow any user to view public prompts', async () => {
      // Change user to someone without explicit permissions
      setTestUser(app, testUsers.noAccess);

      const response = await request(app).get(`/api/prompts/${publicPrompt._id}`).expect(200);

      expect(response.body._id).toBe(publicPrompt._id.toString());
    });
  });

  describe('PATCH /api/prompts/groups/:groupId - Update Prompt Group Security', () => {
    let testGroup;

    beforeEach(async () => {
      // Create a prompt group
      testGroup = await PromptGroup.create({
        name: 'Security Test Group',
        category: 'security-test',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        productionId: new ObjectId(),
      });

      // Grant owner permissions
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: testGroup._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
        grantedBy: testUsers.owner._id,
      });
    });

    afterEach(async () => {
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should allow updating allowed fields (name, category, oneliner)', async () => {
      const updateData = {
        name: 'Updated Group Name',
        category: 'updated-category',
        oneliner: 'Updated description',
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(updateData)
        .expect(200);

      expect(response.body.name).toBe(updateData.name);
      expect(response.body.category).toBe(updateData.category);
      expect(response.body.oneliner).toBe(updateData.oneliner);
    });

    it('should reject request with author field (400 Bad Request)', async () => {
      const maliciousUpdate = {
        name: 'Legit Update',
        author: testUsers.noAccess._id.toString(), // Try to change ownership
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
      expect(response.body.details).toBeDefined();
    });

    it('should reject request with authorName field (400 Bad Request)', async () => {
      const maliciousUpdate = {
        name: 'Legit Update',
        authorName: 'Malicious Author Name',
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
    });

    it('should reject request with _id field (400 Bad Request)', async () => {
      const newId = new ObjectId();
      const maliciousUpdate = {
        name: 'Legit Update',
        _id: newId.toString(),
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
    });

    it('should reject request with productionId field (400 Bad Request)', async () => {
      const newProductionId = new ObjectId();
      const maliciousUpdate = {
        name: 'Legit Update',
        productionId: newProductionId.toString(),
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
    });

    it('should reject request with createdAt field (400 Bad Request)', async () => {
      const maliciousDate = new Date('2020-01-01');
      const maliciousUpdate = {
        name: 'Legit Update',
        createdAt: maliciousDate.toISOString(),
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
    });

    it('should reject request with __v field (400 Bad Request)', async () => {
      const maliciousUpdate = {
        name: 'Legit Update',
        __v: 999,
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected
      expect(response.body.error).toBe('Invalid request body');
    });

    it('should reject request with multiple sensitive fields (400 Bad Request)', async () => {
      const maliciousUpdate = {
        name: 'Legit Update',
        author: testUsers.noAccess._id.toString(),
        authorName: 'Hacker',
        _id: new ObjectId().toString(),
        productionId: new ObjectId().toString(),
        createdAt: new Date('2020-01-01').toISOString(),
        __v: 999,
      };

      const response = await request(app)
        .patch(`/api/prompts/groups/${testGroup._id}`)
        .send(maliciousUpdate)
        .expect(400);

      // Verify the request was rejected with validation errors
      expect(response.body.error).toBe('Invalid request body');
      expect(response.body.details).toBeDefined();
      expect(Array.isArray(response.body.details)).toBe(true);
    });
  });

  describe('Pagination', () => {
    beforeEach(async () => {
      // Create multiple prompt groups for pagination testing
      const groups = [];
      for (let i = 0; i < 15; i++) {
        const group = await PromptGroup.create({
          name: `Test Group ${i + 1}`,
          category: 'pagination-test',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - i * 1000), // Stagger updatedAt for consistent ordering
        });
        groups.push(group);

        // Grant owner permissions on each group
        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }
    });

    afterEach(async () => {
      await PromptGroup.deleteMany({});
      await AclEntry.deleteMany({});
    });

    it('should correctly indicate hasMore when there are more pages', async () => {
      const response = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '10' })
        .expect(200);

      expect(response.body.promptGroups).toHaveLength(10);
      expect(response.body.has_more).toBe(true);
      expect(response.body.after).toBeTruthy();
      // Since has_more is true, pages should be a high number (9999 in our fix)
      expect(parseInt(response.body.pages)).toBeGreaterThan(1);
    });

    it('should correctly indicate no more pages on the last page', async () => {
      // First get the cursor for page 2
      const firstPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '10' })
        .expect(200);

      expect(firstPage.body.has_more).toBe(true);
      expect(firstPage.body.after).toBeTruthy();

      // Now fetch the second page using the cursor
      const response = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '10', cursor: firstPage.body.after })
        .expect(200);

      expect(response.body.promptGroups).toHaveLength(5); // 15 total, 10 on page 1, 5 on page 2
      expect(response.body.has_more).toBe(false);
    });

    it('should support cursor-based pagination', async () => {
      // First page
      const firstPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5' })
        .expect(200);

      expect(firstPage.body.promptGroups).toHaveLength(5);
      expect(firstPage.body.has_more).toBe(true);
      expect(firstPage.body.after).toBeTruthy();

      // Second page using cursor
      const secondPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5', cursor: firstPage.body.after })
        .expect(200);

      expect(secondPage.body.promptGroups).toHaveLength(5);
      expect(secondPage.body.has_more).toBe(true);
      expect(secondPage.body.after).toBeTruthy();

      // Verify different groups
      const firstPageIds = firstPage.body.promptGroups.map((g) => g._id);
      const secondPageIds = secondPage.body.promptGroups.map((g) => g._id);
      expect(firstPageIds).not.toEqual(secondPageIds);
    });

    it('should paginate correctly with category filtering', async () => {
      // Create groups with different categories
      await PromptGroup.deleteMany({}); // Clear existing groups
      await AclEntry.deleteMany({});

      // Create 8 groups with category 'test-cat-1'
      for (let i = 0; i < 8; i++) {
        const group = await PromptGroup.create({
          name: `Category 1 Group ${i + 1}`,
          category: 'test-cat-1',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - i * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Create 7 groups with category 'test-cat-2'
      for (let i = 0; i < 7; i++) {
        const group = await PromptGroup.create({
          name: `Category 2 Group ${i + 1}`,
          category: 'test-cat-2',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - (i + 8) * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Test pagination with category filter
      const firstPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5', category: 'test-cat-1' })
        .expect(200);

      expect(firstPage.body.promptGroups).toHaveLength(5);
      expect(firstPage.body.promptGroups.every((g) => g.category === 'test-cat-1')).toBe(true);
      expect(firstPage.body.has_more).toBe(true);
      expect(firstPage.body.after).toBeTruthy();

      const secondPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5', cursor: firstPage.body.after, category: 'test-cat-1' })
        .expect(200);

      expect(secondPage.body.promptGroups).toHaveLength(3); // 8 total, 5 on page 1, 3 on page 2
      expect(secondPage.body.promptGroups.every((g) => g.category === 'test-cat-1')).toBe(true);
      expect(secondPage.body.has_more).toBe(false);
    });

    it('should paginate correctly with name/keyword filtering', async () => {
      // Create groups with specific names
      await PromptGroup.deleteMany({}); // Clear existing groups
      await AclEntry.deleteMany({});

      // Create 12 groups with 'Search' in the name
      for (let i = 0; i < 12; i++) {
        const group = await PromptGroup.create({
          name: `Search Test Group ${i + 1}`,
          category: 'search-test',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - i * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Create 5 groups without 'Search' in the name
      for (let i = 0; i < 5; i++) {
        const group = await PromptGroup.create({
          name: `Other Group ${i + 1}`,
          category: 'other-test',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - (i + 12) * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Test pagination with name filter
      const firstPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '10', name: 'Search' })
        .expect(200);

      expect(firstPage.body.promptGroups).toHaveLength(10);
      expect(firstPage.body.promptGroups.every((g) => g.name.includes('Search'))).toBe(true);
      expect(firstPage.body.has_more).toBe(true);
      expect(firstPage.body.after).toBeTruthy();

      const secondPage = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '10', cursor: firstPage.body.after, name: 'Search' })
        .expect(200);

      expect(secondPage.body.promptGroups).toHaveLength(2); // 12 total, 10 on page 1, 2 on page 2
      expect(secondPage.body.promptGroups.every((g) => g.name.includes('Search'))).toBe(true);
      expect(secondPage.body.has_more).toBe(false);
    });

    it('should paginate correctly with combined filters', async () => {
      // Create groups with various combinations
      await PromptGroup.deleteMany({}); // Clear existing groups
      await AclEntry.deleteMany({});

      // Create 6 groups matching both category and name filters
      for (let i = 0; i < 6; i++) {
        const group = await PromptGroup.create({
          name: `API Test Group ${i + 1}`,
          category: 'api-category',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - i * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Create groups that only match one filter
      for (let i = 0; i < 4; i++) {
        const group = await PromptGroup.create({
          name: `API Other Group ${i + 1}`,
          category: 'other-category',
          author: testUsers.owner._id,
          authorName: testUsers.owner.name,
          productionId: new ObjectId(),
          updatedAt: new Date(Date.now() - (i + 6) * 1000),
        });

        await grantPermission({
          principalType: PrincipalType.USER,
          principalId: testUsers.owner._id,
          resourceType: ResourceType.PROMPTGROUP,
          resourceId: group._id,
          accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
          grantedBy: testUsers.owner._id,
        });
      }

      // Test pagination with both filters
      const response = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5', name: 'API', category: 'api-category' })
        .expect(200);

      expect(response.body.promptGroups).toHaveLength(5);
      expect(
        response.body.promptGroups.every(
          (g) => g.name.includes('API') && g.category === 'api-category',
        ),
      ).toBe(true);
      expect(response.body.has_more).toBe(true);
      expect(response.body.after).toBeTruthy();

      // Page 2
      const page2 = await request(app)
        .get('/api/prompts/groups')
        .query({ limit: '5', cursor: response.body.after, name: 'API', category: 'api-category' })
        .expect(200);

      expect(page2.body.promptGroups).toHaveLength(1); // 6 total, 5 on page 1, 1 on page 2
      expect(page2.body.has_more).toBe(false);
    });
  });
});

async function responseOf(pending) {
  const { status, body } = await pending;
  return { status, body };
}

describe('GET /api/prompts/groups/:groupId/resolve', () => {
  afterEach(async () => {
    await Prompt.deleteMany({});
    await PromptGroup.deleteMany({});
    await AclEntry.deleteMany({});
  });

  it('resolves the production revision for a native group', async () => {
    const { group, prompt } = await createAccessiblePromptGroup({
      name: 'Resolve native group',
      prompt: 'Native production text',
    });

    const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`).expect(200);

    expect(response.body).toEqual({
      source: 'native',
      groupId: group._id.toString(),
      promptId: prompt._id.toString(),
      prompt: 'Native production text',
      type: 'text',
    });
  });

  it('returns 403 without VIEW permission', async () => {
    const { group } = await createAccessiblePromptGroup({
      name: 'Resolve forbidden group',
      prompt: 'Native text',
    });
    setTestUser(app, testUsers.noAccess);

    const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`).expect(403);

    expect(response.body.error).toBe('Forbidden');
  });

  it('returns 404 for a missing group', async () => {
    const response = await request(app)
      .get(`/api/prompts/groups/${new ObjectId()}/resolve`)
      .expect(404);

    expect(response.body).toEqual({
      error: 'Not Found',
      message: `${ResourceType.PROMPTGROUP} not found`,
    });
  });

  it('is not captured by GET /:promptId', async () => {
    const { group, prompt } = await createAccessiblePromptGroup({
      name: 'Resolve route segments',
      prompt: 'Native text',
    });

    const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`);

    expect(response.status).toBe(200);
    expect(response.body).toEqual({
      source: 'native',
      groupId: group._id.toString(),
      promptId: prompt._id.toString(),
      prompt: 'Native text',
      type: 'text',
    });
  });

  describe('a Langfuse-origin group', () => {
    const langfuseEnv = {
      LANGFUSE_PROMPT_SYNC_AVAILABLE: 'true',
      LANGFUSE_PUBLIC_KEY: 'pk-resolve',
      LANGFUSE_SECRET_KEY: 'sk-resolve',
      LANGFUSE_PROJECT_ID: 'resolve-project',
      LANGFUSE_BASE_URL: 'https://langfuse.resolve.test',
    };
    let fetchSpy;
    let group;
    let previousLangfuseEnv;

    beforeEach(async () => {
      previousLangfuseEnv = {};
      for (const key of Object.keys(langfuseEnv)) {
        previousLangfuseEnv[key] = process.env[key];
      }
      Object.assign(process.env, langfuseEnv);
      await db.upsertConfig(
        PrincipalType.ROLE,
        BASE_CONFIG_PRINCIPAL_ID,
        PrincipalModel.ROLE,
        { langfuse: { promptSync: { enabled: true } } },
        10,
      );
      group = await PromptGroup.create({
        name: 'Langfuse group',
        category: 'resolve-test',
        author: testUsers.owner._id,
        authorName: testUsers.owner.name,
        source: 'langfuse',
        sourcePromptName: 'greeting',
        sourceProjectId: 'resolve-project',
        sourceDestination: 'env',
      });
      await grantPermission({
        principalType: PrincipalType.USER,
        principalId: testUsers.owner._id,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: group._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
        grantedBy: testUsers.owner._id,
      });
    });

    afterEach(async () => {
      for (const key of Object.keys(langfuseEnv)) {
        if (previousLangfuseEnv[key] === undefined) {
          delete process.env[key];
        } else {
          process.env[key] = previousLangfuseEnv[key];
        }
      }
      if (fetchSpy) {
        fetchSpy.mockRestore();
        fetchSpy = undefined;
      }
      await Config.deleteMany({});
    });

    function mockLangfuseFetch(responder) {
      fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(responder);
    }

    function textPromptResponse(payload, status = 200) {
      return new Response(JSON.stringify(payload), {
        status,
        headers: { 'Content-Type': 'application/json' },
      });
    }

    it('resolves the production label, with no sourceUrl for a non-admin', async () => {
      mockLangfuseFetch(async () =>
        textPromptResponse({
          name: 'greeting',
          version: 1,
          type: 'text',
          labels: ['production'],
          prompt: 'Hello {{name}}',
        }),
      );

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(200);

      expect(response.body).toEqual({
        source: 'langfuse',
        groupId: group._id.toString(),
        prompt: 'Hello {{name}}',
        type: 'text',
        version: 1,
        labels: ['production'],
      });
      expect(response.body.sourceUrl).toBeUndefined();
      const [url] = fetchSpy.mock.calls[0];
      expect(url).toContain('label=production');
      expect(url).not.toContain('version=');
    });

    it('resolves the production label with sourceUrl for an admin', async () => {
      setTestUser(app, testUsers.admin);
      mockLangfuseFetch(async () =>
        textPromptResponse({
          name: 'greeting',
          version: 1,
          type: 'text',
          labels: ['production'],
          prompt: 'Hello {{name}}',
        }),
      );

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(200);

      expect(response.body).toEqual({
        source: 'langfuse',
        groupId: group._id.toString(),
        prompt: 'Hello {{name}}',
        type: 'text',
        version: 1,
        labels: ['production'],
        sourceUrl: 'https://langfuse.resolve.test/project/resolve-project/prompts/greeting',
      });
    });

    it('allows a public viewer with no explicit grant to resolve the group, with no sourceUrl', async () => {
      await grantPermission({
        principalType: PrincipalType.PUBLIC,
        principalId: null,
        resourceType: ResourceType.PROMPTGROUP,
        resourceId: group._id,
        accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
        grantedBy: testUsers.owner._id,
      });
      setTestUser(app, testUsers.noAccess);
      mockLangfuseFetch(async () =>
        textPromptResponse({
          name: 'greeting',
          version: 1,
          type: 'text',
          labels: ['production'],
          prompt: 'Hello {{name}}',
        }),
      );

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(200);

      expect(response.body).toEqual({
        source: 'langfuse',
        groupId: group._id.toString(),
        prompt: 'Hello {{name}}',
        type: 'text',
        version: 1,
        labels: ['production'],
      });
      expect(response.body.sourceUrl).toBeUndefined();
    });

    it('returns 403 for a user with no grant at all on the group', async () => {
      setTestUser(app, testUsers.noAccess);

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(403);

      expect(response.body.error).toBe('Forbidden');
    });

    it('resolves an exact version and sends it with no label', async () => {
      mockLangfuseFetch(async () =>
        textPromptResponse({
          name: 'greeting',
          version: 3,
          type: 'text',
          labels: [],
          prompt: 'Hello v3',
        }),
      );

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .query({ version: 3 })
        .expect(200);

      expect(response.body).toEqual({
        source: 'langfuse',
        groupId: group._id.toString(),
        prompt: 'Hello v3',
        type: 'text',
        version: 3,
        labels: [],
      });
      expect(response.body.sourceUrl).toBeUndefined();
      const [url] = fetchSpy.mock.calls[0];
      expect(url).toContain('version=3');
      expect(url).not.toContain('label=');
    });

    it('rejects a chat prompt with 422', async () => {
      mockLangfuseFetch(async () =>
        textPromptResponse({
          name: 'greeting',
          version: 1,
          type: 'chat',
          labels: ['production'],
          prompt: [{ role: 'system', content: 'secret' }],
        }),
      );

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(422);

      expect(response.body).toEqual({ code: 'unsupported_type' });
    });

    it('returns 404 with the Langfuse message for a missing prompt', async () => {
      mockLangfuseFetch(async () => new Response(null, { status: 404 }));

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(404);

      expect(response.body).toEqual({
        code: 'not_found',
        message: 'Prompt not found in Langfuse',
      });
    });

    it('returns 404 not_available when prompt sync is gated off', async () => {
      delete process.env.LANGFUSE_PROMPT_SYNC_AVAILABLE;
      mockLangfuseFetch(async () => textPromptResponse({}));

      const response = await request(app)
        .get(`/api/prompts/groups/${group._id}/resolve`)
        .expect(404);

      expect(response.body).toEqual({ code: 'not_available' });
      expect(fetchSpy).not.toHaveBeenCalled();
    });
  });
});

describe('GET /api/prompts/groups/:groupId/revisions', () => {
  afterEach(async () => {
    await Prompt.deleteMany({});
    await PromptGroup.deleteMany({});
    await AclEntry.deleteMany({});
  });

  it('lists native revisions newest first with the Production entry marked', async () => {
    const { group, prompt: production } = await createAccessiblePromptGroup({
      name: 'Revisions native group',
      prompt: 'Production text',
    });
    const draft = await Prompt.create({
      prompt: 'Draft text',
      author: testUsers.owner._id,
      type: 'text',
      groupId: group._id,
    });

    const response = await request(app)
      .get(`/api/prompts/groups/${group._id}/revisions`)
      .expect(200);

    expect(response.body).toEqual({
      source: 'native',
      groupId: group._id.toString(),
      revisions: [
        { source: 'native', promptId: draft._id.toString(), version: 2, isProduction: false },
        {
          source: 'native',
          promptId: production._id.toString(),
          version: 1,
          isProduction: true,
        },
      ],
    });
  });

  it('returns 403 without VIEW permission on the group', async () => {
    const { group } = await createAccessiblePromptGroup({
      name: 'Revisions forbidden group',
      prompt: 'Native text',
    });
    setTestUser(app, testUsers.noAccess);

    const response = await request(app)
      .get(`/api/prompts/groups/${group._id}/revisions`)
      .expect(403);

    expect(response.body.error).toBe('Forbidden');
  });

  it('returns 404 for a missing group', async () => {
    const response = await request(app)
      .get(`/api/prompts/groups/${new ObjectId()}/revisions`)
      .expect(404);

    expect(response.body).toEqual({
      error: 'Not Found',
      message: `${ResourceType.PROMPTGROUP} not found`,
    });
  });

  it('allows a user with only VIEW access, not just the owner', async () => {
    const { group } = await createAccessiblePromptGroup({
      name: 'Revisions viewer group',
      prompt: 'Native text',
    });
    await grantPermission({
      principalType: PrincipalType.USER,
      principalId: testUsers.viewer._id,
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
      grantedBy: testUsers.owner._id,
    });
    setTestUser(app, testUsers.viewer);

    const response = await request(app)
      .get(`/api/prompts/groups/${group._id}/revisions`)
      .expect(200);

    expect(response.body.source).toBe('native');
  });

  it('returns 403 for a role without PROMPTS USE, before the group VIEW check', async () => {
    const { group } = await createAccessiblePromptGroup({
      name: 'Revisions no-PROMPTS-USE group',
      prompt: 'Native text',
    });
    // getRoleByName's mock returns null for any role besides USER/ADMIN, so this
    // role carries no PROMPTS.USE grant even though the user has group VIEW access.
    const noUseUser = await User.create({
      name: 'No Prompts Use',
      email: '[email protected]',
      role: 'NoPromptsUseRole',
    });
    await grantPermission({
      principalType: PrincipalType.USER,
      principalId: noUseUser._id,
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
      grantedBy: testUsers.owner._id,
    });
    setTestUser(app, noUseUser);

    const response = await request(app)
      .get(`/api/prompts/groups/${group._id}/revisions`)
      .expect(403);

    expect(response.body).toEqual({ message: 'Forbidden: Insufficient permissions' });
  });
});

describe('Externally managed (Langfuse) prompt groups are read-only', () => {
  const readOnlyBody = { code: 'read_only', error: 'Externally managed prompts are read-only' };
  let group;

  async function seedLangfuseGroup(owner = testUsers.owner) {
    const langfuseGroup = await PromptGroup.create({
      name: 'Read-only Langfuse group',
      category: 'langfuse-read-only',
      author: owner._id,
      authorName: owner.name,
      source: 'langfuse',
      sourcePromptName: 'greeting',
      sourceProjectId: 'ro-project',
      sourceDestination: 'env',
    });
    await grantPermission({
      principalType: PrincipalType.USER,
      principalId: owner._id,
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: langfuseGroup._id,
      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
      grantedBy: owner._id,
    });
    return langfuseGroup;
  }

  beforeEach(async () => {
    group = await seedLangfuseGroup();
  });

  afterEach(async () => {
    await Prompt.deleteMany({});
    await PromptGroup.deleteMany({});
    await AclEntry.deleteMany({});
  });

  it('rejects PATCH /groups/:groupId with 403 and leaves the group unchanged', async () => {
    const before = await PromptGroup.findById(group._id).lean();

    const response = await request(app)
      .patch(`/api/prompts/groups/${group._id}`)
      .send({ name: 'Hacked name' })
      .expect(403);

    expect(response.body).toEqual(readOnlyBody);
    const after = await PromptGroup.findById(group._id).lean();
    expect(after).toEqual(before);
  });

  it('rejects DELETE /groups/:groupId with 403 and leaves the group in place', async () => {
    const response = await request(app).delete(`/api/prompts/groups/${group._id}`).expect(403);

    expect(response.body).toEqual(readOnlyBody);
    await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
    const ownerEntry = await AclEntry.findOne({
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      principalType: PrincipalType.USER,
      principalId: testUsers.owner._id,
    });
    expect(ownerEntry).toBeTruthy();
  });

  it('rejects POST /groups/:groupId/prompts (new revision) with 403 and adds no revision', async () => {
    const response = await request(app)
      .post(`/api/prompts/groups/${group._id}/prompts`)
      .send({ prompt: { prompt: 'New text', type: 'text' } })
      .expect(403);

    expect(response.body).toEqual(readOnlyBody);
    await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(0);
  });

  it('rejects PATCH /groups/:groupId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
    setTestUser(app, testUsers.admin);
    const before = await PromptGroup.findById(group._id).lean();

    const response = await request(app)
      .patch(`/api/prompts/groups/${group._id}`)
      .send({ name: 'Admin hack' })
      .expect(403);

    expect(response.body).toEqual(readOnlyBody);
    const after = await PromptGroup.findById(group._id).lean();
    expect(after).toEqual(before);
  });

  it('rejects DELETE /groups/:groupId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
    setTestUser(app, testUsers.admin);

    const response = await request(app).delete(`/api/prompts/groups/${group._id}`).expect(403);

    expect(response.body).toEqual(readOnlyBody);
    await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
  });

  describe('with a Prompt row inserted directly for the group', () => {
    let revision;

    beforeEach(async () => {
      revision = await Prompt.create({
        prompt: 'Synced from Langfuse',
        author: testUsers.owner._id,
        type: 'text',
        groupId: group._id,
      });
    });

    it('rejects PATCH /:promptId/tags/production with 403 and does not promote', async () => {
      const response = await request(app)
        .patch(`/api/prompts/${revision._id}/tags/production`)
        .expect(403);

      expect(response.body).toEqual(readOnlyBody);
      const after = await PromptGroup.findById(group._id).lean();
      expect(after.productionId ?? null).toBeNull();
      await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
    });

    it('rejects DELETE /:promptId with 403 and keeps the revision', async () => {
      const response = await request(app)
        .delete(`/api/prompts/${revision._id}`)
        .query({ groupId: group._id.toString() })
        .expect(403);

      expect(response.body).toEqual(readOnlyBody);
      await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
      await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
    });

    it('rejects DELETE /:promptId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
      setTestUser(app, testUsers.admin);

      const response = await request(app)
        .delete(`/api/prompts/${revision._id}`)
        .query({ groupId: group._id.toString() })
        .expect(403);

      expect(response.body).toEqual(readOnlyBody);
      await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
    });
  });

  it('keeps POST /groups/:groupId/use working: it increments numberOfGenerations', async () => {
    const response = await request(app).post(`/api/prompts/groups/${group._id}/use`).expect(200);

    expect(response.body).toEqual({ numberOfGenerations: 1 });
    const after = await PromptGroup.findById(group._id).lean();
    expect(after.numberOfGenerations).toBe(1);
  });

  it('keeps sharing working through the access-permissions routes', async () => {
    setTestUser(app, testUsers.owner);

    const response = await request(app)
      .put(`/api/permissions/${ResourceType.PROMPTGROUP}/${group._id}`)
      .send({
        updated: [
          {
            type: PrincipalType.USER,
            id: testUsers.viewer._id.toString(),
            accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
          },
        ],
      })
      .expect(200);

    expect(response.body.message).toBe('Permissions updated successfully');

    const sharedEntry = await AclEntry.findOne({
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      principalType: PrincipalType.USER,
      principalId: testUsers.viewer._id,
    });
    expect(sharedEntry).toBeTruthy();

    // Sharing an externally managed group only grants an ACL entry; it never touches
    // the read-only group document itself.
    const after = await PromptGroup.findById(group._id).lean();
    expect(after.name).toBe(group.name);
  });
});

describe('A stored prompt group with no source (predates the field) stays editable', () => {
  let group;

  beforeEach(async () => {
    // Bypasses the schema's `source: 'native'` default to reproduce a group
    // written before the field existed.
    const inserted = await PromptGroup.collection.insertOne({
      name: 'Pre-source Group',
      category: 'legacy-no-source',
      author: testUsers.owner._id,
      authorName: testUsers.owner.name,
      productionId: new ObjectId(),
    });
    group = { _id: inserted.insertedId };

    await grantPermission({
      principalType: PrincipalType.USER,
      principalId: testUsers.owner._id,
      resourceType: ResourceType.PROMPTGROUP,
      resourceId: group._id,
      accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
      grantedBy: testUsers.owner._id,
    });
  });

  afterEach(async () => {
    await Prompt.deleteMany({});
    await PromptGroup.deleteMany({});
    await AclEntry.deleteMany({});
  });

  it('allows PATCH /groups/:groupId to rename it, same as a native group', async () => {
    const response = await request(app)
      .patch(`/api/prompts/groups/${group._id}`)
      .send({ name: 'Renamed legacy group' })
      .expect(200);

    expect(response.body.name).toBe('Renamed legacy group');
    const stored = await PromptGroup.findById(group._id).lean();
    expect(stored.name).toBe('Renamed legacy group');
  });

  it('allows POST /groups/:groupId/prompts to add a text prompt, same as a native group', async () => {
    const response = await request(app)
      .post(`/api/prompts/groups/${group._id}/prompts`)
      .send({ prompt: { prompt: 'New legacy prompt text', type: 'text' } })
      .expect(200);

    expect(response.body.prompt.prompt).toBe('New legacy prompt text');
    await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(1);
  });
});

describe('Prompt Routes - response and failure compatibility', () => {
  let consoleErrorSpy;
  let group;
  let revision;

  beforeEach(async () => {
    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
    ({ group, prompt: revision } = await createAccessiblePromptGroup({
      name: 'Compatibility Group',
      prompt: 'Compatibility prompt',
    }));
  });

  afterEach(async () => {
    consoleErrorSpy.mockRestore();
    jest.restoreAllMocks();
    await Prompt.deleteMany({});
    await PromptGroup.deleteMany({});
    await AclEntry.deleteMany({});
  });

  it('rejects a group whose initial prompt has no type', async () => {
    await request(app)
      .post('/api/prompts')
      .send({ prompt: { prompt: 'Untyped prompt' }, group: { name: 'Untyped Group' } })
      .expect(400, { error: 'Prompt type must be "text" or "chat"' });

    await expect(PromptGroup.countDocuments({ name: 'Untyped Group' })).resolves.toBe(0);
  });

  it('sends 404 from the access check for a malformed ID', async () => {
    const notFound = (resourceType) => ({
      status: 404,
      body: { error: 'Not Found', message: `${resourceType} not found` },
    });
    expect(await responseOf(request(app).get('/api/prompts/groups/not-an-id'))).toEqual(
      notFound(ResourceType.PROMPTGROUP),
    );
    expect(await responseOf(request(app).get('/api/prompts/not-an-id'))).toEqual(
      notFound(ResourceType.PROMPTGROUP),
    );
  });

  it('sends 500 from the access check when the database read fails', async () => {
    const accessFailure = {
      status: 500,
      body: {
        error: 'Internal Server Error',
        message: 'Failed to check resource access permissions',
      },
    };
    jest.spyOn(PromptGroup, 'aggregate').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });
    expect(await responseOf(request(app).get(`/api/prompts/groups/${group._id}`))).toEqual(
      accessFailure,
    );

    jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });
    expect(await responseOf(request(app).get(`/api/prompts/${revision._id}`))).toEqual(
      accessFailure,
    );
  });

  it('adds a revision from the editor payload, which includes groupId', async () => {
    const response = await request(app)
      .post(`/api/prompts/groups/${group._id}/prompts`)
      .send({ prompt: { prompt: 'Second revision', type: 'chat', groupId: group._id.toString() } })
      .expect(200);

    expect(response.body.prompt).toEqual(
      expect.objectContaining({
        prompt: 'Second revision',
        type: 'chat',
        groupId: group._id.toString(),
        author: testUsers.owner._id.toString(),
      }),
    );
    await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(2);
  });

  it('sends the legacy 200 message when saving a revision fails', async () => {
    jest.spyOn(Prompt, 'create').mockRejectedValueOnce(new Error('database unavailable'));

    const response = await request(app)
      .post(`/api/prompts/groups/${group._id}/prompts`)
      .send({ prompt: { prompt: 'Lost revision', type: 'text' } })
      .expect(200);

    expect(response.body).toEqual({ message: 'Error saving prompt' });
  });

  it('returns the group detail with its full Production revision', async () => {
    const response = await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);

    expect(response.body._id).toBe(group._id.toString());
    expect(response.body.productionPrompt).toEqual(
      expect.objectContaining({
        _id: revision._id.toString(),
        prompt: 'Compatibility prompt',
        type: 'text',
        groupId: group._id.toString(),
      }),
    );
  });

  it('returns 404 from the handler when a capability bypass reads a missing group', async () => {
    setTestUser(app, testUsers.admin);

    const response = await request(app).get(`/api/prompts/groups/${new ObjectId()}`).expect(404);

    expect(response.body).toEqual({ message: 'Prompt group not found' });
  });

  it('returns an empty 200 when a capability bypass reads a missing revision', async () => {
    setTestUser(app, testUsers.admin);

    const response = await request(app).get(`/api/prompts/${new ObjectId()}`).expect(200);

    expect(response.text).toBe('');
  });

  it('returns revision history newest first with management fields', async () => {
    const newer = await Prompt.create({
      prompt: 'Newer revision',
      author: testUsers.owner._id,
      type: 'text',
      groupId: group._id,
      createdAt: new Date(Date.now() + 1000),
    });

    const response = await request(app)
      .get('/api/prompts')
      .query({ groupId: group._id.toString() })
      .expect(200);

    expect(response.body.map((item) => item._id)).toEqual([
      newer._id.toString(),
      revision._id.toString(),
    ]);
    expect(response.body[0]).toEqual(
      expect.objectContaining({ author: testUsers.owner._id.toString(), type: 'text' }),
    );
  });

  it('keeps the malformed and denied revision-history responses', async () => {
    expect(
      await responseOf(request(app).get('/api/prompts').query({ groupId: 'not-an-id' })),
    ).toEqual({ status: 400, body: { error: 'Invalid groupId' } });

    setTestUser(app, testUsers.noAccess);
    expect(
      await responseOf(request(app).get('/api/prompts').query({ groupId: group._id.toString() })),
    ).toEqual({
      status: 403,
      body: { error: 'Insufficient permissions to view prompts in this group' },
    });
  });

  it('sends the legacy 200 message when revision history fails', async () => {
    jest.spyOn(Prompt, 'find').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });

    const response = await request(app)
      .get('/api/prompts')
      .query({ groupId: group._id.toString() })
      .expect(200);

    expect(response.body).toEqual({ message: 'Error getting prompts' });
  });

  it('returns the updated group document fields from a metadata update', async () => {
    const response = await request(app)
      .patch(`/api/prompts/groups/${group._id}`)
      .send({ name: 'Renamed Group', command: 'renamed' })
      .expect(200);

    expect(Object.keys(response.body).sort()).toEqual(
      [
        '__v',
        '_id',
        'author',
        'authorName',
        'category',
        'command',
        'createdAt',
        'name',
        'numberOfGenerations',
        'oneliner',
        'productionId',
        'source',
        'updatedAt',
      ].sort(),
    );
    expect(response.body).toEqual(
      expect.objectContaining({ name: 'Renamed Group', command: 'renamed', source: 'native' }),
    );
  });

  it('sends the legacy 200 message when a metadata update fails', async () => {
    jest.spyOn(PromptGroup, 'findOneAndUpdate').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });

    const response = await request(app)
      .patch(`/api/prompts/groups/${group._id}`)
      .send({ name: 'Renamed Group' })
      .expect(200);

    expect(response.body).toEqual({ message: 'Error updating prompt group' });
  });

  it('sends the legacy 200 message when a capability bypass promotes a missing revision', async () => {
    setTestUser(app, testUsers.admin);

    const response = await request(app)
      .patch(`/api/prompts/${new ObjectId()}/tags/production`)
      .expect(200);

    expect(response.body).toEqual({ message: 'Error making prompt production' });
  });

  it('does not promote when the preliminary read of a capability bypass fails', async () => {
    const candidate = await Prompt.create({
      prompt: 'Candidate revision',
      author: testUsers.owner._id,
      type: 'text',
      groupId: group._id,
    });
    setTestUser(app, testUsers.admin);
    jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });
    const promote = jest.spyOn(PromptGroup, 'findByIdAndUpdate');

    await request(app)
      .patch(`/api/prompts/${candidate._id}/tags/production`)
      .expect(500, { error: 'Error updating prompt production' });

    expect(promote).not.toHaveBeenCalled();
    const stored = await PromptGroup.findById(group._id).lean();
    expect(stored.productionId.toString()).toBe(revision._id.toString());
  });

  it('requires groupId for revision history, including READ_PROMPTS callers', async () => {
    const missingGroupId = { status: 400, body: { error: 'Invalid or missing groupId' } };
    expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);

    setTestUser(app, testUsers.admin);
    expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);
  });

  it('reuses the records that the access check loaded', async () => {
    const readGroup = jest.spyOn(PromptGroup, 'aggregate');
    await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);
    expect(readGroup).toHaveBeenCalledTimes(1);

    const readRevision = jest.spyOn(Prompt, 'findOne');
    await request(app).get(`/api/prompts/${revision._id}`).expect(200);
    expect(readRevision).toHaveBeenCalledTimes(1);

    readRevision.mockClear();
    await request(app).patch(`/api/prompts/${revision._id}/tags/production`).expect(200);
    // The access check reads once; the mutation's own `findById` is the second call.
    expect(readRevision).toHaveBeenCalledTimes(2);
  });

  it('returns 500 for GET /groups without limit or pageSize', async () => {
    expect(await responseOf(request(app).get('/api/prompts/groups'))).toEqual({
      status: 500,
      body: { error: 'Error getting prompt groups' },
    });
  });

  it('returns the full catalog array from GET /all with the public flag', async () => {
    const response = await request(app).get('/api/prompts/all').expect(200);

    expect(response.body).toEqual([
      expect.objectContaining({
        _id: group._id.toString(),
        productionPrompt: { _id: revision._id.toString(), prompt: 'Compatibility prompt' },
      }),
    ]);
    expect(response.body[0].isPublic).toBeUndefined();
  });

  it('keeps the Usage responses', async () => {
    const recordUsage = () => request(app).post(`/api/prompts/groups/${group._id}/use`);
    expect(await responseOf(recordUsage())).toEqual({
      status: 200,
      body: { numberOfGenerations: 1 },
    });

    jest.spyOn(PromptGroup, 'findByIdAndUpdate').mockImplementationOnce(() => {
      throw new Error('database unavailable');
    });
    expect(await responseOf(recordUsage())).toEqual({
      status: 500,
      body: { error: 'Error recording prompt usage' },
    });
  });

  it('keeps the revision and group deletion responses', async () => {
    await request(app)
      .delete(`/api/prompts/${revision._id}`)
      .expect(400, { error: 'Invalid or missing groupId' });

    const response = await request(app)
      .delete(`/api/prompts/${revision._id}`)
      .query({ groupId: group._id.toString() })
      .expect(200);

    expect(response.body).toEqual({
      prompt: 'Prompt deleted successfully',
      promptGroup: { message: 'Prompt group deleted successfully', id: group._id.toString() },
    });
    await expect(PromptGroup.countDocuments({ _id: group._id })).resolves.toBe(0);
  });

  it('keeps the group deletion response', async () => {
    expect(await responseOf(request(app).delete(`/api/prompts/groups/${group._id}`))).toEqual({
      status: 200,
      body: { message: 'Prompt group deleted successfully' },
    });
  });
});