domma-cms 0.89.0 → 0.90.0

package/plugins/seo/tests/seo.test.js

@@ -1,192 +0,0 @@
-/** SEO - the pure parts: redirects, reading and judging a page, settings, structured data, robots. */
-import {test} from 'node:test';
-import assert from 'node:assert/strict';
-import {chains, checkRule, matchRedirect, normalisePath, onMoved} from '../admin/lib/redirects.js';
-import {analyse, attrs, decode, scanHtml, siteIssues, snippet} from '../admin/lib/analyse.js';
-import {checkSettings, DEFAULT_SETTINGS, excluded, mergeDefaults} from '../admin/lib/settings.js';
-import {applySeo, organisationLd, robotsLines} from '../admin/lib/schema.js';
-
-const rule = (from, to, code = 301, id = from) => ({id, from, to, code});
-
-test('paths: trailing slashes, case, doubled slashes and queries do not matter', () => {
-    assert.equal(normalisePath('/About/'), '/about');
-    assert.equal(normalisePath('about'), '/about');
-    assert.equal(normalisePath('//a///b/?x=1#y'), '/a/b');
-    assert.equal(normalisePath('/'), '/');
-    assert.equal(normalisePath(''), '');
-    assert.equal(normalisePath('/caf%C3%A9'), '/café');
-});
-
-test('redirects: exact before prefix, the longest prefix wins, the query travels', () => {
-    const rules = [rule('/old', '/new'), rule('/news/*', '/blog/*'), rule('/news/2019/*', '/archive', 302), rule('/gone', '', 410)];
-    assert.deepEqual(matchRedirect(rules, '/OLD/?utm=x').location, '/new?utm=x');
-    assert.equal(matchRedirect(rules, '/news/hello').location, '/blog/hello');
-    assert.equal(matchRedirect(rules, '/news').location, '/blog', 'the prefix itself goes to the target root');
-    assert.equal(matchRedirect(rules, '/news/2019/x').location, '/archive');
-    assert.equal(matchRedirect(rules, '/news/2019/x').code, 302);
-    assert.equal(matchRedirect(rules, '/gone').code, 410);
-    assert.equal(matchRedirect(rules, '/newsletter'), null, 'a prefix matches whole segments');
-    assert.equal(matchRedirect([rule('/a', '/b?ref=1')], '/a?x=2').location, '/b?ref=1', 'a target with its own query keeps it');
-    assert.equal(matchRedirect([rule('/a', 'https://ex.com/b')], '/a').location, 'https://ex.com/b');
-});
-
-test('redirect rules are checked: self, loops, duplicates, the admin, bad targets', () => {
-    const ok = checkRule({from: '/Old-Page/', to: '/new-page'});
-    assert.deepEqual(ok.errors, {});
-    assert.equal(ok.rule.from, '/old-page');
-    assert.equal(checkRule({from: '/a', to: '/a'}).errors.to, 'It would redirect to itself.');
-    assert.match(checkRule({from: '/b', to: '/a'}, [rule('/a', '/b')]).errors.to, /loop/);
-    assert.match(checkRule({from: '/c', to: '/a'}, [rule('/a', '/b'), rule('/b', '/c')]).errors.to, /loop/, 'a longer loop too');
-    assert.match(checkRule({from: '/a', to: '/x'}, [rule('/a', '/b')]).errors.from, /already/);
-    assert.ok(checkRule({from: '/admin/x', to: '/y'}).errors.from);
-    assert.ok(checkRule({from: '/*', to: '/y'}).errors.from);
-    assert.ok(checkRule({from: '/a', to: 'javascript:alert(1)'}).errors.to);
-    assert.ok(checkRule({from: '/a', to: '//evil.example'}).errors.to);
-    assert.ok(checkRule({from: '/a', to: '/b/*'}).errors.to, 'a * needs a prefix rule');
-    assert.deepEqual(checkRule({from: '/a/*', to: '/b/*'}).errors, {});
-    assert.deepEqual(checkRule({from: '/a', code: 410}).errors, {}, 'gone needs no target');
-    assert.ok(checkRule({from: '/a', to: '/b', code: 303}).errors.code);
-});
-
-test('a moved page: a redirect is added, older ones re-aimed, none from the new address', () => {
-    let rules = [rule('/older', '/old', 301, 'r1'), rule('/new', '/elsewhere', 301, 'r2')];
-    rules = onMoved(rules, '/old', '/new', {id: 'r3', now: 'T'});
-    assert.deepEqual(rules.map(r => [r.from, r.to]), [['/older', '/new'], ['/old', '/new']]);
-    assert.equal(rules.at(-1).auto, true);
-    assert.deepEqual(chains(rules), [], 'no chains left');
-    assert.deepEqual(chains([rule('/a', '/b', 301, 'a'), rule('/b', '/c', 301, 'b')]).map(c => [c.rule.id, c.via.id]), [['a', 'b']]);
-    assert.equal(onMoved(rules, '/x', '/x'), rules, 'no move, no change');
-});
-
-const PAGE = `<!doctype html><html lang="en"><head>
-<title>Garden tools &amp; seeds | Shop</title>
-<meta name="description" content="Everything for the garden: garden tools, seeds and advice from people who grow things for a living.">
-<link rel="canonical" href="https://ex.com/garden-tools">
-<meta property="og:image" content="https://ex.com/a.jpg">
-<script type="application/ld+json">{"@type":"WebPage"}</script>
-<script type="application/ld+json">{"@graph":[{"@type":"BreadcrumbList"}]}</script>
-</head><body>
-<!-- <h1>not this</h1> -->
-<script>document.write('<h1>nor this</h1>')</script>
-<h1>Garden tools</h1><p>Our garden tools are made to last. Choose from forks, spades and trowels.</p>
-<h2>Forks</h2><h4>Skipped a level</h4>
-<img src="/a.jpg" alt="A fork"><img src="/b.jpg"><img src="/c.jpg" alt=""><img src="/d.jpg" role="presentation">
-<a href="/spades">Spades</a> <a href="https://other.example/">Other</a> <a href="#top">Top</a>
-</body></html>`;
-
-test('scanHtml: what a crawler sees, ignoring scripts and comments', () => {
-    const f = scanHtml(PAGE);
-    assert.equal(f.title, 'Garden tools & seeds | Shop');
-    assert.match(f.description, /^Everything for the garden/);
-    assert.equal(f.canonical, 'https://ex.com/garden-tools');
-    assert.equal(f.lang, 'en');
-    assert.deepEqual(f.headings.map(h => `${h.level}:${h.text}`), ['1:Garden tools', '2:Forks', '4:Skipped a level']);
-    assert.deepEqual(f.images.map(i => i.alt), ['A fork', null, '', null]);
-    assert.equal(f.links.length, 3);
-    assert.deepEqual(f.jsonLdTypes, ['WebPage', 'BreadcrumbList']);
-    assert.ok(f.words > 10);
-    assert.match(f.firstPara, /made to last/);
-    assert.deepEqual(attrs('<meta name=x content=\'a "b"\' async>'), {name: 'x', content: 'a "b"', async: ''});
-    assert.equal(decode('&lt;a&gt; &#39;x&#x27; &pound;&nbsp;'), '<a> \'x\' £ ');
-});
-
-test('analyse: the checks, a focus keyphrase, and the score', () => {
-    const f = scanHtml(PAGE);
-    const r = analyse(f, {urlPath: '/garden-tools', focus: 'garden tools', origin: 'https://ex.com'});
-    const by = Object.fromEntries(r.checks.map(c => [c.id, c.status]));
-    assert.equal(by.title, 'warn', '27 characters is short');
-    assert.equal(by.h1, 'pass');
-    assert.equal(by.headings, 'warn', 'H2 -> H4 is a skip');
-    assert.equal(by.alt, 'fail', 'one image has no alt; decoration and alt="" are fine');
-    assert.equal(by.links, 'pass');
-    assert.equal(by.focus, 'pass');
-    assert.equal(by.canonical, 'pass');
-    assert.equal(by.schema, 'pass');
-    assert.equal(by.words, 'warn', 'a few dozen words');
-    assert.ok(r.score > 0 && r.score < 100);
-    assert.equal(r.failing, 1);
-
-    const bare = analyse(scanHtml('<html><head></head><body><p>hi</p></body></html>'), {urlPath: '/x'});
-    const b = Object.fromEntries(bare.checks.map(c => [c.id, c.status]));
-    assert.equal(b.title, 'fail');
-    assert.equal(b.description, 'fail');
-    assert.equal(b.h1, 'fail');
-    assert.equal(b.lang, 'warn');
-    assert.equal(b.focus, 'info');
-
-    const missing = analyse(f, {urlPath: '/garden-tools', focus: 'lawn mower'});
-    assert.equal(missing.checks.find(c => c.id === 'focus').status, 'fail');
-    assert.equal(analyse(scanHtml('<html><head><meta name="robots" content="noindex"></head></html>')).checks.find(c => c.id === 'index').status, 'info');
-    assert.equal(analyse(scanHtml('<script type="application/ld+json">{bad</script>')).checks.find(c => c.id === 'schema').status, 'fail');
-});
-
-test('siteIssues: duplicate titles and descriptions, hidden pages left out', () => {
-    const r = siteIssues([
-        {urlPath: '/a', title: 'Home', description: 'Same'},
-        {urlPath: '/b', title: 'home', description: 'Same'},
-        {urlPath: '/c', title: 'Home', noindex: true},
-        {urlPath: '/d', title: 'Other', description: ''}
-    ]);
-    assert.deepEqual(r.duplicateTitles.map(d => d.paths), [['/a', '/b']]);
-    assert.deepEqual(r.duplicateDescriptions.map(d => d.paths), [['/a', '/b']]);
-});
-
-test('snippet: cut where search results cut, crumbs from the address', () => {
-    const s = snippet({title: 'x'.repeat(40) + ' ' + 'y'.repeat(30), description: 'short', url: 'https://ex.com/a/b'});
-    assert.equal(s.titleCut, true);
-    assert.ok(s.title.endsWith('…'));
-    assert.equal(s.crumbs, 'ex.com › a › b');
-    assert.equal(s.descriptionCut, false);
-});
-
-test('settings: checked, merged, and a missing organisation name refused', () => {
-    const {errors, settings} = checkSettings({audit: {titleMax: 20}, sitemap: {exclude: 'thanks\n/private/'}, organisation: {enabled: true}});
-    assert.ok(errors['audit.titleMax']);
-    assert.ok(errors['sitemap.exclude']);
-    assert.ok(errors['organisation.name']);
-    assert.equal(settings.audit.titleMax, DEFAULT_SETTINGS.audit.titleMax);
-    const ok = checkSettings({sitemap: {exclude: '/private/\n/thanks', sources: {blog: false}}, robots: {extra: 'Disallow: /x/\n# note'}, organisation: {sameAs: 'https://x.com/a'}});
-    assert.deepEqual(ok.errors, {});
-    assert.deepEqual(ok.settings.sitemap.exclude, ['/private/', '/thanks']);
-    assert.equal(ok.settings.sitemap.sources.blog, false);
-    assert.ok(checkSettings({robots: {extra: 'nonsense line'}}).errors['robots.extra']);
-    assert.deepEqual(mergeDefaults({audit: {everyHours: 6}}).audit.titleMax, DEFAULT_SETTINGS.audit.titleMax);
-    assert.equal(excluded('/private/x', ['/private/']), true);
-    assert.equal(excluded('/private', ['/private/']), true);
-    assert.equal(excluded('/privateer', ['/private/']), false);
-    assert.equal(excluded('/thanks', ['/thanks']), true);
-    assert.equal(excluded('/thanks/more', ['/thanks']), false);
-});
-
-test('structured data: the organisation on the home page, BlogPosting on posts, overrides applied', () => {
-    const settings = mergeDefaults({organisation: {enabled: true, type: 'LocalBusiness', name: 'Acme', logo: '/logo.png', address: {locality: 'Leeds'}}});
-    assert.equal(organisationLd({enabled: false}), null);
-    const ld = organisationLd(settings.organisation, {origin: 'https://ex.com'});
-    assert.equal(ld.logo, 'https://ex.com/logo.png');
-    assert.equal(ld.address.addressLocality, 'Leeds');
-
-    const base = {title: 'T', description: 'D', image: '', ogType: 'website', noindex: false, canonical: 'https://ex.com/', og: {}, twitter: {}, jsonLd: [{'@type': 'WebPage'}], extra: []};
-    const home = applySeo(base, {page: {urlPath: '/'}, kind: 'page', origin: 'https://ex.com', settings});
-    assert.deepEqual(home.jsonLd.map(x => x['@type']), ['WebPage', 'LocalBusiness']);
-    assert.deepEqual(base.jsonLd.length, 1, 'core\'s model is not changed in place');
-
-    const post = applySeo({...base, canonical: 'https://ex.com/blog/p'}, {page: {urlPath: '/blog/p', item: {type: 'blog:post'}}, kind: 'plugin', origin: 'https://ex.com', settings,
-        override: {title: 'Better', description: 'Better D', image: '/p.jpg', noindex: true}});
-    assert.equal(post.title, 'Better');
-    assert.equal(post.image, 'https://ex.com/p.jpg');
-    assert.equal(post.noindex, true);
-    assert.equal(post.ogType, 'article');
-    const bp = post.jsonLd.find(x => x['@type'] === 'BlogPosting');
-    assert.equal(bp.headline, 'Better');
-    assert.equal(bp.publisher.name, 'Acme');
-    assert.equal(post.jsonLd[0].description, 'Better D');
-});
-
-test('robots: extra rules join the * group; their own groups go before Sitemap; block all', () => {
-    const core = ['User-agent: *', 'Allow: /', 'Disallow: /admin/', 'Disallow: /api/', '', 'Sitemap: https://ex.com/sitemap.xml'];
-    assert.deepEqual(robotsLines(core, {extra: 'Disallow: /tmp/'}), ['User-agent: *', 'Allow: /', 'Disallow: /admin/', 'Disallow: /api/', 'Disallow: /tmp/', '', 'Sitemap: https://ex.com/sitemap.xml']);
-    const g = robotsLines(core, {extra: 'User-agent: GPTBot\nDisallow: /'});
-    assert.deepEqual(g.slice(5), ['User-agent: GPTBot', 'Disallow: /', '', 'Sitemap: https://ex.com/sitemap.xml']);
-    assert.deepEqual(robotsLines(core, {blockAll: true}).slice(1), ['User-agent: *', 'Disallow: /']);
-    assert.equal(robotsLines(core, {}), core);
-});