Files
TREK/server/tests/unit/mcp/tools-addon-gating.test.ts
T
Maurice 1b16fd1683 test(db): run the demo tool gate, addon gating, atlas and assignments MCP suites on the real database module
They seed through the booted container's ORM instead of a second ORM over
the SQLite snapshot mock, and reset through resetDatabase, so they run in
the Postgres lane as well. The tour the assignment cases put on a day is
made with makeTour instead of a raw insert.
2026-11-17 18:20:16 +01:00

288 lines
10 KiB
TypeScript

/**
* Unit tests for MCP addon gating and scope enforcement in tools.
*/
import { ADDON_IDS } from '../../../src/addons';
import { setAddonEnabled } from '../../helpers/factories/settings';
import { makeTrip } from '../../helpers/factories/trips';
import { makeUser } from '../../helpers/factories/users';
import { FakeRealtimeService } from '../../helpers/fake-realtime';
import { createMcpHarness, parseToolResult, type McpHarness } from '../../helpers/mcp-harness';
import { resetDatabase } from '../../helpers/reset-database';
import { bootTestApp } from '../../helpers/test-app';
import { MikroORM } from '@mikro-orm/core';
import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
const realtime = new FakeRealtimeService();
const broadcastMock = realtime.broadcastMock;
// The booted container's own ORM, the one the tools write through.
let orm: MikroORM;
beforeAll(async () => {
orm = (await bootTestApp(realtime)).get(MikroORM);
});
beforeEach(async () => {
await resetDatabase(orm);
broadcastMock.mockClear();
// The summary reads these three off the injected AddonsService, so the case
// that wants one off writes the row the admin panel writes. resetDatabase
// puts back the default addon rows, so each case restates what it needs.
for (const id of [ADDON_IDS.BUDGET, ADDON_IDS.PACKING, ADDON_IDS.COLLAB]) {
await setAddonEnabled(orm, id, true);
}
});
afterAll(async () => {
await (await bootTestApp(realtime)).close();
});
async function withHarness(userId: number, fn: (h: McpHarness) => Promise<void>, scopes?: string[] | null) {
const h = await createMcpHarness({ realtime, userId, withResources: false, scopes: scopes ?? null });
try {
await fn(h);
} finally {
await h.cleanup();
}
}
// ---------------------------------------------------------------------------
// get_trip_summary — addon gating
// ---------------------------------------------------------------------------
describe('get_trip_summary — addon gating', () => {
it('when all addons enabled: packing, budget, collab_notes, todos are present', async () => {
const { user } = await makeUser(orm);
const trip = await makeTrip(orm, user.id, { title: 'Full Trip' });
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'get_trip_summary', arguments: { tripId: trip.id } });
expect(result.isError).toBeFalsy();
const data = parseToolResult(result) as any;
expect(data.packing).toBeDefined();
expect(data.budget).toBeDefined();
expect(Array.isArray(data.collab_notes)).toBe(true);
expect(Array.isArray(data.todos)).toBe(true);
});
});
it('when budget disabled: budget is undefined in response', async () => {
const { user } = await makeUser(orm);
const trip = await makeTrip(orm, user.id, { title: 'No Budget Trip' });
await setAddonEnabled(orm, ADDON_IDS.BUDGET, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'get_trip_summary', arguments: { tripId: trip.id } });
expect(result.isError).toBeFalsy();
const data = parseToolResult(result) as any;
expect(data.budget).toBeUndefined();
// packing and collab still present
expect(data.packing).toBeDefined();
expect(Array.isArray(data.collab_notes)).toBe(true);
});
});
it('when packing disabled: packing is undefined and todos is empty array', async () => {
const { user } = await makeUser(orm);
const trip = await makeTrip(orm, user.id, { title: 'No Packing Trip' });
await setAddonEnabled(orm, ADDON_IDS.PACKING, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'get_trip_summary', arguments: { tripId: trip.id } });
expect(result.isError).toBeFalsy();
const data = parseToolResult(result) as any;
expect(data.packing).toBeUndefined();
expect(Array.isArray(data.todos)).toBe(true);
expect(data.todos).toHaveLength(0);
});
});
it('when collab disabled: collab_notes is empty array, pollCount is 0, messageCount is 0', async () => {
const { user } = await makeUser(orm);
const trip = await makeTrip(orm, user.id, { title: 'No Collab Trip' });
await setAddonEnabled(orm, ADDON_IDS.COLLAB, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'get_trip_summary', arguments: { tripId: trip.id } });
expect(result.isError).toBeFalsy();
const data = parseToolResult(result) as any;
expect(Array.isArray(data.collab_notes)).toBe(true);
expect(data.collab_notes).toHaveLength(0);
expect(data.pollCount).toBe(0);
expect(data.messageCount).toBe(0);
});
});
});
// ---------------------------------------------------------------------------
// Budget tools — addon gating
// ---------------------------------------------------------------------------
describe('Budget tools — addon gating', () => {
it('when budget addon disabled, create_budget_item is not registered', async () => {
const { user } = await makeUser(orm);
await setAddonEnabled(orm, ADDON_IDS.BUDGET, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({
name: 'create_budget_item',
arguments: { tripId: 1, name: 'Test', total_price: 100 },
});
expect(result.isError).toBe(true);
});
});
});
// ---------------------------------------------------------------------------
// Packing tools — addon gating
// ---------------------------------------------------------------------------
describe('Packing tools — addon gating', () => {
it('when packing addon disabled, create_packing_item is not registered', async () => {
const { user } = await makeUser(orm);
await setAddonEnabled(orm, ADDON_IDS.PACKING, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({
name: 'create_packing_item',
arguments: { tripId: 1, name: 'Sunscreen' },
});
expect(result.isError).toBe(true);
});
});
});
// ---------------------------------------------------------------------------
// Collab tools — addon gating
// ---------------------------------------------------------------------------
describe('Collab tools — addon gating', () => {
it('when collab addon disabled, create_collab_note is not registered', async () => {
const { user } = await makeUser(orm);
await setAddonEnabled(orm, ADDON_IDS.COLLAB, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({
name: 'create_collab_note',
arguments: { tripId: 1, title: 'Test Note' },
});
expect(result.isError).toBe(true);
});
});
});
// ---------------------------------------------------------------------------
// Atlas tools — addon gating
// ---------------------------------------------------------------------------
describe('Atlas tools — addon gating', () => {
it('when atlas addon disabled, mark_country_visited is not registered', async () => {
const { user } = await makeUser(orm);
await setAddonEnabled(orm, ADDON_IDS.ATLAS, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'mark_country_visited', arguments: { country_code: 'FR' } });
expect(result.isError).toBe(true);
});
});
it('when atlas addon disabled, create_bucket_list_item is not registered', async () => {
const { user } = await makeUser(orm);
await setAddonEnabled(orm, ADDON_IDS.ATLAS, false);
await withHarness(user.id, async (h) => {
const result = await h.client.callTool({ name: 'create_bucket_list_item', arguments: { name: 'Paris' } });
expect(result.isError).toBe(true);
});
});
});
// ---------------------------------------------------------------------------
// Scope enforcement in tools
// ---------------------------------------------------------------------------
describe('Scope enforcement in tools', () => {
it('with scopes trips:read, create_trip is not registered (write not in scopes)', async () => {
const { user } = await makeUser(orm);
await withHarness(
user.id,
async (h) => {
const result = await h.client.callTool({ name: 'create_trip', arguments: { title: 'Should Fail' } });
expect(result.isError).toBe(true);
},
['trips:read'],
);
});
it('with scopes trips:write, create_trip is registered and works', async () => {
const { user } = await makeUser(orm);
await withHarness(
user.id,
async (h) => {
const result = await h.client.callTool({ name: 'create_trip', arguments: { title: 'My Trip' } });
expect(result.isError).toBeFalsy();
const data = parseToolResult(result) as any;
expect(data.trip.title).toBe('My Trip');
},
['trips:write'],
);
});
it('with scopes null (full access), create_trip is registered', async () => {
const { user } = await makeUser(orm);
await withHarness(
user.id,
async (h) => {
const result = await h.client.callTool({ name: 'create_trip', arguments: { title: 'Full Access Trip' } });
expect(result.isError).toBeFalsy();
},
null,
);
});
it('with scopes trips:read, create_budget_item is not registered (budget:write not in scopes)', async () => {
const { user } = await makeUser(orm);
await withHarness(
user.id,
async (h) => {
const result = await h.client.callTool({
name: 'create_budget_item',
arguments: { tripId: 1, name: 'Hotel', total_price: 200 },
});
expect(result.isError).toBe(true);
},
['trips:read'],
);
});
it('with scopes budget:write and trips:read, create_budget_item is registered (budget addon enabled)', async () => {
const { user } = await makeUser(orm);
const trip = await makeTrip(orm, user.id, { title: 'Budget Trip' });
await withHarness(
user.id,
async (h) => {
const result = await h.client.callTool({
name: 'create_budget_item',
arguments: { tripId: trip.id, name: 'Hotel', total_price: 200 },
});
expect(result.isError).toBeFalsy();
},
['budget:write', 'trips:read'],
);
});
});