Files
AndreaSlopFotografie/web/src/lib/shootPageView.test.ts
SluijsensandClaude Opus 5.5 e5f4348178 Adds the shoot-type pages content and SEO foundation
Five pages under /soorten-fotoshoots/<id> with draft copy awaiting
Andrea's approval (DRAFT markers), structured data (Service,
BreadcrumbList, FAQPage), sitemap and Lighthouse entries. The overview
route moves to soorten-fotoshoots/index.tsx.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 13:31:46 +01:00

370 lines
13 KiB
TypeScript
Raw Permalink Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import fc from 'fast-check';
import { describe, expect, it } from 'vitest';
import sleepingBaby from '../assets/portfolio/f41a8700.jpg';
import packages from '../content/packages';
import shootPageShared from '../content/shootPageShared';
import loveshootPage from '../content/shootPages/loveshoot';
import newbornPage from '../content/shootPages/newborn';
import shootTypes from '../content/shootTypes';
import siteContent from '../content/siteContent';
import type { ContentImage, RichText } from '../content/types';
import {
anyPackage,
anySiteContent,
contentImage,
knownPlaceholders,
plainText,
shootPageContent,
shootPageShared as anyShared,
shootType,
shootTypeId,
} from '../test/arbitraries';
import { shootPackage } from './shootPackage';
import { SHOOT_TYPE_IDS, shootPagePath } from './shootPages';
import {
MOSAIC_MIN_PHOTOS,
PROCESS_STEP_ORDER,
shootPageView,
type ShootPageSources,
type ShootPageView,
} from './shootPageView';
import { visiblePackages } from './visiblePackages';
const NBSP = ' ';
const sources: ShootPageSources = {
shootTypes,
packages,
shared: shootPageShared,
site: siteContent,
portfolioShoots: ['newborn'],
};
// Shoot types with unique ids, some with a detail photo
const shoots = fc.uniqueArray(
fc
.tuple(shootType, fc.option(contentImage, { nil: undefined }))
.map(([shoot, detailImage]) =>
detailImage === undefined ? shoot : { ...shoot, detailImage },
),
{ selector: (shoot) => shoot.id, maxLength: 5 },
);
// The sources as the CMS could deliver them. The reply time has no braces,
// as in the content: it is filled in as a value.
const anySources: fc.Arbitrary<ShootPageSources> = fc.record({
shootTypes: shoots,
packages: fc.array(anyPackage, { maxLength: 6 }),
shared: anyShared,
site: fc.tuple(anySiteContent, plainText).map(([site, replyTime]) => ({
...site,
contactForm: { ...site.contactForm, replyTime },
})),
portfolioShoots: fc.subarray([...SHOOT_TYPE_IDS]),
});
// A shoot id (mostly one of the sources), the sources, and page content
// that mostly belongs to that shoot, its photos repeating the shoot's own
const viewCase = anySources.chain((given) => {
const ids = given.shootTypes.map((shoot) => shoot.id);
const id =
ids.length > 0
? fc.oneof(
{ arbitrary: fc.constantFrom(...ids), weight: 4 },
shootTypeId,
)
: shootTypeId;
return id.chain((shootId) => {
const shoot = given.shootTypes.find((item) => item.id === shootId);
const reuse =
shoot === undefined
? []
: [
shoot.image,
...(shoot.detailImage ? [shoot.detailImage] : []),
];
return fc.record({
id: fc.constant(shootId),
sources: fc.constant(given),
page: fc.oneof(
{ arbitrary: shootPageContent(shootId, reuse), weight: 4 },
shootPageContent(undefined, reuse),
),
});
});
});
// A case for which the view exists
const resolvedCase = viewCase.filter(
({ id, page, sources: given }) =>
page.id === id && given.shootTypes.some((shoot) => shoot.id === id),
);
const build = (c: {
id: Parameters<typeof shootPageView>[0];
page: Parameters<typeof shootPageView>[1];
sources: ShootPageSources;
}) => shootPageView(c.id, c.page, c.sources) as ShootPageView;
const plain = (text: RichText) =>
text.map((piece) => (typeof piece === 'string' ? piece : piece.text));
// Every text in which placeholders are filled in
const filledTexts = (view: ShootPageView) => [
...view.stories.flatMap((story) => [
story.eyebrow,
story.title,
...story.paragraphs.flatMap(plain),
]),
...view.process.steps.map((step) => step.text),
...(view.faq?.items ?? []).flatMap((item) => [
item.question,
...plain(item.answer),
]),
view.offer.depositNote,
];
// The photos the story blocks and the package block show
const usedElsewhere = (view: ShootPageView): ContentImage[] => [
...view.stories.flatMap((story) =>
story.image === undefined ? [] : [story.image],
),
view.offer.image,
];
describe('shootPageView with the real content', () => {
it('builds the newborn page with its package, filled texts and mosaic', () => {
const view = shootPageView('newborn', newbornPage, sources)!;
expect(view.path).toBe('/soorten-fotoshoots/newborn');
expect(view.breadcrumb).toEqual({
label: 'Kruimelpad',
items: [
{ label: 'Home', to: '/' },
{ label: 'Soorten fotoshoots', to: '/soorten-fotoshoots' },
{ label: 'Newborn', to: '/soorten-fotoshoots/newborn' },
],
});
expect(view.offer.pkg?.price).toBe(185);
expect(view.offer.bookLink).toEqual({
to: '/contact',
search: { pakket: 'newborn' },
});
expect(view.closing.link).toEqual(view.offer.bookLink);
expect(view.offer.askLink).toEqual({ to: '/contact' });
expect(view.offer.depositNote).toBe(
`Aanbetaling €${NBSP}50, restbedrag na de shoot.`,
);
expect(view.offer.image).toBe(shootTypes[0].detailImage);
expect(view.process.steps.map((step) => step.id)).toEqual(
PROCESS_STEP_ORDER,
);
expect(view.process.steps[0].text).toBe(
'Stuur een berichtje. Ik reageer binnen 1-2 werkdagen.',
);
expect(view.process.steps[2].text).toBe(
`Met een aanbetaling van €${NBSP}50 staat je datum vast.`,
);
expect(view.process.steps[3].text).toBe(newbornPage.process.duration);
// The sleeping baby is in a story block already (D14)
expect(view.photos?.images).toEqual(
newbornPage.photos.images.filter(
(image) => image.src !== sleepingBaby,
),
);
expect(view.photos?.images).toHaveLength(3);
expect(view.photos?.portfolioLink).toEqual({
to: '/portfolio',
search: { shoot: 'newborn' },
});
expect(view.faq?.items.length).toBe(newbornPage.faq.items.length);
});
it('builds the loveshoot page without package and without mosaic', () => {
const view = shootPageView('loveshoot', loveshootPage, sources)!;
expect(view.offer.pkg).toBeUndefined();
expect(view).not.toHaveProperty('offer.pkg');
expect(view.offer.bookLink).toEqual({ to: '/contact' });
expect(view.closing.link).toEqual({ to: '/contact' });
expect(view.offer.onRequest.price).toBe('Prijs op aanvraag');
expect(view.photos).toBeUndefined();
expect(view.breadcrumb.items.at(-1)).toEqual({
label: 'Loveshoot',
to: '/soorten-fotoshoots/loveshoot',
});
});
it('gives undefined for a missing shoot type or content of another shoot', () => {
expect(
shootPageView('newborn', newbornPage, {
...sources,
shootTypes: shootTypes.filter(
(shoot) => shoot.id !== 'newborn',
),
}),
).toBeUndefined();
expect(
shootPageView('loveshoot', newbornPage, sources),
).toBeUndefined();
});
it('leaves out the FAQ without questions and the portfolio link when the portfolio does not show the shoot', () => {
const view = shootPageView(
'newborn',
{ ...newbornPage, faq: { ...newbornPage.faq, items: [] } },
{ ...sources, portfolioShoots: [] },
)!;
expect(view.faq).toBeUndefined();
expect(view.photos).toBeDefined();
expect(view.photos).not.toHaveProperty('portfolioLink');
});
});
describe('shootPageView', () => {
it('is undefined exactly when the shoot type is missing or the content is of another shoot (invariant)', () => {
fc.assert(
fc.property(viewCase, ({ id, page, sources: given }) => {
const view = shootPageView(id, page, given);
const exists =
page.id === id &&
given.shootTypes.some((shoot) => shoot.id === id);
expect(view !== undefined).toBe(exists);
if (view !== undefined) {
expect(view.id).toBe(id);
expect(view.shoot.id).toBe(id);
expect(view.path).toBe(shootPagePath(id));
}
}),
);
});
it('always has the six steps in their fixed order, whatever the content order (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
expect(view.process.steps.map((step) => step.id)).toEqual(
PROCESS_STEP_ORDER,
);
view.process.steps.forEach((step) => {
expect(step.title).toBe(
c.sources.shared.process.steps[step.id].title,
);
});
}),
);
});
it('leaves no known placeholder in any text (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
for (const text of filledTexts(build(c))) {
for (const name of knownPlaceholders) {
expect(text).not.toContain(`{${name}}`);
}
}
}),
);
});
it('shows each remaining page photo once, in order, never one used elsewhere, or no photos below the minimum (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
const used = new Set(usedElsewhere(view).map((i) => i.src));
const remaining = new Set(
c.page.photos.images
.map((image) => image.src)
.filter((src) => !used.has(src)),
);
if (remaining.size < MOSAIC_MIN_PHOTOS) {
expect(view.photos).toBeUndefined();
return;
}
const images = view.photos!.images;
const srcs = images.map((image) => image.src);
expect(new Set(srcs).size).toBe(srcs.length);
expect(new Set(srcs)).toEqual(remaining);
expect(srcs.some((src) => used.has(src))).toBe(false);
// An ordered subset: each photo is a page photo, found
// after the one before it
let from = 0;
for (const image of images) {
const at = c.page.photos.images.indexOf(image, from);
expect(at).toBeGreaterThanOrEqual(from);
from = at + 1;
}
}),
);
});
it('shows the package exactly when shootPackage finds one (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
expect(view.offer.pkg).toBe(
shootPackage(view.shoot, c.sources.packages),
);
}),
);
});
it('only ever preselects a shown package (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
const shown = visiblePackages(c.sources.packages).map(
(pkg) => pkg.id,
);
for (const link of [view.offer.bookLink, view.closing.link]) {
expect(link.to).toBe('/contact');
if (link.search !== undefined) {
expect(shown).toContain(link.search.pakket);
expect(link.search.pakket).toBe(view.offer.pkg?.id);
}
}
}),
);
});
it('ends the breadcrumb with this page, after Home and the overview (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
expect(view.breadcrumb.items.map((item) => item.to)).toEqual([
'/',
'/soorten-fotoshoots',
view.path,
]);
expect(view.breadcrumb.items.at(-1)?.label).toBe(
view.shoot.name,
);
}),
);
});
it('links the photos to the portfolio exactly when the portfolio shows the shoot (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
if (view.photos === undefined) return;
expect(view.photos.portfolioLink !== undefined).toBe(
c.sources.portfolioShoots.includes(c.id),
);
}),
);
});
it('has a FAQ exactly when there are questions, all of them in order (invariant)', () => {
fc.assert(
fc.property(resolvedCase, (c) => {
const view = build(c);
expect(view.faq !== undefined).toBe(
c.page.faq.items.length > 0,
);
expect((view.faq?.items ?? []).map((item) => item.id)).toEqual(
c.page.faq.items.map((item) => item.id),
);
}),
);
});
});