Files
crosscode-platform/apps/events/backend/tests/v2.test.ts
T
joshuaandClaude Opus 5.5 6b3c55902e TypeScript backend and /api/v2 foundations (1.51.0)
- tsconfig (allowJs, strict .ts), npm run build -> dist/, typecheck, dev via tsx, ts-jest.
- src/index.js is now a launcher (dist build when it matches, else tsx); server moved to app.js.
- /api/v2: defineRoute with zod -> request validation, response stripping, OpenAPI 3.1 at
  /docs/v2; one error shape and one paged-list shape. First endpoints: events, event, me,
  my registrations.
- deploy.sh/install.sh build the backend; rollback to older releases skips the build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ls1vMdg2GYqbnKZmPaX1ot
2026-10-29 08:48:54 +02:00

153 lines
8.2 KiB
TypeScript

import express from 'express';
import request from 'supertest';
// /api/v2 (1.51.0): the route declarations validate requests, shape responses and errors the same
// way everywhere, and produce the OpenAPI document.
const mockDb = {
event: { findMany: jest.fn(), count: jest.fn(), findFirst: jest.fn() },
user: { findUnique: jest.fn() },
registration: { findMany: jest.fn(), count: jest.fn() },
};
jest.mock('../src/config/db', () => mockDb);
jest.mock('../src/utils/campuses', () => ({
campusesEnabled: jest.fn().mockResolvedValue(false),
resolveCampusFilter: jest.fn(async (v: string) => v),
campusWhere: jest.fn(() => ({})),
}));
// Signed in as whoever the test says (the real middleware checks JWTs against the database).
let signedIn: { id: string; role: string } | null = null;
jest.mock('../src/middleware/authMiddleware', () => {
const deny = (status: number, message: string) => (_req: unknown, res: { status(n: number): void }, next: (e: Error) => void) => { res.status(status); next(new Error(message)); };
return {
protect: (req: { user?: unknown }, res: { status(n: number): void }, next: (e?: Error) => void) => (signedIn ? ((req.user = signedIn), next()) : deny(401, 'Not authorized, no token')(req, res, next as (e: Error) => void)),
optionalAuth: (req: { user?: unknown }, _res: unknown, next: () => void) => { if (signedIn) req.user = signedIn; next(); },
admin: (req: { user?: { role: string } }, res: { status(n: number): void }, next: (e?: Error) => void) => (req.user?.role === 'admin' ? next() : deny(403, 'Not authorized as an admin')(req, res, next as (e: Error) => void)),
staff: jest.fn(), supervisor: jest.fn(),
};
});
import { v2Router } from '../src/v2';
import { routes } from '../src/v2/route';
import { buildOpenApi } from '../src/v2/openapi';
const app = express();
app.use(express.json());
app.use('/api/v2', v2Router());
const event = (over: Record<string, unknown> = {}) => ({
id: 'e1', title: 'Youth Camp', startDate: new Date('2026-12-04T16:00:00Z'), endDate: new Date('2026-12-06T12:00:00Z'),
location: 'Camp Joy', price: 600, picture: '/uploads/events/camp.jpg', requiresRegistration: true, scheduleType: 'single',
campus: null, series: { id: 's1', name: 'Camps', slug: 'camps' }, ...over,
});
beforeEach(() => { signedIn = null; jest.clearAllMocks(); });
describe('GET /api/v2/events', () => {
test('a page of public events, with meta and ISO dates', async () => {
mockDb.event.findMany.mockResolvedValue([event()]);
mockDb.event.count.mockResolvedValue(31);
const res = await request(app).get('/api/v2/events?page=2&limit=10&q=camp');
expect(res.status).toBe(200);
expect(res.body.meta).toEqual({ page: 2, limit: 10, total: 31, pages: 4 });
expect(res.body.data[0]).toMatchObject({ id: 'e1', startDate: '2026-12-04T16:00:00.000Z', series: { slug: 'camps' } });
expect(res.body.data[0].pictureUrl).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/uploads\/events\/camp\.jpg$/);
const args = mockDb.event.findMany.mock.calls[0][0];
expect(args).toMatchObject({ skip: 10, take: 10 });
expect(args.where.AND).toEqual(expect.arrayContaining([{ isActive: true, isHidden: false, goLiveAt: { lte: expect.any(Date) } }, { title: { contains: 'camp', mode: 'insensitive' } }]));
});
test('fields the schema does not list are never sent', async () => {
mockDb.event.findMany.mockResolvedValue([event({ cashupStatus: 'closed', createdById: 'u9' })]);
mockDb.event.count.mockResolvedValue(1);
const res = await request(app).get('/api/v2/events');
expect(Object.keys(res.body.data[0]).sort()).toEqual(['campus', 'endDate', 'id', 'location', 'pictureUrl', 'price', 'requiresRegistration', 'scheduleType', 'series', 'startDate', 'title']);
});
test('a bad query is a VALIDATION_FAILED error naming the field', async () => {
const res = await request(app).get('/api/v2/events?limit=500&page=0');
expect(res.status).toBe(400);
expect(res.body.error.code).toBe('VALIDATION_FAILED');
expect(Object.keys(res.body.error.fields).sort()).toEqual(['limit', 'page']);
expect(mockDb.event.findMany).not.toHaveBeenCalled();
});
});
describe('GET /api/v2/events/:id', () => {
test('leaves out kids and volunteer tickets and shows the early-bird price now', async () => {
mockDb.event.findFirst.mockResolvedValue({
...event(), description: 'A weekend away', registrationDeadline: null, kidsOptionId: 'kids', volunteerOptionId: null,
eventOptions: [
{ id: 'o1', name: 'Camper', price: 600, isMainTicket: true, sessionMode: 'all', earlyBirdTiers: [{ id: 't', price: 500, deadline: new Date(Date.now() + 864e5), stockLimit: 0 }] },
{ id: 'kids', name: 'Kids check-in', price: 0, isMainTicket: false, sessionMode: 'all', earlyBirdTiers: [] },
],
sessions: [],
});
const res = await request(app).get('/api/v2/events/e1');
expect(res.status).toBe(200);
expect(res.body.data.ticketOptions).toEqual([{ id: 'o1', name: 'Camper', price: 600, currentPrice: 500, isMainTicket: true, sessionMode: 'all' }]);
});
test('an unknown or private event is NOT_FOUND', async () => {
mockDb.event.findFirst.mockResolvedValue(null);
const res = await request(app).get('/api/v2/events/nope');
expect(res.status).toBe(404);
expect(res.body).toEqual({ error: { code: 'NOT_FOUND', message: "That event wasn't found." } });
});
});
describe('me', () => {
test('signed out is UNAUTHENTICATED in the v2 shape', async () => {
const res = await request(app).get('/api/v2/me');
expect(res.status).toBe(401);
expect(res.body.error.code).toBe('UNAUTHENTICATED');
});
test('my registrations with totals and what is owing', async () => {
signedIn = { id: 'u1', role: 'user' };
mockDb.registration.findMany.mockResolvedValue([{
id: 'r1', status: 'partial_paid', createdAt: new Date('2026-10-01T10:00:00Z'), discountTotal: 0,
event: { id: 'e1', title: 'Youth Camp', startDate: new Date('2026-12-04T16:00:00Z'), endDate: new Date('2026-12-06T12:00:00Z') },
registrationOptions: [{ quantity: 2, priceSnapshot: 600, eventOption: { name: 'Camper', price: 600, earlyBirdTiers: [] }, variant: null, tranches: [] }],
payments: [{ amount: 500, createdAt: new Date() }],
}]);
mockDb.registration.count.mockResolvedValue(1);
const res = await request(app).get('/api/v2/me/registrations');
expect(res.status).toBe(200);
expect(res.body.data[0]).toMatchObject({ id: 'r1', totalDue: 1200, amountPaid: 500, balance: 700, items: [{ ticket: 'Camper', variant: null, quantity: 2, unitPrice: 600 }] });
expect(mockDb.registration.findMany.mock.calls[0][0].where).toMatchObject({ userId: 'u1', status: { not: 'cancelled' } });
});
});
describe('the API description', () => {
test('openapi.json is for admins', async () => {
signedIn = { id: 'u1', role: 'user' };
expect((await request(app).get('/api/v2/openapi.json')).body.error.code).toBe('FORBIDDEN');
signedIn = { id: 'a1', role: 'admin' };
const res = await request(app).get('/api/v2/openapi.json');
expect(res.status).toBe(200);
expect(res.body.openapi).toBe('3.1.0');
});
test('every route is described, with its parameters, auth and response', () => {
const doc = buildOpenApi({ version: 'test' });
for (const r of routes) {
const op = (doc.paths as Record<string, Record<string, Record<string, unknown>>>)[r.path.replace(/:(\w+)/g, '{$1}')][r.method];
expect(op).toBeDefined();
expect(op.responses).toHaveProperty(String(r.status ?? 200));
}
const list = doc.paths['/events'].get as { parameters: { name: string; in: string }[]; security?: unknown };
expect(list.parameters.map(p => p.name)).toEqual(['page', 'limit', 'q', 'campus', 'series']);
expect(list.security).toBeUndefined();
expect((doc.paths['/me'].get as { security: unknown }).security).toEqual([{ bearerAuth: [] }]);
expect((doc.paths['/events/{id}'].get as { parameters: { name: string; in: string; required: boolean }[] }).parameters[0]).toMatchObject({ name: 'id', in: 'path', required: true });
});
test('an unknown v2 path is a v2 NOT_FOUND', async () => {
const res = await request(app).get('/api/v2/nothing-here');
expect(res.status).toBe(404);
expect(res.body.error.code).toBe('NOT_FOUND');
});
});