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>
140 lines
5.4 KiB
TypeScript
140 lines
5.4 KiB
TypeScript
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();
|
|
}
|
|
});
|
|
});
|