Adds the URL rules to the preview server, IIS config and deploy

The preview server and web.config now follow the same URLs as nginx, without
the SPA fallback. Lighthouse exceptions need a recorded reason and the 404 page
is audited through an opt-in route. The deploy checks the build first and the
served result afterwards. The IIS rules stay unverified until a host exists.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-01 18:13:21 +01:00
co-authored by Claude Opus 5.5
parent 716692825e
commit e4e7f8c82c
17 changed files with 1919 additions and 220 deletions
+533
View File
@@ -0,0 +1,533 @@
import { execFile, spawnSync } from 'node:child_process';
import { existsSync } from 'node:fs';
import {
mkdir,
mkdtemp,
readdir,
readFile,
rm,
writeFile,
} from 'node:fs/promises';
import {
createServer,
type IncomingMessage,
type Server,
type ServerResponse,
} from 'node:http';
import type { AddressInfo } from 'node:net';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { gzipSync } from 'node:zlib';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { startPreviewServer } from '../config/previewServer.ts';
import { securityHeaders } from '../config/securityHeaders.ts';
import { createFixtureSite, type FixtureSite } from './support/fixtureSite.ts';
// De deploy-scripts uit web/deploy: de artefactcontrole, de controle na een
// deploy en de upload naar productie (BR-HST-14, 15, 18). Alles draait tegen
// een fixture-site, een stub of een lokaal doel; er gaat niets het netwerk op.
const inCi = Boolean(process.env.CI);
const deployDir = resolve('deploy').replaceAll('\\', '/');
// Op Windows is `bash` in het PATH soms de WSL-launcher in System32; die
// start een distributie. Daarom Git Bash zoeken, naast git.exe of in het PATH.
function findBash(): string | undefined {
if (process.platform !== 'win32') {
return spawnSync('bash', ['-c', 'true']).status === 0
? 'bash'
: undefined;
}
const candidates = (process.env.PATH ?? '')
.split(';')
.filter(Boolean)
.flatMap((dir) => [
join(dir, 'bash.exe'),
join(dir, '..', 'bin', 'bash.exe'),
join(dir, '..', 'usr', 'bin', 'bash.exe'),
])
.filter((candidate) => !/system32/i.test(candidate));
return candidates.find(
(candidate) =>
existsSync(candidate) &&
spawnSync(candidate, ['-c', 'true']).status === 0,
);
}
const hasCommand = (name: string) =>
spawnSync(name, ['--version'], { stdio: 'ignore' }).status === 0;
const bashBin = findBash();
const toolsMissing = !bashBin || !hasCommand('curl');
// Zonder bash of curl: in CI een duidelijke fout, lokaal een zichtbare melding
if (toolsMissing) {
describe('deploy-scripts', () => {
it('bash of curl niet gevonden: deploy-scripttests overgeslagen', (context) => {
if (inCi) throw new Error('bash of curl ontbreekt in CI');
console.log(context.task.name);
context.skip();
});
});
}
interface Run {
code: number;
stdout: string;
stderr: string;
}
function runScript(
script: string,
args: string[],
env: Record<string, string> = {},
): Promise<Run> {
return new Promise((done) => {
execFile(
bashBin ?? 'bash',
[`${deployDir}/${script}`, ...args],
{ env: { ...process.env, ...env }, maxBuffer: 16 * 1024 * 1024 },
(error, stdout, stderr) =>
done({
code: error ? Number(error.code ?? 1) : 0,
stdout,
stderr,
}),
);
});
}
const slash = (path: string) => path.replaceAll('\\', '/');
const temporaryDirs: string[] = [];
async function makeTemp(prefix: string): Promise<string> {
const dir = await mkdtemp(join(tmpdir(), prefix));
temporaryDirs.push(dir);
return dir;
}
afterAll(async () => {
await Promise.all(
temporaryDirs.map((dir) => rm(dir, { recursive: true, force: true })),
);
});
async function tree(dir: string, base = dir): Promise<string[]> {
const result: string[] = [];
for (const entry of await readdir(dir, { withFileTypes: true })) {
const full = join(dir, entry.name);
if (entry.isDirectory()) result.push(...(await tree(full, base)));
else result.push(slash(full.slice(base.length + 1)));
}
return result.sort();
}
async function write(dir: string, file: string, content = file) {
const target = join(dir, file);
await mkdir(dirname(target), { recursive: true });
await writeFile(target, content);
}
// Een minimale, geldige dist voor de artefactcontrole en de upload
const validFiles = [
'index.html',
'404.html',
'over-mij.html',
'soorten-fotoshoots/newborn.html',
'assets/a.js',
'robots.txt',
];
async function makeDist(): Promise<string> {
const dir = await makeTemp('andreaslop-dist-');
for (const file of validFiles) await write(dir, file);
return dir;
}
describe.skipIf(toolsMissing)('check-artifact.sh', () => {
it('laat een geldige build door en meldt wat het vond', async () => {
const dist = await makeDist();
const run = await runScript('check-artifact.sh', [slash(dist)]);
expect(run.code).toBe(0);
expect(run.stdout).toContain('index.html');
expect(run.stdout).toContain('404.html');
expect(run.stdout).toContain('over-mij.html');
});
it.each(['index.html', '404.html', 'over-mij.html'])(
'weigert een build zonder %s',
async (file) => {
const dist = await makeDist();
await rm(join(dist, file));
const run = await runScript('check-artifact.sh', [slash(dist)]);
expect(run.code).toBe(1);
expect(run.stderr).toContain(`${file} ontbreekt`);
},
);
it('weigert een build met een servermap', async () => {
const dist = await makeDist();
await write(dist, 'server/server.js');
const run = await runScript('check-artifact.sh', [slash(dist)]);
expect(run.code).toBe(1);
expect(run.stderr).toContain('server');
});
it('weigert een source map, ook diep in de map', async () => {
const dist = await makeDist();
await write(dist, 'assets/deep/a.js.map');
const run = await runScript('check-artifact.sh', [slash(dist)]);
expect(run.code).toBe(1);
expect(run.stderr).toContain('a.js.map');
});
it('weigert een map die niet bestaat', async () => {
const run = await runScript('check-artifact.sh', [
slash(join(tmpdir(), 'bestaat-niet-andreaslop')),
]);
expect(run.code).not.toBe(0);
});
});
// Een kleine server met de bedoelde regels (nieuw) of met het oude gedrag van
// de SPA-config (oud: elk pad geeft index.html met 200). Bij 'nieuw' kan een
// header of de gzip weggelaten worden.
interface StubOptions {
behaviour: 'new' | 'old';
omitHeader?: string;
gzip?: boolean;
robots?: boolean;
}
async function startStub(
dir: string,
options: StubOptions,
): Promise<{ origin: string; close: () => Promise<void> }> {
const headers: Record<string, string> = {
...securityHeaders('production'),
};
if (options.robots) headers['X-Robots-Tag'] = 'noindex, nofollow';
if (options.omitHeader) delete headers[options.omitHeader];
const files = new Set(await tree(dir));
const pages = new Set(
[...files]
.filter((file) => file.endsWith('.html') && file !== '404.html')
.map((file) =>
file === 'index.html' ? '/' : '/' + file.slice(0, -5),
),
);
const reply = async (
request: IncomingMessage,
response: ServerResponse,
status: number,
file: string,
) => {
const body = await readFile(join(dir, file));
const gzipped =
options.gzip === true &&
file.endsWith('.js') &&
/gzip/.test(request.headers['accept-encoding'] ?? '');
response.writeHead(status, {
...headers,
...(gzipped ? { 'Content-Encoding': 'gzip' } : {}),
});
response.end(gzipped ? gzipSync(body) : body);
};
const redirect = (response: ServerResponse, location: string) => {
response.writeHead(301, { ...headers, Location: location });
response.end();
};
const server: Server = createServer((request, response) => {
const path = (request.url ?? '/').split('?')[0];
void (async () => {
if (options.behaviour === 'old') {
// Oude nginx: bestaand bestand, anders de homepage met 200
const file = path.slice(1);
await reply(
request,
response,
200,
files.has(file) ? file : 'index.html',
);
return;
}
if (files.has(path.slice(1)) && path !== '/') {
await reply(request, response, 200, path.slice(1));
} else if (pages.has(path)) {
await reply(
request,
response,
200,
path === '/' ? 'index.html' : `${path.slice(1)}.html`,
);
} else if (path.length > 1 && path.endsWith('/')) {
redirect(response, path.slice(0, -1));
} else if (pages.has(path.toLowerCase())) {
redirect(response, path.toLowerCase());
} else {
await reply(request, response, 404, '404.html');
}
})();
});
await new Promise<void>((done) => server.listen(0, '127.0.0.1', done));
const { port } = server.address() as AddressInfo;
return {
origin: `http://127.0.0.1:${port}`,
close: () =>
new Promise<void>((done, fail) => {
server.close((error) => (error ? fail(error) : done()));
server.closeAllConnections();
}),
};
}
describe.skipIf(toolsMissing)('verify-deployment.sh', () => {
let site: FixtureSite;
let dist: string;
beforeAll(async () => {
site = await createFixtureSite();
dist = slash(site.dir);
// De homepage verwijst naar de JavaScript, voor de compressiecontrole
await writeFile(
join(site.dir, 'index.html'),
'<!doctype html><html><head><script src="/assets/index-AbC123xYz.js"></script></head><body>fixture:index.html</body></html>',
);
});
afterAll(() => site.remove());
const withStub = async <T>(
options: StubOptions,
action: (origin: string) => Promise<T>,
) => {
const stub = await startStub(site.dir, options);
try {
return await action(stub.origin);
} finally {
await stub.close();
}
};
it('slaagt tegen de previewserver op de fixture-site', async () => {
const server = await startPreviewServer(site.dir, 0);
const { port } = server.address() as AddressInfo;
try {
const run = await runScript('verify-deployment.sh', [
`http://127.0.0.1:${port}`,
dist,
]);
expect(run.stderr).not.toContain('FOUT');
expect(run.code).toBe(0);
expect(run.stdout).toContain('Controle geslaagd');
} finally {
await new Promise<void>((done) => {
server.close(() => done());
server.closeAllConnections();
});
}
});
it('slaagt tegen een server met de bedoelde regels, ook met een slash aan het eind van de URL', async () => {
await withStub({ behaviour: 'new' }, async (origin) => {
const run = await runScript('verify-deployment.sh', [
`${origin}/`,
dist,
]);
expect(run.stderr).not.toContain('FOUT');
expect(run.code).toBe(0);
});
});
it('faalt tegen het oude gedrag (homepage voor elk pad) en noemt de bytes van /over-mij (V11)', async () => {
await withStub({ behaviour: 'old' }, async (origin) => {
const run = await runScript('verify-deployment.sh', [origin, dist]);
expect(run.code).toBe(1);
expect(run.stderr).toContain(
'/over-mij: antwoord is niet gelijk aan over-mij.html',
);
expect(run.stderr).toContain('status 200, verwacht 404');
expect(run.stderr).toContain(
'/over-mij/: status 200, verwacht 301',
);
});
});
it.each(Object.keys(securityHeaders('production')))(
'faalt als %s ontbreekt',
async (name) => {
await withStub(
{ behaviour: 'new', omitHeader: name },
async (origin) => {
const run = await runScript('verify-deployment.sh', [
origin,
dist,
]);
expect(run.code).toBe(1);
expect(run.stderr).toContain(`header ${name} ontbreekt`);
},
);
},
);
it('met --test: slaagt met X-Robots-Tag en gzip', async () => {
await withStub(
{ behaviour: 'new', robots: true, gzip: true },
async (origin) => {
const run = await runScript('verify-deployment.sh', [
origin,
dist,
'--test',
]);
expect(run.stderr).not.toContain('FOUT');
expect(run.code).toBe(0);
},
);
});
it('met --test: faalt zonder X-Robots-Tag', async () => {
await withStub({ behaviour: 'new', gzip: true }, async (origin) => {
const run = await runScript('verify-deployment.sh', [
origin,
dist,
'--test',
]);
expect(run.code).toBe(1);
expect(run.stderr).toContain('header X-Robots-Tag ontbreekt');
});
});
it('met --test: faalt zonder gzip, zonder --test is dat een waarschuwing', async () => {
await withStub(
{ behaviour: 'new', robots: true, gzip: false },
async (origin) => {
const strict = await runScript('verify-deployment.sh', [
origin,
dist,
'--test',
]);
expect(strict.code).toBe(1);
expect(strict.stderr).toContain('geen Content-Encoding: gzip');
const lenient = await runScript('verify-deployment.sh', [
origin,
dist,
]);
expect(lenient.code).toBe(0);
expect(lenient.stderr).toContain('WAARSCHUWING');
},
);
});
it.each(['', 'ftp://example.nl', 'http://a b', 'example.nl'])(
'weigert de ongeldige URL %j',
async (url) => {
const run = await runScript('verify-deployment.sh', [url, dist]);
expect(run.code).toBe(2);
expect(run.stderr).toContain('Ongeldige URL');
},
);
});
// lftp staat niet overal (lokaal vaak niet; CI installeert het): zonder lftp
// lokaal een zichtbare melding, in CI een fout
const lftpMissing = !hasCommand('lftp') || process.platform === 'win32';
if (lftpMissing) {
describe('upload-production.sh', () => {
it('lftp niet gevonden: uploadtest overgeslagen (de lftp-syntaxis blijft onbewezen)', (context) => {
if (inCi) throw new Error('lftp ontbreekt in CI');
console.log(context.task.name);
context.skip();
});
});
}
describe.skipIf(toolsMissing || lftpMissing)('upload-production.sh', () => {
const upload = async (
dist: string,
target: string,
pass?: '1' | '2' | '3',
) =>
runScript('upload-production.sh', [slash(dist), slash(target)], {
LFTP_OPEN: 'file:///',
...(pass ? { UPLOAD_PASS: pass } : {}),
});
async function setup() {
const dist = await makeDist();
const target = await makeTemp('andreaslop-target-');
await write(target, 'stale.txt');
return { dist, target };
}
it('zet de rondes in volgorde: eerst alles behalve HTML, dan HTML, dan opruimen', async () => {
const { dist, target } = await setup();
const first = await upload(dist, target, '1');
expect(first.code).toBe(0);
expect(await tree(target)).toEqual([
'assets/a.js',
'robots.txt',
'stale.txt',
]);
const second = await upload(dist, target, '2');
expect(second.code).toBe(0);
expect(await tree(target)).toEqual([
'404.html',
'assets/a.js',
'index.html',
'over-mij.html',
'robots.txt',
'soorten-fotoshoots/newborn.html',
'stale.txt',
'web.config',
]);
const third = await upload(dist, target, '3');
expect(third.code).toBe(0);
expect(await tree(target)).toEqual([
'404.html',
'assets/a.js',
'index.html',
'over-mij.html',
'robots.txt',
'soorten-fotoshoots/newborn.html',
'web.config',
]);
});
it('zet alle assets vóór de eerste HTML (FR-PR-18) en de web.config vóór de HTML', async () => {
const { dist, target } = await setup();
const run = await upload(dist, target);
expect(run.code).toBe(0);
const lines = run.stdout.split('\n');
const at = (needle: string) =>
lines.findIndex((line) => line.includes(needle));
const firstHtml = lines.findIndex((line) => /\.html/.test(line));
expect(at('assets/a.js')).toBeGreaterThanOrEqual(0);
expect(at('assets/a.js')).toBeLessThan(firstHtml);
expect(at('web.config')).toBeGreaterThanOrEqual(0);
expect(at('web.config')).toBeLessThan(firstHtml);
const expected = [...validFiles, 'web.config'].sort();
expect(await tree(target)).toEqual(expected);
});
it('weigert een ongeldige build en uploadt dan niets', async () => {
const { dist, target } = await setup();
await rm(join(dist, 'index.html'));
const run = await upload(dist, target);
expect(run.code).not.toBe(0);
expect(await tree(target)).toEqual(['stale.txt']);
});
it('neemt de web.config uit deploy/iis over', async () => {
const { dist, target } = await setup();
const run = await upload(dist, target);
expect(run.code).toBe(0);
expect(await readFile(join(target, 'web.config'), 'utf8')).toBe(
await readFile(join(deployDir, 'iis/web.config'), 'utf8'),
);
});
});