Files
AndreaSlopFotografie/web/config/previewServer.test.ts
SluijsensandClaude Sonnet 5.5 ad0b114828 Hero from the CMS: markers HERO-HTML and HERO-PRELOAD, hero key in the data block, picture per ratio, baked fallback
The prerendered hero is plain HTML between the markers (first photo, h1, buttons), the slider takes over after hydration with the hero of the host block, the API or the build. The head preload is added to the finished HTML. Hero texts move into nl.json. The stand-in host and the e2e tests cover the hero.

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

1039 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);
// Live pakketten: geen gegevens, zonder 404
expect((await ask(port, '/api/v1/offerings')).status).toBe(204);
expect((await ask(port, '/api/v1/offerings/banner')).status).toBe(204);
expect((await ask(port, '/api/v1/hero')).status).toBe(204);
// 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');
});
});