@soundbi/sound-connect 0.1.0

package/dist/__tests__/ingest.test.js

@@ -0,0 +1,639 @@
+/**
+ * STORY-011 / STORY-012 — ingest_file / ingest_folder unit tests.
+ *
+ * Tests the pure logic functions in src/ingest.ts:
+ *   - validateAndResolvePath: path confinement and extension check (AC3)
+ *   - normalizeMarkdown: normalization (AC1)
+ *   - chunkContent: chunking (AC1)
+ *   - sha256: hash computation (AC2)
+ *   - sourceTypeForExt: source_type derivation (STORY-012 AC2)
+ *   - parseGlobToExtensions: glob filter parsing (STORY-012 AC1)
+ *   - enumerateFolder: folder file enumeration (STORY-012 AC1)
+ *   - ingestFolder: full folder ingest pipeline with mocked backend (STORY-012)
+ *
+ * Network-touching code (postChunk / ingestMarkdownFile / ingestFolder) is tested
+ * via fetch mocks rather than live backend calls.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { writeFile, rm, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { validateAndResolvePath, normalizeMarkdown, chunkContent, sha256, ingestMarkdownFile, sourceTypeForExt, parseGlobToExtensions, enumerateFolder, ingestFolder, SUPPORTED_EXTENSIONS, } from '../ingest.js';
+// ── normalizeMarkdown ─────────────────────────────────────────────────────────
+describe('normalizeMarkdown()', () => {
+    it('converts CRLF to LF', () => {
+        expect(normalizeMarkdown('line1\r\nline2')).toBe('line1\nline2');
+    });
+    it('converts bare CR to LF', () => {
+        expect(normalizeMarkdown('line1\rline2')).toBe('line1\nline2');
+    });
+    it('strips trailing whitespace from each line', () => {
+        expect(normalizeMarkdown('hello   \nworld  ')).toBe('hello\nworld');
+    });
+    it('collapses 3+ blank lines to 2', () => {
+        const input = 'a\n\n\n\nb';
+        expect(normalizeMarkdown(input)).toBe('a\n\nb');
+    });
+    it('preserves exactly 2 blank lines (paragraph spacing)', () => {
+        const input = 'a\n\nb';
+        expect(normalizeMarkdown(input)).toBe('a\n\nb');
+    });
+    it('trims leading and trailing blank lines', () => {
+        expect(normalizeMarkdown('\n\nhello\n\n')).toBe('hello');
+    });
+    it('returns empty string for whitespace-only content', () => {
+        expect(normalizeMarkdown('   \n\n   ')).toBe('');
+    });
+    it('is idempotent — normalizing twice gives the same result', () => {
+        const content = 'Hello\r\n\nWorld   \n\n\nFoo';
+        const once = normalizeMarkdown(content);
+        const twice = normalizeMarkdown(once);
+        expect(once).toBe(twice);
+    });
+});
+// ── chunkContent ──────────────────────────────────────────────────────────────
+describe('chunkContent()', () => {
+    it('returns single chunk for short content', () => {
+        const content = 'Hello world';
+        const chunks = chunkContent(content);
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0]).toBe(content);
+    });
+    it('returns single chunk when content is exactly at limit', () => {
+        // 6000 chars exactly
+        const content = 'a'.repeat(6_000);
+        const chunks = chunkContent(content);
+        expect(chunks).toHaveLength(1);
+    });
+    it('splits long content into multiple chunks', () => {
+        // Build content > 6000 chars with clear paragraph breaks
+        const para = 'x'.repeat(500);
+        const content = Array.from({ length: 20 }, () => para).join('\n\n');
+        const chunks = chunkContent(content);
+        expect(chunks.length).toBeGreaterThan(1);
+    });
+    it('every chunk is non-empty', () => {
+        const para = 'word '.repeat(200);
+        const content = Array.from({ length: 15 }, () => para).join('\n\n');
+        const chunks = chunkContent(content);
+        for (const chunk of chunks) {
+            expect(chunk.length).toBeGreaterThan(0);
+        }
+    });
+    it('chunks together cover all paragraphs (no content lost)', () => {
+        // Use distinguishable paragraph markers
+        const paragraphs = Array.from({ length: 20 }, (_, i) => `PARA${i}: ${'y'.repeat(400)}`);
+        const content = paragraphs.join('\n\n');
+        const chunks = chunkContent(content);
+        for (let i = 0; i < paragraphs.length; i++) {
+            const marker = `PARA${i}:`;
+            const found = chunks.some(c => c.includes(marker));
+            expect(found, `${marker} not found in any chunk`).toBe(true);
+        }
+    });
+});
+// ── sha256 ────────────────────────────────────────────────────────────────────
+describe('sha256()', () => {
+    it('returns a 64-char hex string', () => {
+        const hash = sha256('hello');
+        expect(hash).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('is deterministic', () => {
+        expect(sha256('test content')).toBe(sha256('test content'));
+    });
+    it('different content produces different hashes', () => {
+        expect(sha256('content A')).not.toBe(sha256('content B'));
+    });
+    it('matches known SHA-256 value for empty string', () => {
+        // SHA-256('') = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+        expect(sha256('')).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+    });
+});
+// ── validateAndResolvePath ────────────────────────────────────────────────────
+describe('validateAndResolvePath() — AC3', () => {
+    let tmpDir;
+    let testFile;
+    beforeEach(async () => {
+        tmpDir = join(tmpdir(), `sc-test-${Date.now()}`);
+        await mkdir(tmpDir, { recursive: true });
+        testFile = join(tmpDir, 'note.md');
+        await writeFile(testFile, '# Test\nHello world\n');
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('resolves and returns the absolute path for a valid .md file', async () => {
+        const resolved = await validateAndResolvePath(testFile);
+        expect(resolved).toBe(testFile);
+    });
+    it('AC3: throws on empty path', async () => {
+        await expect(validateAndResolvePath('')).rejects.toThrow(/empty/i);
+    });
+    it('AC3: throws on whitespace-only path', async () => {
+        await expect(validateAndResolvePath('   ')).rejects.toThrow(/empty/i);
+    });
+    it('AC3: throws for unsupported extension (.pdf, v1.1 deferred)', async () => {
+        const pdfFile = join(tmpDir, 'report.pdf');
+        await writeFile(pdfFile, '%PDF-fake');
+        await expect(validateAndResolvePath(pdfFile)).rejects.toThrow(/supported/i);
+    });
+    it('AC3 STORY-012: accepts .txt transcript files', async () => {
+        const txtFile = join(tmpDir, 'transcript.txt');
+        await writeFile(txtFile, 'Hello transcript');
+        const resolved = await validateAndResolvePath(txtFile);
+        expect(resolved).toBe(txtFile);
+    });
+    it('AC3 STORY-012: accepts .vtt transcript files', async () => {
+        const vttFile = join(tmpDir, 'captions.vtt');
+        await writeFile(vttFile, 'WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nHello');
+        const resolved = await validateAndResolvePath(vttFile);
+        expect(resolved).toBe(vttFile);
+    });
+    it('AC3 STORY-012: accepts .srt transcript files', async () => {
+        const srtFile = join(tmpDir, 'captions.srt');
+        await writeFile(srtFile, '1\n00:00:00,000 --> 00:00:01,000\nHello\n');
+        const resolved = await validateAndResolvePath(srtFile);
+        expect(resolved).toBe(srtFile);
+    });
+    it('AC3: throws with "File not found" for missing file', async () => {
+        const missing = join(tmpDir, 'does-not-exist.md');
+        await expect(validateAndResolvePath(missing)).rejects.toThrow(/not found/i);
+    });
+    it('AC3: resolves ../ sequences in the path (no traversal surprise)', async () => {
+        // Build a path that uses ../ to re-enter the same directory.
+        // Use the parent dir name + the tmp dir's last segment to avoid
+        // Windows absolute-path-join issues (join() on Win32 with an absolute
+        // mid-segment keeps both roots).
+        const { dirname, basename: pathBasename } = await import('node:path');
+        const parentDir = dirname(tmpDir);
+        const dirName = pathBasename(tmpDir);
+        const tricky = join(parentDir, dirName, '..', dirName, 'note.md');
+        const resolved = await validateAndResolvePath(tricky);
+        expect(resolved).toBe(testFile);
+    });
+});
+// ── ingestMarkdownFile (mocked fetch) ─────────────────────────────────────────
+describe('ingestMarkdownFile() — AC1–AC4 (mocked backend)', () => {
+    let tmpDir;
+    let testFile;
+    beforeEach(async () => {
+        tmpDir = join(tmpdir(), `sc-ingest-${Date.now()}`);
+        await mkdir(tmpDir, { recursive: true });
+        testFile = join(tmpDir, 'note.md');
+        await writeFile(testFile, '# Test Note\n\nHello from Sound Connect.\n');
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    function mockFetch(response) {
+        const mockRes = {
+            ok: response.ok,
+            status: response.status,
+            headers: { get: () => null },
+            text: async () => JSON.stringify(response.body),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(mockRes));
+    }
+    it('AC4: returns summary with chunks_ingested=1, chunks_deduped=0 on fresh ingest', async () => {
+        mockFetch({ ok: true, status: 200, body: { ok: true, deduped: false } });
+        const summary = await ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'test-token',
+        });
+        expect(summary.chunks_sent).toBe(1);
+        expect(summary.chunks_ingested).toBe(1);
+        expect(summary.chunks_deduped).toBe(0);
+        expect(summary.file).toBe(testFile);
+        expect(summary.content_hash).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('AC4: returns summary with chunks_deduped=1 when backend reports dedup', async () => {
+        mockFetch({ ok: true, status: 200, body: { ok: true, deduped: true } });
+        const summary = await ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'test-token',
+        });
+        expect(summary.chunks_sent).toBe(1);
+        expect(summary.chunks_ingested).toBe(0);
+        expect(summary.chunks_deduped).toBe(1);
+    });
+    it('AC2: sends correct provenance fields in POST body', async () => {
+        let capturedBody = null;
+        const mockRes = {
+            ok: true,
+            status: 200,
+            headers: { get: () => null },
+            text: async () => JSON.stringify({ ok: true, deduped: false }),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (_url, opts) => {
+            capturedBody = JSON.parse(opts.body);
+            return mockRes;
+        }));
+        await ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'test-token',
+            authorEmail: 'test@example.com',
+        });
+        expect(capturedBody).not.toBeNull();
+        expect(capturedBody['source_type']).toBe('markdown');
+        expect(capturedBody['filename']).toBe('note.md');
+        expect(capturedBody['author_email']).toBe('test@example.com');
+        expect(typeof capturedBody['sha256']).toBe('string');
+        expect(typeof capturedBody['timestamp']).toBe('string');
+        expect(typeof capturedBody['content']).toBe('string');
+    });
+    it('AC2: sends Authorization: Bearer header', async () => {
+        let capturedHeaders = null;
+        const mockRes = {
+            ok: true,
+            status: 200,
+            headers: { get: () => null },
+            text: async () => JSON.stringify({ ok: true, deduped: false }),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (_url, opts) => {
+            capturedHeaders = opts.headers;
+            return mockRes;
+        }));
+        await ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'my-bearer-token',
+        });
+        expect(capturedHeaders['Authorization']).toBe('Bearer my-bearer-token');
+    });
+    it('AC2: POSTs to /ingest/:slug URL', async () => {
+        let capturedUrl = null;
+        const mockRes = {
+            ok: true,
+            status: 200,
+            headers: { get: () => null },
+            text: async () => JSON.stringify({ ok: true, deduped: false }),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (url) => {
+            capturedUrl = url;
+            return mockRes;
+        }));
+        await ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(capturedUrl).toBe('https://example.com/ingest/beacon');
+    });
+    it('AC3: throws on missing file with clear message', async () => {
+        await expect(ingestMarkdownFile({
+            filePath: join(tmpDir, 'missing.md'),
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        })).rejects.toThrow(/not found/i);
+    });
+    it('throws clear error on 401 from backend', async () => {
+        mockFetch({ ok: false, status: 401, body: {} });
+        await expect(ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'bad-token',
+        })).rejects.toThrow(/401/);
+    });
+    it('throws clear error on 403 from backend', async () => {
+        mockFetch({ ok: false, status: 403, body: { hint: 'Not a member' } });
+        await expect(ingestMarkdownFile({
+            filePath: testFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        })).rejects.toThrow(/403/);
+    });
+    it('AC4: multi-chunk file returns correct totals', async () => {
+        // Write a file large enough to produce multiple chunks
+        const bigContent = Array.from({ length: 30 }, (_, i) => `## Section ${i}\n\n${'word '.repeat(200).trim()}`).join('\n\n');
+        const bigFile = join(tmpDir, 'big.md');
+        await writeFile(bigFile, bigContent);
+        // All chunks succeed (not deduped)
+        const mockRes = {
+            ok: true,
+            status: 200,
+            headers: { get: () => null },
+            text: async () => JSON.stringify({ ok: true, deduped: false }),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(mockRes));
+        const summary = await ingestMarkdownFile({
+            filePath: bigFile,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(summary.chunks_sent).toBeGreaterThan(1);
+        expect(summary.chunks_ingested).toBe(summary.chunks_sent);
+        expect(summary.chunks_deduped).toBe(0);
+        expect(summary.chunks_ingested + summary.chunks_deduped).toBe(summary.chunks_sent);
+    });
+});
+// ── STORY-012: sourceTypeForExt ───────────────────────────────────────────────
+describe('sourceTypeForExt()', () => {
+    it('returns "markdown" for .md', () => {
+        expect(sourceTypeForExt('.md')).toBe('markdown');
+    });
+    it('returns "transcript" for .txt', () => {
+        expect(sourceTypeForExt('.txt')).toBe('transcript');
+    });
+    it('returns "transcript" for .vtt', () => {
+        expect(sourceTypeForExt('.vtt')).toBe('transcript');
+    });
+    it('returns "transcript" for .srt', () => {
+        expect(sourceTypeForExt('.srt')).toBe('transcript');
+    });
+});
+// ── STORY-012: SUPPORTED_EXTENSIONS ──────────────────────────────────────────
+describe('SUPPORTED_EXTENSIONS', () => {
+    it('contains .md, .txt, .vtt, .srt', () => {
+        expect(SUPPORTED_EXTENSIONS.has('.md')).toBe(true);
+        expect(SUPPORTED_EXTENSIONS.has('.txt')).toBe(true);
+        expect(SUPPORTED_EXTENSIONS.has('.vtt')).toBe(true);
+        expect(SUPPORTED_EXTENSIONS.has('.srt')).toBe(true);
+    });
+    it('does not contain binary formats deferred to v1.1', () => {
+        expect(SUPPORTED_EXTENSIONS.has('.pdf')).toBe(false);
+        expect(SUPPORTED_EXTENSIONS.has('.docx')).toBe(false);
+        expect(SUPPORTED_EXTENSIONS.has('.xlsx')).toBe(false);
+    });
+});
+// ── STORY-012: parseGlobToExtensions ─────────────────────────────────────────
+describe('parseGlobToExtensions()', () => {
+    it('returns all supported extensions when glob is undefined', () => {
+        const exts = parseGlobToExtensions(undefined);
+        expect(exts.has('.md')).toBe(true);
+        expect(exts.has('.txt')).toBe(true);
+        expect(exts.has('.vtt')).toBe(true);
+        expect(exts.has('.srt')).toBe(true);
+    });
+    it('returns all supported extensions when glob is empty string', () => {
+        const exts = parseGlobToExtensions('');
+        expect(exts.size).toBe(SUPPORTED_EXTENSIONS.size);
+    });
+    it('filters to .md only for "*.md"', () => {
+        const exts = parseGlobToExtensions('*.md');
+        expect(exts.has('.md')).toBe(true);
+        expect(exts.has('.txt')).toBe(false);
+        expect(exts.has('.vtt')).toBe(false);
+    });
+    it('filters to .vtt only for "*.vtt"', () => {
+        const exts = parseGlobToExtensions('*.vtt');
+        expect(exts.has('.vtt')).toBe(true);
+        expect(exts.has('.md')).toBe(false);
+    });
+    it('filters to .txt only for "*.txt"', () => {
+        const exts = parseGlobToExtensions('*.txt');
+        expect(exts.has('.txt')).toBe(true);
+        expect(exts.has('.srt')).toBe(false);
+    });
+    it('throws for unsupported extension in glob', () => {
+        expect(() => parseGlobToExtensions('*.pdf')).toThrow(/supported/i);
+    });
+    it('throws for .docx (v1.1 deferred)', () => {
+        expect(() => parseGlobToExtensions('*.docx')).toThrow(/supported/i);
+    });
+    it('returns all extensions for a pattern without wildcard extension', () => {
+        // A pattern like "docs/" has no *.ext — falls back to all supported.
+        const exts = parseGlobToExtensions('docs/');
+        expect(exts.size).toBe(SUPPORTED_EXTENSIONS.size);
+    });
+});
+// ── STORY-012: enumerateFolder ────────────────────────────────────────────────
+describe('enumerateFolder()', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = join(tmpdir(), `sc-folder-${Date.now()}`);
+        await mkdir(tmpDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('AC1: returns .md and transcript files matching the allowed set', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note');
+        await writeFile(join(tmpDir, 'meeting.txt'), 'transcript');
+        await writeFile(join(tmpDir, 'captions.vtt'), 'WEBVTT');
+        await writeFile(join(tmpDir, 'captions.srt'), '1\n');
+        await writeFile(join(tmpDir, 'data.xlsx'), 'binary');
+        const files = await enumerateFolder(tmpDir, SUPPORTED_EXTENSIONS);
+        const names = files.map(f => f.slice(tmpDir.length + 1));
+        expect(names).toContain('note.md');
+        expect(names).toContain('meeting.txt');
+        expect(names).toContain('captions.vtt');
+        expect(names).toContain('captions.srt');
+        expect(names).not.toContain('data.xlsx');
+    });
+    it('AC1: filters to only .md when allowedExts = {".md"}', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note');
+        await writeFile(join(tmpDir, 'meeting.txt'), 'transcript');
+        const files = await enumerateFolder(tmpDir, new Set(['.md']));
+        const names = files.map(f => f.slice(tmpDir.length + 1));
+        expect(names).toContain('note.md');
+        expect(names).not.toContain('meeting.txt');
+    });
+    it('returns empty array for empty folder', async () => {
+        const files = await enumerateFolder(tmpDir, SUPPORTED_EXTENSIONS);
+        expect(files).toHaveLength(0);
+    });
+    it('returns sorted file paths', async () => {
+        await writeFile(join(tmpDir, 'z-note.md'), 'Z');
+        await writeFile(join(tmpDir, 'a-note.md'), 'A');
+        await writeFile(join(tmpDir, 'm-note.md'), 'M');
+        const files = await enumerateFolder(tmpDir, SUPPORTED_EXTENSIONS);
+        const names = files.map(f => f.slice(tmpDir.length + 1));
+        expect(names).toEqual([...names].sort());
+    });
+    it('throws with "Folder not found" for missing directory', async () => {
+        await expect(enumerateFolder(join(tmpDir, 'does-not-exist'), SUPPORTED_EXTENSIONS)).rejects.toThrow(/not found/i);
+    });
+    it('skips subdirectories (flat enumeration only)', async () => {
+        const subDir = join(tmpDir, 'subdir');
+        await mkdir(subDir);
+        await writeFile(join(subDir, 'nested.md'), '# Nested');
+        await writeFile(join(tmpDir, 'top.md'), '# Top');
+        const files = await enumerateFolder(tmpDir, SUPPORTED_EXTENSIONS);
+        const names = files.map(f => f.slice(tmpDir.length + 1));
+        expect(names).toContain('top.md');
+        expect(names).not.toContain(join('subdir', 'nested.md'));
+    });
+});
+// ── STORY-012: ingestFolder (mocked backend) ──────────────────────────────────
+describe('ingestFolder() — AC1–AC4 (mocked backend)', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = join(tmpdir(), `sc-folder-ingest-${Date.now()}`);
+        await mkdir(tmpDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    function mockFetchAlways(body, ok = true, status = 200) {
+        const mockRes = {
+            ok,
+            status,
+            headers: { get: () => null },
+            text: async () => JSON.stringify(body),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(mockRes));
+    }
+    it('AC4: returns per-file result table with correct structure', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note\n\nContent');
+        await writeFile(join(tmpDir, 'meeting.txt'), 'Hello transcript');
+        mockFetchAlways({ ok: true, deduped: false });
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_found).toBe(2);
+        expect(result.results).toHaveLength(2);
+        expect(result.results.every(r => r.status === 'ingested')).toBe(true);
+    });
+    it('AC1: enumerates .md and transcript files', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note');
+        await writeFile(join(tmpDir, 'meeting.vtt'), 'WEBVTT\n');
+        await writeFile(join(tmpDir, 'report.pdf'), '%PDF'); // should be skipped
+        mockFetchAlways({ ok: true, deduped: false });
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_found).toBe(2);
+    });
+    it('AC2: source_type is "markdown" for .md and "transcript" for .txt', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Markdown file');
+        await writeFile(join(tmpDir, 'transcript.txt'), 'Transcript content');
+        const capturedBodies = [];
+        const mockRes = {
+            ok: true,
+            status: 200,
+            headers: { get: () => null },
+            text: async () => JSON.stringify({ ok: true, deduped: false }),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (_url, opts) => {
+            capturedBodies.push(JSON.parse(opts.body));
+            return mockRes;
+        }));
+        await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        const mdBody = capturedBodies.find(b => b['filename'].endsWith('.md'));
+        const txtBody = capturedBodies.find(b => b['filename'].endsWith('.txt'));
+        expect(mdBody['source_type']).toBe('markdown');
+        expect(txtBody['source_type']).toBe('transcript');
+    });
+    it('AC3: idempotency — re-run marks files as deduped', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note\n\nContent');
+        mockFetchAlways({ ok: true, deduped: true });
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_ingested).toBe(0);
+        expect(result.files_deduped).toBe(1);
+        expect(result.results[0].status).toBe('deduped');
+    });
+    it('AC4: failed files are captured in results, do not abort the run (ADR-011)', async () => {
+        await writeFile(join(tmpDir, 'good.md'), '# Good file');
+        await writeFile(join(tmpDir, 'bad.md'), '# Bad file');
+        let callCount = 0;
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async () => {
+            callCount++;
+            if (callCount === 1) {
+                // First file succeeds.
+                return {
+                    ok: true,
+                    status: 200,
+                    headers: { get: () => null },
+                    text: async () => JSON.stringify({ ok: true, deduped: false }),
+                };
+            }
+            // Second file returns 401 — should be captured as failed.
+            return {
+                ok: false,
+                status: 401,
+                headers: { get: () => null },
+                text: async () => JSON.stringify({}),
+            };
+        }));
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_found).toBe(2);
+        expect(result.files_ingested + result.files_failed).toBe(2);
+        const failedFile = result.results.find(r => r.status === 'failed');
+        expect(failedFile).toBeDefined();
+        expect(failedFile.error).toBeTruthy();
+    });
+    it('AC1: glob filter "*.md" restricts to markdown files only', async () => {
+        await writeFile(join(tmpDir, 'note.md'), '# Note');
+        await writeFile(join(tmpDir, 'meeting.txt'), 'transcript');
+        mockFetchAlways({ ok: true, deduped: false });
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            glob: '*.md',
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_found).toBe(1);
+        expect(result.results[0].file).toMatch(/\.md$/);
+    });
+    it('AC4: folder-level totals are consistent with per-file results', async () => {
+        await writeFile(join(tmpDir, 'a.md'), '# A');
+        await writeFile(join(tmpDir, 'b.md'), '# B');
+        await writeFile(join(tmpDir, 'c.txt'), 'C');
+        let call = 0;
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async () => {
+            call++;
+            // a.md → ingested, b.md → deduped, c.txt → ingested
+            const deduped = call === 2;
+            return {
+                ok: true,
+                status: 200,
+                headers: { get: () => null },
+                text: async () => JSON.stringify({ ok: true, deduped }),
+            };
+        }));
+        const result = await ingestFolder({
+            folderPath: tmpDir,
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        });
+        expect(result.files_found).toBe(3);
+        expect(result.files_ingested + result.files_deduped + result.files_failed).toBe(3);
+        expect(result.results).toHaveLength(3);
+    });
+    it('throws when the folder does not exist', async () => {
+        await expect(ingestFolder({
+            folderPath: join(tmpDir, 'no-such-folder'),
+            backendUrl: 'https://example.com',
+            clientSlug: 'beacon',
+            token: 'tok',
+        })).rejects.toThrow(/not found/i);
+    });
+});
+//# sourceMappingURL=ingest.test.js.map