Files
TREK/server/tests/unit/mcp/tools-addon-gating.test.ts
T
Maurice 0e04eeaf9a test: send the reset and seeding steps one by one or together, not awaited in a loop
resetDatabase empties tables and puts back the default categories one after another through the repo's oneByOne helper, where the order can matter, and the default addons and photo providers together; the MCP suites switch their addons on together and create ordered stops through oneByOne. The warnings this brings below the baseline, and the no-explicit-any and no-unused-vars counts earlier commits lowered, are lowered in scripts/eslint-baseline.json.
2026-11-17 23:04:09 +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.
await Promise.all(
[ADDON_IDS.BUDGET, ADDON_IDS.PACKING, ADDON_IDS.COLLAB].map((id) => 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'],
);
});
});