The script body had been saved twice, so a production upload would have run twice and left web.config backups on the host. Browser tests also get longer limits on the slow CI runner; the page behaves the same. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
306 lines
11 KiB
TypeScript
306 lines
11 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
import type { Page } from 'playwright-core';
|
|
import sitePages from '../src/sitePages.ts';
|
|
import {
|
|
eventually,
|
|
inCi,
|
|
openPage,
|
|
waitForHydration,
|
|
} from './support/browser.ts';
|
|
import { startServer } from './support/server.ts';
|
|
|
|
// FR-PR-09, FR-PR-10, V-D6: Reveal is zichtbaar in de HTML en in de eerste
|
|
// render; na de hydratatie verbergt alleen een element dat helemaal onder het
|
|
// scherm staat zich, zonder overgang, en het verschijnt bij het scrollen.
|
|
let server: Awaited<ReturnType<typeof startServer>>;
|
|
beforeAll(async () => {
|
|
server = await startServer();
|
|
});
|
|
afterAll(() => server.close());
|
|
|
|
interface Entry {
|
|
// Bovenkant en schermhoogte bij de eerste frame waarin het element bestaat
|
|
top: number;
|
|
viewport: number;
|
|
opacities: number[];
|
|
}
|
|
interface Sampler {
|
|
entries: Entry[];
|
|
mark: () => void;
|
|
marked: number;
|
|
}
|
|
declare global {
|
|
interface Window {
|
|
__reveal: Sampler;
|
|
}
|
|
}
|
|
|
|
// Leest op elke animatieframe, vanaf de eerste, de dekking van elke Reveal
|
|
async function installSampler(page: Page) {
|
|
await page.addInitScript(() => {
|
|
const seen = new Map<Element, { top: number; opacities: number[] }>();
|
|
const entries: Entry[] = [];
|
|
const sampler: Sampler = {
|
|
entries,
|
|
marked: 0,
|
|
mark() {
|
|
sampler.marked = entries.length;
|
|
},
|
|
};
|
|
window.__reveal = sampler;
|
|
const tick = () => {
|
|
for (const element of document.querySelectorAll('[data-reveal]')) {
|
|
let entry = seen.get(element) as Entry | undefined;
|
|
if (!entry) {
|
|
entry = {
|
|
top: element.getBoundingClientRect().top,
|
|
viewport: window.innerHeight,
|
|
opacities: [],
|
|
};
|
|
seen.set(element, entry);
|
|
entries.push(entry);
|
|
}
|
|
entry.opacities.push(Number(getComputedStyle(element).opacity));
|
|
}
|
|
requestAnimationFrame(tick);
|
|
};
|
|
requestAnimationFrame(tick);
|
|
});
|
|
}
|
|
|
|
const samples = (page: Page, from = 0) =>
|
|
page.evaluate((start) => window.__reveal.entries.slice(start), from);
|
|
|
|
const pages = [
|
|
'/',
|
|
'/over-mij',
|
|
'/portfolio',
|
|
'/soorten-fotoshoots',
|
|
'/contact',
|
|
'/soorten-fotoshoots/newborn',
|
|
];
|
|
const sizes = [
|
|
{ width: 390, height: 823 },
|
|
{ width: 1350, height: 940 },
|
|
];
|
|
|
|
// De opacity gaat nooit van 0 terug naar 1 zonder scroll: 1...1 0...0
|
|
const stepsDown = (opacities: number[]) =>
|
|
opacities.every((value, index) => {
|
|
if (value !== 0 && value !== 1) return false;
|
|
return index === 0 || !(opacities[index - 1] === 0 && value === 1);
|
|
});
|
|
|
|
const open = (
|
|
path: string,
|
|
size: { width: number; height: number },
|
|
reducedMotion?: 'reduce',
|
|
) =>
|
|
openPage(server.origin + path, {
|
|
...size,
|
|
reducedMotion,
|
|
prepare: installSampler,
|
|
});
|
|
|
|
// Na de hydratatie nog twee seconden meten: een late verberging of een
|
|
// overgang zou in die tijd zichtbaar worden
|
|
async function settle(page: Page) {
|
|
await waitForHydration(page);
|
|
await page.waitForTimeout(2000);
|
|
}
|
|
|
|
describe.each(sizes)('Reveal bij het laden op $width x $height', (size) => {
|
|
it.each(pages)(
|
|
'%s: wat in beeld staat blijft op elke frame 1, de rest gaat zonder overgang naar 0',
|
|
async (path) => {
|
|
const { page, ...opened } = await open(path, size);
|
|
await settle(page);
|
|
const entries = await samples(page);
|
|
expect(entries.length).toBeGreaterThan(0);
|
|
|
|
const hidden = await page.locator('[data-reveal="hidden"]').count();
|
|
let below = 0;
|
|
for (const entry of entries) {
|
|
if (entry.top < entry.viewport) {
|
|
expect(entry.opacities.every((value) => value === 1)).toBe(
|
|
true,
|
|
);
|
|
} else {
|
|
below++;
|
|
expect(stepsDown(entry.opacities)).toBe(true);
|
|
}
|
|
}
|
|
// Wat onder het scherm begon, is na de hydratatie verborgen,
|
|
// tenzij de opmaak het intussen in beeld schoof
|
|
const finalHidden = entries.filter(
|
|
(entry) => entry.opacities.at(-1) === 0,
|
|
).length;
|
|
expect(finalHidden).toBe(hidden);
|
|
expect(finalHidden).toBeLessThanOrEqual(below);
|
|
expect(opened.messages).toEqual([]);
|
|
},
|
|
);
|
|
|
|
it('met verminderde beweging is elke Reveal op elke frame zichtbaar', async () => {
|
|
for (const path of pages) {
|
|
const { page } = await open(path, size, 'reduce');
|
|
await settle(page);
|
|
const entries = await samples(page);
|
|
expect(entries.length).toBeGreaterThan(0);
|
|
for (const entry of entries) {
|
|
expect(entry.opacities.every((value) => value === 1)).toBe(
|
|
true,
|
|
);
|
|
}
|
|
await expect(
|
|
page.locator('[data-reveal="hidden"]').count(),
|
|
).resolves.toBe(0);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Reveal bij het scrollen', () => {
|
|
it('toont een verborgen element binnen 1,5 s als het in beeld komt', async () => {
|
|
const { page } = await open('/', { width: 390, height: 823 });
|
|
await settle(page);
|
|
// Een handle: de locator zou na het tonen het volgende verborgen
|
|
// element aanwijzen
|
|
const target = await page
|
|
.locator('[data-reveal="hidden"]')
|
|
.first()
|
|
.elementHandle();
|
|
expect(target).not.toBeNull();
|
|
await target!.evaluate((element) =>
|
|
element.scrollIntoView({ block: 'center', behavior: 'instant' }),
|
|
);
|
|
// De overgang duurt 0,8 s; 1,5 s laat lokaal ruimte voor de
|
|
// IntersectionObserver. Op de Pi (CI-run 598: opacity 0,987 na 1,5 s)
|
|
// vertraagt de zwaar belaste hoofdthread die, dus daar ruimer: een
|
|
// vastgelopen overgang haalt 10 s ook niet.
|
|
await expect
|
|
.poll(() => target!.evaluate((e) => getComputedStyle(e).opacity), {
|
|
timeout: inCi ? 10_000 : 1500,
|
|
interval: 50,
|
|
})
|
|
.toBe('1');
|
|
await expect(target!.getAttribute('data-reveal')).resolves.toBe(
|
|
'visible',
|
|
);
|
|
});
|
|
|
|
it('laat de prijskaarten onder het scherm met oplopende vertraging verschijnen', async () => {
|
|
const { page } = await open('/', { width: 1350, height: 940 });
|
|
await settle(page);
|
|
const cards = page.locator('[data-testid="pricing"] [data-reveal]');
|
|
const hiddenCards = page.locator(
|
|
'[data-testid="pricing"] [data-reveal="hidden"]',
|
|
);
|
|
await expect(cards.count()).resolves.toBeGreaterThan(3);
|
|
await expect(hiddenCards.count()).resolves.toBeGreaterThanOrEqual(3);
|
|
await page.getByTestId('pricing').evaluate((element) =>
|
|
element.scrollIntoView({
|
|
block: 'center',
|
|
behavior: 'instant',
|
|
}),
|
|
);
|
|
await expect
|
|
.poll(() => hiddenCards.count(), { timeout: 3000, interval: 50 })
|
|
.toBe(0);
|
|
const delays = await cards.evaluateAll((elements) =>
|
|
elements
|
|
.slice(-3)
|
|
.map((element) =>
|
|
parseFloat(getComputedStyle(element).transitionDelay),
|
|
),
|
|
);
|
|
expect(delays[0]).toBeLessThan(delays[1]);
|
|
expect(delays[1]).toBeLessThan(delays[2]);
|
|
});
|
|
|
|
it('toont het raster van /portfolio op 412 x 823 bij het laden (het oude lege raster)', async () => {
|
|
const { page } = await open('/portfolio', { width: 412, height: 823 });
|
|
await settle(page);
|
|
const wrapper = page.locator(
|
|
'[data-reveal]:has([data-testid="portfolio-grid"])',
|
|
);
|
|
await expect(wrapper.getAttribute('data-reveal')).resolves.toBe(
|
|
'visible',
|
|
);
|
|
await expect(
|
|
wrapper.evaluate((element) => getComputedStyle(element).opacity),
|
|
).resolves.toBe('1');
|
|
});
|
|
});
|
|
|
|
describe('Reveal bij een navigatie in de browser (O1)', () => {
|
|
it('houdt wat in beeld staat op elke frame zichtbaar na een klik op Over mij', async () => {
|
|
const { page, ...opened } = await open('/', {
|
|
width: 1350,
|
|
height: 940,
|
|
});
|
|
await settle(page);
|
|
await page.evaluate(() => window.__reveal.mark());
|
|
const from = await page.evaluate(() => window.__reveal.marked);
|
|
await page
|
|
.getByRole('navigation', { name: 'Hoofdmenu' })
|
|
.getByRole('link', { name: 'Over mij' })
|
|
.click();
|
|
await page.waitForURL('**/over-mij');
|
|
await eventually(() =>
|
|
page.locator('h1').first().textContent(),
|
|
).toMatch(/Over mij/);
|
|
await page.waitForTimeout(1500);
|
|
const entries = await samples(page, from);
|
|
expect(entries.length).toBeGreaterThan(0);
|
|
for (const entry of entries) {
|
|
if (entry.top < entry.viewport) {
|
|
expect(entry.opacities.every((value) => value === 1)).toBe(
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
expect(opened.messages).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// BR-RVL-13: een verborgen Reveal hoger dan (schermhoogte - 60) / 0,12 haalt
|
|
// de drempel van 12 % nooit. Per pagina en breedte wordt de hoogste genoteerd.
|
|
describe('hoogte van de verborgen Reveal (V-D6)', () => {
|
|
const viewports = [
|
|
{ width: 320, height: 568 },
|
|
{ width: 360, height: 640 },
|
|
{ width: 412, height: 823 },
|
|
{ width: 768, height: 1024 },
|
|
{ width: 1350, height: 940 },
|
|
];
|
|
it.each(viewports)(
|
|
'blijft onder de grens op $width x $height',
|
|
async (size) => {
|
|
const limit = (size.height - 60) / 0.12;
|
|
const tallest: string[] = [];
|
|
for (const path of Object.keys(sitePages)) {
|
|
const { page } = await openPage(server.origin + path, {
|
|
...size,
|
|
});
|
|
// De footer hydrateert eerder dan de pagina zelf: wacht tot
|
|
// ook de Reveals hun keuze hebben gemaakt
|
|
await settle(page);
|
|
const heights = await page
|
|
.locator('[data-reveal="hidden"]')
|
|
.evaluateAll((elements) =>
|
|
elements.map(
|
|
(element) => element.getBoundingClientRect().height,
|
|
),
|
|
);
|
|
const max = Math.max(0, ...heights);
|
|
tallest.push(`${path}: ${Math.round(max)} px`);
|
|
expect(max).toBeLessThanOrEqual(limit);
|
|
}
|
|
console.info(
|
|
`V-D6 ${size.width} x ${size.height}, grens ${Math.round(limit)} px; ` +
|
|
tallest.join('; '),
|
|
);
|
|
},
|
|
);
|
|
});
|