Files
TREK/server/tests/integration/oauth-authorize.test.ts
T
Maurice 6e7336b8d7 test(db): run the MCP and OAuth suites on the real database module
They reset through resetDatabase and seed through the ORM factories
instead of the SQLite snapshot mock, so they run in the Postgres lane as
well. The OAuth service they drove by hand over a second ORM on the
SQLite handle is now the container's own, called in a request context.

The MCP audit cases wait for the mcp.tool_call row: the transport writes
it without awaiting it, so on Postgres it can land after the response.
2026-11-17 23:04:03 +01:00

293 lines
11 KiB
TypeScript

/**
* HTTP-level tests for GET /oauth/authorize — the MCP SDK authorizationHandler
* wrapping TREK's OAuthServerProvider. Written as byte-level parity oracles for
* the MCP/OAuth mount migration: they must pass identically while the handler
* is mounted pre-init AND after it moves behind the Nest container.
*
* This was the one platform surface with no HTTP coverage at all —
* trekOAuthProvider.authorize and trekClientsStore.getClient run for the first
* time under test here.
*/
import { buildApp } from '../../src/bootstrap';
import { Addons } from '../../src/db/entities/Addons.entity';
import { withRequestContext } from '../../src/nest/database/request-context';
import { OauthService } from '../../src/nest/oauth/oauth.service';
import { upsertRow } from '../helpers/factories/rows';
import { makeUser } from '../helpers/factories/users';
import { resetDatabase } from '../helpers/reset-database';
import { resetRateLimits } from '../helpers/test-db';
import { MikroORM } from '@mikro-orm/core';
import type { INestApplication } from '@nestjs/common';
import crypto from 'crypto';
import type { Application } from 'express';
import request from 'supertest';
import { describe, it, expect, vi, beforeAll, beforeEach, afterAll } from 'vitest';
vi.mock('../../src/app-config', async (importOriginal) => {
const actual = await importOriginal<typeof import('../../src/app-config')>();
return { ...actual, getMcpSafeUrl: () => 'https://trek.example.com' };
});
vi.mock('../../src/mcp/sessionManager', () => ({
revokeUserSessions: vi.fn(),
revokeUserSessionsForClient: vi.fn(),
sessions: new Map(),
}));
// The consent controller writes pending codes through the container instance;
// the SDK-mounted authorize path reads them back. The map is module-scoped in
// oauth.pending-codes.ts, so the container's service instance shares it — the
// same single-instance property the full auth-code loop below proves end-to-end.
let containerSideOauth: OauthService;
let nestApp: INestApplication;
let app: Application;
let orm: MikroORM;
function makePkce() {
const verifier = crypto.randomBytes(32).toString('base64url');
const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
return { verifier, challenge };
}
async function setMcpEnabled(enabled: boolean) {
await upsertRow(orm, Addons, {
id: 'mcp',
name: 'MCP',
description: 'AI assistant integration',
type: 'integration',
icon: 'Terminal',
enabled,
sort_order: 12,
});
}
/** DCR-register a public client and return its client_id. */
async function registerClient(redirectUri = 'https://client.example.com/cb', scope = 'trips:read'): Promise<string> {
const res = await request(app)
.post('/oauth/register')
.set('Content-Type', 'application/json')
.send({ redirect_uris: [redirectUri], token_endpoint_auth_method: 'none', scope });
expect(res.status).toBe(201);
return res.body.client_id as string;
}
beforeAll(async () => {
nestApp = await buildApp();
app = nestApp.getHttpAdapter().getInstance();
orm = nestApp.get(MikroORM);
containerSideOauth = nestApp.get(OauthService);
});
beforeEach(async () => {
await resetDatabase(orm);
await resetRateLimits(nestApp);
await setMcpEnabled(true);
});
afterAll(async () => {
await nestApp.close();
});
describe('GET /oauth/authorize — SDK authorizationHandler over trekOAuthProvider', () => {
it('AUTHZ-001 — happy path 302-redirects to the SPA consent page with the exact forwarded params', async () => {
const clientId = await registerClient();
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
state: 'st4te',
code_challenge: challenge,
code_challenge_method: 'S256',
resource: 'https://trek.example.com/mcp',
});
expect(res.status).toBe(302);
const expected = new URLSearchParams({
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
state: 'st4te',
resource: 'https://trek.example.com/mcp',
});
expect(res.headers.location).toBe(`https://trek.example.com/oauth/consent?${expected.toString()}`);
});
it('AUTHZ-002 — omitted resource defaults to the MCP endpoint and still reaches consent', async () => {
const clientId = await registerClient();
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
});
expect(res.status).toBe(302);
const loc = new URL(res.headers.location);
expect(`${loc.origin}${loc.pathname}`).toBe('https://trek.example.com/oauth/consent');
expect(loc.searchParams.get('client_id')).toBe(clientId);
// No resource param was sent, so none is forwarded.
expect(loc.searchParams.get('resource')).toBeNull();
expect(loc.searchParams.get('state')).toBeNull();
});
it('AUTHZ-002B: a private-use scheme registers and authorizes with the byte-identical URI (#2227)', async () => {
const redirectUri = 'workbuddy://workbuddy/mcp/connector%3A/oauth/callback';
const clientId = await registerClient(redirectUri);
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: redirectUri,
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
});
expect(res.status).toBe(302);
const loc = new URL(res.headers.location);
expect(`${loc.origin}${loc.pathname}`).toBe('https://trek.example.com/oauth/consent');
// Forwarded unchanged: the %3A must survive to the token exchange.
expect(loc.searchParams.get('redirect_uri')).toBe(redirectUri);
});
it('AUTHZ-003 — wrong resource 302-redirects back to the client with invalid_target', async () => {
const clientId = await registerClient();
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
state: 'xyz',
code_challenge: challenge,
code_challenge_method: 'S256',
resource: 'https://evil.example.com/other',
});
expect(res.status).toBe(302);
const loc = new URL(res.headers.location);
expect(`${loc.origin}${loc.pathname}`).toBe('https://client.example.com/cb');
expect(loc.searchParams.get('error')).toBe('invalid_target');
expect(loc.searchParams.get('error_description')).toBe('Requested resource must be the TREK MCP endpoint');
expect(loc.searchParams.get('state')).toBe('xyz');
});
it('AUTHZ-004 — unknown client_id is a 400 invalid_client, no redirect', async () => {
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: 'does-not-exist',
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
});
expect(res.status).toBe(400);
expect(res.body.error).toBe('invalid_client');
});
it('AUTHZ-005 — unregistered redirect_uri is a 400 invalid_request, no redirect', async () => {
const clientId = await registerClient();
const { challenge } = makePkce();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://attacker.example.com/cb',
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
});
expect(res.status).toBe(400);
expect(res.body.error).toBe('invalid_request');
});
it('AUTHZ-006 — missing code_challenge redirects back to the client with invalid_request', async () => {
const clientId = await registerClient();
const res = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
});
expect(res.status).toBe(302);
const loc = new URL(res.headers.location);
expect(`${loc.origin}${loc.pathname}`).toBe('https://client.example.com/cb');
expect(loc.searchParams.get('error')).toBe('invalid_request');
});
it('AUTHZ-007 — MCP addon off: authorize and register both 404 with empty bodies', async () => {
await setMcpEnabled(false);
const authz = await request(app).get('/oauth/authorize').query({ client_id: 'x' });
expect(authz.status).toBe(404);
expect(authz.text).toBe('');
const reg = await request(app)
.post('/oauth/register')
.set('Content-Type', 'application/json')
.send({ redirect_uris: ['https://client.example.com/cb'], token_endpoint_auth_method: 'none' });
expect(reg.status).toBe(404);
expect(reg.text).toBe('');
});
it('AUTHZ-008 — full loop: register → authorize → consent-written code → token exchange', async () => {
const { user } = await makeUser(orm);
const clientId = await registerClient();
const { verifier, challenge } = makePkce();
// 1. authorize forwards to consent
const authz = await request(app).get('/oauth/authorize').query({
response_type: 'code',
client_id: clientId,
redirect_uri: 'https://client.example.com/cb',
scope: 'trips:read',
code_challenge: challenge,
code_challenge_method: 'S256',
resource: 'https://trek.example.com/mcp',
});
expect(authz.status).toBe(302);
// 2. the consent controller writes the code through the container
// singleton; the module-scoped pending-code map is what lets the
// SDK-side exchange see it.
const code = await withRequestContext(orm, () =>
containerSideOauth.createAuthCode({
clientId,
userId: user.id,
redirectUri: 'https://client.example.com/cb',
scopes: ['trips:read'],
resource: 'https://trek.example.com/mcp',
codeChallenge: challenge,
codeChallengeMethod: 'S256',
}),
);
expect(code).toBeTruthy();
// 3. token exchange through the public token endpoint
const token = await request(app).post('/oauth/token').send({
grant_type: 'authorization_code',
client_id: clientId,
code,
redirect_uri: 'https://client.example.com/cb',
code_verifier: verifier,
resource: 'https://trek.example.com/mcp',
});
expect(token.status).toBe(200);
expect(token.body.access_token).toMatch(/^trekoa_/);
expect(token.body.token_type).toBe('Bearer');
expect(token.body.scope).toBe('trips:read');
});
});