Files
AndreaSlopFotografie/web/config/previewServer.test.ts
T
SluijsensandClaude Sonnet 5.5 7737104a77 Lets the CI preview server stand in for the contact API
With contactForm.enabled=true the e2e and Lighthouse runs asked a token route
that CI does not have (404, console error, run 666). The preview server gets an
opt-in --contact-stub (token 200 without captcha, submit 202); the e2e server
helper and the Lighthouse start command switch it on. Tests that need another
answer still replace it per page with page.route.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 19:39:03 +01:00

1035 lines
41 KiB
TypeScript

import { spawn } from 'node:child_process';
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { request, type Server } from 'node:http';
import { createServer } from 'node:net';
import { tmpdir } from 'node:os';
import { dirname, join, posix, win32 } from 'node:path';
import { fileURLToPath } from 'node:url';
import { gunzipSync } from 'node:zlib';
import fc from 'fast-check';
import { afterEach, describe, expect, it } from 'vitest';
import {
anyRequestPath,
dottedFileName,
existingFiles,
existsIn,
pageName,
} from '../src/test/requestArbitraries';
import {
hostilePath,
knownPage,
pageVariant,
queryString,
unknownPath,
} from '../src/test/urlArbitraries';
import { canonicalRedirect, pagePaths } from './canonicalUrls';
import { pageFile } from './pageFiles';
import { securityHeaders } from './securityHeaders';
import {
acceptsGzip,
contentTypeOf,
resolveRequest,
startPreviewServer,
type ResolvedRequest,
} from './previewServer';
const NOT_FOUND = { file: '404.html', status: 404 };
const FILES = new Set([
'index.html',
'404.html',
'over-mij.html',
'soorten-fotoshoots.html',
'soorten-fotoshoots/newborn.html',
'assets/a.js',
'assets/app.js',
'favicon.png',
'robots.txt',
'sitemap.xml',
]);
const resolveIn = (path: string, options?: { auditRoute?: boolean }) =>
resolveRequest(path, existsIn(FILES), options);
const PAGE_FILES = new Set(pagePaths.map(pageFile));
const redirectTo = (redirect: string): ResolvedRequest => ({
redirect,
status: 301,
});
// Volgt redirects tot een bestand of een 404 en telt de stappen
function follow(path: string, files: ReadonlySet<string> = FILES) {
let current = path;
for (let hops = 0; hops <= 5; hops++) {
const result = resolveRequest(current, existsIn(files));
if (!('redirect' in result)) return { result, hops };
current = result.redirect;
}
throw new Error(`geen einde aan de redirects vanaf ${path}`);
}
describe('resolveRequest', () => {
it('geeft index.html voor /', () => {
expect(resolveIn('/')).toEqual({ file: 'index.html', status: 200 });
});
it('geeft het paginabestand voor een pad zonder punt als dat bestaat', () => {
expect(resolveIn('/over-mij')).toEqual({
file: 'over-mij.html',
status: 200,
});
expect(resolveIn('/soorten-fotoshoots/newborn')).toEqual({
file: 'soorten-fotoshoots/newborn.html',
status: 200,
});
});
it('geeft 404.html met 404 voor een pad zonder bestaande pagina', () => {
expect(resolveIn('/nope')).toEqual(NOT_FOUND);
expect(resolveIn('/soorten-fotoshoots/nope')).toEqual(NOT_FOUND);
});
it('behandelt een laatste segment met een punt als bestandsverzoek', () => {
expect(resolveIn('/assets/app.js')).toEqual({
file: 'assets/app.js',
status: 200,
});
expect(resolveIn('/favicon.png')).toEqual({
file: 'favicon.png',
status: 200,
});
expect(resolveIn('/over-mij.html')).toEqual(redirectTo('/over-mij'));
expect(resolveIn('/assets/weg.js')).toEqual(NOT_FOUND);
});
it('zoekt geen paginabestand achter een bestandsverzoek', () => {
// /over-mij.x is een bestand, geen pagina
expect(resolveIn('/over-mij.x')).toEqual(NOT_FOUND);
});
it('decodeert één keer', () => {
expect(resolveIn('/over%2Dmij')).toEqual({
file: 'over-mij.html',
status: 200,
});
// Dubbel gecodeerd wordt na één keer een gewone (onbekende) naam
expect(resolveIn('/over%252Dmij')).toEqual(NOT_FOUND);
});
it('weigert een pad dat niet decodeert', () => {
expect(resolveIn('/%')).toEqual(NOT_FOUND);
expect(resolveIn('/%zz')).toEqual(NOT_FOUND);
expect(resolveIn('/%c0%af')).toEqual(NOT_FOUND);
});
it('weigert NUL en backslash, ook gecodeerd', () => {
expect(resolveIn('/over-mij%00')).toEqual(NOT_FOUND);
expect(resolveIn('/over-mij\0.html')).toEqual(NOT_FOUND);
expect(resolveIn('/assets\\app.js')).toEqual(NOT_FOUND);
expect(resolveIn('/assets%5Capp.js')).toEqual(NOT_FOUND);
});
it('weigert .. in elke codering', () => {
for (const path of [
'/../index.html',
'/assets/../index.html',
'/%2e%2e/index.html',
'/%2E%2E/index.html',
'/assets/%2e%2e/index.html',
'/..%2findex.html',
'/assets%2f..%2findex.html',
'/..',
'/assets/..',
]) {
expect(resolveIn(path), path).toEqual(NOT_FOUND);
}
});
it('weigert . en segmenten van alleen punten en spaties', () => {
for (const path of [
'/./index.html',
'/assets/./app.js',
'/...',
'/.. ',
]) {
expect(resolveIn(path), path).toEqual(NOT_FOUND);
}
});
it('weigert een pad zonder voorste slash en een Windows-stationsletter', () => {
expect(resolveIn('')).toEqual(NOT_FOUND);
expect(resolveIn('index.html')).toEqual(NOT_FOUND);
expect(resolveRequest('/c:/windows/x.ini', () => true)).toEqual(
NOT_FOUND,
);
});
it('geeft 404 voor een dubbele slash', () => {
expect(resolveIn('//over-mij')).toEqual(NOT_FOUND);
expect(resolveIn('/assets//app.js')).toEqual(NOT_FOUND);
expect(resolveIn('/over-mij//x')).toEqual(NOT_FOUND);
});
it('geeft 404 voor een doel dat met // of /\\ zou beginnen (BR-HST-06)', () => {
for (const path of [
'//evil.example/',
'//evil.example//',
'/%5Cevil.example/',
'/\\evil.example/',
'/a//b/',
'/over-mij\r\nx/',
]) {
expect(resolveIn(path), path).toEqual(NOT_FOUND);
}
});
describe('regels uit BR-HST-03 tot 05', () => {
it('stuurt een slash aan het eind met één 301 naar het pad zonder', () => {
expect(resolveIn('/over-mij/')).toEqual(redirectTo('/over-mij'));
expect(resolveIn('/over-mij///')).toEqual(redirectTo('/over-mij'));
expect(resolveIn('/soorten-fotoshoots/')).toEqual(
redirectTo('/soorten-fotoshoots'),
);
expect(resolveIn('/onbekend/')).toEqual(redirectTo('/onbekend'));
expect(resolveIn('/assets/')).toEqual(redirectTo('/assets'));
});
it('codeert een doel dat niet uit de paginalijst komt opnieuw', () => {
expect(resolveIn('/een%20pad/')).toEqual(redirectTo('/een%20pad'));
expect(resolveIn('/a%3Fb/')).toEqual(redirectTo('/a%3Fb'));
expect(resolveIn('/caf%C3%A9/')).toEqual(redirectTo('/caf%C3%A9'));
});
it('geeft /404 en /404.html status 404, ook als 404.html bestaat', () => {
expect(resolveIn('/404')).toEqual(NOT_FOUND);
expect(resolveIn('/404.html')).toEqual(NOT_FOUND);
expect(resolveRequest('/404.html', () => false)).toEqual(NOT_FOUND);
});
it('stuurt /index en /index.html met een 301 naar /', () => {
expect(resolveIn('/index')).toEqual(redirectTo('/'));
expect(resolveIn('/index.html')).toEqual(redirectTo('/'));
expect(resolveIn('/index/')).toEqual(redirectTo('/'));
});
it('stuurt hoofdletters en .html van een bekende pagina naar het kanonieke pad', () => {
expect(resolveIn('/over-mij.html')).toEqual(
redirectTo('/over-mij'),
);
expect(resolveIn('/Over-Mij')).toEqual(redirectTo('/over-mij'));
expect(resolveIn('/OVER-MIJ.HTML')).toEqual(
redirectTo('/over-mij'),
);
expect(resolveIn('/Over-Mij/')).toEqual(redirectTo('/over-mij'));
expect(resolveIn('/soorten-fotoshoots/newborn.html')).toEqual(
redirectTo('/soorten-fotoshoots/newborn'),
);
});
it('stuurt een onbekend pad niet door op hoofdletters', () => {
expect(resolveIn('/Onbekend')).toEqual(NOT_FOUND);
expect(resolveIn('/x.html')).toEqual(NOT_FOUND);
});
it('laat / en de kanonieke paden zonder redirect', () => {
for (const path of ['/', '/over-mij', '/soorten-fotoshoots']) {
expect(resolveIn(path)).not.toHaveProperty('redirect');
}
});
it('stuurt een map naast een paginabestand nooit door of toont haar (BR-HST-07)', () => {
// soorten-fotoshoots.html staat naast de map soorten-fotoshoots/
expect(resolveIn('/soorten-fotoshoots')).toEqual({
file: 'soorten-fotoshoots.html',
status: 200,
});
expect(resolveIn('/assets')).toEqual(NOT_FOUND);
});
});
describe('tabel uit BR-HST (resultaten per verzoek)', () => {
const ok = (file: string): ResolvedRequest => ({ file, status: 200 });
const notFound = NOT_FOUND as ResolvedRequest;
const rows: [string, ResolvedRequest][] = [
['/', ok('index.html')],
['/over-mij', ok('over-mij.html')],
['/soorten-fotoshoots', ok('soorten-fotoshoots.html')],
[
'/soorten-fotoshoots/newborn',
ok('soorten-fotoshoots/newborn.html'),
],
['/over-mij/', redirectTo('/over-mij')],
['/over-mij///', redirectTo('/over-mij')],
['/soorten-fotoshoots/', redirectTo('/soorten-fotoshoots')],
['/over-mij.html', redirectTo('/over-mij')],
[
'/soorten-fotoshoots/newborn.html',
redirectTo('/soorten-fotoshoots/newborn'),
],
['/index', redirectTo('/')],
['/index.html', redirectTo('/')],
['/index/', redirectTo('/')],
['/Over-Mij', redirectTo('/over-mij')],
['/OVER-MIJ.HTML', redirectTo('/over-mij')],
['/Over-Mij/', redirectTo('/over-mij')],
['/404', notFound],
['/404.html', notFound],
['/onbekend', notFound],
['/Onbekend', notFound],
['/x.html', notFound],
['/assets/missing.js', notFound],
['/onbekend/', redirectTo('/onbekend')],
['/assets', notFound],
['/assets/', redirectTo('/assets')],
['/assets/a.js', ok('assets/a.js')],
['/robots.txt', ok('robots.txt')],
['/sitemap.xml', ok('sitemap.xml')],
['/favicon.png', ok('favicon.png')],
];
it.each(rows)('%s', (path, expected) => {
expect(resolveIn(path)).toEqual(expected);
});
});
describe('opt-in route /__audit/404 (BR-HST-22)', () => {
it('geeft zonder de optie 404 en met de optie 200 voor de 404-pagina', () => {
expect(resolveIn('/__audit/404')).toEqual(NOT_FOUND);
expect(resolveIn('/__audit/404', { auditRoute: false })).toEqual(
NOT_FOUND,
);
expect(resolveIn('/__audit/404', { auditRoute: true })).toEqual({
file: '404.html',
status: 200,
});
});
it('laat /404.html en /404 een echte 404 met de optie aan', () => {
for (const path of ['/404', '/404.html']) {
expect(resolveIn(path, { auditRoute: true }), path).toEqual(
NOT_FOUND,
);
}
});
});
it('geeft index.html voor / ook als de bestandslijst leeg is', () => {
expect(resolveRequest('/', () => false)).toEqual({
file: 'index.html',
status: 200,
});
});
});
describe('resolveRequest (eigenschappen)', () => {
it('blijft binnen clientDir, voor elk pad (invariant, P16)', () => {
fc.assert(
fc.property(
anyRequestPath,
existingFiles,
fc.boolean(),
(path, files, everythingExists) => {
const result = resolveRequest(
path,
everythingExists ? () => true : existsIn(files),
);
if ('redirect' in result) return;
const { file, status } = result;
expect(file.split('/')).not.toContain('..');
expect(file.startsWith('/')).toBe(false);
expect(posix.isAbsolute(file)).toBe(false);
expect(win32.isAbsolute(file)).toBe(false);
expect(file).not.toContain('\\');
expect(file).not.toContain('\0');
// 404 hoort alleen bij de 404-pagina
if (status === 404) expect(file).toBe('404.html');
},
),
);
});
it('kent / en /x en /bestand.ext zoals het model (oracle, P17)', () => {
fc.assert(
fc.property(
existingFiles,
pageName,
fc.array(pageName, { maxLength: 2 }),
dottedFileName,
(files, name, dirs, dotted) => {
const exists = existsIn(files);
// Het model: wat bestaat is 200, de rest 404. /404 en
// /404.html zijn 404 ook al bestaat 404.html, en een
// afwijkende vorm van een bekende pagina krijgt een 301.
const expected = (path: string, file: string) => {
const canonical = canonicalRedirect(path);
if (canonical !== undefined) {
return { redirect: canonical, status: 301 };
}
return files.has(file) && file !== '404.html'
? { file, status: 200 }
: NOT_FOUND;
};
expect(resolveRequest('/', exists)).toEqual({
file: 'index.html',
status: 200,
});
const page = [...dirs, name].join('/');
expect(resolveRequest(`/${page}`, exists)).toEqual(
expected(`/${page}`, `${page}.html`),
);
const asset = [...dirs, dotted].join('/');
expect(resolveRequest(`/${asset}`, exists)).toEqual(
expected(`/${asset}`, asset),
);
// Een bestand dat echt bestaat wordt gevonden, behalve
// 404.html en de paginabestanden die naar hun pad gaan
for (const file of files) {
expect(resolveRequest(`/${file}`, exists)).toEqual(
expected(`/${file}`, file),
);
}
},
),
);
});
it('is totaal en veilig voor vijandige paden en paginavarianten (invariant, P-HST-01)', () => {
fc.assert(
fc.property(
fc.oneof(hostilePath, pageVariant, unknownPath, anyRequestPath),
fc.boolean(),
fc.boolean(),
(path, auditRoute, everythingExists) => {
const result = resolveRequest(
path,
everythingExists ? () => true : existsIn(FILES),
{ auditRoute },
);
expect([200, 301, 404]).toContain(result.status);
if ('redirect' in result) {
expect(result.redirect.startsWith('/')).toBe(true);
expect(result.redirect.startsWith('//')).toBe(false);
expect(result.redirect.startsWith('/\\')).toBe(false);
expect(result.redirect).not.toMatch(
// eslint-disable-next-line no-control-regex
/[\u0000-\u001f\u007f\\]/,
);
} else {
expect(result.file.split('/')).not.toContain('..');
expect(result.file.startsWith('/')).toBe(false);
expect(win32.isAbsolute(result.file)).toBe(false);
expect(posix.isAbsolute(result.file)).toBe(false);
}
},
),
);
});
it('is totaal en veilig voor een vijandig pad, bijvoorbeeld // en /\\ (voorbeeld, P-HST-01)', () => {
for (const path of ['//evil.example/', '/%5Cevil.example/', '//']) {
const result = resolveIn(path);
if ('redirect' in result) {
expect(result.redirect.startsWith('//')).toBe(false);
}
}
expect(resolveIn('/%5Cevil.example/')).toEqual(NOT_FOUND);
});
it('brengt elke variant van een bekende pagina in hoogstens 2 stappen bij de pagina (idempotent, P-HST-02, 03)', () => {
fc.assert(
fc.property(pageVariant, (path) => {
const { result, hops } = follow(path, PAGE_FILES);
expect(hops).toBeLessThanOrEqual(2);
const canonical = canonicalRedirect(path);
const target = canonical ?? path;
const page = target === '/' ? 'index' : target.slice(1);
expect(result).toEqual({ file: `${page}.html`, status: 200 });
// Het kanonieke pad is een dekpunt: geen redirect meer
expect(
resolveRequest(target, existsIn(PAGE_FILES)),
).not.toHaveProperty('redirect');
}),
);
});
it('stuurt elke bekende pagina via een variant naar zichzelf (voorbeeld, P-HST-02)', () => {
expect(follow('/Soorten-Fotoshoots/Newborn.html//')).toEqual({
result: {
file: 'soorten-fotoshoots/newborn.html',
status: 200,
},
hops: 1,
});
});
it('geeft 404 voor onbekende paden, 404 voor /404 en /404.html, en nooit een redirect voor / (invariant, P-HST-06)', () => {
fc.assert(
fc.property(unknownPath, knownPage, (path, page) => {
expect(resolveIn(path)).toEqual(NOT_FOUND);
expect(resolveIn('/404')).toEqual(NOT_FOUND);
expect(resolveIn('/404.html')).toEqual(NOT_FOUND);
expect(resolveIn('/')).toEqual({
file: 'index.html',
status: 200,
});
expect(resolveIn(page)).not.toHaveProperty('redirect');
}),
);
});
});
describe('contentTypeOf', () => {
it('kiest het type op de extensie, hoofdletterongevoelig', () => {
expect(contentTypeOf('a.html')).toBe('text/html; charset=utf-8');
expect(contentTypeOf('a.JS')).toBe('text/javascript; charset=utf-8');
expect(contentTypeOf('a.woff2')).toBe('font/woff2');
expect(contentTypeOf('a.png')).toBe('image/png');
expect(contentTypeOf('a.onbekend')).toBe('application/octet-stream');
expect(contentTypeOf('geen-extensie')).toBe('application/octet-stream');
});
});
// Groot genoeg voor meerdere stukken in de stroom, en ook niet-ASCII
const GROOT_SCRIPT = 'const tekst = "héllo wörld ✓";\n'.repeat(5000);
// Geen geldige UTF-8: de bytes moeten ongewijzigd aankomen
const BINARY = Buffer.from(Array.from({ length: 2000 }, (_, i) => i % 256));
const GZIP = { 'Accept-Encoding': 'gzip, deflate, br' };
interface Answer {
status: number;
headers: Record<string, string | string[] | undefined>;
body: string;
// De ontvangen bytes, voor gzip en binaire bestanden
raw: Buffer;
}
// node:http in plaats van fetch: die laat het pad ongemoeid, ook '..'
const ask = (
port: number,
path: string,
method = 'GET',
headers: Record<string, string> = {},
): Promise<Answer> =>
new Promise((resolve, reject) => {
const req = request(
{ host: '127.0.0.1', port, path, method, headers },
(response) => {
const chunks: Buffer[] = [];
response.on('data', (chunk: Buffer) => chunks.push(chunk));
response.on('end', () => {
const raw = Buffer.concat(chunks);
resolve({
status: response.statusCode ?? 0,
headers: response.headers,
body: raw.toString('utf8'),
raw,
});
});
},
);
req.on('error', reject);
req.end();
});
const tempDirs: string[] = [];
const servers: Server[] = [];
afterEach(async () => {
await Promise.all(
servers
.splice(0)
.map((server) => new Promise((done) => server.close(done))),
);
for (const dir of tempDirs.splice(0)) {
rmSync(dir, { recursive: true, force: true });
}
});
function siteDir(): string {
const root = mkdtempSync(join(tmpdir(), 'preview-'));
tempDirs.push(root);
const clientDir = join(root, 'dist', 'client');
mkdirSync(join(clientDir, 'assets'), { recursive: true });
writeFileSync(join(clientDir, 'index.html'), '<p>home</p>');
writeFileSync(join(clientDir, 'over-mij.html'), '<p>over mij</p>');
writeFileSync(join(clientDir, '404.html'), '<p>niet gevonden</p>');
writeFileSync(join(clientDir, 'soorten-fotoshoots.html'), '<p>soorten</p>');
mkdirSync(join(clientDir, 'soorten-fotoshoots'));
writeFileSync(
join(clientDir, 'soorten-fotoshoots', 'newborn.html'),
'<p>newborn</p>',
);
writeFileSync(join(clientDir, 'assets', 'app.js'), 'boot()');
writeFileSync(join(clientDir, 'assets', 'groot.js'), GROOT_SCRIPT);
writeFileSync(join(clientDir, 'logo.png'), BINARY);
writeFileSync(join(clientDir, 'font.woff2'), BINARY);
// Buiten clientDir: mag nooit bereikbaar zijn
writeFileSync(join(root, 'dist', 'geheim.txt'), 'geheim');
return clientDir;
}
async function serve(
clientDir: string,
options?: { auditRoute?: boolean; contactStub?: boolean },
): Promise<number> {
const server = await startPreviewServer(clientDir, 0, options);
servers.push(server);
const address = server.address();
if (typeof address !== 'object' || !address) throw new Error('geen poort');
return address.port;
}
describe('startPreviewServer', () => {
it('stuurt een pagina met 200, het type en no-cache', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/over-mij');
expect(answer.status).toBe(200);
expect(answer.body).toBe('<p>over mij</p>');
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
expect(answer.headers['cache-control']).toBe('no-cache');
});
it('stuurt een asset met het type van de extensie, zonder no-cache', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/assets/app.js?v=1#x');
expect(answer.status).toBe(200);
expect(answer.body).toBe('boot()');
expect(answer.headers['content-type']).toBe(
'text/javascript; charset=utf-8',
);
expect(answer.headers['cache-control']).toBeUndefined();
});
it('zet de securityheaders op 200 en op 404', async () => {
const port = await serve(siteDir());
const expected = securityHeaders('production');
for (const path of ['/', '/nope']) {
const { headers } = await ask(port, path);
for (const [name, value] of Object.entries(expected)) {
expect(headers[name.toLowerCase()], `${path} ${name}`).toBe(
value,
);
}
}
});
it('antwoordt op een onbekend pad met de 404-pagina en status 404', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/nope');
expect(answer.status).toBe(404);
expect(answer.body).toBe('<p>niet gevonden</p>');
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
});
it('antwoordt op /404 en /404.html met de 404-pagina en status 404', async () => {
const port = await serve(siteDir());
const expected = securityHeaders('production');
for (const path of ['/404', '/404.html']) {
const answer = await ask(port, path);
expect(answer.status, path).toBe(404);
expect(answer.body, path).toBe('<p>niet gevonden</p>');
expect(answer.headers['content-type'], path).toBe(
'text/html; charset=utf-8',
);
for (const [name, value] of Object.entries(expected)) {
expect(answer.headers[name.toLowerCase()], path).toBe(value);
}
}
expect((await ask(port, '/404.html', 'HEAD')).status).toBe(404);
});
it('heeft /__audit/404 alleen met de optie (BR-HST-22)', async () => {
const without = await serve(siteDir());
expect((await ask(without, '/__audit/404')).status).toBe(404);
const port = await serve(siteDir(), { auditRoute: true });
const audit = await ask(port, '/__audit/404');
expect(audit.status).toBe(200);
expect(audit.body).toBe('<p>niet gevonden</p>');
expect(audit.headers['content-type']).toBe('text/html; charset=utf-8');
expect((await ask(port, '/404.html')).status).toBe(404);
expect((await ask(port, '/404')).status).toBe(404);
expect((await ask(port, '/andere')).status).toBe(404);
});
it('bootst de contact-API alleen na met de optie (--contact-stub)', async () => {
const without = await serve(siteDir());
expect(
(await ask(without, '/api/v1/contact-messages/token')).status,
).toBe(404);
const port = await serve(siteDir(), { contactStub: true });
const token = await ask(port, '/api/v1/contact-messages/token');
expect(token.status).toBe(200);
expect(token.headers['content-type']).toBe('application/json');
expect(JSON.parse(token.body)).toMatchObject({
captcha: null,
minSeconds: expect.any(Number),
});
expect(
(await ask(port, '/api/v1/contact-messages', 'POST')).status,
).toBe(202);
// Al het andere blijft zoals het was
expect((await ask(port, '/api/v1/andere')).status).toBe(404);
expect((await ask(port, '/api/v1/contact-messages')).status).toBe(404);
});
it('stuurt een 301 met een relatieve Location, de query en de securityheaders, zonder inhoud', async () => {
const port = await serve(siteDir());
const expected = securityHeaders('production');
for (const method of ['GET', 'HEAD']) {
const answer = await ask(port, '/Over-Mij/?x=1&y=%20', method);
expect(answer.status, method).toBe(301);
expect(answer.headers.location, method).toBe('/over-mij?x=1&y=%20');
expect(answer.headers['content-length'], method).toBe('0');
expect(answer.headers['cache-control'], method).toBeUndefined();
expect(answer.raw.length, method).toBe(0);
for (const [name, value] of Object.entries(expected)) {
expect(answer.headers[name.toLowerCase()], name).toBe(value);
}
}
const plain = await ask(port, '/onbekend/');
expect(plain.status).toBe(301);
expect(plain.headers.location).toBe('/onbekend');
});
it('houdt de query byte voor byte in de Location (invariant, P-HST-05)', async () => {
const port = await serve(siteDir());
await fc.assert(
fc.asyncProperty(pageVariant, queryString, async (path, query) => {
const canonical = canonicalRedirect(path);
fc.pre(canonical !== undefined);
const answer = await ask(port, `${path}?${query}`);
expect(answer.status).toBe(301);
expect(answer.headers.location).toBe(`${canonical}?${query}`);
}),
{ numRuns: 50 },
);
});
it('houdt de query in de Location, voorbeeld (P-HST-05)', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/soorten-fotoshoots/?shoot=newborn');
expect(answer.headers.location).toBe(
'/soorten-fotoshoots?shoot=newborn',
);
// Zonder query geen vraagteken
const bare = await ask(port, '/over-mij/');
expect(bare.headers.location).toBe('/over-mij');
});
it('serveert /soorten-fotoshoots als pagina naast zijn map, en /assets niet (V3)', async () => {
const port = await serve(siteDir());
const page = await ask(port, '/soorten-fotoshoots');
expect(page.status).toBe(200);
expect(page.body).toBe('<p>soorten</p>');
expect((await ask(port, '/soorten-fotoshoots/newborn')).body).toBe(
'<p>newborn</p>',
);
expect((await ask(port, '/assets')).status).toBe(404);
const slash = await ask(port, '/assets/');
expect(slash.status).toBe(301);
expect(slash.headers.location).toBe('/assets');
});
it('geeft /%5Cevil.example/ en //evil.example/ de 404-pagina, geen redirect', async () => {
const port = await serve(siteDir());
for (const path of ['/%5Cevil.example/', '//evil.example/']) {
const answer = await ask(port, path);
expect(answer.status, path).toBe(404);
expect(answer.headers.location, path).toBeUndefined();
expect(answer.body, path).toBe('<p>niet gevonden</p>');
}
});
it('geeft 405 op POST, PUT en DELETE, met securityheaders', async () => {
const port = await serve(siteDir());
for (const method of ['POST', 'PUT', 'DELETE']) {
const answer = await ask(port, '/', method);
expect(answer.status, method).toBe(405);
expect(answer.headers.allow).toBe('GET, HEAD');
expect(answer.headers['content-security-policy']).toBeDefined();
}
});
it('stuurt bij HEAD de headers en lengte maar geen inhoud', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/over-mij', 'HEAD');
expect(answer.status).toBe(200);
expect(answer.body).toBe('');
expect(answer.headers['content-length']).toBe(
String('<p>over mij</p>'.length),
);
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
expect((await ask(port, '/nope', 'HEAD')).status).toBe(404);
});
it('komt met geen enkele traversal buiten clientDir (misbruikgeval)', async () => {
const port = await serve(siteDir());
for (const path of [
'/../geheim.txt',
'/%2e%2e/geheim.txt',
'/..%2fgeheim.txt',
'/assets/../../geheim.txt',
'/..%5cgeheim.txt',
'/%2e%2e%5cgeheim.txt',
'/geheim.txt%00.html',
]) {
const answer = await ask(port, path);
expect(answer.status, path).toBe(404);
expect(answer.body, path).not.toContain('geheim');
}
});
it('geeft een gewone 404 als clientDir geen 404.html heeft', async () => {
const clientDir = siteDir();
rmSync(join(clientDir, '404.html'));
const port = await serve(clientDir);
const answer = await ask(port, '/nope');
expect(answer.status).toBe(404);
expect(answer.body).toBe('Not Found');
const head = await ask(port, '/nope', 'HEAD');
expect(head.status).toBe(404);
expect(head.body).toBe('');
});
it('weigert te starten op een bezette poort', async () => {
const port = await serve(siteDir());
await expect(startPreviewServer(siteDir(), port)).rejects.toThrow(
/EADDRINUSE/,
);
});
});
describe('acceptsGzip', () => {
it('leest Accept-Encoding met gewichten en sterretje', () => {
expect(acceptsGzip(undefined)).toBe(false);
expect(acceptsGzip('')).toBe(false);
expect(acceptsGzip('gzip')).toBe(true);
expect(acceptsGzip('GZIP, deflate')).toBe(true);
expect(acceptsGzip('br;q=1.0, gzip;q=0.5')).toBe(true);
expect(acceptsGzip('gzip;q=0')).toBe(false);
expect(acceptsGzip('gzip; q=0.0, *')).toBe(false);
expect(acceptsGzip('*')).toBe(true);
expect(acceptsGzip('*;q=0')).toBe(false);
expect(acceptsGzip('deflate, br')).toBe(false);
expect(acceptsGzip('identity')).toBe(false);
});
});
describe('startPreviewServer met compressie (BR-SRV-08)', () => {
it('comprimeert tekst als gzip wordt geaccepteerd en geeft dezelfde bytes terug', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/assets/groot.js', 'GET', GZIP);
expect(answer.status).toBe(200);
expect(answer.headers['content-encoding']).toBe('gzip');
expect(answer.headers['vary']).toBe('Accept-Encoding');
expect(answer.headers['content-type']).toBe(
'text/javascript; charset=utf-8',
);
// Een stroom: geen Content-Length, wel chunked
expect(answer.headers['content-length']).toBeUndefined();
expect(answer.headers['transfer-encoding']).toBe('chunked');
expect(answer.raw.length).toBeLessThan(GROOT_SCRIPT.length / 10);
expect(gunzipSync(answer.raw).toString('utf8')).toBe(GROOT_SCRIPT);
});
it('stuurt tekst ongecomprimeerd zonder gzip in Accept-Encoding', async () => {
const port = await serve(siteDir());
const variants: Record<string, string>[] = [
{},
{ 'Accept-Encoding': 'identity' },
{ 'Accept-Encoding': 'gzip;q=0' },
];
for (const headers of variants) {
const answer = await ask(port, '/assets/groot.js', 'GET', headers);
expect(answer.headers['content-encoding']).toBeUndefined();
expect(answer.headers['vary']).toBe('Accept-Encoding');
expect(answer.headers['content-length']).toBe(
String(Buffer.byteLength(GROOT_SCRIPT)),
);
expect(answer.body).toBe(GROOT_SCRIPT);
}
});
it('comprimeert elk teksttype, met het type van de extensie', async () => {
const clientDir = siteDir();
for (const name of ['a.svg', 'a.json', 'a.xml', 'a.txt', 'a.css']) {
writeFileSync(join(clientDir, name), `inhoud van ${name}`);
}
const port = await serve(clientDir);
for (const name of [
'a.svg',
'a.json',
'a.xml',
'a.txt',
'a.css',
'over-mij',
]) {
const answer = await ask(port, `/${name}`, 'GET', GZIP);
expect(answer.headers['content-encoding'], name).toBe('gzip');
expect(answer.headers['content-type'], name).toBe(
contentTypeOf(name === 'over-mij' ? 'over-mij.html' : name),
);
expect(gunzipSync(answer.raw).toString('utf8'), name).toBe(
name === 'over-mij' ? '<p>over mij</p>' : `inhoud van ${name}`,
);
}
});
it('laat afbeeldingen en lettertypen ongemoeid', async () => {
const port = await serve(siteDir());
for (const path of ['/logo.png', '/font.woff2']) {
const answer = await ask(port, path, 'GET', GZIP);
expect(answer.status, path).toBe(200);
expect(answer.headers['content-encoding'], path).toBeUndefined();
expect(answer.headers['vary'], path).toBeUndefined();
expect(answer.headers['content-length'], path).toBe(
String(BINARY.length),
);
expect(answer.raw.equals(BINARY), path).toBe(true);
}
});
it('comprimeert ook de 404-pagina, met status 404', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/nope', 'GET', GZIP);
expect(answer.status).toBe(404);
expect(answer.headers['content-encoding']).toBe('gzip');
expect(answer.headers['vary']).toBe('Accept-Encoding');
expect(gunzipSync(answer.raw).toString('utf8')).toBe(
'<p>niet gevonden</p>',
);
const plain = await ask(port, '/nope');
expect(plain.status).toBe(404);
expect(plain.headers['content-encoding']).toBeUndefined();
expect(plain.body).toBe('<p>niet gevonden</p>');
});
it('stuurt bij HEAD de gzip-headers maar geen inhoud', async () => {
const port = await serve(siteDir());
const answer = await ask(port, '/assets/groot.js', 'HEAD', GZIP);
expect(answer.status).toBe(200);
expect(answer.raw.length).toBe(0);
expect(answer.headers['content-encoding']).toBe('gzip');
expect(answer.headers['vary']).toBe('Accept-Encoding');
expect(answer.headers['content-length']).toBeUndefined();
});
it('houdt de securityheaders ook op gecomprimeerde antwoorden', async () => {
const port = await serve(siteDir());
const { headers } = await ask(port, '/over-mij', 'GET', GZIP);
for (const [name, value] of Object.entries(
securityHeaders('production'),
)) {
expect(headers[name.toLowerCase()], name).toBe(value);
}
});
});
describe('previewServer als opdrachtregel', () => {
const script = join(
dirname(fileURLToPath(import.meta.url)),
'previewServer.ts',
);
const children: ReturnType<typeof spawn>[] = [];
afterEach(() => {
for (const child of children.splice(0)) child.kill();
});
const start = (...args: string[]) => {
const child = spawn(process.execPath, [script, ...args], {
stdio: ['ignore', 'pipe', 'pipe'],
});
children.push(child);
let stdout = '';
let stderr = '';
child.stdout.on('data', (chunk) => (stdout += chunk));
child.stderr.on('data', (chunk) => (stderr += chunk));
const exited = new Promise<number | null>((done) =>
child.on('exit', done),
);
const ready = new Promise<string>((done) => {
const check = () => {
if (stdout.includes('Local')) done(stdout);
};
child.stdout.on('data', check);
exited.then(() => done(stdout));
});
return { ready, exited, stderr: () => stderr };
};
it('meldt een Local-regel met de url en bedient de map', async () => {
const clientDir = siteDir();
const run = start('--port', '0', '--strictPort', '--dir', clientDir);
const line = await run.ready;
const match = /Local:\s+http:\/\/127\.0\.0\.1:(\d+)\//.exec(line);
expect(match).not.toBeNull();
const answer = await ask(Number(match![1]), '/over-mij');
expect(answer.status).toBe(200);
});
it('opent /__audit/404 alleen met --audit-route', async () => {
const clientDir = siteDir();
const open = async (...extra: string[]) => {
const run = start(
'--port',
'0',
'--strictPort',
'--dir',
clientDir,
...extra,
);
const line = await run.ready;
return Number(/:(\d+)\//.exec(line)![1]);
};
expect((await ask(await open(), '/__audit/404')).status).toBe(404);
const audit = await ask(await open('--audit-route'), '/__audit/404');
expect(audit.status).toBe(200);
expect(audit.body).toBe('<p>niet gevonden</p>');
});
it('stopt met exitcode 1 op een bezette poort met --strictPort', async () => {
const blocker = createServer();
await new Promise<void>((done) =>
blocker.listen(0, '127.0.0.1', () => done()),
);
try {
const taken = (blocker.address() as { port: number }).port;
const run = start(
`--port=${taken}`,
'--strictPort',
'--dir',
siteDir(),
);
expect(await run.exited).toBe(1);
expect(run.stderr()).toContain(String(taken));
} finally {
await new Promise((done) => blocker.close(done));
}
});
it('schuift naar een volgende poort zonder --strictPort', async () => {
const blocker = createServer();
await new Promise<void>((done) =>
blocker.listen(0, '127.0.0.1', () => done()),
);
try {
const taken = (blocker.address() as { port: number }).port;
const run = start('--port', String(taken), '--dir', siteDir());
const line = await run.ready;
const port = Number(/:(\d+)\//.exec(line)![1]);
expect(port).toBeGreaterThan(taken);
} finally {
await new Promise((done) => blocker.close(done));
}
});
it('stopt met exitcode 1 bij een ongeldige poort', async () => {
const run = start('--port', 'abc');
expect(await run.exited).toBe(1);
expect(run.stderr()).toContain('Ongeldige poort');
});
});