Lighthouse and the browser tests need a real 404 status, the .html mapping and the production headers, which vite preview does not give. It is not wired into the scripts yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
523 lines
19 KiB
TypeScript
523 lines
19 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 fc from 'fast-check';
|
|
import { afterEach, describe, expect, it } from 'vitest';
|
|
import {
|
|
anyRequestPath,
|
|
dottedFileName,
|
|
existingFiles,
|
|
existsIn,
|
|
pageName,
|
|
} from '../src/test/requestArbitraries';
|
|
import { securityHeaders } from './securityHeaders';
|
|
import {
|
|
contentTypeOf,
|
|
resolveRequest,
|
|
startPreviewServer,
|
|
} 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/app.js',
|
|
'favicon.png',
|
|
]);
|
|
const resolveIn = (path: string) => resolveRequest(path, existsIn(FILES));
|
|
|
|
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({
|
|
file: 'over-mij.html',
|
|
status: 200,
|
|
});
|
|
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);
|
|
const drive = resolveRequest('/c:/windows/x.ini', () => true);
|
|
expect(win32.isAbsolute(drive.file)).toBe(false);
|
|
expect(drive).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);
|
|
});
|
|
|
|
describe('tussenregels uit BR-SRV-07', () => {
|
|
it('geeft 404 voor een slash aan het eind, zonder redirect', () => {
|
|
expect(resolveIn('/over-mij/')).toEqual(NOT_FOUND);
|
|
expect(resolveIn('/soorten-fotoshoots/')).toEqual(NOT_FOUND);
|
|
expect(resolveIn('/assets/')).toEqual(NOT_FOUND);
|
|
});
|
|
|
|
it('antwoordt op /404 met 404.html en status 404, niet 200', () => {
|
|
expect(resolveIn('/404')).toEqual(NOT_FOUND);
|
|
});
|
|
|
|
it('serveert /404.html als bestand met 200 (BR-SRV-04)', () => {
|
|
// Lighthouse weigert een 404-status en valt hierop terug
|
|
expect(resolveIn('/404.html')).toEqual({
|
|
file: '404.html',
|
|
status: 200,
|
|
});
|
|
expect(resolveRequest('/404.html', () => false)).toEqual(NOT_FOUND);
|
|
});
|
|
|
|
it('geeft /index en /index.html het bestand van /', () => {
|
|
expect(resolveIn('/index')).toEqual({
|
|
file: 'index.html',
|
|
status: 200,
|
|
});
|
|
expect(resolveIn('/index.html')).toEqual({
|
|
file: 'index.html',
|
|
status: 200,
|
|
});
|
|
});
|
|
|
|
it('geeft nooit een redirect terug', () => {
|
|
for (const path of ['/over-mij/', '/404', '/index', '/']) {
|
|
expect(resolveIn(path)).not.toHaveProperty('redirect');
|
|
}
|
|
});
|
|
});
|
|
|
|
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 { file, status } = resolveRequest(
|
|
path,
|
|
everythingExists ? () => true : existsIn(files),
|
|
);
|
|
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. Alleen het
|
|
// pagina-pad /404 is 404 ook al bestaat 404.html; het
|
|
// bestandsverzoek /404.html is 200.
|
|
const expected = (file: string, isPage = false) =>
|
|
files.has(file) && !(isPage && 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}.html`, true),
|
|
);
|
|
|
|
const asset = [...dirs, dotted].join('/');
|
|
expect(resolveRequest(`/${asset}`, exists)).toEqual(
|
|
expected(asset),
|
|
);
|
|
// Een bestand dat echt bestaat wordt altijd gevonden
|
|
for (const file of files) {
|
|
expect(resolveRequest(`/${file}`, exists)).toEqual({
|
|
file,
|
|
status: 200,
|
|
});
|
|
}
|
|
},
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
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');
|
|
});
|
|
});
|
|
|
|
interface Answer {
|
|
status: number;
|
|
headers: Record<string, string | string[] | undefined>;
|
|
body: string;
|
|
}
|
|
|
|
// node:http in plaats van fetch: die laat het pad ongemoeid, ook '..'
|
|
const ask = (port: number, path: string, method = 'GET'): Promise<Answer> =>
|
|
new Promise((resolve, reject) => {
|
|
const req = request(
|
|
{ host: '127.0.0.1', port, path, method },
|
|
(response) => {
|
|
const chunks: Buffer[] = [];
|
|
response.on('data', (chunk: Buffer) => chunks.push(chunk));
|
|
response.on('end', () =>
|
|
resolve({
|
|
status: response.statusCode ?? 0,
|
|
headers: response.headers,
|
|
body: Buffer.concat(chunks).toString('utf8'),
|
|
}),
|
|
);
|
|
},
|
|
);
|
|
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, 'assets', 'app.js'), 'boot()');
|
|
// Buiten clientDir: mag nooit bereikbaar zijn
|
|
writeFileSync(join(root, 'dist', 'geheim.txt'), 'geheim');
|
|
return clientDir;
|
|
}
|
|
|
|
async function serve(clientDir: string): Promise<number> {
|
|
const server = await startPreviewServer(clientDir, 0);
|
|
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 met status 404', async () => {
|
|
const port = await serve(siteDir());
|
|
expect((await ask(port, '/404')).status).toBe(404);
|
|
const file = await ask(port, '/404.html');
|
|
expect(file.status).toBe(200);
|
|
expect(file.body).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('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('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');
|
|
});
|
|
});
|