Compares the preview server with real nginx in tests

The preview server must behave like the real server, or Lighthouse and the
browser tests prove the wrong thing. The tests also cover the new URLs in a real
browser: one redirect, one title, a clean hydration.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-01 18:30:08 +01:00
co-authored by Claude Opus 5.5
parent e4e7f8c82c
commit 38708b8439
10 changed files with 539 additions and 88 deletions
+2 -1
View File
@@ -18,7 +18,8 @@ afterAll(() => server.close());
async function fetchDocument(path: string) {
const response = await fetch(server.origin + path);
expect(response.status).toBe(200);
// /404.html is een echte 404 (BR-HST-05)
expect(response.status).toBe(path === '/404.html' ? 404 : 200);
const html = await response.text();
return {
html,
+25 -45
View File
@@ -25,9 +25,9 @@ const notFoundPaths = [
'/soorten-fotoshoots/onbekend',
];
// Alleen een document dat de server bewust met 404 beantwoordt (BR-SRV-05)
const expectedStatus = (path: string) =>
path === '/404.html' || pages.includes(path) ? 200 : 404;
// Alleen een document dat de server bewust met 404 beantwoordt (BR-SRV-05);
// /404 en /404.html zijn echte 404's (BR-HST-05)
const expectedStatus = (path: string) => (pages.includes(path) ? 200 : 404);
describe.each(widths)('hydratatie op %i px', (width) => {
it.each([...pages, ...notFoundPaths])(
@@ -74,6 +74,7 @@ describe('de 404-pagina, gemaakt voor /404 en getoond op een andere URL', () =>
server.origin + '/404.html',
{
width,
expectNotFound: true,
prepare: async (page) => {
await page.route(
/\/assets\/_-[^/]+\.js$/,
@@ -282,47 +283,26 @@ describe('contactformulier op /contact (V8)', () => {
});
});
// BR-404-07: een URL die de server niet kent maar de router wel. Dit is een
// waarneming, geen controle die de suite laat falen. De
// preview-server draait op Windows en Linux anders (hoofdletters in
// bestandsnamen), dus de Linux-situatie wordt nagespeeld: 404.html met 404.
describe('URL die de server niet kent en de router wel (BR-404-07)', () => {
it.each(['/Over-Mij', '/over-mij/'])('observeert %s', async (path) => {
const real = await fetch(server.origin + path, { redirect: 'manual' });
const observe = async (
served: string,
prepare?: (page: Page) => Promise<void>,
) => {
const { page, ...opened } = await openPage(server.origin + path, {
prepare,
// BR-404-07, BR-HST-08: een URL die de router wel kent maar de server niet als
// pagina bedient kan geen verschil tussen HTML en eerste render meer geven,
// want de server verwijst hem eerst door naar het canonieke pad. Het volledige
// gedrag in Chrome staat in urls.e2e.ts.
describe('URL die alleen de router kent wordt doorverwezen (BR-HST-08)', () => {
it.each(['/Over-Mij', '/over-mij/'])(
'%s gaat met één 301 naar /over-mij',
async (path) => {
const real = await fetch(server.origin + path, {
redirect: 'manual',
});
await page.waitForTimeout(1500);
const state = await page.evaluate(() => ({
url: location.pathname,
h1: document.querySelector('h1')?.textContent,
titles: [...document.querySelectorAll('title')].map(
(t) => t.textContent,
),
}));
console.info(
`BR-404-07 ${path} (${served}): ${JSON.stringify({ ...state, status: opened.status, messages: opened.messages })}`,
);
};
console.info(
`BR-404-07 ${path}: preview-server geeft ${real.status} ${real.headers.get('content-type')}`,
);
await observe('preview-server van deze machine');
await observe(
'404.html met 404, zoals een hoofdlettergevoelige host',
async (page) => {
await page.route(server.origin + path, async (route) => {
const notFound = await route.fetch({
url: server.origin + '/404.html',
});
await route.fulfill({ response: notFound, status: 404 });
});
},
);
expect(real.status).toBeGreaterThan(0);
});
expect(real.status).toBe(301);
expect(real.headers.get('location')).toBe('/over-mij');
const { page, ...opened } = await openPage(server.origin + path);
await waitForHydration(page);
expect(new URL(page.url()).pathname).toBe('/over-mij');
expect(opened.status).toBe(200);
expect(opened.messages).toEqual([]);
expect(opened.violations).toEqual([]);
},
);
});
+2 -2
View File
@@ -120,8 +120,8 @@ describe.each(paths)('rauwe HTML van %s', (path) => {
describe('rauwe HTML van 404.html', () => {
it('heeft één titel, één noindex en geen beschrijving of canonical', async () => {
// 404.html als bestand: status 200 (BR-SRV-04)
const { html, document } = await fetchDocument('/404.html');
// 404.html als URL is een echte 404 (BR-HST-05)
const { html, document } = await fetchDocument('/404.html', 404);
const titles = document.querySelectorAll('title');
expect(titles).toHaveLength(1);
expect(titles[0].textContent).toBe(
+355 -29
View File
@@ -1,8 +1,19 @@
import { request } from 'node:http';
import { connect } from 'node:net';
import fc from 'fast-check';
import { existsSync, readFileSync, statSync } from 'node:fs';
import { request, type IncomingMessage, type Server } from 'node:http';
import { connect, type AddressInfo } from 'node:net';
import { join } from 'node:path';
import { gunzipSync } from 'node:zlib';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { afterAll, beforeAll, describe, expect, inject, it } from 'vitest';
import { pagePaths } from '../config/canonicalUrls.ts';
import { NOT_FOUND_FILE, pageFile } from '../config/pageFiles.ts';
import { startPreviewServer } from '../config/previewServer.ts';
import { securityHeaders } from '../config/securityHeaders.ts';
import {
pageVariant,
queryString,
unknownPath,
} from '../src/test/urlArbitraries.ts';
import { createFixtureSite, type FixtureSite } from './support/fixtureSite.ts';
import {
findNginx,
@@ -10,11 +21,15 @@ import {
type MimeVariant,
type RunningNginx,
} from './support/nginx.ts';
import { clientDir } from './support/server.ts';
// BR-HST-24: de nginx-regels worden bewezen door een echte nginx, niet door de
// tekst te lezen. De site is een kleine fixture (geen build nodig); dezelfde
// regels voor de previewserver staan in previewServer.test.ts.
// Seed van deze run, gekozen en gelogd in config/testSeed.ts (PBT-08)
fc.configureGlobal({ seed: inject('fcSeed') });
const nginxBin = findNginx();
const inCi = Boolean(process.env.CI);
@@ -43,34 +58,44 @@ interface Reply {
body: Buffer;
}
// node:http en niet fetch: fetch voegt dubbele headers samen en pakt gzip uit
// node:http en niet fetch: fetch voegt dubbele headers samen en pakt gzip uit.
// Met raw gaat het pad ongewijzigd over de lijn; anders maakt de URL-parser er
// zijn eigen vorm van (een backslash wordt een slash).
function get(
origin: string,
path: string,
options: { method?: string; headers?: Record<string, string> } = {},
options: {
method?: string;
headers?: Record<string, string>;
raw?: boolean;
} = {},
): Promise<Reply> {
return new Promise((resolve, reject) => {
const req = request(
origin + path,
{ method: options.method ?? 'GET', headers: options.headers },
(res) => {
const chunks: Buffer[] = [];
res.on('data', (chunk: Buffer) => chunks.push(chunk));
res.on('end', () =>
resolve({
status: res.statusCode ?? 0,
headers: Object.fromEntries(
Object.entries(res.headers).map(([k, v]) => [
k,
String(v),
]),
),
rawHeaders: res.rawHeaders,
body: Buffer.concat(chunks),
}),
);
},
);
const init = {
method: options.method ?? 'GET',
headers: options.headers,
};
const onReply = (res: IncomingMessage) => {
const chunks: Buffer[] = [];
res.on('data', (chunk: Buffer) => chunks.push(chunk));
res.on('end', () =>
resolve({
status: res.statusCode ?? 0,
headers: Object.fromEntries(
Object.entries(res.headers).map(([k, v]) => [
k,
String(v),
]),
),
rawHeaders: res.rawHeaders,
body: Buffer.concat(chunks),
}),
);
};
const { hostname, port } = new URL(origin);
const req = options.raw
? request({ hostname, port, path, ...init }, onReply)
: request(origin + path, init, onReply);
req.on('error', reject);
req.end();
});
@@ -123,6 +148,14 @@ function getHttp10(origin: string, path: string, headers: string[]) {
});
}
// De versie van nginx één keer in de uitvoer, hoeveel instanties er ook starten
let versionAnnounced = false;
function announce(nginx: RunningNginx) {
if (versionAnnounced) return;
versionAnnounced = true;
console.log(`[serverRules] nginx -v: ${nginx.version}`);
}
const mimeVariants: MimeVariant[] = ['new', 'old'];
const rulesSuite = nginxBin ? describe : describe.skip;
@@ -139,9 +172,7 @@ rulesSuite.each(mimeVariants)(
siteDir: site.dir,
mimeVariant: variant,
});
console.log(
`[serverRules] nginx -v: ${nginx.version} (${nginx.origin})`,
);
announce(nginx);
});
afterAll(async () => {
await nginx?.stop();
@@ -374,3 +405,298 @@ rulesSuite.each(mimeVariants)(
});
},
);
// P-HST-09 (oracle): dezelfde fixturesite achter de echte nginx en achter de
// previewserver. Voor elk pad moeten ze gelijk antwoorden op status, Location
// (zonder schema en host), het bestand dat geserveerd is en gzip. Bewust
// anders, en dus niet vergeleken:
// - 405-tekst en de Server-header: nginx heeft eigen teksten;
// - het MIME-type van .js: hangt van de nginx-versie af (beide tabellen staan
// hierboven in de suite per mime-variant);
// - /robots.txt: nginx vervangt hem door Disallow, de previewserver serveert
// het bestand (de fixture heeft er een);
// - X-Robots-Tag: alleen nginx (testsite), de previewserver stuurt hem nooit;
// - Cache-Control op een 301: nginx zet no-cache via add_header op
// server-niveau, de previewserver stuurt er geen (BR-HST-12); op bestanden
// buiten HTML zet de previewserver er geen;
// - paden met een leeg segment (//), zie het blok onderaan de suite;
// - /%2e%2e/ en een NUL in het pad: nginx weigert die met 400, de
// previewserver geeft 404.
const parityRules = nginxBin ? describe : describe.skip;
parityRules('pariteit: previewserver tegen echte nginx (P-HST-09)', () => {
let site: FixtureSite;
let nginx: RunningNginx;
let preview: Server;
let previewOrigin: string;
beforeAll(async () => {
site = await createFixtureSite();
nginx = await startNginx({ siteDir: site.dir });
announce(nginx);
preview = await startPreviewServer(site.dir, 0);
previewOrigin = `http://127.0.0.1:${(preview.address() as AddressInfo).port}`;
});
afterAll(async () => {
preview?.closeAllConnections();
await new Promise<void>((resolve) =>
preview ? preview.close(() => resolve()) : resolve(),
);
await nginx?.stop();
await site?.remove();
});
const acceptGzip = { 'Accept-Encoding': 'gzip' };
const search = (query: string) => (query ? `?${query}` : '');
const decoded = (reply: Reply) =>
reply.headers['content-encoding'] === 'gzip'
? gunzipSync(reply.body)
: reply.body;
const servedFile = (reply: Reply) =>
/fixture:[\w./-]+/.exec(decoded(reply).toString('latin1'))?.[0];
const locationOf = (reply: Reply) =>
reply.headers.location?.replace(/^https?:\/\/[^/]+/, '');
// Wat aan de headers van één antwoord niet klopt
function headerFindings(
server: 'nginx' | 'preview',
reply: Reply,
checkCache: boolean,
) {
const found: string[] = [];
for (const [name, value] of Object.entries(
securityHeaders('production'),
)) {
const count = countHeader(reply, name);
const actual = reply.headers[name.toLowerCase()];
if (count !== 1 || actual !== value) {
found.push(`${server}: ${name} ${count}x, waarde ${actual}`);
}
}
const robots = countHeader(reply, 'X-Robots-Tag');
if (robots !== (server === 'nginx' ? 1 : 0)) {
found.push(`${server}: X-Robots-Tag ${robots}x`);
}
if (checkCache) {
const count = countHeader(reply, 'Cache-Control');
const expected =
server === 'preview' && reply.status === 301 ? 0 : 1;
if (count !== expected) {
found.push(
`${server}: Cache-Control ${count}x, verwacht ${expected}x`,
);
}
}
return found;
}
// Alle verschillen voor één pad, leesbaar met het pad erbij
async function differences(path: string, checkCache = true) {
const [fromNginx, fromPreview] = await Promise.all([
get(nginx.origin, path, { headers: acceptGzip, raw: true }),
get(previewOrigin, path, { headers: acceptGzip, raw: true }),
]);
const found: string[] = [];
const same = (what: string, a: unknown, b: unknown) => {
if (a !== b) found.push(`${what}: nginx ${a}, preview ${b}`);
};
same('status', fromNginx.status, fromPreview.status);
same('Location', locationOf(fromNginx), locationOf(fromPreview));
same('bestand', servedFile(fromNginx), servedFile(fromPreview));
same(
'Content-Encoding',
fromNginx.headers['content-encoding'],
fromPreview.headers['content-encoding'],
);
if (
fromNginx.status !== 301 &&
!decoded(fromNginx).equals(decoded(fromPreview))
) {
found.push('inhoud: de bytes verschillen');
}
if (checkCache && fromNginx.status !== 301) {
same(
'Cache-Control',
fromNginx.headers['cache-control'],
fromPreview.headers['cache-control'],
);
}
found.push(
...headerFindings('nginx', fromNginx, checkCache),
...headerFindings('preview', fromPreview, checkCache),
);
return found.map((finding) => `${path} ${finding}`);
}
// De tabel van het URL-contract, rij voor rij
it.each([
'/',
'/over-mij',
'/soorten-fotoshoots',
'/soorten-fotoshoots/newborn',
'/over-mij?x=1',
'/?x=1',
'/over-mij/',
'/over-mij///',
'/soorten-fotoshoots/',
'/soorten-fotoshoots/?x=1',
'/over-mij.html',
'/soorten-fotoshoots/newborn.html',
'/index',
'/index.html',
'/index/',
'/Over-Mij',
'/OVER-MIJ.HTML',
'/Over-Mij/',
'/Over-Mij?x=1&y=%20z',
'/404',
'/404.html',
'/onbekend',
'/Onbekend',
'/x.html',
'/onbekend/',
'/onbekend/?a=b',
'/assets',
'/assets/',
'/assets/missing.js',
'/%5Cevil.example',
'/%5Cevil.example/',
])('%s: nginx en previewserver antwoorden gelijk', async (path) => {
expect(await differences(path)).toEqual([]);
});
// Bestanden: zelfde status, bytes en gzip-keuze (Cache-Control: zie boven)
it.each([
'/sitemap.xml',
'/favicon.png',
'/assets/index-AbC123xYz.js',
'/assets/style-Qw9.css',
'/assets/icon-Zz1.svg',
'/assets/data.json',
'/assets/readme.txt',
'/assets/font-Ab.woff2',
])('%s: gelijke status, bytes en gzip', async (path) => {
expect(await differences(path, false)).toEqual([]);
});
// Bekende pagina's in elke vorm en onbekende paden met en zonder slash,
// met en zonder query
const parityPath = fc.oneof(
fc
.tuple(pageVariant, queryString)
.map(([path, query]) => path + search(query)),
fc
.tuple(unknownPath, fc.boolean(), queryString)
.map(
([path, slash, query]) =>
path + (slash ? '/' : '') + search(query),
),
);
it('nginx en previewserver antwoorden gelijk op gegenereerde paden (oracle)', async () => {
await fc.assert(
fc.asyncProperty(parityPath, async (path) => {
expect(await differences(path)).toEqual([]);
}),
{ numRuns: 100 },
);
});
// Buiten de pariteit: een leeg segment. nginx voegt de slashes samen
// (merge_slashes) en bedient of verwijst het samengevoegde pad; de
// previewserver kent een leeg segment niet (BR-SRV-07) en geeft 404, op
// slashes alleen na (// en /// gaan naar /). Een verschil in uitkomst kan
// geen verkeerde eerste render geven, want browser en router maken zulke
// paden niet, en geen doorverwijzing begint met // (BR-HST-06).
describe('lege segmenten, buiten de pariteit', () => {
it.each([
['//', 'index.html'],
['///', 'index.html'],
['//over-mij', 'over-mij.html'],
])(
'nginx voegt de slashes van %s samen en bedient %s',
async (path, file) => {
const reply = await get(nginx.origin, path, { raw: true });
expect(reply.status).toBe(200);
expect(reply.body.toString()).toContain(
site.markers.get(file) ?? file,
);
},
);
it.each([
['/a//b/', '/a/b'],
['//evil.example/', '/evil.example'],
])('nginx verwijst %s naar %s', async (path, target) => {
const reply = await get(nginx.origin, path, { raw: true });
expect(reply.status).toBe(301);
expect(reply.headers.location).toBe(target);
});
it.each(['//', '///', '//over-mij', '/a//b/', '//evil.example/'])(
'de previewserver geeft voor %s 404 of een doorverwijzing naar /',
async (path) => {
const reply = await get(previewOrigin, path, { raw: true });
if (reply.status === 301) {
expect(reply.headers.location).toBe('/');
} else {
expect(reply.status).toBe(404);
}
},
);
});
});
// De echte build achter de echte nginx: elke pagina, de 404 en de map naast
// het paginabestand. Heeft een actuele dist nodig (pnpm build).
const buildSuite = nginxBin ? describe : describe.skip;
buildSuite('nginx op de echte build (dist/client)', () => {
let nginx: RunningNginx;
const bytesOf = (file: string) => readFileSync(join(clientDir, file));
beforeAll(async () => {
nginx = await startNginx({ siteDir: clientDir });
announce(nginx);
});
afterAll(async () => {
await nginx?.stop();
});
it.each([...pagePaths])(
'%s geeft 200 met de bytes van het paginabestand',
async (path) => {
const reply = await get(nginx.origin, path, { raw: true });
expect(reply.status).toBe(200);
expect(reply.body.equals(bytesOf(pageFile(path)))).toBe(true);
},
);
it('een onbekende URL geeft 404 met de bytes van 404.html', async () => {
const reply = await get(nginx.origin, '/bestaat-niet', { raw: true });
expect(reply.status).toBe(404);
expect(reply.body.equals(bytesOf(NOT_FOUND_FILE))).toBe(true);
});
it('de map soorten-fotoshoots/ staat naast soorten-fotoshoots.html zonder dat /soorten-fotoshoots omleidt', async () => {
expect(
statSync(join(clientDir, 'soorten-fotoshoots')).isDirectory(),
).toBe(true);
expect(existsSync(join(clientDir, 'soorten-fotoshoots.html'))).toBe(
true,
);
const page = await get(nginx.origin, '/soorten-fotoshoots', {
raw: true,
});
expect(page.status).toBe(200);
expect(page.body.equals(bytesOf('soorten-fotoshoots.html'))).toBe(true);
const dir = await get(nginx.origin, '/soorten-fotoshoots/', {
raw: true,
});
expect(dir.status).toBe(301);
expect(dir.headers.location).toBe('/soorten-fotoshoots');
});
it('toont geen maplijst voor /assets', async () => {
const reply = await get(nginx.origin, '/assets', { raw: true });
expect(reply.status).toBe(404);
expect(reply.body.equals(bytesOf(NOT_FOUND_FILE))).toBe(true);
});
});
+4 -3
View File
@@ -8,9 +8,10 @@ import { startPreviewServer } from '../../config/previewServer.ts';
export const clientDir = resolve('dist/client');
// Dezelfde server als `pnpm preview`, met de productie-CSP en echte 404's,
// op een poort die het systeem kiest zodat tests elkaar niet in de weg zitten
export async function startServer() {
const server = await startPreviewServer(clientDir, 0);
// op een poort die het systeem kiest zodat tests elkaar niet in de weg zitten.
// auditRoute zet de opt-in route /__audit/404 aan, zoals Lighthouse hem start.
export async function startServer(options: { auditRoute?: boolean } = {}) {
const server = await startPreviewServer(clientDir, 0, options);
const { port } = server.address() as AddressInfo;
return {
origin: `http://127.0.0.1:${port}`,
+139
View File
@@ -0,0 +1,139 @@
import type { Page } from 'playwright-core';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import type { RoutePath } from '../src/navigation.ts';
import { pageHead, siteName } from '../src/seo.ts';
import { openPage, waitForHydration } from './support/browser.ts';
import { startServer } from './support/server.ts';
// BR-HST-02, 05, 08, 22; V8: Chrome volgt de 301 van de previewserver, komt op
// het canonieke adres uit met de query intact en hydrateert zonder melding.
// Een onbekende URL en /404.html tonen de 404-pagina met status 404.
let server: Awaited<ReturnType<typeof startServer>>;
beforeAll(async () => {
server = await startServer();
});
afterAll(() => server.close());
// De documentverzoeken van de hoofdpagina in volgorde, ook de doorverwijzing:
// page.goto geeft alleen het eindantwoord
function recordNavigations() {
const log: { status: number; url: string }[] = [];
const prepare = async (page: Page) => {
page.on('response', (response) => {
if (
response.request().resourceType() === 'document' &&
response.frame() === page.mainFrame()
) {
log.push({ status: response.status(), url: response.url() });
}
});
};
return { log, prepare };
}
const countTags = (page: Page) =>
page.evaluate(() => ({
titles: document.querySelectorAll('title').length,
robots: [...document.querySelectorAll('meta[name="robots"]')].map(
(meta) => meta.getAttribute('content'),
),
}));
describe('doorverwijzingen naar het canonieke adres (BR-HST-03, 04, 08)', () => {
it.each([
['/Over-Mij', '/over-mij'],
['/Over-Mij?pakket=gezin', '/over-mij?pakket=gezin'],
['/over-mij/', '/over-mij'],
['/over-mij/?x=1', '/over-mij?x=1'],
['/soorten-fotoshoots/', '/soorten-fotoshoots'],
['/index.html', '/'],
['/over-mij.html', '/over-mij'],
])('%s gaat met één 301 naar %s', async (path, canonical) => {
const { log, prepare } = recordNavigations();
const { page, ...opened } = await openPage(server.origin + path, {
prepare,
});
// Eén 301, dan de pagina zelf, met de query van het verzoek erbij
expect(log).toEqual([
{ status: 301, url: server.origin + path },
{ status: 200, url: server.origin + canonical },
]);
expect(opened.status).toBe(200);
await waitForHydration(page);
const canonicalPath = new URL(server.origin + canonical).pathname;
expect(new URL(page.url()).pathname).toBe(canonicalPath);
// De titel is die van de pagina zelf, niet van de 404-pagina
await expect(page.title()).resolves.toBe(
pageHead(canonicalPath as RoutePath).meta[0].title,
);
const tags = await countTags(page);
expect(tags.titles).toBe(1);
expect(tags.robots).toEqual(
canonicalPath === '/privacyverklaring' ? ['noindex'] : [],
);
expect(opened.messages).toEqual([]);
expect(opened.violations).toEqual([]);
});
});
describe('de 404-pagina met status 404 (BR-HST-02, 05)', () => {
it.each(['/onbekend', '/404.html', '/404'])(
'%s toont de 404-pagina en blijft op dat adres',
async (path) => {
const { log, prepare } = recordNavigations();
const { page, ...opened } = await openPage(server.origin + path, {
expectNotFound: true,
prepare,
});
// Geen doorverwijzing: het document zelf is de 404
expect(log).toEqual([{ status: 404, url: server.origin + path }]);
expect(opened.status).toBe(404);
await waitForHydration(page);
expect(new URL(page.url()).pathname).toBe(path);
await expect(page.title()).resolves.toBe(
`Pagina niet gevonden | ${siteName}`,
);
const tags = await countTags(page);
expect(tags.titles).toBe(1);
expect(tags.robots).toEqual(['noindex']);
expect(opened.messages).toEqual([]);
expect(opened.violations).toEqual([]);
},
);
});
describe('de auditroute /__audit/404 (BR-HST-22)', () => {
it('is zonder de optie een gewone onbekende URL met status 404', async () => {
const { status } = await openPage(server.origin + '/__audit/404', {
expectNotFound: true,
});
expect(status).toBe(404);
});
it('geeft met de optie de 404-pagina met status 200 en hydrateert zonder melding', async () => {
const audit = await startServer({ auditRoute: true });
try {
const { page, ...opened } = await openPage(
audit.origin + '/__audit/404',
);
expect(opened.status).toBe(200);
await waitForHydration(page);
await expect(page.title()).resolves.toBe(
`Pagina niet gevonden | ${siteName}`,
);
const tags = await countTags(page);
expect(tags.titles).toBe(1);
expect(tags.robots).toEqual(['noindex']);
expect(opened.messages).toEqual([]);
expect(opened.violations).toEqual([]);
// /404.html blijft ook met de optie een echte 404
const real = await fetch(audit.origin + '/404.html');
expect(real.status).toBe(404);
} finally {
await audit.close();
}
});
});