Resource Hints Auditor
Pricing
Pay per usage
"Enrich public GitHub repository URLs with stars, forks, topics, license, activity, owner metadata, release data, and lead-scoring signals. Built for B2B lead generation, devtools research, and competitive intelligence."
Pricing
Pay per usage
Rating
0.0
(0)
Developer
Sanskar Jaiswal
Maintained by CommunityActor stats
0
Bookmarked
2
Total users
1
Monthly active users
4 days ago
Last modified
Categories
Share
FROM apify/actor-node:20
COPY package*.json ./RUN npm --quiet set progress=false \ && npm install --omit=dev --omit=optional
COPY . ./
CMD ["npm", "start"]{ "name": "resource-hints-auditor", "version": "0.1.0", "description": "Apify Actor that audits public pages for resource hints (preload, prefetch, preconnect, dns-prefetch, modulepreload, prerender) and returns a score, grade, and Core Web Vitals recommendations.", "type": "module", "private": true, "main": "src/main.js", "scripts": { "start": "node src/main.js", "test": "node --test test/*.test.js", "lint": "node --check src/main.js" }, "dependencies": { "apify": "^3.4.5" }, "devDependencies": {}}{ "actorSpecification": 1, "name": "resource-hints-auditor", "title": "Resource Hints Auditor", "description": "Audit a public page for resource hints (preload, prefetch, preconnect, dns-prefetch, modulepreload, prerender). Returns per-hint analysis, crossorigin gaps, duplicates, score, grade, and Core Web Vitals recommendations.", "version": "0.1", "buildTag": "latest", "meta": { "templateId": "js-start" }, "input": "./input_schema.json", "output": "./output_schema.json", "storages": { "dataset": "./dataset_schema.json" }, "dockerfile": "./Dockerfile", "defaultRunOptions": { "build": "latest", "timeoutSecs": 60, "memoryMbytes": 512 }}{ "actorSpecification": 1, "fields": { "type": "object", "properties": { "inputUrl": { "type": "string", "description": "The URL provided as input" }, "finalUrl": { "type": "string", "description": "Final URL after redirects" }, "https": { "type": "boolean", "description": "Whether the final response was served over HTTPS" }, "hintCount": { "type": "integer", "description": "Total number of resource hint link tags found" }, "byType": { "type": "object", "description": "Count of hints grouped by rel type (preload, prefetch, preconnect, dns-prefetch, modulepreload, prerender)" }, "hints": { "type": "array", "description": "Per-hint analysis: rel, href, as, crossorigin, origin, issue, recommendation" }, "issues": { "type": "array", "description": "Aggregated issue descriptions" }, "score": { "type": "integer", "description": "Resource hints readiness score (0-100)" }, "grade": { "type": "string", "description": "Letter grade (A+, A, B, C, D, E, F)" }, "checkedAt": { "type": "string", "format": "date-time", "description": "ISO timestamp" }, "recommendations": { "type": "array", "description": "Actionable recommendations for improving resource hints" } } }, "views": { "overview": { "title": "Overview", "transformation": { "fields": ["finalUrl", "https", "hintCount", "byType", "grade", "score", "issues", "recommendations", "checkedAt"] }, "display": { "component": "table", "properties": { "finalUrl": { "label": "URL", "format": "link" }, "https": { "label": "HTTPS", "format": "boolean" }, "hintCount": { "label": "Hints", "format": "number" }, "byType": { "label": "By type", "format": "object" }, "grade": { "label": "Grade", "format": "text" }, "score": { "label": "Score", "format": "number" }, "issues": { "label": "Issues", "format": "array" }, "recommendations": { "label": "Recommendations", "format": "array" }, "checkedAt": { "label": "Checked", "format": "date" } } } } }}{ "title": "Resource Hints Auditor", "type": "object", "schemaVersion": 1, "description": "Audit a public web page for resource hints (preload, prefetch, preconnect, dns-prefetch, modulepreload, prerender). Get per-hint analysis, crossorigin gaps, duplicates, score, grade, and Core Web Vitals recommendations.", "properties": { "startUrl": { "title": "Page URL", "type": "string", "description": "Public page URL to audit. The actor fetches the HTML once and parses <link> resource hints. HTTP and HTTPS only. Private IP ranges are blocked.", "editor": "textfield", "prefill": "https://example.com", "pattern": "^https?://.+" }, "timeoutSeconds": { "title": "Request timeout (seconds)", "type": "integer", "description": "Timeout for the HTTP request.", "minimum": 3, "maximum": 30, "default": 10, "unit": "seconds", "editor": "number" }, "maxHtmlBytes": { "title": "Max HTML bytes", "type": "integer", "description": "Maximum HTML body size to download and parse.", "minimum": 16384, "maximum": 2097152, "default": 1048576, "editor": "number" } }, "required": ["startUrl"]}{ "actorOutputSchemaVersion": 1, "title": "Output schema of Resource Hints Auditor", "description": "Audit results are stored in the default dataset.", "properties": { "results": { "type": "string", "title": "Audit results", "template": "{{links.apiDefaultDatasetUrl}}/items" } }}1import { Actor } from 'apify';2import dns from 'node:dns/promises';3import net from 'node:net';4import { fileURLToPath } from 'node:url';5
6const USER_AGENT = 'ResourceHintsAuditor/0.1 (+https://apify.com)';7const DEFAULT_TIMEOUT_SECONDS = 10;8const DEFAULT_MAX_HTML_BYTES = 1024 * 1024;9const MAX_HTML_BYTES = 2 * 1024 * 1024;10
11/* ---------------------------------------------------------------------------12 * SSRF protection — shared pattern used across URL-fetching factory actors.13 * Allows only HTTP/HTTPS, rejects URL credentials, rejects localhost/private14 * IP literals, DNS-resolves hostnames, and rejects DNS that resolves to15 * private IP ranges.16 * ------------------------------------------------------------------------- */17
18function isPrivateIPv4(ip) {19 const parts = ip.split('.').map(Number);20 if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) return false;21 const [a, b] = parts;22 return a === 1023 || (a === 172 && b >= 16 && b <= 31)24 || (a === 192 && b === 168)25 || a === 12726 || a === 027 || (a === 169 && b === 254);28}29
30function isPrivateIPv6(ip) {31 const normalized = ip.toLowerCase();32 return normalized === '::1'33 || normalized.startsWith('fc')34 || normalized.startsWith('fd')35 || normalized.startsWith('fe80:');36}37
38export async function normalizeAndValidateUrl(rawUrl) {39 if (!rawUrl || typeof rawUrl !== 'string') throw new Error('startUrl is required');40 if (/^[a-z][a-z0-9+.-]*:/i.test(rawUrl) && !/^https?:\/\//i.test(rawUrl)) {41 throw new Error('Only HTTP and HTTPS URLs are supported');42 }43
44 const withScheme = /^https?:\/\//i.test(rawUrl) ? rawUrl : `https://${rawUrl}`;45 const url = new URL(withScheme);46 if (!['http:', 'https:'].includes(url.protocol)) throw new Error('Only HTTP and HTTPS URLs are supported');47 if (!url.hostname || url.username || url.password) throw new Error('URL must be public and must not include credentials');48
49 const literalType = net.isIP(url.hostname);50 if (literalType === 4 && isPrivateIPv4(url.hostname)) throw new Error('Private IPv4 targets are blocked');51 if (literalType === 6 && isPrivateIPv6(url.hostname)) throw new Error('Private IPv6 targets are blocked');52
53 const records = literalType ? [{ address: url.hostname, family: literalType }] : await dns.lookup(url.hostname, { all: true });54 for (const record of records) {55 if (record.family === 4 && isPrivateIPv4(record.address)) throw new Error('DNS resolves to a private IPv4 address; blocked for SSRF safety');56 if (record.family === 6 && isPrivateIPv6(record.address)) throw new Error('DNS resolves to a private IPv6 address; blocked for SSRF safety');57 }58 return url;59}60
61/* ---------------------------------------------------------------------------62 * HTTP fetch with manual redirect revalidation (SSRF-safe) and body cap.63 * ------------------------------------------------------------------------- */64
65async function fetchHtml(initialUrl, timeoutSeconds, maxBytes, redirectsRemaining = 3) {66 await normalizeAndValidateUrl(initialUrl.href);67 const controller = new AbortController();68 const timeout = setTimeout(() => controller.abort(), timeoutSeconds * 1000);69 try {70 const response = await fetch(initialUrl, {71 redirect: 'manual',72 signal: controller.signal,73 headers: {74 'user-agent': USER_AGENT,75 accept: 'text/html,application/xhtml+xml,*/*;q=0.1',76 },77 });78
79 if ([301, 302, 303, 307, 308].includes(response.status)) {80 if (redirectsRemaining <= 0) throw new Error('Too many redirects');81 const location = response.headers.get('location');82 if (!location) throw new Error('Redirect without Location header');83 const nextUrl = new URL(location, initialUrl.href);84 await normalizeAndValidateUrl(nextUrl.href);85 return fetchHtml(nextUrl, timeoutSeconds, maxBytes, redirectsRemaining - 1);86 }87
88 // Read up to maxBytes + 1 to detect truncation.89 const reader = response.body.getReader();90 const chunks = [];91 let total = 0;92 let truncated = false;93 while (true) {94 const { done, value } = await reader.read();95 if (done) break;96 if (total + value.length > maxBytes) {97 chunks.push(value.slice(0, Math.max(0, maxBytes - total)));98 truncated = true;99 break;100 }101 chunks.push(value);102 total += value.length;103 }104 try { await reader.cancel(); } catch { /* ignore */ }105
106 const html = new TextDecoder('utf-8', { fatal: false }).decode(Buffer.concat(chunks));107 const headerMap = {};108 response.headers.forEach((value, key) => { headerMap[key.toLowerCase()] = value; });109
110 return {111 ok: response.ok,112 status: response.status,113 finalUrl: response.url || initialUrl.href,114 https: (response.url || initialUrl.href).startsWith('https://'),115 html,116 headers: headerMap,117 truncated,118 error: null,119 };120 } catch (error) {121 return {122 ok: false,123 status: null,124 finalUrl: initialUrl.href,125 https: initialUrl.protocol === 'https:',126 html: '',127 headers: {},128 truncated: false,129 error: error.message,130 };131 } finally {132 clearTimeout(timeout);133 }134}135
136/* ---------------------------------------------------------------------------137 * HTML helpers — keep minimal; only what the audit needs.138 * ------------------------------------------------------------------------- */139
140function decodeHtmlEntities(value) {141 if (!value) return '';142 return value143 .replace(/&/gi, '&')144 .replace(/"/gi, '"')145 .replace(/'|'/gi, "'")146 .replace(/</gi, '<')147 .replace(/>/gi, '>')148 .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))149 .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)))150 .trim();151}152
153function parseAttributes(tag) {154 const attrs = {};155 // Matches key="value", key='value', key=value, or standalone boolean key.156 const attrPattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*(?:=\s*("[^"]*"|'[^']*'|[^\s"'>/]+))?/g;157 for (const match of tag.matchAll(attrPattern)) {158 if (match[2] === undefined) {159 // Boolean attribute (e.g., crossorigin, async, defer).160 attrs[match[1].toLowerCase()] = '';161 } else {162 const raw = match[2];163 const unquoted = raw.startsWith('"') || raw.startsWith("'") ? raw.slice(1, -1) : raw;164 attrs[match[1].toLowerCase()] = decodeHtmlEntities(unquoted);165 }166 }167 return attrs;168}169
170function allLinkTags(html) {171 return [...html.matchAll(/<link\b[^>]*>/gi)].map((m) => ({172 raw: m[0],173 attrs: parseAttributes(m[0]),174 }));175}176
177/* ---------------------------------------------------------------------------178 * Resource hint analysis and scoring.179 * ------------------------------------------------------------------------- */180
181const HINT_RELS = new Set(['preload', 'prefetch', 'preconnect', 'dns-prefetch', 'modulepreload', 'prerender']);182
183function originOf(href, baseUrl) {184 try {185 const u = new URL(href, baseUrl);186 return `${u.protocol}//${u.host}`;187 } catch {188 return null;189 }190}191
192function classifyHint(tag, baseUrl) {193 const rels = (tag.attrs.rel || '').toLowerCase().split(/\s+/).filter(Boolean);194 const hintRel = rels.find((r) => HINT_RELS.has(r));195 if (!hintRel) return null;196
197 const href = tag.attrs.href || '';198 const as = (tag.attrs.as || '').toLowerCase() || null;199 const crossorigin = tag.attrs.crossorigin !== undefined ? (tag.attrs.crossorigin || 'anonymous') : null;200 const origin = href ? originOf(href, baseUrl) : null;201
202 const issues = [];203 let recommendation = null;204
205 if (!href) {206 issues.push('missing href');207 recommendation = 'Add an href attribute to this resource hint.';208 }209
210 if ((hintRel === 'preconnect' || hintRel === 'dns-prefetch') && !href) {211 recommendation = 'Add an href with the origin to preconnect to.';212 }213
214 // crossorigin mismatch detection: preconnect without crossorigin for fonts/cross-origin resources215 if (hintRel === 'preconnect' && href && !crossorigin) {216 issues.push('preconnect without crossorigin may not cache credentials for cross-origin resources like fonts');217 recommendation = 'Add crossorigin to <link rel="preconnect"> for cross-origin resources that send credentials (e.g., Google Fonts).';218 }219
220 // preload without `as`221 if (hintRel === 'preload' && href && !as) {222 issues.push('preload without as attribute');223 recommendation = 'Add an as attribute to <link rel="preload"> so the browser prioritizes correctly.';224 }225
226 // preload with `as=fetch` plus crossorigin for fetch requests needing credentials227 if (hintRel === 'preload' && as === 'fetch' && !crossorigin) {228 issues.push('preload as=fetch without crossorigin');229 recommendation = 'If the preloaded fetch request uses credentials, add crossorigin to <link rel="preload" as="fetch">.';230 }231
232 return {233 rel: hintRel,234 href: href || '',235 as,236 crossorigin,237 origin,238 issues,239 recommendation,240 };241}242
243export function analyzeResourceHints(html, baseUrl) {244 const linkTags = allLinkTags(html);245 const hints = [];246 const seen = new Set();247
248 for (const tag of linkTags) {249 const parsed = classifyHint(tag, baseUrl);250 if (!parsed) continue;251
252 // duplicate detection: exact rel+href flags "preconnect http://example.com"253 const key = `${parsed.rel}|${parsed.href}`;254 if (parsed.href && seen.has(key)) {255 parsed.issues.push('duplicate hint (same rel + href)');256 if (!parsed.recommendation) parsed.recommendation = 'Remove the duplicate <link> hint; duplicate tags waste head bytes.';257 } else if (parsed.href) {258 seen.add(key);259 }260 hints.push(parsed);261 }262
263 const byType = {};264 for (const h of hints) {265 byType[h.rel] = (byType[h.rel] || 0) + 1;266 }267
268 // Aggregate issues269 const issues = [];270 for (const h of hints) {271 for (const issue of h.issues) {272 const line = `${h.rel} ${h.href || '(no href)'}: ${issue}`;273 if (!issues.includes(line)) issues.push(line);274 }275 }276
277 return { hints, byType, issues };278}279
280export function scoreResourceHints(hints, issues, hintCount) {281 // Base score: presence of basics282 let earned = 0;283 const possible = 60; // ponytail: max = 20+15+5+5+5+10284
285 const rels = new Set(hints.map((h) => h.rel));286 const hasPreconnect = rels.has('preconnect');287 const hasDnsPrefetch = rels.has('dns-prefetch');288 const hasPreload = rels.has('preload');289 const hasModulepreload = rels.has('modulepreload');290 const hasPrefetch = rels.has('prefetch');291
292 // Up to 40 pts for having common hints293 if (hasPreconnect) earned += 20;294 if (hasPreload) earned += 15;295 if (hasModulepreload) earned += 5;296
297 // Up to 20 pts more for breadth298 if (hasDnsPrefetch) earned += 5;299 if (hasPrefetch) earned += 5;300 if (hints.length >= 1) earned += 10;301
302 // Subtract for issues: max 40 pts lost303 const issuePenalty = Math.min(issues.length * 10, 40);304 earned = Math.max(0, earned - issuePenalty);305
306 if (hintCount === 0) return 0;307 return Math.round((earned / possible) * 100);308}309
310export function gradeFromScore(score) {311 if (score >= 95) return 'A+';312 if (score >= 85) return 'A';313 if (score >= 75) return 'B';314 if (score >= 65) return 'C';315 if (score >= 50) return 'D';316 if (score >= 30) return 'E';317 return 'F';318}319
320export function buildRecommendations(hints, issues, byType) {321 const recs = new Set();322
323 for (const h of hints) {324 if (h.recommendation) recs.add(h.recommendation);325 }326
327 if (!('preload' in byType)) {328 recs.add('Add <link rel="preload"> for late-discovered critical resources (fonts, CSS, JS, images) to improve LCP.');329 }330 if (!('preconnect' in byType)) {331 recs.add('Add <link rel="preconnect" crossorigin> for critical third-party origins (CDNs, font hosts) to warm TCP/TLS connections.');332 }333 if (!('dns-prefetch' in byType)) {334 recs.add('Add <link rel="dns-prefetch"> for third-party hostnames to reduce DNS latency on first request.');335 }336
337 if (issues.length === 0 && hints.length > 0) {338 recs.add('Resource hints look well-structured. Schedule this audit periodically to catch regressions.');339 }340
341 return [...recs];342}343
344/* ---------------------------------------------------------------------------345 * Main audit pipeline.346 * ------------------------------------------------------------------------- */347
348export async function auditResourceHints(input) {349 const startUrl = await normalizeAndValidateUrl(input.startUrl);350 const timeoutSeconds = Math.min(Math.max(Number(input.timeoutSeconds || DEFAULT_TIMEOUT_SECONDS), 3), 30);351 const maxHtmlBytes = Math.min(Math.max(Number(input.maxHtmlBytes || DEFAULT_MAX_HTML_BYTES), 16384), MAX_HTML_BYTES);352
353 const fetchResult = await fetchHtml(startUrl, timeoutSeconds, maxHtmlBytes);354
355 if (fetchResult.error) {356 return {357 inputUrl: input.startUrl,358 finalUrl: fetchResult.finalUrl,359 https: fetchResult.https,360 hintCount: 0,361 byType: {},362 hints: [],363 issues: [],364 score: 0,365 grade: 'F',366 checkedAt: new Date().toISOString(),367 recommendations: ['The request failed before HTML could be inspected. Verify the URL is reachable and try again.'],368 error: fetchResult.error,369 };370 }371
372 // Only parse HTML for text/html responses; tolerate other content types by treating as empty.373 const contentType = fetchResult.headers['content-type'] || '';374 const isHtml = /text\/html|application\/xhtml+xml/i.test(contentType);375
376 const { hints, byType, issues } = isHtml377 ? analyzeResourceHints(fetchResult.html, fetchResult.finalUrl)378 : { hints: [], byType: {}, issues: ['Response is not HTML; cannot parse resource hints.'] };379
380 const score = scoreResourceHints(hints, issues, hints.length);381 const grade = gradeFromScore(score);382 const recommendations = buildRecommendations(hints, issues, byType);383
384 return {385 inputUrl: input.startUrl,386 finalUrl: fetchResult.finalUrl,387 https: fetchResult.https,388 hintCount: hints.length,389 byType,390 hints,391 issues,392 score,393 grade,394 checkedAt: new Date().toISOString(),395 recommendations,396 };397}398
399/* ---------------------------------------------------------------------------400 * Apify runtime entry point.401 * ------------------------------------------------------------------------- */402
403const isExecutedDirectly = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];404
405if (process.env.NODE_ENV !== 'test' && isExecutedDirectly) {406 await Actor.init();407 try {408 const input = await Actor.getInput();409 const result = await auditResourceHints(input || {});410 await Actor.pushData(result);411 await Actor.setValue('OUTPUT', result);412 Actor.log.info('Resource hints audit complete', { finalUrl: result.finalUrl, hintCount: result.hintCount, score: result.score, grade: result.grade });413 } finally {414 await Actor.exit();415 }416}1import test from 'node:test';2import assert from 'node:assert/strict';3import {4 analyzeResourceHints,5 buildRecommendations,6 gradeFromScore,7 normalizeAndValidateUrl,8 scoreResourceHints,9} from '../src/main.js';10
11/* ---------------------------------------------------------------------------12 * SSRF / URL validation security tests13 * ------------------------------------------------------------------------- */14
15test('normalizeAndValidateUrl blocks private IPv4 literal', async () => {16 await assert.rejects(() => normalizeAndValidateUrl('http://127.0.0.1/'), /Private IPv4/);17});18
19test('normalizeAndValidateUrl blocks 169.254 link-local', async () => {20 await assert.rejects(() => normalizeAndValidateUrl('http://169.254.169.254/'), /Private IPv4/);21});22
23test('normalizeAndValidateUrl rejects URL credentials', async () => {24 await assert.rejects(() => normalizeAndValidateUrl('https://user:pass@example.com'), /credentials/);25});26
27test('normalizeAndValidateUrl rejects non-HTTP schemes', async () => {28 await assert.rejects(() => normalizeAndValidateUrl('file:///etc/hosts'), /HTTP and HTTPS/);29});30
31test('normalizeAndValidateUrl rejects ftp scheme', async () => {32 await assert.rejects(() => normalizeAndValidateUrl('ftp://example.com/file'), /HTTP and HTTPS/);33});34
35test('normalizeAndValidateUrl accepts public hostname and defaults to https', async () => {36 const url = await normalizeAndValidateUrl('example.com');37 assert.equal(url.hostname, 'example.com');38 assert.equal(url.protocol, 'https:');39});40
41/* ---------------------------------------------------------------------------42 * Resource hint analysis tests43 * ------------------------------------------------------------------------- */44
45const BASE_URL = 'https://example.com/page';46
47test('analyzeResourceHints extracts preload, preconnect, and dns-prefetch', () => {48 const html = `49 <html><head>50 <link rel="preload" href="/font.woff2" as="font" crossorigin>51 <link rel="preconnect" href="https://cdn.example.com" crossorigin>52 <link rel="dns-prefetch" href="//fonts.example.com">53 </head></html>`;54 const { hints, byType } = analyzeResourceHints(html, BASE_URL);55 assert.equal(hints.length, 3);56 assert.equal(byType.preload, 1);57 assert.equal(byType.preconnect, 1);58 assert.equal(byType['dns-prefetch'], 1);59});60
61test('analyzeResourceHints flags preload without as', () => {62 const html = `<link rel="preload" href="/style.css">`;63 const { hints, issues } = analyzeResourceHints(html, BASE_URL);64 assert.equal(hints.length, 1);65 assert.ok(issues.some((i) => i.includes('preload without as')));66 assert.ok(hints[0].recommendation.includes('as attribute'));67});68
69test('analyzeResourceHints flags preconnect without crossorigin for fonts', () => {70 const html = `<link rel="preconnect" href="https://fonts.example.com">`;71 const { hints, issues } = analyzeResourceHints(html, BASE_URL);72 assert.equal(hints.length, 1);73 assert.ok(issues.some((i) => i.includes('crossorigin')));74});75
76test('analyzeResourceHints flags duplicate preload with same href', () => {77 const html = `78 <link rel="preload" href="/font.woff2" as="font" crossorigin>79 <link rel="preload" href="/font.woff2" as="font" crossorigin>`;80 const { hints, issues } = analyzeResourceHints(html, BASE_URL);81 assert.equal(hints.length, 2);82 assert.ok(issues.some((i) => i.includes('duplicate hint')));83});84
85test('analyzeResourceHints handles boolean crossorigin attribute (bareword)', () => {86 const html = `<link rel="preconnect" href="https://cdn.example.com" crossorigin>`;87 const { hints, issues } = analyzeResourceHints(html, BASE_URL);88 assert.equal(hints.length, 1);89 assert.equal(hints[0].crossorigin, 'anonymous');90 // With crossorigin present, the preconnect-without-crossorigin issue should NOT fire.91 assert.ok(!issues.some((i) => i.includes('crossorigin')), 'should not flag crossorigin when boolean form is present');92});93
94test('analyzeResourceHints ignores non-hint link tags', () => {95 const html = `96 <link rel="stylesheet" href="/style.css">97 <link rel="icon" href="/favicon.ico">98 <link rel="canonical" href="https://example.com/page">`;99 const { hints, byType } = analyzeResourceHints(html, BASE_URL);100 assert.equal(hints.length, 0);101 assert.deepEqual(byType, {});102});103
104test('analyzeResourceHints flags missing href', () => {105 const html = `<link rel="preconnect">`;106 const { hints, issues } = analyzeResourceHints(html, BASE_URL);107 assert.equal(hints.length, 1);108 assert.ok(issues.some((i) => i.includes('missing href')));109});110
111test('analyzeResourceHints detects modulepreload', () => {112 const html = `<link rel="modulepreload" href="/app.mjs">`;113 const { hints, byType } = analyzeResourceHints(html, BASE_URL);114 assert.equal(hints.length, 1);115 assert.equal(byType.modulepreload, 1);116});117
118test('analyzeResourceHints handles empty HTML', () => {119 const { hints, byType, issues } = analyzeResourceHints('', BASE_URL);120 assert.equal(hints.length, 0);121 assert.deepEqual(byType, {});122 assert.deepEqual(issues, []);123});124
125test('classifyHint with rel containing multiple values picks hint rel', () => {126 const html = `<link rel="preload stylesheet" href="/style.css" as="style">`;127 const { hints, byType } = analyzeResourceHints(html, BASE_URL);128 // "stylesheet" is not in HINT_RELS, "preload" is.129 assert.equal(hints.length, 1);130 assert.equal(byType.preload, 1);131});132
133test('origin computation resolves relative href against base URL', () => {134 const html = `<link rel="preload" href="/asset.js" as="script">`;135 const { hints } = analyzeResourceHints(html, BASE_URL);136 assert.equal(hints[0].origin, 'https://example.com');137});138
139/* ---------------------------------------------------------------------------140 * Scoring tests141 * ------------------------------------------------------------------------- */142
143test('scoreResourceHints returns 0 when no hints', () => {144 assert.equal(scoreResourceHints([], [], 0), 0);145});146
147test('scoreResourceHints rewards preconnect + preload', () => {148 const hints = [149 { rel: 'preconnect', href: 'https://cdn.example.com', issues: [] },150 { rel: 'preload', href: '/font.woff2', as: 'font', issues: [] },151 ];152 const score = scoreResourceHints(hints, [], 2);153 assert.ok(score >= 60, `expected score >= 60, got ${score}`);154});155
156test('scoreResourceHints penalizes issues', () => {157 const goodHints = [158 { rel: 'preconnect', href: 'https://cdn.example.com', issues: [] },159 { rel: 'preload', href: '/font.woff2', as: 'font', issues: [] },160 ];161 const goodScore = scoreResourceHints(goodHints, [], 2);162 const issueScore = scoreResourceHints(goodHints, ['issue1', 'issue2', 'issue3', 'issue4'], 2);163 assert.ok(issueScore < goodScore, 'penalized score should be lower');164});165
166/* ---------------------------------------------------------------------------167 * Grading tests168 * ------------------------------------------------------------------------- */169
170test('gradeFromScore returns expected letter grades', () => {171 assert.equal(gradeFromScore(100), 'A+');172 assert.equal(gradeFromScore(90), 'A');173 assert.equal(gradeFromScore(78), 'B');174 assert.equal(gradeFromScore(67), 'C');175 assert.equal(gradeFromScore(55), 'D');176 assert.equal(gradeFromScore(35), 'E');177 assert.equal(gradeFromScore(10), 'F');178});179
180/* ---------------------------------------------------------------------------181 * Recommendation tests182 * ------------------------------------------------------------------------- */183
184test('buildRecommendations suggests preload when missing', () => {185 const recs = buildRecommendations([], [], {});186 assert.ok(recs.some((r) => r.includes('preload')));187 assert.ok(recs.some((r) => r.includes('preconnect')));188 assert.ok(recs.some((r) => r.includes('dns-prefetch')));189});190
191test('buildRecommendations includes per-hint fixes', () => {192 const hints = [193 { rel: 'preload', href: '/style.css', as: null, issues: ['preload without as attribute'], recommendation: 'Add an as attribute to <link rel="preload">.' },194 ];195 const recs = buildRecommendations(hints, ['preload /style.css: preload without as attribute'], { preload: 1 });196 assert.ok(recs.some((r) => r.includes('as attribute')));197});198
199test('buildRecommendations positive note when well-structured', () => {200 const hints = [201 { rel: 'preconnect', href: 'https://cdn.example.com', issues: [], recommendation: null },202 { rel: 'preload', href: '/font.woff2', as: 'font', issues: [], recommendation: null },203 ];204 const byType = { preconnect: 1, preload: 1 };205 const recs = buildRecommendations(hints, [], byType);206 assert.ok(recs.some((r) => r.includes('well-structured')));207});