@chriswiegman/hugo-tools 0.2.1 → 0.3.0

package/src/book.test.mjs

@@ -13,6 +13,8 @@ import {
 	uniqSortedDates,
 	authorDirFromAuthorLF,
 	keyFor,
+	needsReReadDates,
+	stripBOM,
 	goodreadsBookUrl,
 	openLibraryIsbnUrl,
 	amazonSearchLink,
@@ -20,11 +22,26 @@ import {
 	parseExistingMarkdown,
 	replaceFinishedBlock,
 	updateTitleInFrontMatter,
+	updateRatingInFrontMatter,
+	parseExistingReference,
+	upsertReferenceInFrontMatter,
+	parseExistingCover,
+	upsertCoverInFrontMatter,
 	extractGoodreadsId,
 	extractFileIsbns,
 	toFrontMatter,
 	buildExistingIndex,
 	findExistingFile,
+	lookupAsinFromOpenLibrary,
+	lookupAsinFromGoogleBooks,
+	lookupAsinFromAmazonPa,
+	lookupAsin,
+	extFromContentType,
+	coverUrlFromAssetPath,
+	fetchOpenLibraryCover,
+	fetchGoogleBooksCover,
+	fetchBookCover,
+	saveCover,
 } from './book.mjs';
 
 // ---------------------------------------------------------------------------
@@ -48,8 +65,9 @@ function sampleMarkdown({
 	finished = ['2023-01-15'],
 	goodreadsId = '12345',
 	isbn13 = '9781234567890',
+	reference = null,
 } = {}) {
-	return [
+	const lines = [
 		'---',
 		`title: "${title}"`,
 		`author: "${author}"`,
@@ -60,9 +78,40 @@ function sampleMarkdown({
 		`  amazon: "https://www.amazon.com/s?k=${isbn13}"`,
 		`  openlibrary: "https://openlibrary.org/search?isbn=${isbn13}"`,
 		`  goodreads: "https://www.goodreads.com/book/show/${goodreadsId}"`,
-		'---',
-		'',
-	].join('\n');
+	];
+
+	if (reference) {
+		lines.push('reference:', `  isbn: "${reference.isbn ?? ''}"`, `  asin: "${reference.asin ?? ''}"`);
+	}
+
+	lines.push('---', '');
+	return lines.join('\n');
+}
+
+function fakeFetch(map) {
+	return async (url) => {
+		for (const [match, handler] of map) {
+			const matches = typeof match === 'string' ? url.includes(match) : match.test(url);
+
+			if (matches) return typeof handler === 'function' ? handler(url) : handler;
+		}
+
+		throw new Error(`fakeFetch: no handler for ${url}`);
+	};
+}
+
+function jsonResponse(body, ok = true) {
+	return { ok, json: async () => body };
+}
+
+function imageResponse(bytes, contentType = 'image/jpeg', ok = true) {
+	const buf = Buffer.from(bytes);
+
+	return {
+		ok,
+		headers: { get: () => contentType },
+		arrayBuffer: async () => buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength),
+	};
 }
 
 // ---------------------------------------------------------------------------
@@ -280,6 +329,65 @@ test('keyFor: trims whitespace before combining', () => {
 	assert.equal(keyFor('  Test Book  ', '  John Doe  '), 'test book|john doe');
 });
 
+// ---------------------------------------------------------------------------
+// needsReReadDates
+// ---------------------------------------------------------------------------
+
+test('needsReReadDates: false when read once and one date on file', () => {
+	assert.equal(needsReReadDates(1, 1), false);
+});
+
+test('needsReReadDates: false when never read (readCount 0)', () => {
+	assert.equal(needsReReadDates(0, 0), false);
+});
+
+test('needsReReadDates: true when read twice but only one date on file', () => {
+	assert.equal(needsReReadDates(2, 1), true);
+});
+
+test('needsReReadDates: false once dates on file catch up to read count', () => {
+	assert.equal(needsReReadDates(2, 2), false);
+});
+
+test('needsReReadDates: false when dates on file exceed read count', () => {
+	// e.g. the user manually recorded more reads than Goodreads' counter shows
+	assert.equal(needsReReadDates(2, 3), false);
+});
+
+test('needsReReadDates: true for a book read many times with a single date on file', () => {
+	assert.equal(needsReReadDates(5, 1), true);
+});
+
+test('needsReReadDates: false for non-finite readCount', () => {
+	assert.equal(needsReReadDates(NaN, 0), false);
+	assert.equal(needsReReadDates(undefined, 0), false);
+});
+
+// ---------------------------------------------------------------------------
+// stripBOM
+// ---------------------------------------------------------------------------
+
+test('stripBOM: removes a leading UTF-8 BOM', () => {
+	assert.equal(stripBOM('Book Id,Title'), 'Book Id,Title');
+});
+
+test('stripBOM: leaves text without a BOM unchanged', () => {
+	assert.equal(stripBOM('Book Id,Title'), 'Book Id,Title');
+});
+
+test('stripBOM: only strips a leading BOM, not one mid-string', () => {
+	assert.equal(stripBOM('Book Id,Title'), 'Book Id,Title');
+});
+
+test('stripBOM: empty string stays empty', () => {
+	assert.equal(stripBOM(''), '');
+});
+
+test('stripBOM: null/undefined coerce to empty string', () => {
+	assert.equal(stripBOM(null), '');
+	assert.equal(stripBOM(undefined), '');
+});
+
 // ---------------------------------------------------------------------------
 // goodreadsBookUrl / openLibraryIsbnUrl / amazonSearchLink
 // ---------------------------------------------------------------------------
@@ -433,6 +541,26 @@ test('parseExistingMarkdown: returns empty array for invalid front matter', () =
 	assert.deepEqual(finished, []);
 });
 
+test('parseExistingMarkdown: extracts rating', () => {
+	const md = sampleMarkdown({ rating: 5 });
+	const { rating } = parseExistingMarkdown(md);
+
+	assert.equal(rating, 5);
+});
+
+test('parseExistingMarkdown: returns null rating when field is absent', () => {
+	const md = ['---', 'title: "Test"', 'finished:', '  - "2023-01-15"', '---', ''].join('\n');
+	const { rating } = parseExistingMarkdown(md);
+
+	assert.equal(rating, null);
+});
+
+test('parseExistingMarkdown: returns null rating for invalid front matter', () => {
+	const { rating } = parseExistingMarkdown('no front matter here');
+
+	assert.equal(rating, null);
+});
+
 // ---------------------------------------------------------------------------
 // replaceFinishedBlock
 // ---------------------------------------------------------------------------
@@ -508,6 +636,412 @@ test('updateTitleInFrontMatter: preserves all other front matter', () => {
 	assert.ok(result.includes('goodreads:'));
 });
 
+// ---------------------------------------------------------------------------
+// updateRatingInFrontMatter
+// ---------------------------------------------------------------------------
+
+test('updateRatingInFrontMatter: replaces rating line', () => {
+	const md = sampleMarkdown({ rating: 3 });
+	const result = updateRatingInFrontMatter(md, 5);
+
+	assert.ok(result.includes('rating: 5'));
+	assert.ok(!result.includes('rating: 3'));
+});
+
+test('updateRatingInFrontMatter: preserves all other front matter', () => {
+	const md = sampleMarkdown({ title: 'Keep Me', rating: 2 });
+	const result = updateRatingInFrontMatter(md, 4);
+
+	assert.ok(result.includes('title: "Keep Me"'));
+	assert.ok(result.includes('goodreads:'));
+});
+
+// ---------------------------------------------------------------------------
+// parseExistingReference
+// ---------------------------------------------------------------------------
+
+test('parseExistingReference: extracts isbn and asin from reference block', () => {
+	const md = sampleMarkdown({ reference: { isbn: '9781234567890', asin: 'B00ABCDEFG' } });
+	const result = parseExistingReference(md);
+
+	assert.deepEqual(result, { isbn: '9781234567890', asin: 'B00ABCDEFG' });
+});
+
+test('parseExistingReference: returns blanks when reference block is absent', () => {
+	const md = sampleMarkdown();
+	const result = parseExistingReference(md);
+
+	assert.deepEqual(result, { isbn: '', asin: '' });
+});
+
+test('parseExistingReference: returns blanks for fields present but empty', () => {
+	const md = sampleMarkdown({ reference: { isbn: '', asin: '' } });
+	const result = parseExistingReference(md);
+
+	assert.deepEqual(result, { isbn: '', asin: '' });
+});
+
+test('parseExistingReference: returns blanks for invalid front matter', () => {
+	assert.deepEqual(parseExistingReference('no front matter here'), { isbn: '', asin: '' });
+});
+
+// ---------------------------------------------------------------------------
+// upsertReferenceInFrontMatter
+// ---------------------------------------------------------------------------
+
+test('upsertReferenceInFrontMatter: inserts a new block when none exists', () => {
+	const md = sampleMarkdown();
+	const result = upsertReferenceInFrontMatter(md, { isbn: '9781234567890', asin: 'B00ABCDEFG' });
+
+	assert.ok(result.includes('reference:'));
+	assert.ok(result.includes('  isbn: "9781234567890"'));
+	assert.ok(result.includes('  asin: "B00ABCDEFG"'));
+	assert.ok(result.includes('title: "Test Book"'));
+});
+
+test('upsertReferenceInFrontMatter: replaces an existing block', () => {
+	const md = sampleMarkdown({ reference: { isbn: '9781234567890', asin: '' } });
+	const result = upsertReferenceInFrontMatter(md, { isbn: '9781234567890', asin: 'B00ABCDEFG' });
+
+	assert.equal((result.match(/reference:/g) || []).length, 1);
+	assert.ok(result.includes('  asin: "B00ABCDEFG"'));
+});
+
+test('upsertReferenceInFrontMatter: preserves all other front matter', () => {
+	const md = sampleMarkdown({ title: 'Keep Me', rating: 5 });
+	const result = upsertReferenceInFrontMatter(md, { isbn: '123', asin: '456' });
+
+	assert.ok(result.includes('title: "Keep Me"'));
+	assert.ok(result.includes('rating: 5'));
+	assert.ok(result.includes('goodreads:'));
+});
+
+// ---------------------------------------------------------------------------
+// ASIN lookup
+// ---------------------------------------------------------------------------
+
+test('lookupAsinFromOpenLibrary: extracts amazon identifier', async () => {
+	const fetchImpl = fakeFetch([
+		['openlibrary.org', jsonResponse({
+			'ISBN:9781234567890': { identifiers: { amazon: ['b00abcdefg'] } },
+		})],
+	]);
+
+	assert.equal(await lookupAsinFromOpenLibrary('9781234567890', fetchImpl), 'B00ABCDEFG');
+});
+
+test('lookupAsinFromOpenLibrary: returns empty string when no amazon identifier', async () => {
+	const fetchImpl = fakeFetch([
+		['openlibrary.org', jsonResponse({ 'ISBN:9781234567890': { identifiers: {} } })],
+	]);
+
+	assert.equal(await lookupAsinFromOpenLibrary('9781234567890', fetchImpl), '');
+});
+
+test('lookupAsinFromOpenLibrary: returns empty string on non-OK response', async () => {
+	const fetchImpl = fakeFetch([['openlibrary.org', jsonResponse({}, false)]]);
+
+	assert.equal(await lookupAsinFromOpenLibrary('9781234567890', fetchImpl), '');
+});
+
+test('lookupAsinFromOpenLibrary: returns empty string when fetch throws', async () => {
+	const fetchImpl = async () => {
+		throw new Error('network down');
+	};
+
+	assert.equal(await lookupAsinFromOpenLibrary('9781234567890', fetchImpl), '');
+});
+
+test('lookupAsinFromOpenLibrary: empty isbn returns empty string without fetching', async () => {
+	assert.equal(await lookupAsinFromOpenLibrary('', async () => {
+		throw new Error('should not be called');
+	}), '');
+});
+
+test('lookupAsinFromGoogleBooks: extracts ASIN-shaped OTHER identifier', async () => {
+	const fetchImpl = fakeFetch([
+		['googleapis.com', jsonResponse({
+			items: [{ volumeInfo: { industryIdentifiers: [
+				{ type: 'ISBN_13', identifier: '9781234567890' },
+				{ type: 'OTHER', identifier: 'B00ABCDEFG' },
+			] } }],
+		})],
+	]);
+
+	assert.equal(await lookupAsinFromGoogleBooks('9781234567890', fetchImpl), 'B00ABCDEFG');
+});
+
+test('lookupAsinFromGoogleBooks: returns empty string when no OTHER identifier matches', async () => {
+	const fetchImpl = fakeFetch([
+		['googleapis.com', jsonResponse({
+			items: [{ volumeInfo: { industryIdentifiers: [{ type: 'ISBN_10', identifier: '1234567890' }] } }],
+		})],
+	]);
+
+	assert.equal(await lookupAsinFromGoogleBooks('9781234567890', fetchImpl), '');
+});
+
+test('lookupAsinFromAmazonPa: returns empty string without config', async () => {
+	const fetchImpl = async () => {
+		throw new Error('should not be called');
+	};
+
+	assert.equal(await lookupAsinFromAmazonPa('9781234567890', null, fetchImpl), '');
+});
+
+test('lookupAsinFromAmazonPa: signs the request and returns the ASIN', async () => {
+	let seenAuth = '';
+	const fetchImpl = async (url, opts) => {
+		seenAuth = opts.headers.authorization;
+		return jsonResponse({ ItemsResult: { Items: [{ ASIN: 'b00abcdefg' }] } });
+	};
+	const config = { accessKey: 'AKIA...', secretKey: 'secret', partnerTag: 'tag-20' };
+
+	const result = await lookupAsinFromAmazonPa('9781234567890', config, fetchImpl);
+
+	assert.equal(result, 'B00ABCDEFG');
+	assert.ok(seenAuth.startsWith('AWS4-HMAC-SHA256 Credential=AKIA...'));
+});
+
+test('lookupAsin: falls back from Open Library to Google Books', async () => {
+	const fetchImpl = fakeFetch([
+		['openlibrary.org', jsonResponse({ 'ISBN:9781234567890': { identifiers: {} } })],
+		['googleapis.com', jsonResponse({
+			items: [{ volumeInfo: { industryIdentifiers: [{ type: 'OTHER', identifier: 'B00ABCDEFG' }] } }],
+		})],
+	]);
+
+	assert.equal(await lookupAsin('9781234567890', null, new Map(), fetchImpl), 'B00ABCDEFG');
+});
+
+test('lookupAsin: caches results per ISBN', async () => {
+	let calls = 0;
+	const fetchImpl = async () => {
+		calls++;
+		return jsonResponse({ 'ISBN:9781234567890': { identifiers: { amazon: ['B00ABCDEFG'] } } });
+	};
+	const cache = new Map();
+
+	await lookupAsin('9781234567890', null, cache, fetchImpl);
+	await lookupAsin('9781234567890', null, cache, fetchImpl);
+
+	assert.equal(calls, 1);
+});
+
+test('lookupAsin: empty isbn returns empty string without fetching', async () => {
+	const fetchImpl = async () => {
+		throw new Error('should not be called');
+	};
+
+	assert.equal(await lookupAsin('', null, new Map(), fetchImpl), '');
+});
+
+// ---------------------------------------------------------------------------
+// Cover art (opt-in)
+// ---------------------------------------------------------------------------
+
+test('extFromContentType: maps known image types to extensions', () => {
+	assert.equal(extFromContentType('image/jpeg'), '.jpg');
+	assert.equal(extFromContentType('image/png'), '.png');
+	assert.equal(extFromContentType('image/webp'), '.webp');
+	assert.equal(extFromContentType('image/gif'), '.gif');
+});
+
+test('extFromContentType: strips charset/parameter suffix', () => {
+	assert.equal(extFromContentType('image/jpeg; charset=binary'), '.jpg');
+});
+
+test('extFromContentType: defaults to .jpg for unknown or missing types', () => {
+	assert.equal(extFromContentType('application/octet-stream'), '.jpg');
+	assert.equal(extFromContentType(''), '.jpg');
+	assert.equal(extFromContentType(undefined), '.jpg');
+});
+
+test('coverUrlFromAssetPath: strips the assets/ prefix and normalizes separators', () => {
+	assert.equal(
+		coverUrlFromAssetPath(path.join('assets', 'images', 'books', 'king-stephen', 'it.jpg')),
+		'/images/books/king-stephen/it.jpg',
+	);
+});
+
+test('fetchOpenLibraryCover: returns buffer and content type on success', async () => {
+	const fetchImpl = fakeFetch([
+		['covers.openlibrary.org', imageResponse([1, 2, 3], 'image/jpeg')],
+	]);
+
+	const result = await fetchOpenLibraryCover('9781234567890', fetchImpl);
+
+	assert.ok(result);
+	assert.equal(result.contentType, 'image/jpeg');
+	assert.deepEqual([...result.buffer], [1, 2, 3]);
+});
+
+test('fetchOpenLibraryCover: returns null on non-OK response (no cover)', async () => {
+	const fetchImpl = fakeFetch([
+		['covers.openlibrary.org', imageResponse([], 'image/jpeg', false)],
+	]);
+
+	assert.equal(await fetchOpenLibraryCover('9781234567890', fetchImpl), null);
+});
+
+test('fetchOpenLibraryCover: returns null when fetch throws', async () => {
+	const fetchImpl = async () => {
+		throw new Error('network down');
+	};
+
+	assert.equal(await fetchOpenLibraryCover('9781234567890', fetchImpl), null);
+});
+
+test('fetchOpenLibraryCover: empty isbn returns null without fetching', async () => {
+	assert.equal(await fetchOpenLibraryCover('', async () => {
+		throw new Error('should not be called');
+	}), null);
+});
+
+test('fetchGoogleBooksCover: fetches the volume thumbnail and returns image bytes', async () => {
+	const fetchImpl = fakeFetch([
+		['googleapis.com', jsonResponse({
+			items: [{ volumeInfo: { imageLinks: { thumbnail: 'http://books.google.com/thumb.jpg' } } }],
+		})],
+		['books.google.com', imageResponse([4, 5, 6], 'image/png')],
+	]);
+
+	const result = await fetchGoogleBooksCover('9781234567890', fetchImpl);
+
+	assert.ok(result);
+	assert.equal(result.contentType, 'image/png');
+	assert.deepEqual([...result.buffer], [4, 5, 6]);
+});
+
+test('fetchGoogleBooksCover: returns null when volume has no imageLinks', async () => {
+	const fetchImpl = fakeFetch([
+		['googleapis.com', jsonResponse({ items: [{ volumeInfo: {} }] })],
+	]);
+
+	assert.equal(await fetchGoogleBooksCover('9781234567890', fetchImpl), null);
+});
+
+test('fetchGoogleBooksCover: empty isbn returns null without fetching', async () => {
+	assert.equal(await fetchGoogleBooksCover('', async () => {
+		throw new Error('should not be called');
+	}), null);
+});
+
+test('fetchBookCover: prefers Open Library over Google Books', async () => {
+	const fetchImpl = fakeFetch([
+		['covers.openlibrary.org', imageResponse([1], 'image/jpeg')],
+		['googleapis.com', () => {
+			throw new Error('should not be called');
+		}],
+	]);
+
+	const result = await fetchBookCover('9781234567890', fetchImpl);
+
+	assert.ok(result);
+	assert.deepEqual([...result.buffer], [1]);
+});
+
+test('fetchBookCover: falls back to Google Books when Open Library has no cover', async () => {
+	const fetchImpl = fakeFetch([
+		['covers.openlibrary.org', imageResponse([], 'image/jpeg', false)],
+		['googleapis.com', jsonResponse({
+			items: [{ volumeInfo: { imageLinks: { thumbnail: 'http://books.google.com/thumb.jpg' } } }],
+		})],
+		['books.google.com', imageResponse([9], 'image/jpeg')],
+	]);
+
+	const result = await fetchBookCover('9781234567890', fetchImpl);
+
+	assert.ok(result);
+	assert.deepEqual([...result.buffer], [9]);
+});
+
+test('fetchBookCover: returns null when neither source has a cover', async () => {
+	const fetchImpl = fakeFetch([
+		['covers.openlibrary.org', imageResponse([], 'image/jpeg', false)],
+		['googleapis.com', jsonResponse({ items: [] })],
+	]);
+
+	assert.equal(await fetchBookCover('9781234567890', fetchImpl), null);
+});
+
+test('fetchBookCover: empty isbn returns null without fetching', async () => {
+	assert.equal(await fetchBookCover('', async () => {
+		throw new Error('should not be called');
+	}), null);
+});
+
+test('saveCover: writes image bytes under coversDir and returns the Hugo URL path', async () => {
+	await withTempDir(async (tmpDir) => {
+		const cover = { buffer: Buffer.from([1, 2, 3]), contentType: 'image/png' };
+		const url = await saveCover('assets/images/books', 'king-stephen', 'it', cover, tmpDir);
+
+		assert.equal(url, '/images/books/king-stephen/it.png');
+
+		const written = await fs.readFile(path.join(tmpDir, 'assets', 'images', 'books', 'king-stephen', 'it.png'));
+
+		assert.deepEqual([...written], [1, 2, 3]);
+	});
+});
+
+test('saveCover: creates intermediate directories as needed', async () => {
+	await withTempDir(async (tmpDir) => {
+		const cover = { buffer: Buffer.from([7]), contentType: 'image/jpeg' };
+
+		await saveCover('assets/images/books', 'doe-jane', 'a-title', cover, tmpDir);
+
+		const exists = await fs.access(path.join(tmpDir, 'assets', 'images', 'books', 'doe-jane', 'a-title.jpg'))
+			.then(() => true)
+			.catch(() => false);
+
+		assert.ok(exists);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// parseExistingCover / upsertCoverInFrontMatter
+// ---------------------------------------------------------------------------
+
+test('parseExistingCover: extracts the cover value when present', () => {
+	const md = ['---', 'title: "Test"', 'cover: "/images/books/king-stephen/it.jpg"', '---', ''].join('\n');
+
+	assert.equal(parseExistingCover(md), '/images/books/king-stephen/it.jpg');
+});
+
+test('parseExistingCover: returns empty string when the field is absent', () => {
+	assert.equal(parseExistingCover(sampleMarkdown()), '');
+});
+
+test('parseExistingCover: returns empty string for invalid front matter', () => {
+	assert.equal(parseExistingCover('no front matter here'), '');
+});
+
+test('upsertCoverInFrontMatter: inserts the field when absent', () => {
+	const md = sampleMarkdown();
+	const result = upsertCoverInFrontMatter(md, '/images/books/king-stephen/it.jpg');
+
+	assert.ok(result.includes('cover: "/images/books/king-stephen/it.jpg"'));
+	assert.ok(result.includes('title: "Test Book"'));
+});
+
+test('upsertCoverInFrontMatter: replaces an existing cover field without duplicating it', () => {
+	const md = ['---', 'title: "Test"', 'cover: "/old.jpg"', '---', ''].join('\n');
+	const result = upsertCoverInFrontMatter(md, '/new.jpg');
+
+	assert.equal((result.match(/^cover:/gm) || []).length, 1);
+	assert.ok(result.includes('cover: "/new.jpg"'));
+	assert.ok(!result.includes('/old.jpg'));
+});
+
+test('upsertCoverInFrontMatter: preserves all other front matter', () => {
+	const md = sampleMarkdown({ title: 'Keep Me', rating: 5 });
+	const result = upsertCoverInFrontMatter(md, '/cover.jpg');
+
+	assert.ok(result.includes('title: "Keep Me"'));
+	assert.ok(result.includes('rating: 5'));
+	assert.ok(result.includes('goodreads:'));
+});
+
 // ---------------------------------------------------------------------------
 // extractGoodreadsId
 // ---------------------------------------------------------------------------
@@ -600,6 +1134,59 @@ test('toFrontMatter: escapes special chars in title and author', () => {
 	assert.ok(fm.includes('author: "Author \\"A\\""'));
 });
 
+test('toFrontMatter: includes reference isbn/asin when provided', () => {
+	const fm = toFrontMatter({
+		title: 'Test Book',
+		author: 'John Doe',
+		rating: 4,
+		finished: [],
+		links: { amazon: '', openlibrary: '', goodreads: '' },
+		reference: { isbn: '9781234567890', asin: 'B00ABCDEFG' },
+	});
+
+	assert.ok(fm.includes('reference:'));
+	assert.ok(fm.includes('  isbn: "9781234567890"'));
+	assert.ok(fm.includes('  asin: "B00ABCDEFG"'));
+});
+
+test('toFrontMatter: reference fields default to blank when omitted', () => {
+	const fm = toFrontMatter({
+		title: 'Test Book',
+		author: 'John Doe',
+		rating: 4,
+		finished: [],
+		links: { amazon: '', openlibrary: '', goodreads: '' },
+	});
+
+	assert.ok(fm.includes('  isbn: ""'));
+	assert.ok(fm.includes('  asin: ""'));
+});
+
+test('toFrontMatter: includes cover field when provided', () => {
+	const fm = toFrontMatter({
+		title: 'Test Book',
+		author: 'John Doe',
+		rating: 4,
+		finished: [],
+		links: { amazon: '', openlibrary: '', goodreads: '' },
+		cover: '/images/books/doe-john/test-book.jpg',
+	});
+
+	assert.ok(fm.includes('cover: "/images/books/doe-john/test-book.jpg"'));
+});
+
+test('toFrontMatter: cover defaults to blank when omitted', () => {
+	const fm = toFrontMatter({
+		title: 'Test Book',
+		author: 'John Doe',
+		rating: 4,
+		finished: [],
+		links: { amazon: '', openlibrary: '', goodreads: '' },
+	});
+
+	assert.ok(fm.includes('cover: ""'));
+});
+
 // ---------------------------------------------------------------------------
 // buildExistingIndex (async)
 // ---------------------------------------------------------------------------
@@ -885,3 +1472,33 @@ test('integration: title-change rename via buildExistingIndex', async () => {
 		assert.ok(newContent.includes('title: "New Title"'));
 	});
 });
+
+test('integration: a re-read flagged by needsReReadDates is advisory only — no dates are fabricated', async () => {
+	await withTempDir(async (tmpDir) => {
+		// A book Goodreads says was read twice, but the export (and thus the file) only
+		// ever carries one date — the merge pipeline must not invent a second date.
+		const authorDir = path.join(tmpDir, 'doe-john');
+
+		await fs.mkdir(authorDir);
+		const filePath = path.join(authorDir, 'test-book.md');
+		const original = sampleMarkdown({ finished: ['2023-01-15'] });
+
+		await fs.writeFile(filePath, original);
+
+		const existingContent = await fs.readFile(filePath, 'utf8');
+		const { finished: existingFinished } = parseExistingMarkdown(existingContent);
+		// Goodreads' "Date Read" for this run is identical to what's already on file.
+		const csvFinished = ['2023-01-15'];
+		const finishedMerged = uniqSortedDates([...existingFinished, ...csvFinished]);
+
+		assert.deepEqual(finishedMerged, ['2023-01-15']);
+		assert.equal(needsReReadDates(2, finishedMerged.length), true);
+
+		// No new dates means the file is untouched by the merge itself.
+		const hasNewDates =
+			finishedMerged.length !== existingFinished.length ||
+			finishedMerged.some((d, i) => d !== existingFinished[i]);
+
+		assert.equal(hasNewDates, false);
+	});
+});