The build still bakes the current packages and the active banner into the HTML. After hydration the page asks /api/v1/offerings and /api/v1/offerings/banner once and replaces what differs; errors and time-outs keep what was baked, and a 204 from the banner route hides the banner. The banner is now the OfferingBanner contract (title, text, optional link) instead of layout=banner. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
1038 lines
41 KiB
TypeScript
1038 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);
|
|
// 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');
|
|
});
|
|
});
|