Plain map keys compare case-insensitively, so /Over-Mij was not redirected. A path starting with an encoded backslash could become an open redirect through the trailing-slash rule; it now gets the 404 page. Also makes the tests readable for nginx's workers and less sensitive to the slow CI runner. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
361 lines
14 KiB
TypeScript
361 lines
14 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
import type { Page } from 'playwright-core';
|
|
import sitePages from '../src/sitePages.ts';
|
|
import { eventually, openPage, waitForHydration } from './support/browser.ts';
|
|
import { startServer } from './support/server.ts';
|
|
|
|
// FR-PR-11, FR-PR-21, V-D13, V-D15: welke foto's de browser opvraagt, wanneer
|
|
// en hoe vaak, per breedte. Het verzoeklogboek komt van page.on('request').
|
|
let server: Awaited<ReturnType<typeof startServer>>;
|
|
beforeAll(async () => {
|
|
server = await startServer();
|
|
});
|
|
afterAll(() => server.close());
|
|
|
|
interface Logged {
|
|
url: string;
|
|
// Aangevraagd voor de load-gebeurtenis
|
|
beforeLoad: boolean;
|
|
}
|
|
|
|
const isPhoto = (url: string) =>
|
|
/\/assets\/.*\.(jpe?g|png|webp|avif)$/.test(new URL(url).pathname) &&
|
|
!/\/logo-/.test(url);
|
|
|
|
// Logboek van de afbeeldingsverzoeken, vanaf de allereerste navigatie
|
|
function track() {
|
|
const log: Logged[] = [];
|
|
let loaded = false;
|
|
return {
|
|
log,
|
|
prepare: async (page: Page) => {
|
|
page.on('load', () => (loaded = true));
|
|
page.on('request', (request) => {
|
|
if (request.resourceType() !== 'image') return;
|
|
log.push({ url: request.url(), beforeLoad: !loaded });
|
|
});
|
|
},
|
|
};
|
|
}
|
|
|
|
const counts = (log: Logged[]) => {
|
|
const map = new Map<string, number>();
|
|
for (const { url } of log) map.set(url, (map.get(url) ?? 0) + 1);
|
|
return map;
|
|
};
|
|
|
|
// Elke uitgestelde foto is gehydrateerd: React hangt dan een fiber aan het
|
|
// element. Scrollen voor die tijd (traag apparaat) laat de bovenste foto's
|
|
// nooit in de buurt komen, want ze krijgen pas een src na de hydratatie.
|
|
const deferredImagesHydrated = (page: Page) =>
|
|
page.waitForFunction(() =>
|
|
[...document.querySelectorAll('img[data-deferred]')].every((image) =>
|
|
Object.keys(image).some((key) => key.startsWith('__reactFiber')),
|
|
),
|
|
);
|
|
|
|
// Scrolt de hele pagina door, zodat elke uitgestelde foto in de buurt komt
|
|
async function scrollThrough(page: Page) {
|
|
await deferredImagesHydrated(page);
|
|
const height = await page.evaluate(() => document.body.scrollHeight);
|
|
const step = await page.evaluate(() => Math.floor(window.innerHeight / 2));
|
|
for (let y = 0; y <= height; y += step) {
|
|
await page.evaluate(
|
|
(top) => window.scrollTo({ top, behavior: 'instant' }),
|
|
y,
|
|
);
|
|
await page.waitForTimeout(150);
|
|
}
|
|
await page.waitForLoadState('networkidle');
|
|
}
|
|
|
|
const preloadInfo = (page: Page) =>
|
|
page.evaluate(() =>
|
|
[
|
|
...document.querySelectorAll<HTMLLinkElement>(
|
|
'link[rel="preload"][as="image"]',
|
|
),
|
|
]
|
|
.filter((link) => !/\/logo-/.test(link.href))
|
|
.map((link) => ({
|
|
href: link.href,
|
|
matches: matchMedia(link.media || 'all').matches,
|
|
})),
|
|
);
|
|
|
|
const displayedSources = (page: Page) =>
|
|
page.evaluate(() =>
|
|
[...document.querySelectorAll('img')]
|
|
.filter((image) => image.getClientRects().length > 0)
|
|
.map((image) => image.currentSrc)
|
|
.filter(Boolean),
|
|
);
|
|
|
|
const widths = [
|
|
{ width: 390, height: 844 },
|
|
{ width: 768, height: 1024 },
|
|
{ width: 1350, height: 940 },
|
|
];
|
|
|
|
describe('de tweeling wordt met JavaScript niet opgevraagd', () => {
|
|
it.each(['/soorten-fotoshoots', '/portfolio'])(
|
|
"%s vraagt voor de load alleen foto's op die in de eerste rij, in een preload of in een src staan, en daarna elke foto één keer",
|
|
async (path) => {
|
|
const requests = track();
|
|
const { page, ...opened } = await openPage(server.origin + path, {
|
|
width: 1350,
|
|
height: 940,
|
|
prepare: requests.prepare,
|
|
});
|
|
await page.waitForTimeout(500);
|
|
const early = requests.log
|
|
.filter((entry) => isPhoto(entry.url))
|
|
.map((r) => r.url);
|
|
const allowed = new Set([
|
|
...(await preloadInfo(page)).map((link) => link.href),
|
|
...(await displayedSources(page)),
|
|
]);
|
|
expect(early.length).toBeGreaterThan(0);
|
|
for (const url of early) expect(allowed).toContain(url);
|
|
|
|
await scrollThrough(page);
|
|
const total = counts(
|
|
requests.log.filter((entry) => isPhoto(entry.url)),
|
|
);
|
|
expect(total.size).toBeGreaterThanOrEqual(early.length);
|
|
for (const [url, count] of total) {
|
|
expect(count, url).toBe(1);
|
|
}
|
|
expect(opened.messages).toEqual([]);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('preloads per breedte', () => {
|
|
const expected = (path: string, width: number) => {
|
|
if (path === '/portfolio')
|
|
return width >= 1024 ? 3 : width >= 768 ? 2 : 1;
|
|
if (path === '/contact') return width >= 1024 ? 1 : 0;
|
|
return 1;
|
|
};
|
|
const preloadPages = Object.keys(sitePages).filter(
|
|
(path) => path !== '/privacyverklaring',
|
|
);
|
|
|
|
it.each(widths)(
|
|
'geeft elke pagina het juiste aantal passende preloads, gebruikt en niet dubbel opgevraagd ($width px)',
|
|
async (size) => {
|
|
for (const path of preloadPages) {
|
|
const requests = track();
|
|
const { page } = await openPage(server.origin + path, {
|
|
...size,
|
|
prepare: requests.prepare,
|
|
});
|
|
await page.waitForLoadState('networkidle');
|
|
const matching = (await preloadInfo(page)).filter(
|
|
(link) => link.matches,
|
|
);
|
|
expect(matching.length, `${path} bij ${size.width}`).toBe(
|
|
expected(path, size.width),
|
|
);
|
|
|
|
const shown = await displayedSources(page);
|
|
const asked = counts(requests.log);
|
|
for (const link of matching) {
|
|
expect(shown, `${path} gebruikt ${link.href}`).toContain(
|
|
link.href,
|
|
);
|
|
expect(asked.get(link.href), link.href).toBe(1);
|
|
}
|
|
}
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('/contact', () => {
|
|
it('vraagt de foto naast het formulier op vanaf lg en nooit eronder, en het portret niet vanaf lg', async () => {
|
|
const wide = track();
|
|
const { page } = await openPage(server.origin + '/contact', {
|
|
width: 1350,
|
|
height: 940,
|
|
prepare: wide.prepare,
|
|
});
|
|
await page.waitForLoadState('networkidle');
|
|
const urls = await page.evaluate(() => ({
|
|
aside: (
|
|
document.querySelector('picture source[srcset]') as
|
|
HTMLSourceElement | undefined
|
|
)?.srcset,
|
|
portrait: [
|
|
...document.querySelectorAll<HTMLImageElement>(
|
|
'img[loading="lazy"]',
|
|
),
|
|
]
|
|
.filter((image) => !/\/logo-/.test(image.src))
|
|
.map((image) => image.src),
|
|
}));
|
|
expect(urls.aside).toBeTruthy();
|
|
const asked = counts(wide.log);
|
|
expect(asked.get(new URL(urls.aside!, server.origin).href)).toBe(1);
|
|
expect(urls.portrait.length).toBeGreaterThan(0);
|
|
for (const portrait of urls.portrait) {
|
|
expect(asked.get(portrait)).toBeUndefined();
|
|
}
|
|
|
|
const narrow = track();
|
|
const mobile = await openPage(server.origin + '/contact', {
|
|
width: 390,
|
|
height: 844,
|
|
prepare: narrow.prepare,
|
|
});
|
|
await mobile.page.waitForLoadState('networkidle');
|
|
expect(
|
|
counts(narrow.log).get(new URL(urls.aside!, server.origin).href),
|
|
).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("logo's", () => {
|
|
// BR-PRE-05, V-D7: buiten de homepage vraagt de browser het lichte logo pas
|
|
// na de load-gebeurtenis op (daarna één keer, zodat een klik naar / het
|
|
// logo niet laat knipperen). Een navigatie voor de load kan nog even knipperen.
|
|
it.each([1350, 412])(
|
|
'vraagt het lichte logo buiten de homepage pas na de load op (%i px)',
|
|
async (width) => {
|
|
for (const path of Object.keys(sitePages)) {
|
|
const requests = track();
|
|
const { page } = await openPage(server.origin + path, {
|
|
width,
|
|
height: 940,
|
|
prepare: requests.prepare,
|
|
});
|
|
const light = () =>
|
|
requests.log.filter((entry) =>
|
|
/\/logo-light-/.test(entry.url),
|
|
);
|
|
// Het verzoek komt pas na de load én de hydratatie; op een
|
|
// traag apparaat is het netwerk dan al even stil geweest
|
|
await eventually(async () => light().length).toBeGreaterThan(0);
|
|
await page.waitForLoadState('networkidle');
|
|
expect(light().length, path).toBe(1);
|
|
expect(light()[0].beforeLoad, path).toBe(path === '/');
|
|
}
|
|
},
|
|
);
|
|
|
|
it('laat het logo niet knipperen bij een klik naar de homepage na de load (1350 px)', async () => {
|
|
const { page } = await openPage(server.origin + '/over-mij', {
|
|
width: 1350,
|
|
height: 940,
|
|
});
|
|
await page.waitForLoadState('networkidle');
|
|
await waitForHydration(page);
|
|
await page.evaluate(() => {
|
|
const w = window as unknown as { __frames: string[] };
|
|
w.__frames = [];
|
|
const tick = () => {
|
|
w.__frames.push(
|
|
[...document.querySelectorAll('header img')]
|
|
.map((img) => {
|
|
const rect = img.getBoundingClientRect();
|
|
return `${(img as HTMLImageElement).complete}|${Math.round(rect.width)}`;
|
|
})
|
|
.join(';'),
|
|
);
|
|
requestAnimationFrame(tick);
|
|
};
|
|
tick();
|
|
});
|
|
await page.locator('[data-testid="nav-logo-link"]').click();
|
|
await page.waitForURL(server.origin + '/');
|
|
await page.waitForTimeout(800);
|
|
const frames = await page.evaluate(
|
|
() => (window as unknown as { __frames: string[] }).__frames,
|
|
);
|
|
// Een getoond logo (breedte > 0) dat nog niet geladen is, is een flits
|
|
const flashes = frames.filter((frame) =>
|
|
frame
|
|
.split(';')
|
|
.some(
|
|
(logo) => logo.startsWith('false|') && !logo.endsWith('|0'),
|
|
),
|
|
);
|
|
expect(flashes).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('de eerste rij van /portfolio (V-D13)', () => {
|
|
it.each(widths)(
|
|
"heeft evenveel kolommen als eager foto's voor de load ($width px)",
|
|
async (size) => {
|
|
const requests = track();
|
|
const { page, ...opened } = await openPage(
|
|
server.origin + '/portfolio',
|
|
{ ...size, prepare: requests.prepare },
|
|
);
|
|
await page.waitForTimeout(500);
|
|
const columns = await page
|
|
.locator('[data-testid^="portfolio-tile-"]')
|
|
.evaluateAll((tiles) => {
|
|
const rects = tiles.map((tile) =>
|
|
tile.getBoundingClientRect(),
|
|
);
|
|
const top = Math.min(...rects.map((rect) => rect.top));
|
|
return new Set(
|
|
rects
|
|
.filter((rect) => Math.abs(rect.top - top) < 1)
|
|
.map((rect) => Math.round(rect.left)),
|
|
).size;
|
|
});
|
|
expect(columns).toBe(
|
|
size.width >= 1024 ? 3 : size.width >= 768 ? 2 : 1,
|
|
);
|
|
|
|
await scrollThrough(page);
|
|
const gridPhotos = new Set(
|
|
await page
|
|
.getByTestId('portfolio-grid')
|
|
.locator('img')
|
|
.evaluateAll((images) =>
|
|
images
|
|
.map(
|
|
(image) =>
|
|
(image as HTMLImageElement).currentSrc,
|
|
)
|
|
.filter(Boolean),
|
|
),
|
|
);
|
|
expect(gridPhotos.size).toBeGreaterThan(columns);
|
|
const before = requests.log.filter(
|
|
(entry) => entry.beforeLoad && gridPhotos.has(entry.url),
|
|
);
|
|
expect(before).toHaveLength(columns);
|
|
for (const [url, count] of counts(requests.log)) {
|
|
if (gridPhotos.has(url)) expect(count, url).toBe(1);
|
|
}
|
|
expect(opened.messages).toEqual([]);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('/portfolio?shoot= (V-D15)', () => {
|
|
it('vraagt geen enkele afbeelding twee keer op nadat het filter is toegepast', async () => {
|
|
const requests = track();
|
|
const { page, ...opened } = await openPage(
|
|
server.origin + '/portfolio?shoot=gezin',
|
|
{ width: 1350, height: 940, prepare: requests.prepare },
|
|
);
|
|
const tiles = page.locator('[data-testid^="portfolio-tile-"]');
|
|
const before = await tiles.count();
|
|
await waitForHydration(page);
|
|
await expect
|
|
.poll(() => tiles.count(), { timeout: 15_000, interval: 100 })
|
|
.toBeLessThan(before);
|
|
await scrollThrough(page);
|
|
for (const [url, count] of counts(requests.log)) {
|
|
expect(count, url).toBe(1);
|
|
}
|
|
expect(opened.messages).toEqual([]);
|
|
});
|
|
});
|