@link-assistant/web-capture 1.1.2 → 1.7.1

package/tests/unit/gdocs.test.js

@@ -0,0 +1,278 @@
+import { jest } from '@jest/globals';
+import {
+  isGoogleDocsUrl,
+  extractDocumentId,
+  buildExportUrl,
+  extractBase64Images,
+  GDOCS_EXPORT_FORMATS,
+} from '../../src/gdocs.js';
+import {
+  extractAndSaveImages,
+  extractBase64ToBuffers,
+  stripBase64Images,
+} from '../../src/extract-images.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+jest.setTimeout(30000);
+
+describe('gdocs', () => {
+  describe('isGoogleDocsUrl', () => {
+    it('returns true for standard Google Docs edit URL', () => {
+      expect(
+        isGoogleDocsUrl(
+          'https://docs.google.com/document/d/1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4/edit'
+        )
+      ).toBe(true);
+    });
+
+    it('returns true for URL with query parameters', () => {
+      expect(
+        isGoogleDocsUrl(
+          'https://docs.google.com/document/d/abc123/edit?tab=t.0'
+        )
+      ).toBe(true);
+    });
+
+    it('returns true for URL without /edit', () => {
+      expect(
+        isGoogleDocsUrl('https://docs.google.com/document/d/abc-123_XYZ/')
+      ).toBe(true);
+    });
+
+    it('returns false for non-Google Docs URL', () => {
+      expect(isGoogleDocsUrl('https://example.com')).toBe(false);
+    });
+
+    it('returns false for Google Sheets URL', () => {
+      expect(
+        isGoogleDocsUrl('https://docs.google.com/spreadsheets/d/abc123/edit')
+      ).toBe(false);
+    });
+
+    it('returns false for empty string', () => {
+      expect(isGoogleDocsUrl('')).toBe(false);
+    });
+
+    it('returns false for null', () => {
+      expect(isGoogleDocsUrl(null)).toBe(false);
+    });
+
+    it('returns false for undefined', () => {
+      expect(isGoogleDocsUrl(undefined)).toBe(false);
+    });
+
+    it('returns false for non-string input', () => {
+      expect(isGoogleDocsUrl(123)).toBe(false);
+    });
+  });
+
+  describe('extractDocumentId', () => {
+    it('extracts document ID from standard URL', () => {
+      expect(
+        extractDocumentId(
+          'https://docs.google.com/document/d/1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4/edit'
+        )
+      ).toBe('1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4');
+    });
+
+    it('extracts document ID from URL with query params', () => {
+      expect(
+        extractDocumentId(
+          'https://docs.google.com/document/d/abc123/edit?tab=t.0'
+        )
+      ).toBe('abc123');
+    });
+
+    it('extracts document ID with hyphens and underscores', () => {
+      expect(
+        extractDocumentId('https://docs.google.com/document/d/abc-123_XYZ/')
+      ).toBe('abc-123_XYZ');
+    });
+
+    it('returns null for non-Google Docs URL', () => {
+      expect(extractDocumentId('https://example.com')).toBeNull();
+    });
+
+    it('returns null for empty string', () => {
+      expect(extractDocumentId('')).toBeNull();
+    });
+
+    it('returns null for null input', () => {
+      expect(extractDocumentId(null)).toBeNull();
+    });
+  });
+
+  describe('buildExportUrl', () => {
+    it('builds HTML export URL', () => {
+      expect(buildExportUrl('abc123', 'html')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('builds Markdown export URL', () => {
+      expect(buildExportUrl('abc123', 'md')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=md'
+      );
+    });
+
+    it('builds PDF export URL', () => {
+      expect(buildExportUrl('abc123', 'pdf')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=pdf'
+      );
+    });
+
+    it('builds TXT export URL', () => {
+      expect(buildExportUrl('abc123', 'txt')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=txt'
+      );
+    });
+
+    it('defaults to html for unknown format', () => {
+      expect(buildExportUrl('abc123', 'invalid')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('defaults to html when format is omitted', () => {
+      expect(buildExportUrl('abc123')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('uses the real document ID from test document', () => {
+      const docId = '1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4';
+      expect(buildExportUrl(docId, 'html')).toBe(
+        `https://docs.google.com/document/d/${docId}/export?format=html`
+      );
+    });
+  });
+
+  describe('GDOCS_EXPORT_FORMATS', () => {
+    it('contains all expected formats', () => {
+      expect(GDOCS_EXPORT_FORMATS).toEqual({
+        html: 'html',
+        txt: 'txt',
+        md: 'md',
+        pdf: 'pdf',
+        docx: 'docx',
+        epub: 'epub',
+        zip: 'zip',
+      });
+    });
+  });
+
+  describe('extractBase64Images', () => {
+    it('extracts a single PNG data URI image', () => {
+      const html = '<img src="data:image/png;base64,iVBORw0KGgo=" alt="test">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(1);
+      expect(images[0].filename).toBe('image-01.png');
+      expect(images[0].mimeType).toBe('image/png');
+      expect(images[0].data).toBeInstanceOf(Buffer);
+      expect(updated).toContain('src="images/image-01.png"');
+      expect(updated).not.toContain('data:image');
+    });
+
+    it('extracts multiple images with correct numbering and extensions', () => {
+      const html =
+        '<img src="data:image/png;base64,AAAA" alt="a"><img src="data:image/jpeg;base64,BBBB" alt="b">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(2);
+      expect(images[0].filename).toBe('image-01.png');
+      expect(images[1].filename).toBe('image-02.jpg');
+      expect(images[1].mimeType).toBe('image/jpeg');
+      expect(updated).toContain('images/image-01.png');
+      expect(updated).toContain('images/image-02.jpg');
+    });
+
+    it('returns empty array when no data URI images', () => {
+      const html = '<p>No images here</p>';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(0);
+      expect(updated).toBe(html);
+    });
+
+    it('preserves non-data-URI images', () => {
+      const html =
+        '<img src="https://example.com/photo.png" alt="remote"><img src="data:image/gif;base64,R0lG" alt="local">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(1);
+      expect(images[0].filename).toBe('image-01.gif');
+      expect(updated).toContain('https://example.com/photo.png');
+      expect(updated).toContain('images/image-01.gif');
+    });
+  });
+
+  describe('image extraction pipeline (issue #53)', () => {
+    const TINY_PNG =
+      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==';
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gdocs-issue53-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('extractBase64Images from HTML produces images with data buffers', () => {
+      const html = `<html><body><img src="data:image/png;base64,${TINY_PNG}" alt="photo"><p>Hello</p></body></html>`;
+      const { html: localHtml, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(1);
+      expect(images[0].filename).toBe('image-01.png');
+      expect(images[0].data.length).toBeGreaterThan(0);
+      // Verify PNG magic bytes in extracted data
+      expect(images[0].data[0]).toBe(0x89);
+      expect(images[0].data[1]).toBe(0x50); // P
+      expect(localHtml).toContain('images/image-01.png');
+      expect(localHtml).not.toContain('data:image');
+    });
+
+    it('default markdown mode extracts base64 images to disk (not strip)', () => {
+      const markdown = `# Hello\n\n![photo](data:image/png;base64,${TINY_PNG})\n\nEnd.`;
+      const result = extractAndSaveImages(markdown, tmpDir);
+
+      expect(result.extracted).toBe(1);
+      expect(result.markdown).not.toContain('data:image');
+      expect(result.markdown).toContain('images/image-');
+      expect(result.markdown).toContain('.png');
+
+      const imagesDir = path.join(tmpDir, 'images');
+      expect(fs.existsSync(imagesDir)).toBe(true);
+      const files = fs.readdirSync(imagesDir);
+      expect(files).toHaveLength(1);
+      expect(files[0]).toMatch(/^image-.*\.png$/);
+
+      const imgBuf = fs.readFileSync(path.join(imagesDir, files[0]));
+      expect(imgBuf[0]).toBe(0x89); // PNG magic
+    });
+
+    it('keepOriginalLinks strips base64 images', () => {
+      const markdown = `![photo](data:image/png;base64,${TINY_PNG})`;
+      const result = stripBase64Images(markdown);
+
+      expect(result.stripped).toBe(1);
+      expect(result.markdown).toBe('*[image: photo]*');
+      expect(result.markdown).not.toContain('data:image');
+    });
+
+    it('extractBase64ToBuffers produces in-memory buffers for archive', () => {
+      const markdown = `![test](data:image/png;base64,${TINY_PNG})`;
+      const result = extractBase64ToBuffers(markdown);
+
+      expect(result.images).toHaveLength(1);
+      expect(result.images[0].buffer.length).toBeGreaterThan(0);
+      expect(result.images[0].buffer[0]).toBe(0x89); // PNG magic
+      expect(result.markdown).toContain('images/');
+      expect(result.markdown).not.toContain('data:image');
+    });
+  });
+});

package/tests/unit/heading-image.test.js

@@ -0,0 +1,49 @@
+import { convertHtmlToMarkdown } from '../../src/lib.js';
+import { extractBase64Images } from '../../src/gdocs.js';
+
+const PNG_B64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=';
+
+const IMG_REF_PATTERN = /!\[[^\]]*\]\([^)]*images\/[^)]+\)/g;
+
+describe('heading image parity', () => {
+  it('<img> inside <h1> survives Turndown and stays in sync with extraction', () => {
+    const html = `<html><body><h1>Title <img src="data:image/png;base64,${PNG_B64}" alt="x"></h1><p>Body</p></body></html>`;
+
+    const { html: localHtml, images } = extractBase64Images(html);
+    const md = convertHtmlToMarkdown(localHtml);
+    const mdImgCount = (md.match(IMG_REF_PATTERN) || []).length;
+
+    expect(images).toHaveLength(1);
+    expect(mdImgCount).toBe(images.length);
+  });
+
+  it('<img> inside all heading levels is preserved', () => {
+    for (let level = 1; level <= 6; level++) {
+      const tag = `h${level}`;
+      const html = `<html><body><${tag}><img src="data:image/png;base64,${PNG_B64}" alt="icon"> Heading</${tag}></body></html>`;
+
+      const { html: localHtml, images } = extractBase64Images(html);
+      const md = convertHtmlToMarkdown(localHtml);
+      const refs = (md.match(IMG_REF_PATTERN) || []).length;
+
+      expect(refs).toBe(images.length);
+    }
+  });
+
+  it('image count parity across full pipeline', () => {
+    const html = `<html><body>
+<h1><img src="data:image/png;base64,${PNG_B64}" alt="h1"> Chapter</h1>
+<p>Text <img src="data:image/png;base64,${PNG_B64}" alt="p1"> here.</p>
+<h2><img src="data:image/png;base64,${PNG_B64}" alt="h2"> Section</h2>
+<p><img src="data:image/png;base64,${PNG_B64}" alt="p2"></p>
+</body></html>`;
+
+    const { html: localHtml, images } = extractBase64Images(html);
+    const md = convertHtmlToMarkdown(localHtml);
+    const mdRefCount = (md.match(IMG_REF_PATTERN) || []).length;
+
+    expect(images).toHaveLength(4);
+    expect(mdRefCount).toBe(images.length);
+  });
+});

package/tests/unit/latex.test.js

@@ -0,0 +1,123 @@
+import * as cheerio from 'cheerio';
+import {
+  extractHabrFormula,
+  extractKatexFormula,
+  extractMathJaxFormula,
+  isFormulaImage,
+  isMathElement,
+  extractFormula,
+} from '../../src/latex.js';
+
+describe('latex module', () => {
+  describe('extractHabrFormula', () => {
+    it('extracts LaTeX from Habr formula img source attribute', () => {
+      const $ = cheerio.load(
+        '<img class="formula" source=" L \\to L^2 " alt="formula">'
+      );
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBe('L \\to L^2');
+    });
+
+    it('falls back to alt text when source is missing', () => {
+      const $ = cheerio.load('<img class="formula" alt=" x + y ">');
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBe('x + y');
+    });
+
+    it('returns null when no source or alt', () => {
+      const $ = cheerio.load('<img class="formula">');
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBeNull();
+    });
+  });
+
+  describe('extractKatexFormula', () => {
+    it('extracts from annotation element', () => {
+      const $ = cheerio.load(
+        '<span class="katex"><annotation encoding="application/x-tex">E = mc^2</annotation></span>'
+      );
+      const el = $('span.katex')[0];
+      expect(extractKatexFormula($, el)).toBe('E = mc^2');
+    });
+
+    it('extracts from data-tex attribute', () => {
+      const $ = cheerio.load(
+        '<span class="math" data-tex="\\alpha + \\beta"></span>'
+      );
+      const el = $('span.math')[0];
+      expect(extractKatexFormula($, el)).toBe('\\alpha + \\beta');
+    });
+
+    it('returns null when no TeX source found', () => {
+      const $ = cheerio.load('<span class="katex">rendered</span>');
+      const el = $('span.katex')[0];
+      expect(extractKatexFormula($, el)).toBeNull();
+    });
+  });
+
+  describe('extractMathJaxFormula', () => {
+    it('extracts from data-tex attribute', () => {
+      const $ = cheerio.load(
+        '<mjx-container data-tex="\\sum_{i=1}^{n}"></mjx-container>'
+      );
+      const el = $('mjx-container')[0];
+      expect(extractMathJaxFormula($, el)).toBe('\\sum_{i=1}^{n}');
+    });
+  });
+
+  describe('isFormulaImage', () => {
+    it('identifies img.formula elements', () => {
+      const $ = cheerio.load('<img class="formula" source="x^2">');
+      expect(isFormulaImage($, $('img')[0])).toBe(true);
+    });
+
+    it('identifies img with source attribute', () => {
+      const $ = cheerio.load('<img source="x^2">');
+      expect(isFormulaImage($, $('img')[0])).toBe(true);
+    });
+
+    it('rejects regular images', () => {
+      const $ = cheerio.load('<img src="photo.jpg" alt="photo">');
+      expect(isFormulaImage($, $('img')[0])).toBe(false);
+    });
+  });
+
+  describe('isMathElement', () => {
+    it('identifies katex elements', () => {
+      const $ = cheerio.load('<span class="katex">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(true);
+    });
+
+    it('identifies math elements', () => {
+      const $ = cheerio.load('<span class="math">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(true);
+    });
+
+    it('identifies mjx-container', () => {
+      const $ = cheerio.load('<mjx-container>x</mjx-container>');
+      expect(isMathElement($, $('mjx-container')[0])).toBe(true);
+    });
+
+    it('rejects regular elements', () => {
+      const $ = cheerio.load('<span class="text">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(false);
+    });
+  });
+
+  describe('extractFormula', () => {
+    it('extracts from Habr formula image', () => {
+      const $ = cheerio.load('<img class="formula" source="L \\to L^2">');
+      expect(extractFormula($, $('img')[0])).toBe('L \\to L^2');
+    });
+
+    it('extracts from KaTeX element', () => {
+      const $ = cheerio.load('<span class="katex" data-tex="\\alpha"></span>');
+      expect(extractFormula($, $('span')[0])).toBe('\\alpha');
+    });
+
+    it('returns null for regular elements', () => {
+      const $ = cheerio.load('<p>text</p>');
+      expect(extractFormula($, $('p')[0])).toBeNull();
+    });
+  });
+});

package/tests/unit/localize-images.test.js

@@ -0,0 +1,78 @@
+import {
+  extractImageReferences,
+  getExtensionFromUrl,
+  generateLocalFilename,
+} from '../../src/localize-images.js';
+
+describe('localize-images module', () => {
+  describe('extractImageReferences', () => {
+    it('extracts markdown image references', () => {
+      const md =
+        '![alt text](https://example.com/img.png)\n![photo](https://cdn.example.com/photo.jpg)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(2);
+      expect(images[0].altText).toBe('alt text');
+      expect(images[0].url).toBe('https://example.com/img.png');
+      expect(images[1].altText).toBe('photo');
+      expect(images[1].url).toBe('https://cdn.example.com/photo.jpg');
+    });
+
+    it('ignores local image references', () => {
+      const md = '![local](images/figure-1.png)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(0);
+    });
+
+    it('ignores non-image links', () => {
+      const md = '[link text](https://example.com)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(0);
+    });
+
+    it('returns empty array for no images', () => {
+      const images = extractImageReferences('plain text');
+      expect(images).toHaveLength(0);
+    });
+  });
+
+  describe('getExtensionFromUrl', () => {
+    it('detects .png extension', () => {
+      expect(getExtensionFromUrl('https://example.com/image.png')).toBe('.png');
+    });
+
+    it('detects .jpg extension', () => {
+      expect(getExtensionFromUrl('https://example.com/photo.jpg')).toBe('.jpg');
+    });
+
+    it('detects .gif extension', () => {
+      expect(getExtensionFromUrl('https://example.com/anim.gif')).toBe('.gif');
+    });
+
+    it('handles query parameters', () => {
+      expect(
+        getExtensionFromUrl('https://example.com/image.png?w=800&h=600')
+      ).toBe('.png');
+    });
+
+    it('defaults to .png for unknown extension', () => {
+      expect(getExtensionFromUrl('https://example.com/image')).toBe('.png');
+    });
+  });
+
+  describe('generateLocalFilename', () => {
+    it('generates zero-padded filename', () => {
+      expect(generateLocalFilename('https://example.com/img.png', 0)).toBe(
+        'image-01.png'
+      );
+      expect(generateLocalFilename('https://example.com/img.jpg', 9)).toBe(
+        'image-10.jpg'
+      );
+    });
+
+    it('preserves file extension from URL', () => {
+      expect(generateLocalFilename('https://example.com/photo.gif', 2)).toBe(
+        'image-03.gif'
+      );
+    });
+  });
+});

package/tests/unit/metadata.test.js

@@ -0,0 +1,140 @@
+import * as cheerio from 'cheerio';
+import {
+  extractMetadata,
+  formatMetadataBlock,
+  formatFooterBlock,
+} from '../../src/metadata.js';
+
+describe('metadata module', () => {
+  describe('extractMetadata', () => {
+    it('extracts author information', () => {
+      const $ = cheerio.load(
+        '<a class="tm-user-info__username" href="/user/john">john_doe</a>'
+      );
+      const meta = extractMetadata($);
+      expect(meta.author).toBe('john_doe');
+      expect(meta.authorUrl).toBe('/user/john');
+    });
+
+    it('extracts publication date', () => {
+      const $ = cheerio.load(
+        '<time datetime="2024-01-15T10:00:00Z">Jan 15</time>'
+      );
+      const meta = extractMetadata($);
+      expect(meta.publishDate).toBe('2024-01-15T10:00:00Z');
+      expect(meta.publishDateText).toBe('Jan 15');
+    });
+
+    it('extracts hubs', () => {
+      const $ = cheerio.load(`
+        <a class="tm-publication-hub__link"><span>Math</span></a>
+        <a class="tm-publication-hub__link"><span>Science</span></a>
+      `);
+      const meta = extractMetadata($);
+      expect(meta.hubs).toEqual(['Math', 'Science']);
+    });
+
+    it('extracts tags from meta keywords', () => {
+      const $ = cheerio.load(
+        '<meta name="keywords" content="math, science, theory">'
+      );
+      const meta = extractMetadata($);
+      expect(meta.tags).toEqual(['math', 'science', 'theory']);
+    });
+
+    it('extracts LD+JSON author name', () => {
+      const $ = cheerio.load(
+        '<script type="application/ld+json">{"author":{"name":"John Doe"},"dateModified":"2024-02-01"}</script>'
+      );
+      const meta = extractMetadata($);
+      expect(meta.authorFullName).toBe('John Doe');
+      expect(meta.dateModified).toBe('2024-02-01');
+    });
+
+    it('extracts votes and comments', () => {
+      const $ = cheerio.load(`
+        <span class="tm-votes-meter__value">+42</span>
+        <span class="tm-article-comments-counter-link__value">15</span>
+      `);
+      const meta = extractMetadata($);
+      expect(meta.votes).toBe('+42');
+      expect(meta.comments).toBe('15');
+    });
+
+    it('returns empty object for minimal HTML', () => {
+      const $ = cheerio.load('<div>plain content</div>');
+      const meta = extractMetadata($);
+      expect(meta).toBeDefined();
+      expect(meta.author).toBeUndefined();
+    });
+  });
+
+  describe('formatMetadataBlock', () => {
+    it('formats author line with link', () => {
+      const lines = formatMetadataBlock({
+        author: 'john',
+        authorUrl: '/user/john',
+      });
+      expect(lines).toContain('**Author:** [john](/user/john)');
+    });
+
+    it('formats author with full name', () => {
+      const lines = formatMetadataBlock({
+        author: 'john',
+        authorFullName: 'John Doe',
+        authorUrl: '/user/john',
+      });
+      expect(lines[0]).toContain('John Doe (john)');
+    });
+
+    it('formats publication date', () => {
+      const lines = formatMetadataBlock({
+        publishDate: '2024-01-15T10:00:00Z',
+      });
+      expect(lines.some((l) => l.includes('Published:'))).toBe(true);
+      expect(lines.some((l) => l.includes('January 15, 2024'))).toBe(true);
+    });
+
+    it('includes hubs and tags', () => {
+      const lines = formatMetadataBlock({
+        hubs: ['Math', 'Science'],
+        tags: ['theory', 'links'],
+      });
+      expect(lines.some((l) => l.includes('Math, Science'))).toBe(true);
+      expect(lines.some((l) => l.includes('theory, links'))).toBe(true);
+    });
+
+    it('returns empty array for null metadata', () => {
+      expect(formatMetadataBlock(null)).toEqual([]);
+    });
+  });
+
+  describe('formatFooterBlock', () => {
+    it('includes separator line', () => {
+      const lines = formatFooterBlock({ author: 'test' });
+      expect(lines[0]).toBe('---');
+    });
+
+    it('formats tag links', () => {
+      const lines = formatFooterBlock({
+        tagLinks: [{ name: 'math', url: '/tag/math' }],
+      });
+      expect(lines.some((l) => l.includes('[math](/tag/math)'))).toBe(true);
+    });
+
+    it('formats article stats', () => {
+      const lines = formatFooterBlock({
+        votes: '+10',
+        views: '5000',
+        comments: '3',
+      });
+      const statsLine = lines.find((l) => l.includes('Votes:'));
+      expect(statsLine).toContain('+10');
+      expect(statsLine).toContain('5000');
+    });
+
+    it('returns empty array for null metadata', () => {
+      expect(formatFooterBlock(null)).toEqual([]);
+    });
+  });
+});