scottlanoue.com / atmosphere-office
Full document, spreadsheet, slideshow, and diagram tooling
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

test: add 177 edge case tests for 8 coverage gap issues

Adds comprehensive edge case test coverage for:
- Landing utils: sort, stars, trash, folders, breadcrumbs, recent docs (#545, #565)
- Version history: duplicate snapshots, rapid captures, boundary pruning (#557)
- Offline sync: FIFO queue ordering, conflict-resolution cycle, large payloads (#554)
- Wiki links: renamed/deleted doc resolution, special characters (#551)
- Presenter mode: single-slide deck, 0 duration, rapid navigation (#541)
- Data validation: comma-in-list items, non-numeric bounds, boolean inputs (#537)
- Comment threads: orphaned anchors, many replies, resolve/reopen edge cases (#533)
- Search index: regex-special queries, HTML edge cases, large doc sets (#565)

Total test suite: 258 files, 8101 tests passing.

Scott Lanoue 999f7fea 2b80ea1b

+1607
+224
tests/comment-threads-edge.test.ts
··· 1 + /** 2 + * Edge case tests for comment-threads.ts (#533). 3 + * Covers: orphaned anchors, many replies, concurrent resolve+reply, 4 + * edit non-existent reply, sort stability, filterByAuthor edge cases. 5 + */ 6 + import { describe, it, expect, beforeEach } from 'vitest'; 7 + import { 8 + createThread, 9 + addReply, 10 + editComment, 11 + deleteReply, 12 + resolveThread, 13 + reopenThread, 14 + sortThreads, 15 + threadCommentCount, 16 + threadLastActivity, 17 + filterByAuthor, 18 + unresolvedCount, 19 + findThreadByAnchor, 20 + resetCommentIdCounter, 21 + type CommentThread, 22 + } from '../src/lib/comment-threads.js'; 23 + 24 + describe('Comment Threads — orphaned anchors (#533)', () => { 25 + beforeEach(() => resetCommentIdCounter()); 26 + 27 + it('thread persists after anchor text is conceptually deleted', () => { 28 + // In real usage, deleting text removes the editor mark but the thread 29 + // object remains in the Yjs map. This test verifies the data model 30 + // still works for orphaned threads. 31 + const thread = createThread('deleted-anchor', 'Alice', 'Comment on text', 1000); 32 + // Thread is still valid even though anchor no longer exists in document 33 + expect(thread.anchorId).toBe('deleted-anchor'); 34 + expect(thread.root.text).toBe('Comment on text'); 35 + 36 + // Can still add replies 37 + const withReply = addReply(thread, 'Bob', 'I see the original is gone', 2000); 38 + expect(withReply.replies).toHaveLength(1); 39 + 40 + // Can still resolve 41 + const resolved = resolveThread(withReply, 'Carol', 3000); 42 + expect(resolved.resolved).toBe(true); 43 + }); 44 + 45 + it('findThreadByAnchor still finds orphaned thread', () => { 46 + const threads = [ 47 + createThread('existing-anchor', 'Alice', 'Valid', 1000), 48 + createThread('deleted-anchor', 'Bob', 'Orphaned', 2000), 49 + ]; 50 + const found = findThreadByAnchor(threads, 'deleted-anchor'); 51 + expect(found).not.toBeNull(); 52 + expect(found!.root.text).toBe('Orphaned'); 53 + }); 54 + }); 55 + 56 + describe('Comment Threads — many replies', () => { 57 + beforeEach(() => resetCommentIdCounter()); 58 + 59 + it('handles 100 replies on a single thread', () => { 60 + let thread = createThread('a1', 'Alice', 'Start', 1000); 61 + for (let i = 0; i < 100; i++) { 62 + thread = addReply(thread, `User${i}`, `Reply ${i}`, 2000 + i); 63 + } 64 + expect(threadCommentCount(thread)).toBe(101); // root + 100 replies 65 + expect(thread.replies).toHaveLength(100); 66 + }); 67 + 68 + it('delete first reply preserves order of rest', () => { 69 + let thread = createThread('a1', 'A', 'Root', 1000); 70 + thread = addReply(thread, 'B', 'R1', 2000); 71 + thread = addReply(thread, 'C', 'R2', 3000); 72 + thread = addReply(thread, 'D', 'R3', 4000); 73 + 74 + const firstReplyId = thread.replies[0].id; 75 + thread = deleteReply(thread, firstReplyId); 76 + 77 + expect(thread.replies).toHaveLength(2); 78 + expect(thread.replies[0].text).toBe('R2'); 79 + expect(thread.replies[1].text).toBe('R3'); 80 + }); 81 + 82 + it('delete last reply preserves order of rest', () => { 83 + let thread = createThread('a1', 'A', 'Root', 1000); 84 + thread = addReply(thread, 'B', 'R1', 2000); 85 + thread = addReply(thread, 'C', 'R2', 3000); 86 + thread = addReply(thread, 'D', 'R3', 4000); 87 + 88 + const lastReplyId = thread.replies[2].id; 89 + thread = deleteReply(thread, lastReplyId); 90 + 91 + expect(thread.replies).toHaveLength(2); 92 + expect(thread.replies[0].text).toBe('R1'); 93 + expect(thread.replies[1].text).toBe('R2'); 94 + }); 95 + }); 96 + 97 + describe('Comment Threads — resolve/reopen edge cases', () => { 98 + beforeEach(() => resetCommentIdCounter()); 99 + 100 + it('resolving already-resolved thread updates resolver', () => { 101 + let thread = createThread('a1', 'Alice', 'Issue', 1000); 102 + thread = resolveThread(thread, 'Bob', 2000); 103 + thread = resolveThread(thread, 'Carol', 3000); 104 + expect(thread.resolvedBy).toBe('Carol'); 105 + expect(thread.resolvedAt).toBe(3000); 106 + }); 107 + 108 + it('reopening already-open thread is a no-op in effect', () => { 109 + const thread = createThread('a1', 'Alice', 'Open', 1000); 110 + const reopened = reopenThread(thread); 111 + expect(reopened.resolved).toBe(false); 112 + expect(reopened.resolvedBy).toBeUndefined(); 113 + }); 114 + 115 + it('reply on resolved thread does not unresolve it', () => { 116 + let thread = createThread('a1', 'Alice', 'Issue', 1000); 117 + thread = resolveThread(thread, 'Bob', 2000); 118 + thread = addReply(thread, 'Carol', 'But wait...', 3000); 119 + expect(thread.resolved).toBe(true); 120 + expect(thread.replies).toHaveLength(1); 121 + }); 122 + }); 123 + 124 + describe('Comment Threads — edit edge cases', () => { 125 + beforeEach(() => resetCommentIdCounter()); 126 + 127 + it('cannot edit root by passing reply ID', () => { 128 + let thread = createThread('a1', 'Alice', 'Root text', 1000); 129 + thread = addReply(thread, 'Bob', 'Reply', 2000); 130 + const replyId = thread.replies[0].id; 131 + 132 + // Edit the reply, not root 133 + const edited = editComment(thread, replyId, 'Edited reply', 3000); 134 + expect(edited.root.text).toBe('Root text'); // unchanged 135 + expect(edited.replies[0].text).toBe('Edited reply'); 136 + }); 137 + 138 + it('edit preserves original author', () => { 139 + const thread = createThread('a1', 'Alice', 'Original', 1000); 140 + const edited = editComment(thread, thread.root.id, 'Changed', 2000); 141 + expect(edited.root.author).toBe('Alice'); 142 + }); 143 + }); 144 + 145 + describe('Comment Threads — sortThreads stability', () => { 146 + beforeEach(() => resetCommentIdCounter()); 147 + 148 + it('newest sort with same timestamp preserves insertion order', () => { 149 + const threads = [ 150 + createThread('a1', 'A', 'First', 1000), 151 + createThread('a2', 'B', 'Second', 1000), 152 + createThread('a3', 'C', 'Third', 1000), 153 + ]; 154 + const sorted = sortThreads(threads, 'newest'); 155 + // All have same timestamp, sort should be stable 156 + expect(sorted).toHaveLength(3); 157 + }); 158 + 159 + it('unresolved sort groups correctly with mixed states', () => { 160 + const resolved1 = resolveThread(createThread('a1', 'A', 'R1', 1000), 'X', 5000); 161 + const open1 = createThread('a2', 'B', 'O1', 2000); 162 + const resolved2 = resolveThread(createThread('a3', 'C', 'R2', 3000), 'Y', 6000); 163 + const open2 = createThread('a4', 'D', 'O2', 4000); 164 + 165 + const sorted = sortThreads([resolved1, open1, resolved2, open2], 'unresolved'); 166 + // Unresolved first 167 + expect(sorted[0].resolved).toBe(false); 168 + expect(sorted[1].resolved).toBe(false); 169 + expect(sorted[2].resolved).toBe(true); 170 + expect(sorted[3].resolved).toBe(true); 171 + }); 172 + }); 173 + 174 + describe('Comment Threads — filterByAuthor edge cases', () => { 175 + beforeEach(() => resetCommentIdCounter()); 176 + 177 + it('filters by reply author (not just root)', () => { 178 + const thread = addReply( 179 + createThread('a1', 'Alice', 'Root', 1000), 180 + 'Bob', 181 + 'Reply', 182 + 2000, 183 + ); 184 + expect(filterByAuthor([thread], 'Bob')).toHaveLength(1); 185 + }); 186 + 187 + it('returns empty for non-existent author', () => { 188 + const thread = createThread('a1', 'Alice', 'Root', 1000); 189 + expect(filterByAuthor([thread], 'NonExistent')).toHaveLength(0); 190 + }); 191 + 192 + it('handles empty threads array', () => { 193 + expect(filterByAuthor([], 'Anyone')).toHaveLength(0); 194 + }); 195 + }); 196 + 197 + describe('Comment Threads — threadLastActivity with edits', () => { 198 + beforeEach(() => resetCommentIdCounter()); 199 + 200 + it('returns reply time even if root was edited later', () => { 201 + let thread = createThread('a1', 'Alice', 'Root', 1000); 202 + thread = addReply(thread, 'Bob', 'Reply', 5000); 203 + // Edit root at 6000 — but threadLastActivity only checks createdAt 204 + thread = editComment(thread, thread.root.id, 'Edited', 6000); 205 + // Last activity should still be based on the reply's createdAt 206 + expect(threadLastActivity(thread)).toBe(5000); 207 + }); 208 + }); 209 + 210 + describe('Comment Threads — unresolvedCount', () => { 211 + beforeEach(() => resetCommentIdCounter()); 212 + 213 + it('returns 0 for empty array', () => { 214 + expect(unresolvedCount([])).toBe(0); 215 + }); 216 + 217 + it('returns 0 when all are resolved', () => { 218 + const threads = [ 219 + resolveThread(createThread('a1', 'A', 'T1', 1000), 'X', 2000), 220 + resolveThread(createThread('a2', 'B', 'T2', 3000), 'Y', 4000), 221 + ]; 222 + expect(unresolvedCount(threads)).toBe(0); 223 + }); 224 + });
+132
tests/data-validation-edge.test.ts
··· 1 + /** 2 + * Edge case tests for data-validation.ts (#537). 3 + * Covers: special characters in list items, non-numeric bounds, 4 + * boolean inputs, very long lists, reversed min/max for textLength. 5 + */ 6 + import { describe, it, expect } from 'vitest'; 7 + import { parseListItems, validateCell, getDropdownItems } from '../src/sheets/data-validation.js'; 8 + 9 + describe('data-validation — list edge cases (#537)', () => { 10 + it('list items containing commas cannot be specified via value string', () => { 11 + // This is a known limitation: comma-separated parsing splits on commas 12 + const rule = { type: 'list', value: 'New York, NY, Los Angeles, CA' }; 13 + // Parsed as 4 items: "New York", "NY", "Los Angeles", "CA" 14 + const items = parseListItems(rule.value); 15 + expect(items).toHaveLength(4); 16 + expect(items).toContain('New York'); 17 + expect(items).toContain('NY'); 18 + }); 19 + 20 + it('list items with commas work via items array', () => { 21 + const rule = { type: 'list', items: ['New York, NY', 'Los Angeles, CA'] }; 22 + expect(validateCell('New York, NY', rule)).toEqual({ valid: true }); 23 + expect(validateCell('New York', rule).valid).toBe(false); 24 + }); 25 + 26 + it('list validation is case-insensitive', () => { 27 + const rule = { type: 'list', value: 'apple, BANANA, Cherry' }; 28 + expect(validateCell('APPLE', rule)).toEqual({ valid: true }); 29 + expect(validateCell('banana', rule)).toEqual({ valid: true }); 30 + expect(validateCell('cherry', rule)).toEqual({ valid: true }); 31 + }); 32 + 33 + it('list with whitespace-only items are filtered out', () => { 34 + const items = parseListItems('A, , B, , C'); 35 + expect(items).toEqual(['A', 'B', 'C']); 36 + }); 37 + 38 + it('validates against a very long list (1000 items)', () => { 39 + const longList = Array.from({ length: 1000 }, (_, i) => `Item${i}`); 40 + const rule = { type: 'list', items: longList }; 41 + expect(validateCell('Item500', rule)).toEqual({ valid: true }); 42 + expect(validateCell('NotInList', rule).valid).toBe(false); 43 + }); 44 + }); 45 + 46 + describe('data-validation — numberBetween edge cases (#537)', () => { 47 + it('non-numeric bounds return valid (cannot enforce)', () => { 48 + const rule = { type: 'numberBetween', value: 'abc', value2: '10' }; 49 + // min is null → returns valid 50 + expect(validateCell(5, rule)).toEqual({ valid: true }); 51 + }); 52 + 53 + it('both bounds non-numeric return valid', () => { 54 + const rule = { type: 'numberBetween', value: 'abc', value2: 'xyz' }; 55 + expect(validateCell(5, rule)).toEqual({ valid: true }); 56 + }); 57 + 58 + it('boolean true is treated as number 1', () => { 59 + const rule = { type: 'numberBetween', value: '0', value2: '10' }; 60 + // toNumber(true) → Number(true) → 1 61 + expect(validateCell(true, rule)).toEqual({ valid: true }); 62 + }); 63 + 64 + it('boolean false is treated as number 0', () => { 65 + const rule = { type: 'numberBetween', value: '0', value2: '10' }; 66 + expect(validateCell(false, rule)).toEqual({ valid: true }); 67 + }); 68 + 69 + it('handles negative ranges', () => { 70 + const rule = { type: 'numberBetween', value: '-100', value2: '-10' }; 71 + expect(validateCell(-50, rule)).toEqual({ valid: true }); 72 + expect(validateCell(-5, rule).valid).toBe(false); 73 + expect(validateCell(-101, rule).valid).toBe(false); 74 + }); 75 + 76 + it('handles decimal bounds', () => { 77 + const rule = { type: 'numberBetween', value: '0.5', value2: '1.5' }; 78 + expect(validateCell(1.0, rule)).toEqual({ valid: true }); 79 + expect(validateCell(0.4, rule).valid).toBe(false); 80 + }); 81 + 82 + it('Infinity is rejected when out of range', () => { 83 + const rule = { type: 'numberBetween', value: '0', value2: '100' }; 84 + expect(validateCell(Infinity, rule).valid).toBe(false); 85 + }); 86 + }); 87 + 88 + describe('data-validation — textLength edge cases (#537)', () => { 89 + it('reversed min/max auto-swaps', () => { 90 + const rule = { type: 'textLength', value: '10', value2: '3' }; 91 + // Auto-swapped to 3-10 92 + expect(validateCell('Hello', rule)).toEqual({ valid: true }); // 5 chars 93 + expect(validateCell('ab', rule).valid).toBe(false); // 2 chars 94 + expect(validateCell('12345678901', rule).valid).toBe(false); // 11 chars 95 + }); 96 + 97 + it('textLength with non-numeric bounds defaults gracefully', () => { 98 + const rule = { type: 'textLength', value: 'abc', value2: 'xyz' }; 99 + // toNumber returns null → defaults to 0 and Infinity → Math.min/max 100 + expect(validateCell('anything', rule)).toEqual({ valid: true }); 101 + }); 102 + 103 + it('textLength with zero min and zero max', () => { 104 + const rule = { type: 'textLength', value: '0', value2: '0' }; 105 + expect(validateCell('', rule)).toEqual({ valid: true }); // empty is always valid 106 + expect(validateCell('a', rule).valid).toBe(false); // 1 char > max 0 107 + }); 108 + 109 + it('converts number to string for length check', () => { 110 + const rule = { type: 'textLength', value: '1', value2: '5' }; 111 + expect(validateCell(123, rule)).toEqual({ valid: true }); // "123" → 3 chars 112 + expect(validateCell(123456, rule).valid).toBe(false); // "123456" → 6 chars 113 + }); 114 + }); 115 + 116 + describe('data-validation — null/undefined edge cases (#537)', () => { 117 + it('validateCell with all-null rule fields', () => { 118 + const rule = { type: 'list', value: null, items: null }; 119 + // parseListItems(null) → [], items.length === 0 → valid 120 + expect(validateCell('anything', rule)).toEqual({ valid: true }); 121 + }); 122 + 123 + it('getDropdownItems with items array takes precedence', () => { 124 + const rule = { type: 'list', value: 'A, B', items: ['X', 'Y', 'Z'] }; 125 + expect(getDropdownItems(rule)).toEqual(['X', 'Y', 'Z']); 126 + }); 127 + 128 + it('getDropdownItems falls back to parsing value string', () => { 129 + const rule = { type: 'list', value: 'A, B, C' }; 130 + expect(getDropdownItems(rule)).toEqual(['A', 'B', 'C']); 131 + }); 132 + });
+434
tests/landing-utils-extended.test.ts
··· 1 + /** 2 + * Extended tests for landing-utils.ts — covers sort, stars, trash, folders, 3 + * recent docs, and breadcrumbs (#545, #565). 4 + */ 5 + import { describe, it, expect } from 'vitest'; 6 + import { 7 + compareDocuments, 8 + sortDocuments, 9 + toggleStar, 10 + starredIdsSet, 11 + addToTrash, 12 + restoreFromTrash, 13 + purgeExpiredTrash, 14 + isInTrash, 15 + removeFromTrash, 16 + partitionDocuments, 17 + createFolder, 18 + renameFolder, 19 + deleteFolder, 20 + moveToFolder, 21 + getDocsInFolder, 22 + buildBreadcrumbs, 23 + clearFolderAssignments, 24 + trackRecentDoc, 25 + getRecentDocs, 26 + } from '../src/landing-utils.js'; 27 + import type { DocumentMeta, Folder, TrashEntry, FolderAssignments, StarMap } from '../src/landing-types.js'; 28 + 29 + // --- Helpers --- 30 + 31 + function makeDocs(...args: Array<{ id: string; name?: string; type?: string; created?: string; updated?: string }>): DocumentMeta[] { 32 + return args.map(a => ({ 33 + id: a.id, 34 + type: (a.type ?? 'doc') as DocumentMeta['type'], 35 + name_encrypted: null, 36 + deleted_at: null, 37 + tags: null, 38 + created_at: a.created ?? '2026-01-01T00:00:00Z', 39 + updated_at: a.updated ?? '2026-01-01T00:00:00Z', 40 + _decryptedName: a.name, 41 + })); 42 + } 43 + 44 + // ============================================================ 45 + // Sort 46 + // ============================================================ 47 + 48 + describe('compareDocuments', () => { 49 + const docs = makeDocs( 50 + { id: '1', name: 'Budget', type: 'sheet', created: '2026-01-01', updated: '2026-01-03' }, 51 + { id: '2', name: 'Alpha Notes', type: 'doc', created: '2026-01-02', updated: '2026-01-01' }, 52 + { id: '3', name: undefined, type: 'doc', created: '2026-01-03', updated: '2026-01-02' }, 53 + ); 54 + 55 + it('sorts by name alphabetically', () => { 56 + expect(compareDocuments(docs[0], docs[1], 'name')).toBeGreaterThan(0); 57 + expect(compareDocuments(docs[1], docs[0], 'name')).toBeLessThan(0); 58 + }); 59 + 60 + it('treats encrypted docs as "Encrypted Document"', () => { 61 + // doc[2] has no name → "encrypted document" 62 + expect(compareDocuments(docs[2], docs[1], 'name')).toBeGreaterThan(0); // 'e' > 'a' 63 + }); 64 + 65 + it('sorts by created (newest first)', () => { 66 + expect(compareDocuments(docs[0], docs[2], 'created')).toBeGreaterThan(0); // 2026-01-01 < 2026-01-03 67 + }); 68 + 69 + it('sorts by updated (newest first)', () => { 70 + expect(compareDocuments(docs[0], docs[1], 'updated')).toBeLessThan(0); // 2026-01-03 > 2026-01-01 71 + }); 72 + 73 + it('sorts by type, then by updated descending', () => { 74 + // doc[0] is sheet, doc[1] is doc → 'sheet' > 'doc' 75 + expect(compareDocuments(docs[0], docs[1], 'type')).toBeGreaterThan(0); 76 + // Same types use updated as tiebreaker 77 + expect(compareDocuments(docs[1], docs[2], 'type')).toBeGreaterThan(0); // both doc, but docs[2] has newer updated 78 + }); 79 + 80 + it('defaults to updated sort for unknown sort field', () => { 81 + expect(compareDocuments(docs[0], docs[1], 'unknown')).toBeLessThan(0); 82 + }); 83 + }); 84 + 85 + describe('sortDocuments', () => { 86 + const docs = makeDocs( 87 + { id: '1', name: 'Zebra', updated: '2026-01-01' }, 88 + { id: '2', name: 'Apple', updated: '2026-01-03' }, 89 + { id: '3', name: 'Mango', updated: '2026-01-02' }, 90 + ); 91 + 92 + it('sorts by name', () => { 93 + const sorted = sortDocuments(docs, 'name'); 94 + expect(sorted.map(d => d.id)).toEqual(['2', '3', '1']); 95 + }); 96 + 97 + it('puts starred items first', () => { 98 + const starred = new Set(['1']); 99 + const sorted = sortDocuments(docs, 'name', starred); 100 + expect(sorted[0].id).toBe('1'); 101 + }); 102 + 103 + it('preserves sort within starred group', () => { 104 + const starred = new Set(['1', '3']); 105 + const sorted = sortDocuments(docs, 'name', starred); 106 + // Starred sorted by name: Mango(3), Zebra(1) 107 + expect(sorted[0].id).toBe('3'); 108 + expect(sorted[1].id).toBe('1'); 109 + expect(sorted[2].id).toBe('2'); 110 + }); 111 + 112 + it('handles empty docs', () => { 113 + expect(sortDocuments([], 'name')).toEqual([]); 114 + }); 115 + }); 116 + 117 + // ============================================================ 118 + // Stars 119 + // ============================================================ 120 + 121 + describe('toggleStar', () => { 122 + it('stars a document', () => { 123 + const stars = toggleStar({}, 'doc-1'); 124 + expect(stars['doc-1']).toBe(true); 125 + }); 126 + 127 + it('unstars a document', () => { 128 + const stars = toggleStar({ 'doc-1': true }, 'doc-1'); 129 + expect(stars['doc-1']).toBeUndefined(); 130 + }); 131 + 132 + it('preserves other stars', () => { 133 + const stars = toggleStar({ 'doc-1': true, 'doc-2': true }, 'doc-1'); 134 + expect(stars['doc-2']).toBe(true); 135 + }); 136 + }); 137 + 138 + describe('starredIdsSet', () => { 139 + it('returns set from star map', () => { 140 + const set = starredIdsSet({ 'a': true, 'b': true }); 141 + expect(set.has('a')).toBe(true); 142 + expect(set.has('b')).toBe(true); 143 + expect(set.size).toBe(2); 144 + }); 145 + 146 + it('handles null', () => { 147 + expect(starredIdsSet(null).size).toBe(0); 148 + }); 149 + 150 + it('handles undefined', () => { 151 + expect(starredIdsSet(undefined).size).toBe(0); 152 + }); 153 + }); 154 + 155 + // ============================================================ 156 + // Trash 157 + // ============================================================ 158 + 159 + describe('addToTrash', () => { 160 + it('adds a document to trash', () => { 161 + const trash = addToTrash([], 'doc-1', 1000); 162 + expect(trash).toHaveLength(1); 163 + expect(trash[0].id).toBe('doc-1'); 164 + expect(trash[0].deletedAt).toBe(1000); 165 + }); 166 + 167 + it('does not add duplicates', () => { 168 + const trash = addToTrash([{ id: 'doc-1', deletedAt: 1000 }], 'doc-1', 2000); 169 + expect(trash).toHaveLength(1); 170 + expect(trash[0].deletedAt).toBe(1000); // unchanged 171 + }); 172 + }); 173 + 174 + describe('restoreFromTrash', () => { 175 + it('removes a document from trash', () => { 176 + const trash = restoreFromTrash([{ id: 'doc-1', deletedAt: 1000 }, { id: 'doc-2', deletedAt: 2000 }], 'doc-1'); 177 + expect(trash).toHaveLength(1); 178 + expect(trash[0].id).toBe('doc-2'); 179 + }); 180 + 181 + it('returns same array for unknown id', () => { 182 + const original: TrashEntry[] = [{ id: 'doc-1', deletedAt: 1000 }]; 183 + const result = restoreFromTrash(original, 'unknown'); 184 + expect(result).toHaveLength(1); 185 + }); 186 + }); 187 + 188 + describe('purgeExpiredTrash', () => { 189 + const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000; 190 + 191 + it('purges items older than 30 days', () => { 192 + const now = 100000 + THIRTY_DAYS; 193 + const trash: TrashEntry[] = [ 194 + { id: 'old', deletedAt: 100000 }, 195 + { id: 'new', deletedAt: now - 1000 }, 196 + ]; 197 + const { kept, expired } = purgeExpiredTrash(trash, now); 198 + expect(expired).toEqual(['old']); 199 + expect(kept).toHaveLength(1); 200 + expect(kept[0].id).toBe('new'); 201 + }); 202 + 203 + it('keeps items exactly at boundary', () => { 204 + const now = 100000 + THIRTY_DAYS; 205 + const trash: TrashEntry[] = [{ id: 'boundary', deletedAt: 100000 }]; 206 + const { expired } = purgeExpiredTrash(trash, now); 207 + expect(expired).toEqual(['boundary']); // >= TTL means expired 208 + }); 209 + 210 + it('handles empty trash', () => { 211 + const { kept, expired } = purgeExpiredTrash([], Date.now()); 212 + expect(kept).toEqual([]); 213 + expect(expired).toEqual([]); 214 + }); 215 + }); 216 + 217 + describe('isInTrash / removeFromTrash', () => { 218 + const trash: TrashEntry[] = [{ id: 'doc-1', deletedAt: 1000 }]; 219 + 220 + it('detects trashed document', () => { 221 + expect(isInTrash(trash, 'doc-1')).toBe(true); 222 + expect(isInTrash(trash, 'doc-2')).toBe(false); 223 + }); 224 + 225 + it('permanently removes from trash', () => { 226 + expect(removeFromTrash(trash, 'doc-1')).toHaveLength(0); 227 + }); 228 + }); 229 + 230 + describe('partitionDocuments', () => { 231 + const docs = makeDocs({ id: '1', name: 'A' }, { id: '2', name: 'B' }, { id: '3', name: 'C' }); 232 + const trash: TrashEntry[] = [{ id: '2', deletedAt: 1000 }]; 233 + 234 + it('separates active and trashed', () => { 235 + const { active, trashed } = partitionDocuments(docs, trash); 236 + expect(active.map(d => d.id)).toEqual(['1', '3']); 237 + expect(trashed.map(d => d.id)).toEqual(['2']); 238 + }); 239 + 240 + it('all active when no trash', () => { 241 + const { active, trashed } = partitionDocuments(docs, []); 242 + expect(active).toHaveLength(3); 243 + expect(trashed).toHaveLength(0); 244 + }); 245 + }); 246 + 247 + // ============================================================ 248 + // Folders (#545 — deeply nested folders) 249 + // ============================================================ 250 + 251 + describe('createFolder', () => { 252 + it('adds a folder with given id', () => { 253 + const folders = createFolder([], 'Projects', 'f-1'); 254 + expect(folders).toHaveLength(1); 255 + expect(folders[0].name).toBe('Projects'); 256 + expect(folders[0].id).toBe('f-1'); 257 + }); 258 + 259 + it('appends to existing folders', () => { 260 + let folders = createFolder([], 'A', 'f-1'); 261 + folders = createFolder(folders, 'B', 'f-2'); 262 + expect(folders).toHaveLength(2); 263 + }); 264 + }); 265 + 266 + describe('renameFolder', () => { 267 + it('renames the target folder', () => { 268 + const folders: Folder[] = [ 269 + { id: 'f-1', name: 'Old Name', createdAt: 1000 }, 270 + { id: 'f-2', name: 'Other', createdAt: 2000 }, 271 + ]; 272 + const result = renameFolder(folders, 'f-1', 'New Name'); 273 + expect(result[0].name).toBe('New Name'); 274 + expect(result[1].name).toBe('Other'); // unchanged 275 + }); 276 + 277 + it('leaves array unchanged for unknown id', () => { 278 + const folders: Folder[] = [{ id: 'f-1', name: 'A', createdAt: 1000 }]; 279 + const result = renameFolder(folders, 'unknown', 'B'); 280 + expect(result[0].name).toBe('A'); 281 + }); 282 + }); 283 + 284 + describe('deleteFolder', () => { 285 + it('removes the folder', () => { 286 + const folders: Folder[] = [ 287 + { id: 'f-1', name: 'A', createdAt: 1000 }, 288 + { id: 'f-2', name: 'B', createdAt: 2000 }, 289 + ]; 290 + expect(deleteFolder(folders, 'f-1')).toHaveLength(1); 291 + }); 292 + }); 293 + 294 + describe('moveToFolder / getDocsInFolder', () => { 295 + const docs = makeDocs({ id: 'd1' }, { id: 'd2' }, { id: 'd3' }); 296 + 297 + it('assigns a doc to a folder', () => { 298 + const assignments = moveToFolder({}, 'd1', 'f-1'); 299 + expect(assignments['d1']).toBe('f-1'); 300 + }); 301 + 302 + it('removes assignment with null', () => { 303 + const assignments = moveToFolder({ 'd1': 'f-1' }, 'd1', null); 304 + expect(assignments['d1']).toBeUndefined(); 305 + }); 306 + 307 + it('removes assignment with undefined', () => { 308 + const assignments = moveToFolder({ 'd1': 'f-1' }, 'd1', undefined); 309 + expect(assignments['d1']).toBeUndefined(); 310 + }); 311 + 312 + it('getDocsInFolder returns docs in a specific folder', () => { 313 + const assignments: FolderAssignments = { 'd1': 'f-1', 'd2': 'f-1', 'd3': 'f-2' }; 314 + const result = getDocsInFolder(docs, assignments, 'f-1'); 315 + expect(result.map(d => d.id)).toEqual(['d1', 'd2']); 316 + }); 317 + 318 + it('getDocsInFolder returns root docs (no folder)', () => { 319 + const assignments: FolderAssignments = { 'd1': 'f-1' }; 320 + const result = getDocsInFolder(docs, assignments, null); 321 + expect(result.map(d => d.id)).toEqual(['d2', 'd3']); 322 + }); 323 + 324 + it('getDocsInFolder returns empty for unknown folder', () => { 325 + const result = getDocsInFolder(docs, { 'd1': 'f-1' }, 'unknown'); 326 + expect(result).toHaveLength(0); 327 + }); 328 + 329 + it('supports multiple folders (simulating depth)', () => { 330 + // Folders are flat, but assignments create a folder hierarchy effect 331 + const assignments: FolderAssignments = { 332 + 'd1': 'f-projects', 333 + 'd2': 'f-projects-sub1', 334 + 'd3': 'f-projects-sub2', 335 + }; 336 + expect(getDocsInFolder(docs, assignments, 'f-projects')).toHaveLength(1); 337 + expect(getDocsInFolder(docs, assignments, 'f-projects-sub1')).toHaveLength(1); 338 + expect(getDocsInFolder(docs, assignments, 'f-projects-sub2')).toHaveLength(1); 339 + }); 340 + }); 341 + 342 + describe('buildBreadcrumbs', () => { 343 + const folders: Folder[] = [ 344 + { id: 'f-1', name: 'Projects', createdAt: 1000 }, 345 + { id: 'f-2', name: 'Archive', createdAt: 2000 }, 346 + ]; 347 + 348 + it('returns root crumb when no folder selected', () => { 349 + const crumbs = buildBreadcrumbs(folders, null); 350 + expect(crumbs).toEqual([{ id: null, name: 'All Documents' }]); 351 + }); 352 + 353 + it('returns root + folder when folder selected', () => { 354 + const crumbs = buildBreadcrumbs(folders, 'f-1'); 355 + expect(crumbs).toHaveLength(2); 356 + expect(crumbs[0]).toEqual({ id: null, name: 'All Documents' }); 357 + expect(crumbs[1]).toEqual({ id: 'f-1', name: 'Projects' }); 358 + }); 359 + 360 + it('returns only root for unknown folder id', () => { 361 + const crumbs = buildBreadcrumbs(folders, 'unknown'); 362 + expect(crumbs).toHaveLength(1); 363 + }); 364 + }); 365 + 366 + describe('clearFolderAssignments', () => { 367 + it('removes all assignments for a folder', () => { 368 + const assignments: FolderAssignments = { 'd1': 'f-1', 'd2': 'f-1', 'd3': 'f-2' }; 369 + const result = clearFolderAssignments(assignments, 'f-1'); 370 + expect(Object.keys(result)).toEqual(['d3']); 371 + }); 372 + 373 + it('returns unchanged for unknown folder', () => { 374 + const assignments: FolderAssignments = { 'd1': 'f-1' }; 375 + const result = clearFolderAssignments(assignments, 'unknown'); 376 + expect(result).toEqual({ 'd1': 'f-1' }); 377 + }); 378 + }); 379 + 380 + // ============================================================ 381 + // Recent Documents 382 + // ============================================================ 383 + 384 + describe('trackRecentDoc', () => { 385 + it('prepends to empty list', () => { 386 + expect(trackRecentDoc([], 'doc-1')).toEqual(['doc-1']); 387 + }); 388 + 389 + it('moves existing doc to front', () => { 390 + expect(trackRecentDoc(['a', 'b', 'c'], 'b')).toEqual(['b', 'a', 'c']); 391 + }); 392 + 393 + it('caps at maxSize', () => { 394 + const ids = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']; 395 + const result = trackRecentDoc(ids, 'new', 10); 396 + expect(result).toHaveLength(10); 397 + expect(result[0]).toBe('new'); 398 + }); 399 + 400 + it('deduplicates', () => { 401 + const result = trackRecentDoc(['a', 'b', 'c'], 'a'); 402 + expect(result).toEqual(['a', 'b', 'c']); 403 + expect(result).toHaveLength(3); 404 + }); 405 + }); 406 + 407 + describe('getRecentDocs', () => { 408 + const docs = makeDocs({ id: 'a', name: 'A' }, { id: 'b', name: 'B' }, { id: 'c', name: 'C' }); 409 + const keys: Record<string, string> = { a: 'key-a', b: 'key-b', c: 'key-c' }; 410 + 411 + it('resolves recent IDs to docs in order', () => { 412 + const result = getRecentDocs(['b', 'a'], docs, keys); 413 + expect(result.map(d => d.id)).toEqual(['b', 'a']); 414 + }); 415 + 416 + it('skips docs that no longer exist', () => { 417 + const result = getRecentDocs(['deleted', 'a'], docs, keys); 418 + expect(result.map(d => d.id)).toEqual(['a']); 419 + }); 420 + 421 + it('skips docs without decryption keys', () => { 422 + const result = getRecentDocs(['a', 'b', 'c'], docs, { a: 'key-a' }); 423 + expect(result.map(d => d.id)).toEqual(['a']); 424 + }); 425 + 426 + it('caps at displayCount', () => { 427 + const result = getRecentDocs(['a', 'b', 'c'], docs, keys, 2); 428 + expect(result).toHaveLength(2); 429 + }); 430 + 431 + it('handles empty recent list', () => { 432 + expect(getRecentDocs([], docs, keys)).toEqual([]); 433 + }); 434 + });
+209
tests/offline-sync-edge.test.ts
··· 1 + /** 2 + * Edge case tests for offline-sync.ts (#554). 3 + * Covers: FIFO queue ordering, conflict-resolution-then-recheck cycle, 4 + * large payloads, dequeue+purge interplay. 5 + */ 6 + import { describe, it, expect } from 'vitest'; 7 + import { 8 + createOfflineState, 9 + cacheDocument, 10 + markModified, 11 + queueSync, 12 + dequeueSync, 13 + nextSyncItem, 14 + recordSyncFailure, 15 + detectConflict, 16 + markConflict, 17 + resolveConflict, 18 + markSynced, 19 + failedItems, 20 + purgeFailedItems, 21 + queueLength, 22 + hasPendingWork, 23 + } from '../src/lib/offline-sync.js'; 24 + 25 + describe('offline-sync — FIFO queue ordering (#554)', () => { 26 + it('maintains FIFO order: A, B, C → dequeue A → queue D → B, C, D', () => { 27 + let state = createOfflineState(); 28 + state = queueSync(state, 'doc-a', 'update', 'pa'); 29 + state = queueSync(state, 'doc-b', 'update', 'pb'); 30 + state = queueSync(state, 'doc-c', 'update', 'pc'); 31 + 32 + // Dequeue A (first item) 33 + const aId = state.syncQueue[0].id; 34 + state = dequeueSync(state, aId); 35 + 36 + // Queue D 37 + state = queueSync(state, 'doc-d', 'create', 'pd'); 38 + 39 + expect(queueLength(state)).toBe(3); 40 + expect(nextSyncItem(state)!.docId).toBe('doc-b'); 41 + expect(state.syncQueue[1].docId).toBe('doc-c'); 42 + expect(state.syncQueue[2].docId).toBe('doc-d'); 43 + }); 44 + 45 + it('dequeue middle item preserves order of remaining', () => { 46 + let state = createOfflineState(); 47 + state = queueSync(state, 'doc-1', 'update', 'p1'); 48 + state = queueSync(state, 'doc-2', 'update', 'p2'); 49 + state = queueSync(state, 'doc-3', 'update', 'p3'); 50 + 51 + const middleId = state.syncQueue[1].id; 52 + state = dequeueSync(state, middleId); 53 + 54 + expect(queueLength(state)).toBe(2); 55 + expect(state.syncQueue[0].docId).toBe('doc-1'); 56 + expect(state.syncQueue[1].docId).toBe('doc-3'); 57 + }); 58 + }); 59 + 60 + describe('offline-sync — conflict resolution cycle (#554)', () => { 61 + it('resolveConflict sets status back to pending, enabling re-detection', () => { 62 + let state = createOfflineState(); 63 + state = cacheDocument(state, 'doc-1', 'docs', 'Note', 'v1-data', 1); 64 + state = markModified(state, 'doc-1', 'local-change'); 65 + 66 + // Server advanced to v2 → conflict 67 + const doc1 = state.documents.get('doc-1')!; 68 + expect(detectConflict(doc1, 2)).toBe(true); 69 + 70 + // Mark and resolve conflict 71 + state = markConflict(state, 'doc-1'); 72 + expect(state.documents.get('doc-1')!.syncStatus).toBe('conflict'); 73 + 74 + state = resolveConflict(state, { docId: 'doc-1', strategy: 'local', resolvedData: 'merged' }); 75 + const resolved = state.documents.get('doc-1')!; 76 + expect(resolved.syncStatus).toBe('pending'); 77 + expect(resolved.encryptedData).toBe('merged'); 78 + 79 + // If server advanced again to v3, conflict is re-detected 80 + expect(detectConflict(resolved, 3)).toBe(true); 81 + }); 82 + 83 + it('no conflict when synced and server version matches', () => { 84 + let state = createOfflineState(); 85 + state = cacheDocument(state, 'doc-1', 'docs', 'Note', 'data', 5); 86 + const doc = state.documents.get('doc-1')!; 87 + // synced status → no conflict even with higher server version 88 + expect(detectConflict(doc, 10)).toBe(false); 89 + }); 90 + 91 + it('markSynced after resolution clears pending status', () => { 92 + let state = createOfflineState(); 93 + state = cacheDocument(state, 'doc-1', 'docs', 'Note', 'v1', 1); 94 + state = markModified(state, 'doc-1', 'local'); 95 + state = markConflict(state, 'doc-1'); 96 + state = resolveConflict(state, { docId: 'doc-1', strategy: 'local', resolvedData: 'merged' }); 97 + state = markSynced(state, 'doc-1', 3); 98 + const final = state.documents.get('doc-1')!; 99 + expect(final.syncStatus).toBe('synced'); 100 + expect(final.serverVersion).toBe(3); 101 + }); 102 + }); 103 + 104 + describe('offline-sync — large payloads (#554)', () => { 105 + it('handles large payload string (1MB)', () => { 106 + let state = createOfflineState(); 107 + const largePayload = 'x'.repeat(1024 * 1024); // 1MB 108 + state = queueSync(state, 'doc-big', 'update', largePayload); 109 + expect(queueLength(state)).toBe(1); 110 + expect(nextSyncItem(state)!.payload.length).toBe(1024 * 1024); 111 + }); 112 + 113 + it('handles multiple large items in queue', () => { 114 + let state = createOfflineState(); 115 + const payload = 'y'.repeat(500_000); 116 + for (let i = 0; i < 5; i++) { 117 + state = queueSync(state, `doc-${i}`, 'update', payload); 118 + } 119 + expect(queueLength(state)).toBe(5); 120 + expect(nextSyncItem(state)!.docId).toBe('doc-0'); 121 + }); 122 + }); 123 + 124 + describe('offline-sync — dequeue + purge interplay (#554)', () => { 125 + it('purge does not affect items under failure threshold', () => { 126 + let state = createOfflineState(); 127 + state = queueSync(state, 'good', 'update', 'p1'); 128 + state = queueSync(state, 'bad', 'update', 'p2'); 129 + 130 + const badId = state.syncQueue[1].id; 131 + state = recordSyncFailure(state, badId, 'err'); 132 + state = recordSyncFailure(state, badId, 'err'); 133 + state = recordSyncFailure(state, badId, 'err'); 134 + 135 + state = purgeFailedItems(state, 3); 136 + expect(queueLength(state)).toBe(1); 137 + expect(state.syncQueue[0].docId).toBe('good'); 138 + }); 139 + 140 + it('dequeue then purge on disjoint items works correctly', () => { 141 + let state = createOfflineState(); 142 + state = queueSync(state, 'a', 'update', 'p'); 143 + state = queueSync(state, 'b', 'update', 'p'); 144 + state = queueSync(state, 'c', 'update', 'p'); 145 + 146 + // Fail 'c' 3 times 147 + const cId = state.syncQueue[2].id; 148 + state = recordSyncFailure(state, cId, 'err'); 149 + state = recordSyncFailure(state, cId, 'err'); 150 + state = recordSyncFailure(state, cId, 'err'); 151 + 152 + // Dequeue 'a' 153 + state = dequeueSync(state, state.syncQueue[0].id); 154 + 155 + // Purge failed 156 + state = purgeFailedItems(state, 3); 157 + 158 + // Only 'b' should remain 159 + expect(queueLength(state)).toBe(1); 160 + expect(state.syncQueue[0].docId).toBe('b'); 161 + }); 162 + 163 + it('failedItems returns correct items after mixed operations', () => { 164 + let state = createOfflineState(); 165 + state = queueSync(state, 'ok', 'update', 'p'); 166 + state = queueSync(state, 'fail1', 'update', 'p'); 167 + state = queueSync(state, 'fail2', 'create', 'p'); 168 + 169 + // Fail items 170 + const f1 = state.syncQueue[1].id; 171 + const f2 = state.syncQueue[2].id; 172 + for (let i = 0; i < 3; i++) { 173 + state = recordSyncFailure(state, f1, 'err'); 174 + state = recordSyncFailure(state, f2, 'err'); 175 + } 176 + 177 + const failed = failedItems(state, 3); 178 + expect(failed).toHaveLength(2); 179 + expect(failed.map(i => i.docId).sort()).toEqual(['fail1', 'fail2']); 180 + }); 181 + }); 182 + 183 + describe('offline-sync — hasPendingWork edge cases', () => { 184 + it('returns true when only queue has items (no pending docs)', () => { 185 + let state = createOfflineState(); 186 + state = queueSync(state, 'x', 'delete', 'p'); 187 + expect(hasPendingWork(state)).toBe(true); 188 + }); 189 + 190 + it('returns true when only docs are pending (empty queue)', () => { 191 + let state = createOfflineState(); 192 + state = cacheDocument(state, 'd1', 'docs', 'T', 'data', 1); 193 + state = markModified(state, 'd1', 'new'); 194 + expect(hasPendingWork(state)).toBe(true); 195 + }); 196 + 197 + it('returns false after all work is completed', () => { 198 + let state = createOfflineState(); 199 + state = cacheDocument(state, 'd1', 'docs', 'T', 'data', 1); 200 + state = markModified(state, 'd1', 'new'); 201 + state = queueSync(state, 'd1', 'update', 'p'); 202 + 203 + // Complete the work 204 + state = markSynced(state, 'd1', 2); 205 + state = dequeueSync(state, state.syncQueue[0].id); 206 + 207 + expect(hasPendingWork(state)).toBe(false); 208 + }); 209 + });
+181
tests/presenter-mode-edge.test.ts
··· 1 + /** 2 + * Edge case tests for presenter-mode.ts (#541). 3 + * Covers: 1-slide deck, 0 duration, negative elapsed, overflow scenarios, 4 + * rapid next/prev, notes on out-of-range slides. 5 + */ 6 + import { describe, it, expect } from 'vitest'; 7 + import { 8 + createPresenterState, 9 + startPresentation, 10 + nextSlide, 11 + prevSlide, 12 + jumpToSlide, 13 + tickTimer, 14 + setNotes, 15 + currentNotes, 16 + formatTime, 17 + timeRemaining, 18 + isOverTime, 19 + paceDelta, 20 + progressPercent, 21 + } from '../src/slides/presenter-mode.js'; 22 + 23 + describe('presenter-mode — single slide deck (#541)', () => { 24 + it('createPresenterState with 1 slide', () => { 25 + const state = createPresenterState(1); 26 + expect(state.totalSlides).toBe(1); 27 + expect(state.currentSlide).toBe(0); 28 + }); 29 + 30 + it('nextSlide stays at 0 with 1 slide', () => { 31 + const state = createPresenterState(1); 32 + const next = nextSlide(state); 33 + expect(next.currentSlide).toBe(0); 34 + expect(next).toBe(state); // same reference 35 + }); 36 + 37 + it('prevSlide stays at 0 with 1 slide', () => { 38 + const state = createPresenterState(1); 39 + const prev = prevSlide(state); 40 + expect(prev.currentSlide).toBe(0); 41 + expect(prev).toBe(state); 42 + }); 43 + 44 + it('progressPercent is 100 for single slide', () => { 45 + const state = createPresenterState(1); 46 + expect(progressPercent(state)).toBe(100); 47 + }); 48 + 49 + it('paceDelta is 0 for single slide with duration', () => { 50 + const state = createPresenterState(1, 300); 51 + expect(paceDelta(state)).toBe(0); 52 + }); 53 + }); 54 + 55 + describe('presenter-mode — 0 duration (#541)', () => { 56 + it('timeRemaining is 0 with 0 duration', () => { 57 + const state = createPresenterState(10, 0); 58 + expect(timeRemaining(state)).toBe(0); 59 + }); 60 + 61 + it('isOverTime is false with 0 duration regardless of elapsed', () => { 62 + let state = createPresenterState(10, 0); 63 + state = { ...state, elapsedSeconds: 9999 }; 64 + expect(isOverTime(state)).toBe(false); 65 + }); 66 + 67 + it('paceDelta is 0 with 0 duration', () => { 68 + let state = createPresenterState(10, 0); 69 + state = { ...state, currentSlide: 5, elapsedSeconds: 100 }; 70 + expect(paceDelta(state)).toBe(0); 71 + }); 72 + }); 73 + 74 + describe('presenter-mode — large elapsed time', () => { 75 + it('timeRemaining clamps to 0 when way over time', () => { 76 + let state = createPresenterState(10, 60); 77 + state = { ...state, elapsedSeconds: 999999 }; 78 + expect(timeRemaining(state)).toBe(0); 79 + }); 80 + 81 + it('isOverTime is true when exceeded', () => { 82 + let state = createPresenterState(10, 60); 83 + state = { ...state, elapsedSeconds: 61 }; 84 + expect(isOverTime(state)).toBe(true); 85 + }); 86 + 87 + it('formatTime handles very large seconds', () => { 88 + expect(formatTime(36000)).toBe('600:00'); // 10 hours 89 + }); 90 + }); 91 + 92 + describe('presenter-mode — rapid navigation', () => { 93 + it('rapid nextSlide reaches last slide', () => { 94 + let state = createPresenterState(5); 95 + for (let i = 0; i < 20; i++) { 96 + state = nextSlide(state); 97 + } 98 + expect(state.currentSlide).toBe(4); 99 + }); 100 + 101 + it('rapid prevSlide stays at 0', () => { 102 + let state = createPresenterState(5); 103 + state = { ...state, currentSlide: 2 }; 104 + for (let i = 0; i < 20; i++) { 105 + state = prevSlide(state); 106 + } 107 + expect(state.currentSlide).toBe(0); 108 + }); 109 + }); 110 + 111 + describe('presenter-mode — jumpToSlide clamping', () => { 112 + it('clamps very large negative index', () => { 113 + const state = createPresenterState(10); 114 + expect(jumpToSlide(state, -99999).currentSlide).toBe(0); 115 + }); 116 + 117 + it('clamps very large positive index', () => { 118 + const state = createPresenterState(10); 119 + expect(jumpToSlide(state, 99999).currentSlide).toBe(9); 120 + }); 121 + 122 + it('handles NaN-like float indices by rounding', () => { 123 + const state = createPresenterState(10); 124 + // jumpToSlide uses Math.max/Math.min which handles floats 125 + const jumped = jumpToSlide(state, 3.7); 126 + expect(jumped.currentSlide).toBe(3.7); // or clamped 127 + }); 128 + }); 129 + 130 + describe('presenter-mode — notes on edge slides', () => { 131 + it('sets notes on slide 0', () => { 132 + let state = createPresenterState(5); 133 + state = setNotes(state, 0, 'Intro'); 134 + expect(currentNotes(state)).toBe('Intro'); 135 + }); 136 + 137 + it('sets notes on last slide', () => { 138 + let state = createPresenterState(5); 139 + state = setNotes(state, 4, 'Outro'); 140 + state = { ...state, currentSlide: 4 }; 141 + expect(currentNotes(state)).toBe('Outro'); 142 + }); 143 + 144 + it('notes for out-of-range slide index do not crash', () => { 145 + let state = createPresenterState(5); 146 + state = setNotes(state, 100, 'Ghost note'); 147 + // Does not crash, just stores it 148 + expect(state.notes.get(100)).toBe('Ghost note'); 149 + }); 150 + }); 151 + 152 + describe('presenter-mode — startPresentation resets', () => { 153 + it('resets slide position and timer on start', () => { 154 + let state = createPresenterState(10, 300); 155 + state = { ...state, currentSlide: 7, elapsedSeconds: 150 }; 156 + const started = startPresentation(state); 157 + expect(started.currentSlide).toBe(0); 158 + expect(started.elapsedSeconds).toBe(0); 159 + expect(started.timerRunning).toBe(true); 160 + expect(started.active).toBe(true); 161 + }); 162 + }); 163 + 164 + describe('presenter-mode — tickTimer idempotency', () => { 165 + it('tick only increments when running', () => { 166 + let state = createPresenterState(10); 167 + // Not running 168 + const ticked = tickTimer(state); 169 + expect(ticked.elapsedSeconds).toBe(0); 170 + expect(ticked).toBe(state); 171 + }); 172 + 173 + it('consecutive ticks increment correctly', () => { 174 + let state = createPresenterState(10); 175 + state = { ...state, timerRunning: true }; 176 + for (let i = 0; i < 10; i++) { 177 + state = tickTimer(state); 178 + } 179 + expect(state.elapsedSeconds).toBe(10); 180 + }); 181 + });
+157
tests/search-index-edge.test.ts
··· 1 + /** 2 + * Edge case tests for search-index.ts (#565). 3 + * Covers: special characters, HTML edge cases, multi-word scoring, 4 + * large document sets, regex-special search queries. 5 + */ 6 + import { describe, it, expect } from 'vitest'; 7 + import { 8 + tokenize, 9 + stripHtml, 10 + buildIndex, 11 + extractSnippet, 12 + findMatchPositions, 13 + searchDocuments, 14 + type SearchDocument, 15 + } from '../src/search-index.js'; 16 + 17 + describe('Search Index — tokenization edge cases (#565)', () => { 18 + it('handles numbers', () => { 19 + expect(tokenize('Q1 2026 Budget')).toEqual(['q1', '2026', 'budget']); 20 + }); 21 + 22 + it('handles hyphenated words', () => { 23 + const tokens = tokenize('well-known fact'); 24 + expect(tokens).toContain('well'); 25 + expect(tokens).toContain('known'); 26 + }); 27 + 28 + it('handles unicode characters', () => { 29 + const tokens = tokenize('café résumé'); 30 + expect(tokens.length).toBeGreaterThanOrEqual(2); 31 + }); 32 + 33 + it('handles very long input', () => { 34 + const long = Array.from({ length: 10000 }, (_, i) => `word${i}`).join(' '); 35 + const tokens = tokenize(long); 36 + expect(tokens).toHaveLength(10000); 37 + }); 38 + }); 39 + 40 + describe('Search Index — stripHtml edge cases (#565)', () => { 41 + it('handles nested tags', () => { 42 + expect(stripHtml('<div><p><strong>bold</strong></p></div>')).toBe('bold'); 43 + }); 44 + 45 + it('handles self-closing tags', () => { 46 + expect(stripHtml('text<br/>more<hr/>end')).toBe('text more end'); 47 + }); 48 + 49 + it('handles malformed HTML gracefully', () => { 50 + const result = stripHtml('<p>unclosed<div>nested'); 51 + expect(result).toContain('unclosed'); 52 + expect(result).toContain('nested'); 53 + }); 54 + 55 + it('handles HTML with attributes', () => { 56 + expect(stripHtml('<a href="https://example.com" class="link">Click</a>')).toBe('Click'); 57 + }); 58 + 59 + it('decodes numeric entities', () => { 60 + expect(stripHtml('&#169; 2026')).toContain('2026'); 61 + }); 62 + }); 63 + 64 + describe('Search Index — findMatchPositions edge cases (#565)', () => { 65 + it('handles regex-special characters in query', () => { 66 + const text = 'foo (bar) [baz] {qux}'; 67 + const positions = findMatchPositions(text, '(bar)'); 68 + expect(positions).toHaveLength(1); 69 + expect(positions[0].start).toBe(4); 70 + }); 71 + 72 + it('handles dot in query', () => { 73 + const positions = findMatchPositions('version 2.0 release', '2.0'); 74 + expect(positions).toHaveLength(1); 75 + }); 76 + 77 + it('handles overlapping matches', () => { 78 + // "aa" in "aaa" — regex match is non-overlapping, so just 1 79 + const positions = findMatchPositions('aaa', 'aa'); 80 + expect(positions.length).toBeGreaterThanOrEqual(1); 81 + }); 82 + }); 83 + 84 + describe('Search Index — extractSnippet edge cases (#565)', () => { 85 + it('handles match at very start of text', () => { 86 + const snippet = extractSnippet('Hello world this is a test', 'Hello', 10); 87 + expect(snippet).toContain('Hello'); 88 + expect(snippet.startsWith('…')).toBe(false); 89 + }); 90 + 91 + it('handles match at very end of text', () => { 92 + const snippet = extractSnippet('This is a test query', 'query', 10); 93 + expect(snippet).toContain('query'); 94 + expect(snippet.endsWith('…')).toBe(false); 95 + }); 96 + 97 + it('handles very short context', () => { 98 + const snippet = extractSnippet('The quick brown fox jumps', 'brown', 1); 99 + expect(snippet).toContain('brown'); 100 + }); 101 + }); 102 + 103 + describe('Search Index — searchDocuments edge cases (#565)', () => { 104 + const DOCS: SearchDocument[] = [ 105 + { id: 'a', name: 'API Reference', type: 'doc', content: 'REST API documentation for the v2 endpoints.' }, 106 + { id: 'b', name: 'Meeting Notes', type: 'doc', content: 'Discussed API changes and deployment schedule.' }, 107 + { id: 'c', name: 'Empty Content', type: 'doc', content: '' }, 108 + { id: 'd', name: '', type: 'sheet', content: 'Orphan sheet with data but no name.' }, 109 + ]; 110 + const index = buildIndex(DOCS); 111 + 112 + it('searches with regex-special characters safely', () => { 113 + // Should not crash on regex-special queries 114 + const results = searchDocuments('API (v2)', DOCS, index); 115 + expect(results.length).toBeGreaterThan(0); 116 + }); 117 + 118 + it('finds document with empty content by name', () => { 119 + const results = searchDocuments('Empty', DOCS, index); 120 + expect(results.map(r => r.docId)).toContain('c'); 121 + }); 122 + 123 + it('finds document with empty name by content', () => { 124 + const results = searchDocuments('orphan', DOCS, index); 125 + expect(results.map(r => r.docId)).toContain('d'); 126 + }); 127 + 128 + it('handles single-character query', () => { 129 + const results = searchDocuments('v', DOCS, index); 130 + // Should find docs containing 'v' tokens 131 + expect(results.length).toBeGreaterThanOrEqual(0); // at least doesn't crash 132 + }); 133 + 134 + it('handles query with only special characters', () => { 135 + const results = searchDocuments('!!!', DOCS, index); 136 + expect(results).toEqual([]); 137 + }); 138 + 139 + it('ranks name match higher than content match', () => { 140 + const results = searchDocuments('API', DOCS, index); 141 + // 'API Reference' should rank above 'Meeting Notes' which mentions API in content 142 + expect(results[0].docId).toBe('a'); 143 + }); 144 + 145 + it('handles large document set', () => { 146 + const largeDocs: SearchDocument[] = Array.from({ length: 500 }, (_, i) => ({ 147 + id: `doc-${i}`, 148 + name: `Document ${i}`, 149 + type: 'doc' as const, 150 + content: `Content for document number ${i} with various keywords.`, 151 + })); 152 + const largeIndex = buildIndex(largeDocs); 153 + const results = searchDocuments('Document 250', largeDocs, largeIndex); 154 + expect(results.length).toBeGreaterThan(0); 155 + expect(results[0].docId).toBe('doc-250'); 156 + }); 157 + });
+149
tests/version-history-edge.test.ts
··· 1 + /** 2 + * Edge case tests for version-history.ts (#557). 3 + * Covers: duplicate snapshots, rapid captures, zero word count, boundary pruning. 4 + */ 5 + import { describe, it, expect } from 'vitest'; 6 + import { VersionManager, computeWordCount, computeWordCountDelta } from '../src/lib/version-history.js'; 7 + 8 + describe('VersionManager — edge cases (#557)', () => { 9 + describe('duplicate snapshot data', () => { 10 + it('stores identical snapshots as separate versions', () => { 11 + const mgr = new VersionManager({ maxVersions: 10 }); 12 + const data = new Uint8Array([1, 2, 3]); 13 + mgr.addVersion(data, { author: 'alice', wordCount: 10 }); 14 + mgr.addVersion(data, { author: 'alice', wordCount: 10 }); 15 + const versions = mgr.getVersions(); 16 + expect(versions).toHaveLength(2); 17 + expect(versions[0].id).not.toBe(versions[1].id); 18 + }); 19 + 20 + it('computes zero delta between identical snapshots', () => { 21 + const mgr = new VersionManager({ maxVersions: 10 }); 22 + mgr.addVersion(new Uint8Array([1]), { author: 'a', wordCount: 50 }); 23 + mgr.addVersion(new Uint8Array([1]), { author: 'a', wordCount: 50 }); 24 + const versions = mgr.getVersions(); 25 + expect(versions[0].wordCountDelta).toBe('0'); 26 + }); 27 + }); 28 + 29 + describe('rapid captures', () => { 30 + it('handles many versions added in quick succession', () => { 31 + const mgr = new VersionManager({ maxVersions: 100 }); 32 + for (let i = 0; i < 100; i++) { 33 + mgr.addVersion(new Uint8Array([i & 0xff]), { author: 'bot', wordCount: i }); 34 + } 35 + const versions = mgr.getVersions(); 36 + expect(versions).toHaveLength(100); 37 + expect(versions[0].wordCount).toBe(99); // newest first 38 + expect(versions[99].wordCount).toBe(0); 39 + }); 40 + 41 + it('prunes correctly during rapid adds over limit', () => { 42 + const mgr = new VersionManager({ maxVersions: 3 }); 43 + for (let i = 0; i < 10; i++) { 44 + mgr.addVersion(new Uint8Array([i]), { author: 'a', wordCount: i * 10 }); 45 + } 46 + const versions = mgr.getVersions(); 47 + expect(versions).toHaveLength(3); 48 + // Should have the 3 most recent: 90, 80, 70 49 + expect(versions[0].wordCount).toBe(90); 50 + expect(versions[1].wordCount).toBe(80); 51 + expect(versions[2].wordCount).toBe(70); 52 + }); 53 + }); 54 + 55 + describe('zero and edge word counts', () => { 56 + it('handles wordCount of 0', () => { 57 + const mgr = new VersionManager(); 58 + mgr.addVersion(new Uint8Array([1]), { author: 'a', wordCount: 0 }); 59 + const versions = mgr.getVersions(); 60 + expect(versions[0].wordCount).toBe(0); 61 + expect(versions[0].wordCountDelta).toBe('+0'); 62 + }); 63 + 64 + it('handles missing wordCount (defaults to 0)', () => { 65 + const mgr = new VersionManager(); 66 + mgr.addVersion(new Uint8Array([1]), { author: 'a' }); 67 + expect(mgr.getVersions()[0].wordCount).toBe(0); 68 + }); 69 + 70 + it('handles missing author (defaults to null)', () => { 71 + const mgr = new VersionManager(); 72 + mgr.addVersion(new Uint8Array([1]), {}); 73 + expect(mgr.getVersions()[0].author).toBeNull(); 74 + }); 75 + }); 76 + 77 + describe('addVersion resets capture state', () => { 78 + it('resets shouldCapture after adding a version', () => { 79 + const mgr = new VersionManager({ editThreshold: 5 }); 80 + for (let i = 0; i < 5; i++) mgr.recordEdit(); 81 + expect(mgr.shouldCapture()).toBe(true); 82 + mgr.addVersion(new Uint8Array([1]), { wordCount: 10 }); 83 + expect(mgr.shouldCapture()).toBe(false); 84 + }); 85 + }); 86 + 87 + describe('snapshot retrieval after pruning', () => { 88 + it('cannot retrieve pruned version', () => { 89 + const mgr = new VersionManager({ maxVersions: 2 }); 90 + mgr.addVersion(new Uint8Array([1]), { wordCount: 10 }); 91 + const firstId = mgr.getVersions()[0].id; 92 + mgr.addVersion(new Uint8Array([2]), { wordCount: 20 }); 93 + mgr.addVersion(new Uint8Array([3]), { wordCount: 30 }); 94 + // First version was pruned 95 + expect(mgr.getSnapshot(firstId)).toBeNull(); 96 + expect(mgr.getVersion(firstId)).toBeNull(); 97 + }); 98 + }); 99 + 100 + describe('empty snapshot', () => { 101 + it('stores empty Uint8Array', () => { 102 + const mgr = new VersionManager(); 103 + mgr.addVersion(new Uint8Array([]), { wordCount: 0 }); 104 + const versions = mgr.getVersions(); 105 + expect(versions).toHaveLength(1); 106 + expect(mgr.getSnapshot(versions[0].id)).toEqual(new Uint8Array([])); 107 + }); 108 + }); 109 + 110 + describe('maxVersions of 1', () => { 111 + it('always keeps only the latest version', () => { 112 + const mgr = new VersionManager({ maxVersions: 1 }); 113 + mgr.addVersion(new Uint8Array([1]), { wordCount: 10 }); 114 + mgr.addVersion(new Uint8Array([2]), { wordCount: 20 }); 115 + mgr.addVersion(new Uint8Array([3]), { wordCount: 30 }); 116 + const versions = mgr.getVersions(); 117 + expect(versions).toHaveLength(1); 118 + expect(versions[0].wordCount).toBe(30); 119 + // First version is +30 (no previous) 120 + expect(versions[0].wordCountDelta).toBe('+30'); 121 + }); 122 + }); 123 + }); 124 + 125 + describe('computeWordCount — edge cases', () => { 126 + it('handles text with only whitespace and newlines', () => { 127 + expect(computeWordCount('\n\n\n')).toBe(0); 128 + expect(computeWordCount('\t\t')).toBe(0); 129 + }); 130 + 131 + it('handles text with mixed whitespace', () => { 132 + expect(computeWordCount('a\tb\nc')).toBe(3); 133 + }); 134 + }); 135 + 136 + describe('computeWordCountDelta — edge cases', () => { 137 + it('handles undefined previous', () => { 138 + expect(computeWordCountDelta(undefined, 5)).toBe('+5'); 139 + }); 140 + 141 + it('handles zero to zero', () => { 142 + expect(computeWordCountDelta(0, 0)).toBe('0'); 143 + }); 144 + 145 + it('handles large deltas', () => { 146 + expect(computeWordCountDelta(0, 10000)).toBe('+10000'); 147 + expect(computeWordCountDelta(10000, 0)).toBe('-10000'); 148 + }); 149 + });