The baseline ran on vite preview, which compresses, so measurements could not be compared without this. Also records that the real servers need compression. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
671 lines
25 KiB
TypeScript
671 lines
25 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 { securityHeaders } from './securityHeaders';
|
|
import {
|
|
acceptsGzip,
|
|
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');
|
|
});
|
|
});
|
|
|
|
// 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, '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): 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('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.html',
|
|
]) {
|
|
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),
|
|
);
|
|
expect(gunzipSync(answer.raw).toString('utf8'), name).toBe(
|
|
name === 'over-mij.html'
|
|
? '<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('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');
|
|
});
|
|
});
|