memory-journal-mcp 4.3.0 → 4.4.0

package/tests/database/sqlite-adapter.test.ts

@@ -0,0 +1,555 @@
+/**
+ * SqliteAdapter Tests
+ *
+ * Functional tests for database adapter methods not covered by
+ * tests/security/sql-injection.test.ts.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
+import type { RelationshipType } from '../../src/types/index.js'
+
+describe('SqliteAdapter', () => {
+    let db: SqliteAdapter
+    const testDbPath = './test-adapter.db'
+
+    beforeAll(async () => {
+        db = new SqliteAdapter(testDbPath)
+        await db.initialize()
+    })
+
+    afterAll(() => {
+        db.close()
+        try {
+            const fs = require('node:fs')
+            if (fs.existsSync(testDbPath)) {
+                fs.unlinkSync(testDbPath)
+            }
+        } catch {
+            // Ignore cleanup errors
+        }
+    })
+
+    // ========================================================================
+    // Initialize
+    // ========================================================================
+
+    describe('initialize', () => {
+        it('should be idempotent on re-init', async () => {
+            // Second init should not throw
+            await db.initialize()
+        })
+
+        it('should throw when accessing uninitalized db', async () => {
+            const uninit = new SqliteAdapter('./uninit-test.db')
+            expect(() => uninit.getActiveEntryCount()).toThrow('Database not initialized')
+        })
+    })
+
+    // ========================================================================
+    // Entry CRUD
+    // ========================================================================
+
+    describe('createEntry', () => {
+        it('should create an entry with defaults', () => {
+            const entry = db.createEntry({ content: 'Test entry' })
+
+            expect(entry.id).toBeGreaterThan(0)
+            expect(entry.content).toBe('Test entry')
+            expect(entry.entryType).toBe('personal_reflection')
+            expect(entry.isPersonal).toBe(true)
+            expect(entry.tags).toEqual([])
+        })
+
+        it('should create an entry with all fields', () => {
+            const entry = db.createEntry({
+                content: 'Full entry',
+                entryType: 'decision',
+                tags: ['tag-a', 'tag-b'],
+                isPersonal: false,
+                significanceType: 'milestone',
+                autoContext: 'test-context',
+                projectNumber: 42,
+                issueNumber: 7,
+            })
+
+            expect(entry.entryType).toBe('decision')
+            expect(entry.isPersonal).toBe(false)
+            expect(entry.tags).toContain('tag-a')
+            expect(entry.tags).toContain('tag-b')
+        })
+    })
+
+    describe('getEntryById', () => {
+        it('should return entry by ID', () => {
+            const created = db.createEntry({ content: 'Find me' })
+            const found = db.getEntryById(created.id)
+
+            expect(found).not.toBeNull()
+            expect(found?.content).toBe('Find me')
+        })
+
+        it('should return null for nonexistent ID', () => {
+            expect(db.getEntryById(99999)).toBeNull()
+        })
+
+        it('should exclude soft-deleted entries', () => {
+            const entry = db.createEntry({ content: 'Will be deleted' })
+            db.deleteEntry(entry.id)
+
+            expect(db.getEntryById(entry.id)).toBeNull()
+        })
+    })
+
+    describe('getEntryByIdIncludeDeleted', () => {
+        it('should return soft-deleted entries', () => {
+            const entry = db.createEntry({ content: 'Soft deleted' })
+            db.deleteEntry(entry.id)
+
+            const found = db.getEntryByIdIncludeDeleted(entry.id)
+            expect(found).not.toBeNull()
+            expect(found?.content).toBe('Soft deleted')
+        })
+
+        it('should return null for nonexistent ID', () => {
+            expect(db.getEntryByIdIncludeDeleted(99999)).toBeNull()
+        })
+    })
+
+    // ========================================================================
+    // calculateImportance
+    // ========================================================================
+
+    describe('calculateImportance', () => {
+        it('should return 0 for nonexistent entry', () => {
+            const result = db.calculateImportance(99999)
+            expect(result.score).toBe(0)
+            expect(result.breakdown.significance).toBe(0)
+        })
+
+        it('should include recency component for fresh entries', () => {
+            const entry = db.createEntry({ content: 'Fresh entry' })
+            const result = db.calculateImportance(entry.id)
+
+            // Fresh entry should have non-zero recency
+            expect(result.breakdown.recency).toBeGreaterThan(0)
+        })
+
+        it('should include significance component when set', () => {
+            const entry = db.createEntry({
+                content: 'Important entry',
+                significanceType: 'milestone',
+            })
+            const result = db.calculateImportance(entry.id)
+
+            expect(result.breakdown.significance).toBe(0.3)
+        })
+
+        it('should include relationship component', () => {
+            const entry1 = db.createEntry({ content: 'Entry A' })
+            const entry2 = db.createEntry({ content: 'Entry B' })
+            db.linkEntries(entry1.id, entry2.id, 'references')
+
+            const result = db.calculateImportance(entry1.id)
+            expect(result.breakdown.relationships).toBeGreaterThan(0)
+        })
+
+        it('should include causal component for causal relationships', () => {
+            const entry1 = db.createEntry({ content: 'Blocker' })
+            const entry2 = db.createEntry({ content: 'Resolution' })
+            db.linkEntries(entry1.id, entry2.id, 'blocked_by')
+
+            const result = db.calculateImportance(entry1.id)
+            expect(result.breakdown.causal).toBeGreaterThan(0)
+        })
+
+        it('should have score between 0 and 1', () => {
+            const entry = db.createEntry({
+                content: 'Scored entry',
+                significanceType: 'milestone',
+            })
+            const result = db.calculateImportance(entry.id)
+
+            expect(result.score).toBeGreaterThanOrEqual(0)
+            expect(result.score).toBeLessThanOrEqual(1)
+        })
+    })
+
+    // ========================================================================
+    // getRecentEntries / pagination
+    // ========================================================================
+
+    describe('getRecentEntries', () => {
+        it('should respect limit', () => {
+            const entries = db.getRecentEntries(2)
+            expect(entries.length).toBeLessThanOrEqual(2)
+        })
+
+        it('should filter by isPersonal', () => {
+            db.createEntry({ content: 'Personal entry', isPersonal: true })
+            db.createEntry({ content: 'Team entry', isPersonal: false })
+
+            const personal = db.getRecentEntries(100, true)
+            const team = db.getRecentEntries(100, false)
+
+            expect(personal.every((e) => e.isPersonal)).toBe(true)
+            expect(team.every((e) => !e.isPersonal)).toBe(true)
+        })
+    })
+
+    describe('getEntriesPage / getActiveEntryCount', () => {
+        it('should return correct active count', () => {
+            const count = db.getActiveEntryCount()
+            expect(count).toBeGreaterThan(0)
+        })
+
+        it('should paginate through entries', () => {
+            const page1 = db.getEntriesPage(0, 2)
+            const page2 = db.getEntriesPage(2, 2)
+
+            expect(page1.length).toBeLessThanOrEqual(2)
+            // Pages should not overlap (different IDs)
+            if (page2.length > 0) {
+                expect(page1[0]?.id).not.toBe(page2[0]?.id)
+            }
+        })
+    })
+
+    // ========================================================================
+    // deleteEntry
+    // ========================================================================
+
+    describe('deleteEntry', () => {
+        it('should soft delete an entry', () => {
+            const entry = db.createEntry({ content: 'To soft delete' })
+            const result = db.deleteEntry(entry.id)
+
+            expect(result).toBe(true)
+            expect(db.getEntryById(entry.id)).toBeNull()
+            expect(db.getEntryByIdIncludeDeleted(entry.id)).not.toBeNull()
+        })
+
+        it('should permanently delete an entry', () => {
+            const entry = db.createEntry({ content: 'To permanently delete' })
+            const result = db.deleteEntry(entry.id, true)
+
+            expect(result).toBe(true)
+            expect(db.getEntryByIdIncludeDeleted(entry.id)).toBeNull()
+        })
+
+        it('should return false for nonexistent entry', () => {
+            expect(db.deleteEntry(99999)).toBe(false)
+        })
+
+        it('should permanently delete a soft-deleted entry', () => {
+            const entry = db.createEntry({ content: 'Soft then hard' })
+            db.deleteEntry(entry.id) // soft delete
+            const result = db.deleteEntry(entry.id, true) // permanent delete
+
+            expect(result).toBe(true)
+            expect(db.getEntryByIdIncludeDeleted(entry.id)).toBeNull()
+        })
+    })
+
+    // ========================================================================
+    // Search
+    // ========================================================================
+
+    describe('searchEntries', () => {
+        it('should find entries by content', () => {
+            db.createEntry({ content: 'Unique search term xyz123' })
+            const results = db.searchEntries('xyz123')
+
+            expect(results.length).toBeGreaterThan(0)
+            expect(results[0]?.content).toContain('xyz123')
+        })
+
+        it('should respect limit', () => {
+            const results = db.searchEntries('entry', { limit: 1 })
+            expect(results.length).toBeLessThanOrEqual(1)
+        })
+
+        it('should filter by projectNumber', () => {
+            db.createEntry({ content: 'Project specific qwer', projectNumber: 99 })
+            const results = db.searchEntries('qwer', { projectNumber: 99 })
+
+            expect(results.length).toBeGreaterThan(0)
+        })
+
+        it('should return empty for non-matching query', () => {
+            const results = db.searchEntries('nonexistent_term_that_has_no_matches')
+            expect(results).toEqual([])
+        })
+    })
+
+    describe('searchByDateRange', () => {
+        it('should find entries within date range', () => {
+            db.createEntry({ content: 'Date range entry' })
+            const now = new Date()
+            const start = now.toISOString().split('T')[0]!
+            const end = start
+
+            const results = db.searchByDateRange(start, end)
+            expect(results.length).toBeGreaterThan(0)
+        })
+
+        it('should return empty for future date range', () => {
+            const results = db.searchByDateRange('2099-01-01', '2099-12-31')
+            expect(results).toEqual([])
+        })
+    })
+
+    // ========================================================================
+    // Relationships
+    // ========================================================================
+
+    describe('linkEntries / getRelationships', () => {
+        it('should create and retrieve a relationship', () => {
+            const e1 = db.createEntry({ content: 'Rel source' })
+            const e2 = db.createEntry({ content: 'Rel target' })
+
+            const rel = db.linkEntries(e1.id, e2.id, 'references', 'Test link')
+
+            expect(rel.id).toBeGreaterThan(0)
+            expect(rel.relationshipType).toBe('references')
+            expect(rel.description).toBe('Test link')
+        })
+
+        it('should retrieve relationships for an entry', () => {
+            const e1 = db.createEntry({ content: 'Has rels' })
+            const e2 = db.createEntry({ content: 'Also has rels' })
+            db.linkEntries(e1.id, e2.id, 'evolves_from')
+
+            const rels = db.getRelationships(e1.id)
+            expect(rels.length).toBeGreaterThan(0)
+            expect(rels.some((r) => r.relationshipType === 'evolves_from')).toBe(true)
+        })
+
+        it('should throw for nonexistent source entry', () => {
+            const e2 = db.createEntry({ content: 'Target exists' })
+            expect(() => db.linkEntries(99999, e2.id, 'references')).toThrow()
+        })
+
+        it('should throw for nonexistent target entry', () => {
+            const e1 = db.createEntry({ content: 'Source exists' })
+            expect(() => db.linkEntries(e1.id, 99999, 'references')).toThrow()
+        })
+
+        it('should support all relationship types', () => {
+            const types: RelationshipType[] = [
+                'evolves_from',
+                'references',
+                'implements',
+                'blocked_by',
+                'resolved',
+                'caused',
+            ]
+
+            for (const type of types) {
+                const e1 = db.createEntry({ content: `From ${type}` })
+                const e2 = db.createEntry({ content: `To ${type}` })
+                const rel = db.linkEntries(e1.id, e2.id, type)
+                expect(rel.relationshipType).toBe(type)
+            }
+        })
+    })
+
+    // ========================================================================
+    // Tags
+    // ========================================================================
+
+    describe('tag operations', () => {
+        it('should list tags with usage', () => {
+            db.createEntry({ content: 'Tagged', tags: ['unique-tag-abc'] })
+            const tags = db.listTags()
+
+            const found = tags.find((t) => t.name === 'unique-tag-abc')
+            expect(found).toBeDefined()
+            expect(found?.usageCount).toBeGreaterThan(0)
+        })
+
+        it('should get tags for an entry', () => {
+            const entry = db.createEntry({ content: 'Multi tag', tags: ['mt-1', 'mt-2'] })
+            const tags = db.getTagsForEntry(entry.id)
+
+            expect(tags).toContain('mt-1')
+            expect(tags).toContain('mt-2')
+        })
+
+        it('should merge tags', () => {
+            db.createEntry({ content: 'Merge source', tags: ['old-tag'] })
+            const result = db.mergeTags('old-tag', 'new-tag')
+
+            expect(result.sourceDeleted).toBe(true)
+            expect(result.entriesUpdated).toBeGreaterThanOrEqual(0)
+        })
+
+        it('should throw when merging nonexistent source tag', () => {
+            expect(() => db.mergeTags('nonexistent-tag-xyz', 'any-target')).toThrow(
+                'Source tag not found'
+            )
+        })
+    })
+
+    // ========================================================================
+    // Statistics
+    // ========================================================================
+
+    describe('getStatistics', () => {
+        it('should return statistics with day grouping', () => {
+            const stats = db.getStatistics('day')
+
+            expect(stats.totalEntries).toBeGreaterThan(0)
+            expect(stats.entriesByType).toBeDefined()
+            expect(stats.entriesByPeriod).toBeDefined()
+        })
+
+        it('should return statistics with week grouping', () => {
+            const stats = db.getStatistics('week')
+            expect(stats.totalEntries).toBeGreaterThan(0)
+        })
+
+        it('should return statistics with month grouping', () => {
+            const stats = db.getStatistics('month')
+            expect(stats.totalEntries).toBeGreaterThan(0)
+        })
+
+        it('should include causal metrics', () => {
+            const stats = db.getStatistics()
+            expect(stats.causalMetrics).toBeDefined()
+            expect(typeof stats.causalMetrics.blocked_by).toBe('number')
+            expect(typeof stats.causalMetrics.resolved).toBe('number')
+            expect(typeof stats.causalMetrics.caused).toBe('number')
+        })
+    })
+
+    // ========================================================================
+    // Health Status
+    // ========================================================================
+
+    describe('getHealthStatus', () => {
+        it('should return health status', () => {
+            const health = db.getHealthStatus()
+
+            expect(health.database.path).toBe(testDbPath)
+            expect(health.database.entryCount).toBeGreaterThan(0)
+            expect(typeof health.database.sizeBytes).toBe('number')
+            expect(typeof health.database.deletedEntryCount).toBe('number')
+            expect(typeof health.database.relationshipCount).toBe('number')
+            expect(typeof health.database.tagCount).toBe('number')
+        })
+    })
+
+    // ========================================================================
+    // Backup operations
+    // ========================================================================
+
+    describe('backup operations', () => {
+        it('should export to backup file', () => {
+            const backup = db.exportToFile('test-backup')
+
+            expect(backup.filename).toContain('test-backup')
+            expect(backup.sizeBytes).toBeGreaterThan(0)
+
+            // Cleanup
+            const fs = require('node:fs')
+            if (fs.existsSync(backup.path)) {
+                fs.unlinkSync(backup.path)
+            }
+        })
+
+        it('should list backup files', () => {
+            const backup = db.exportToFile('list-test')
+            const backups = db.listBackups()
+
+            expect(backups.length).toBeGreaterThan(0)
+            expect(backups.some((b) => b.filename.includes('list-test'))).toBe(true)
+
+            // Cleanup
+            const fs = require('node:fs')
+            if (fs.existsSync(backup.path)) {
+                fs.unlinkSync(backup.path)
+            }
+        })
+    })
+
+    // ========================================================================
+    // Close
+    // ========================================================================
+
+    describe('close', () => {
+        it('should close without error', () => {
+            const tempDb = new SqliteAdapter('./test-close.db')
+            // Close without init should not throw
+            tempDb.close()
+        })
+    })
+
+    // ========================================================================
+    // Additional branch coverage
+    // ========================================================================
+
+    describe('updateEntry', () => {
+        it('should update entry content', () => {
+            const entry = db.createEntry({ content: 'Original content' })
+            const updated = db.updateEntry(entry.id, { content: 'Updated content' })
+
+            expect(updated).not.toBeNull()
+            expect(updated?.content).toBe('Updated content')
+        })
+
+        it('should update tags', () => {
+            const entry = db.createEntry({ content: 'Tag update', tags: ['initial'] })
+            const updated = db.updateEntry(entry.id, { tags: ['updated-tag'] })
+
+            expect(updated).not.toBeNull()
+            const tags = db.getTagsForEntry(entry.id)
+            expect(tags).toContain('updated-tag')
+        })
+
+        it('should return null for nonexistent entry', () => {
+            const result = db.updateEntry(99999, { content: 'Nope' })
+            expect(result).toBeNull()
+        })
+    })
+
+    describe('searchEntries - advanced filters', () => {
+        it('should filter by issueNumber', () => {
+            db.createEntry({ content: 'Issue filter test', issueNumber: 888 })
+            const results = db.searchEntries('', { issueNumber: 888 })
+            expect(results.length).toBeGreaterThan(0)
+        })
+
+        it('should filter by prNumber', () => {
+            db.createEntry({ content: 'PR filter test', prNumber: 77 })
+            const results = db.searchEntries('', { prNumber: 77 })
+            expect(results.length).toBeGreaterThan(0)
+        })
+
+        it('should filter by isPersonal', () => {
+            const results = db.searchEntries('', { isPersonal: false })
+            expect(results.every((e) => !e.isPersonal)).toBe(true)
+        })
+    })
+
+    describe('searchByDateRange - with type filter', () => {
+        it('should filter by entry type', () => {
+            const today = new Date().toISOString().split('T')[0]!
+            const results = db.searchByDateRange(today, today, {
+                entryType: 'decision',
+            })
+            for (const r of results) {
+                expect(r.entryType).toBe('decision')
+            }
+        })
+
+        it('should filter by tags', () => {
+            db.createEntry({ content: 'Tag date range', tags: ['daterange-tag'] })
+            const today = new Date().toISOString().split('T')[0]!
+            const results = db.searchByDateRange(today, today, {
+                tags: ['daterange-tag'],
+            })
+            expect(results.length).toBeGreaterThan(0)
+        })
+    })
+})