Files

355 lines
23 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { createHmac } from 'node:crypto';
import { afterAll, beforeEach, describe, expect, it } from 'vitest';
import { createState } from '../src/domain/oauth-state.js';
import { getDiscordConnection, getGitHubConnection, getPanel, listApps } from '../src/domain/store.js';
import { createInvite, createWorkspace } from '../src/domain/workspaces.js';
import { form, get, makeAdmin, makeApp, makeWorkspace, resetDb, testConfig, testDb, type TestEnv } from './helpers.js';
let env: TestEnv;
beforeEach(async () => {
await resetDb();
env = await makeApp();
});
afterAll(async () => {
await testDb().end();
});
describe('admin authorization and workspace isolation', () => {
it('requires sign-in for every admin page', async () => {
const ws = await makeWorkspace(env);
for (const url of ['/workspaces', `/w/${ws.workspace.id}`, `/w/${ws.workspace.id}/apps`, `/w/${ws.workspace.id}/tickets`]) {
const res = await env.server.inject({ method: 'GET', url });
expect(res.statusCode, url).toBe(302);
expect(res.headers.location).toBe('/login');
}
});
it('hides other workspaces entirely (404, not 403)', async () => {
const a = await makeWorkspace(env);
const b = await makeWorkspace(env);
const pages = ['', '/apps', '/settings', '/members', '/tickets', '/tickets/panel', '/contributors', '/setup/github', '/setup/discord', `/apps/${b.apps[0]!.id}/edit`];
for (const p of pages) {
const res = await env.server.inject({ method: 'GET', url: `/w/${b.workspace.id}${p}`, ...get(a.owner) });
expect(res.statusCode, p).toBe(404);
}
// Cross-workspace object access via the attacker's own workspace URL also fails.
const edit = await env.server.inject({ method: 'GET', url: `/w/${a.workspace.id}/apps/${b.apps[0]!.id}/edit`, ...get(a.owner) });
expect(edit.statusCode).toBe(404);
const del = await env.server.inject({ method: 'POST', url: `/w/${a.workspace.id}/apps/${b.apps[0]!.id}/delete`, ...form(a.owner) });
expect(del.statusCode).toBe(404);
expect(await listApps(env.db, b.workspace.id)).toHaveLength(1);
const publish = await env.server.inject({ method: 'POST', url: `/w/${b.workspace.id}/tickets/panel`, ...form(a.owner, { intent: 'publish' }) });
expect(publish.statusCode).toBe(404);
});
it('rejects state-changing requests without a valid CSRF token', async () => {
const ws = await makeWorkspace(env);
const res = await env.server.inject({
method: 'POST',
url: `/w/${ws.workspace.id}/apps/${ws.apps[0]!.id}/delete`,
headers: { cookie: ws.owner.cookie, 'content-type': 'application/x-www-form-urlencoded' },
payload: '_csrf=wrong',
});
expect(res.statusCode).toBe(403);
expect(await listApps(env.db, ws.workspace.id)).toHaveLength(1);
});
it('lets only owners manage admins; invitations grant admin access once', async () => {
const ws = await makeWorkspace(env);
const invitee = await makeAdmin(env, 'invitee');
const token = await createInvite(env.db, ws.workspace.id, ws.owner.user.id);
expect((await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}`, ...get(invitee) })).statusCode).toBe(404);
const accept = await env.server.inject({ method: 'POST', url: `/invite/${token}`, ...form(invitee) });
expect(accept.statusCode).toBe(302);
expect((await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}`, ...get(invitee) })).statusCode).toBe(200);
// Reusing the link fails.
const intruder = await makeAdmin(env, 'intruder');
expect((await env.server.inject({ method: 'POST', url: `/invite/${token}`, ...form(intruder) })).statusCode).toBe(404);
// Admins (non-owners) can't invite or remove people.
expect((await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/members/invites`, ...form(invitee) })).statusCode).toBe(403);
expect((await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/members/${ws.owner.user.id}/remove`, ...form(invitee) })).statusCode).toBe(403);
});
it('restricts workspace creation to the first user or configured platform admins', async () => {
const first = await makeAdmin(env);
const second = await makeAdmin(env);
expect((await env.server.inject({ method: 'POST', url: '/workspaces', ...form(first, { name: 'Acme' }) })).statusCode).toBe(302);
const denied = await env.server.inject({ method: 'POST', url: '/workspaces', ...form(second, { name: 'Other' }) });
expect(denied.statusCode).toBe(403);
const cfg = testConfig({ PLATFORM_ADMIN_DISCORD_IDS: second.user.discord_user_id });
await expect(createWorkspace(env.db, cfg, second.user, 'Allowed')).resolves.toMatchObject({ name: 'Allowed' });
await expect(createWorkspace(env.db, cfg, first.user, 'Denied')).rejects.toThrow(/invitation/);
});
it('never renders credentials in pages', async () => {
const ws = await makeWorkspace(env);
for (const p of ['', '/deployment', '/setup/github', '/setup/discord', '/tickets/panel', '/contributors/panel', '/members']) {
const res = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}${p}`, ...get(ws.owner) });
expect(res.statusCode, p).toBe(200);
for (const secret of ['bot-token', 'discord-secret', 'gh-secret', 'webhook-secret', 'PRIVATE KEY']) expect(res.body, `${p} leaks ${secret}`).not.toContain(secret);
}
});
});
describe('integration configuration and validation', () => {
it('only allows repositories the GitHub App can access, with Issues enabled and existing labels', async () => {
const ws = await makeWorkspace(env, { apps: [] });
env.github.addInstallation(9999, 'someone-else', [{ id: 4242, name: 'secret-repo' }]);
const url = `/w/${ws.workspace.id}/apps`;
const outside = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'Sneaky', repo_id: '4242', enabled: '1' }) });
expect(outside.statusCode).toBe(400);
expect(outside.body).toContain('Choose a repository the GitHub App can access');
env.github.repos.get(ws.repoIds[1]!)!.has_issues = false;
const disabled = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'Web', repo_id: String(ws.repoIds[1]), enabled: '1' }) });
expect(disabled.body).toContain('Issues are disabled');
const badLabel = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'Mobile', repo_id: String(ws.repoIds[0]), labels: ['bug', 'nope'], enabled: '1' }) });
expect(badLabel.body).toContain('don’t exist');
const ok = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'Mobile', description: 'Phones', repo_id: String(ws.repoIds[0]), labels: ['bug'], enabled: '1' }) });
expect(ok.statusCode).toBe(302);
const second = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'Tablet', repo_id: String(ws.repoIds[0]), enabled: '1' }) });
expect(second.statusCode).toBe(302); // two apps, one repository
const dup = await env.server.inject({ method: 'POST', url, ...form(ws.owner, { name: 'mobile', repo_id: String(ws.repoIds[0]), enabled: '1' }) });
expect(dup.body).toContain('already exists');
const apps = await listApps(env.db, ws.workspace.id);
expect(apps.map((a) => [a.name, a.labels])).toEqual([['Mobile', ['bug']], ['Tablet', []]]);
const labels = await env.server.inject({ method: 'GET', url: `${url}/labels?repo=4242`, ...get(ws.owner) });
expect(labels.statusCode).toBe(404);
});
it('validates channel choice against the connected server and the bot’s permissions', async () => {
const ws = await makeWorkspace(env);
const guild = env.discord.guilds.get(ws.guildId)!;
guild.channels.push({ id: '777', type: 0, name: 'locked', position: 1, permission_overwrites: [{ id: `${ws.guildId}9`, type: 0, allow: '0', deny: String(1n << 11n) }] });
const page = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/tickets/panel`, ...get(ws.owner) });
expect(page.body).toContain('#locked (bot missing: Send Messages');
const locked = await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/tickets/panel`, ...form(ws.owner, { channel_id: '777', intent: 'save' }) });
expect(locked.statusCode).toBe(302);
expect((await getDiscordConnection(env.db, ws.workspace.id))!.tickets_channel_id).toBe(ws.channelId);
const foreign = await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/tickets/panel`, ...form(ws.owner, { channel_id: '123456', intent: 'save' }) });
expect(foreign.statusCode).toBe(302);
expect((await getDiscordConnection(env.db, ws.workspace.id))!.tickets_channel_id).toBe(ws.channelId);
});
it('reports actionable validation problems', async () => {
const ws = await makeWorkspace(env, { apps: [{ name: 'Mobile App', labels: ['bug'] }, { name: 'Website', repoIndex: 1 }] });
env.github.repos.get(ws.repoIds[1]!)!.has_issues = false;
env.github.repos.get(ws.repoIds[0]!)!.labels = [];
const page = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/tickets/panel`, ...get(ws.owner) });
expect(page.body).toContain('Website: Issues are disabled');
expect(page.body).toContain('label bug no longer exists');
expect(page.body).toContain('Not published');
expect(page.body).not.toContain('value="publish"'); // problems block publishing
env.discord.botGuildIds.delete(ws.guildId);
const removed = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/tickets/panel`, ...get(ws.owner) });
expect(removed.body).toContain('The bot is not in this Discord server');
expect((await getDiscordConnection(env.db, ws.workspace.id))!.status).toBe('removed');
});
it('binds the bot to the server reported by Discord’s token response and validates state', async () => {
const owner = await makeAdmin(env);
const ws = await createWorkspace(env.db, { ...env.deps.config, openWorkspaceCreation: true }, owner.user, 'WS');
env.discord.addGuild('600000000000000001', 'Real Guild', [{ id: '600000000000000002', type: 0, name: 'tickets', position: 0 }]);
env.discord.codes.set('bot-code', { access_token: 'x', expires_in: 600, scope: 'bot identify', guild: { id: '600000000000000001', name: 'Real Guild', icon: null } });
const sid = (await env.db.query('SELECT id FROM sessions WHERE user_id = $1', [owner.user.id])).rows[0].id;
// Wrong/missing state is rejected.
const bad = await env.server.inject({ method: 'GET', url: '/oauth/discord/callback?code=bot-code&state=forged&guild_id=1', ...get(owner) });
expect(bad.headers.location).toMatch(/^\/login\?error=/);
// A state created for another session can't be used.
const other = await makeAdmin(env);
const stolen = await createState(env.db, 'discord_bot', sid, ws.id);
const res1 = await env.server.inject({ method: 'GET', url: `/oauth/discord/callback?code=bot-code&state=${stolen}`, ...get(other) });
expect(res1.headers.location).toBe('/login');
expect(await getDiscordConnection(env.db, ws.id)).toBeNull();
const state = await createState(env.db, 'discord_bot', sid, ws.id);
const ok = await env.server.inject({ method: 'GET', url: `/oauth/discord/callback?code=bot-code&state=${state}&guild_id=999`, ...get(owner) });
expect(ok.headers.location).toBe(`/w/${ws.id}/setup/discord`);
expect((await getDiscordConnection(env.db, ws.id))!.guild_id).toBe('600000000000000001'); // not the spoofed 999
// States are single-use.
const replay = await env.server.inject({ method: 'GET', url: `/oauth/discord/callback?code=bot-code&state=${state}`, ...get(owner) });
expect(replay.headers.location).toMatch(/^\/login\?error=/);
});
it('refuses to connect a Discord server that belongs to another workspace', async () => {
const a = await makeWorkspace(env);
const owner = await makeAdmin(env);
const ws = await createWorkspace(env.db, { ...env.deps.config, openWorkspaceCreation: true }, owner.user, 'WS2');
env.discord.codes.set('steal', { access_token: 'x', expires_in: 600, scope: 'bot identify', guild: { id: a.guildId, name: 'Guild', icon: null } });
const sid = (await env.db.query('SELECT id FROM sessions WHERE user_id = $1', [owner.user.id])).rows[0].id;
const state = await createState(env.db, 'discord_bot', sid, ws.id);
await env.server.inject({ method: 'GET', url: `/oauth/discord/callback?code=steal&state=${state}`, ...get(owner) });
expect(await getDiscordConnection(env.db, ws.id)).toBeNull();
expect((await getDiscordConnection(env.db, a.workspace.id))!.guild_id).toBe(a.guildId);
});
it('accepts only GitHub installations the authorizing user can access', async () => {
const owner = await makeAdmin(env);
const ws = await createWorkspace(env.db, { ...env.deps.config, openWorkspaceCreation: true }, owner.user, 'WS');
env.github.addInstallation(111, 'mine', [{ id: 1, name: 'a' }]);
env.github.addInstallation(222, 'victim', [{ id: 2, name: 'b' }]);
env.github.userInstallationIds = [111];
const sid = (await env.db.query('SELECT id FROM sessions WHERE user_id = $1', [owner.user.id])).rows[0].id;
const spoof = await createState(env.db, 'github_install', sid, ws.id, { mode: 'install' });
await env.server.inject({ method: 'GET', url: `/oauth/github/callback?code=good-code&installation_id=222&setup_action=install&state=${spoof}`, ...get(owner) });
expect(await getGitHubConnection(env.db, ws.id)).toBeNull();
const real = await createState(env.db, 'github_install', sid, ws.id, { mode: 'install' });
const res = await env.server.inject({ method: 'GET', url: `/oauth/github/callback?code=good-code&installation_id=111&setup_action=install&state=${real}`, ...get(owner) });
expect(res.headers.location).toBe(`/w/${ws.id}/setup/github`);
expect(await getGitHubConnection(env.db, ws.id)).toMatchObject({ installation_id: 111, account_login: 'mine', status: 'active' });
const page = await env.server.inject({ method: 'GET', url: `/w/${ws.id}/setup/github`, ...get(owner) });
expect(page.body).toContain('mine/a');
expect(page.body).not.toContain('victim/b');
});
it('updates connection status from signed GitHub webhooks only', async () => {
const ws = await makeWorkspace(env);
const payload = JSON.stringify({ action: 'deleted', installation: { id: ws.installationId, account: { login: 'org' } } });
const unsigned = await env.server.inject({ method: 'POST', url: '/github/webhook', headers: { 'content-type': 'application/json', 'x-github-event': 'installation', 'x-hub-signature-256': 'sha256=00' }, payload });
expect(unsigned.statusCode).toBe(401);
expect((await getGitHubConnection(env.db, ws.workspace.id))!.status).toBe('active');
const sig = `sha256=${createHmac('sha256', 'webhook-secret').update(payload).digest('hex')}`;
const signed = await env.server.inject({ method: 'POST', url: '/github/webhook', headers: { 'content-type': 'application/json', 'x-github-event': 'installation', 'x-hub-signature-256': sig }, payload });
expect(signed.statusCode).toBe(204);
expect((await getGitHubConnection(env.db, ws.workspace.id))!.status).toBe('removed');
});
});
describe('panel publishing', () => {
it('publishes once, then edits the same message in place', async () => {
const ws = await makeWorkspace(env);
const url = `/w/${ws.workspace.id}/tickets/panel`;
await env.server.inject({ method: 'POST', url, ...form(ws.owner, { intent: 'publish' }) });
const panel = (await getPanel(env.db, ws.workspace.id))!;
expect(env.discord.messages.get(panel.message_id)!.channelId).toBe(ws.channelId);
expect(env.discord.messages.get(panel.message_id)!.payload.allowed_mentions).toEqual({ parse: [] });
await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/apps`, ...form(ws.owner, { name: 'Website', repo_id: String(ws.repoIds[1]), enabled: '1' }) });
const apps = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/apps`, ...get(ws.owner) });
expect(apps.body).toContain('doesn’t show your latest changes');
await env.server.inject({ method: 'POST', url, ...form(ws.owner, { intent: 'publish' }) });
const after = (await getPanel(env.db, ws.workspace.id))!;
expect(after.message_id).toBe(panel.message_id);
expect(env.discord.messages.size).toBe(1);
const options = env.discord.messages.get(panel.message_id)!.payload.components[0].components[0].options;
expect(options.map((o: { label: string }) => o.label)).toEqual(['Mobile App', 'Website']);
});
it('re-posts a deleted panel and moves it when the channel changes', async () => {
const ws = await makeWorkspace(env);
const url = `/w/${ws.workspace.id}/tickets/panel`;
await env.server.inject({ method: 'POST', url, ...form(ws.owner, { intent: 'publish' }) });
const first = (await getPanel(env.db, ws.workspace.id))!;
env.discord.messages.delete(first.message_id);
const page = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/tickets/panel`, ...get(ws.owner) });
expect(page.body).toContain('Deleted in Discord');
expect((await getPanel(env.db, ws.workspace.id))!.status).toBe('missing');
await env.server.inject({ method: 'POST', url, ...form(ws.owner, { intent: 'publish' }) });
const second = (await getPanel(env.db, ws.workspace.id))!;
expect(second.message_id).not.toBe(first.message_id);
expect(second.status).toBe('published');
const guild = env.discord.guilds.get(ws.guildId)!;
guild.channels.push({ id: '880', type: 0, name: 'help', position: 2 });
await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/tickets/panel`, ...form(ws.owner, { channel_id: '880', intent: 'save' }) });
await env.server.inject({ method: 'POST', url, ...form(ws.owner, { intent: 'publish' }) });
const moved = (await getPanel(env.db, ws.workspace.id))!;
expect(moved.channel_id).toBe('880');
expect(env.discord.messages.has(second.message_id)).toBe(false);
expect(env.discord.messages.size).toBe(1);
});
it('explains Discord permission errors when publishing', async () => {
const ws = await makeWorkspace(env);
env.discord.failNextCreate = { status: 403, code: 50013 };
const res = await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/tickets/panel`, ...form(ws.owner, { intent: 'publish' }) });
expect(res.statusCode).toBe(302);
expect(await getPanel(env.db, ws.workspace.id)).toBeNull();
const flash = res.cookies.find((c) => c.name === 'tr_flash')!.value;
expect(Buffer.from(flash, 'base64url').toString()).toMatch(/missing permissions/);
});
it('creates a test issue only when the admin explicitly sends one', async () => {
const ws = await makeWorkspace(env);
await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/tickets/panel`, ...get(ws.owner) });
expect(env.github.createCalls).toBe(0);
const res = await env.server.inject({ method: 'POST', url: `/w/${ws.workspace.id}/tickets/panel/test`, ...form(ws.owner, { app_id: ws.apps[0]!.id }) });
expect(res.statusCode).toBe(302);
expect(res.headers.location).toMatch(new RegExp(`/w/${ws.workspace.id}/tickets/`));
const issue = env.github.allIssues()[0]!;
expect(issue.title).toBe('[Test] [Mobile App] Ticket Relay connection test');
expect(issue.body).toContain('This is a test ticket');
const detail = await env.server.inject({ method: 'GET', url: res.headers.location as string, ...get(ws.owner) });
expect(detail.body).toContain('Filed');
});
});
describe('missing deployment configuration', () => {
it('keeps the admin UI usable and explains what is missing', async () => {
const bare = await makeApp({ config: testConfig({ DISCORD_BOT_TOKEN: '', GITHUB_APP_PRIVATE_KEY: '' }) });
const owner = await makeAdmin(bare);
const ws = await createWorkspace(bare.db, { ...bare.deps.config, openWorkspaceCreation: true }, owner.user, 'Bare');
const overview = await bare.server.inject({ method: 'GET', url: `/w/${ws.id}`, ...get(owner) });
expect(overview.body).toContain('Deployment setup incomplete');
const setup = await bare.server.inject({ method: 'GET', url: `/w/${ws.id}/deployment`, ...get(owner) });
expect(setup.body).toContain('DISCORD_BOT_TOKEN');
expect(setup.body).toContain('https://relay.example.test/discord/interactions');
for (const url of ['/setup/github/install', '/setup/github/link', '/setup/discord/install', '/setup/discord/server', '/tickets/panel']) {
const res = await bare.server.inject({ method: 'POST', url: `/w/${ws.id}${url}`, ...form(owner) });
expect(res.statusCode, url).toBe(302);
}
const interactions = await bare.server.inject({ method: 'POST', url: '/discord/interactions', headers: { 'content-type': 'application/json' }, payload: '{}' });
expect(interactions.statusCode).toBe(503);
});
});
describe('GitHub App credential problems', () => {
async function installFlow(env: TestEnv) {
const owner = await makeAdmin(env);
const ws = await createWorkspace(env.db, { ...env.deps.config, openWorkspaceCreation: true }, owner.user, 'WS');
env.github.addInstallation(111, 'mine', [{ id: 1, name: 'a' }]);
env.github.userInstallationIds = [111];
const sid = (await env.db.query('SELECT id FROM sessions WHERE user_id = $1', [owner.user.id])).rows[0].id;
const state = await createState(env.db, 'github_install', sid, ws.id, { mode: 'install' });
const res = await env.server.inject({ method: 'GET', url: `/oauth/github/callback?code=good-code&installation_id=111&setup_action=install&state=${state}`, ...get(owner) });
return { owner, ws, res };
}
it('explains rejected app credentials after install instead of failing with a 500', async () => {
env.github.rejectAppJwt = true;
const { owner, ws, res } = await installFlow(env);
expect(res.statusCode).toBe(302);
expect(res.headers.location).toBe(`/w/${ws.id}/setup/github`);
const flash = Buffer.from(res.cookies.find((c) => c.name === 'tr_flash')!.value, 'base64url').toString();
expect(flash).toMatch(/secrets\/sec\.pem/);
expect(await getGitHubConnection(env.db, ws.id)).toBeNull();
const page = await env.server.inject({ method: 'GET', url: `/w/${ws.id}/setup/github`, ...get(owner) });
expect(page.body).toContain('GitHub App credentials don’t work');
});
it('verifies credentials and catches a wrong slug on the deployment page', async () => {
const ws = await makeWorkspace(env);
const ok = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/deployment`, ...get(ws.owner) });
expect(ok.body).toContain('Credentials work for the GitHub App');
expect(ok.body).toContain('Bot token works');
env.github.appSlug = 'ticket-craft';
const wrong = await env.server.inject({ method: 'GET', url: `/w/${ws.workspace.id}/deployment`, ...get(ws.owner) });
expect(wrong.body).toContain('Set GITHUB_APP_SLUG=ticket-craft');
});
});