d3ro-voice/apps/desktop/tests/main/services/UnifiedSearchService.test.ts

456 lines
14 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { ErrorCode } from '@d3ro/core/errors'
import {
bindTestDatabase,
unbindTestDatabase,
} from '../../../src/main/db'
import {
history,
meetingMemos,
meetingSessions,
type NewHistory,
type NewMeetingMemoRow,
type NewMeetingSessionRow,
} from '../../../src/main/db/schema'
import {
createUnifiedSearchExcerpt,
getUnifiedSearchService,
normalizeUnifiedSearchQuery,
resetUnifiedSearchServiceForTests,
} from '../../../src/main/services/UnifiedSearchService'
import { createTestDb } from '../../helpers/createTestDb'
function makeHistoryRow(overrides: Partial<NewHistory> & { id: string }): NewHistory {
return {
title: '제품 메모',
originalText: '초기 원문',
polishedText: '다음 분기 출시 계획을 정리했습니다.',
focusedApp: null,
focusedAppName: null,
focusedAppWindowTitle: null,
mode: 'dictation',
status: 'completed',
errorCode: null,
audioLocalPath: null,
duration: 10,
detectedLanguage: 'ko',
micDevice: null,
wordCount: 6,
sttModel: null,
llmModel: null,
sttLatencyMs: null,
llmLatencyMs: null,
createdAt: 100,
updatedAt: 100,
appVersion: '1.9.0',
summaryText: null,
isFavorite: false,
...overrides,
}
}
function makeMeetingRow(
overrides: Partial<NewMeetingSessionRow> & { id: string },
): NewMeetingSessionRow {
return {
title: '주간 회의',
status: 'completed',
startedAt: 200,
endedAt: 300,
durationMs: 100,
rawTranscript: '출시 계획을 다음 주에 검토합니다.',
editedTranscript: null,
minutesMarkdown: null,
minutesJson: null,
sttModel: null,
llmModel: null,
sttLatencyMs: null,
llmLatencyMs: null,
errorMessage: null,
createdAt: 200,
updatedAt: 300,
...overrides,
}
}
function makeMemoRow(
overrides: Partial<NewMeetingMemoRow> & { id: string; sessionId: string },
): NewMeetingMemoRow {
return {
content: '기본 메모 내용',
timestampMs: 10_000,
revision: 1,
createdAt: 210,
updatedAt: 210,
...overrides,
}
}
describe('UnifiedSearchService', () => {
let closeDb: (() => void) | null = null
function useFreshTestDb() {
const testDb = createTestDb()
closeDb = testDb.close
bindTestDatabase(testDb.db)
return testDb
}
beforeEach(() => {
resetUnifiedSearchServiceForTests()
unbindTestDatabase()
})
afterEach(() => {
resetUnifiedSearchServiceForTests()
unbindTestDatabase()
if (closeDb) {
closeDb()
closeDb = null
}
vi.restoreAllMocks()
})
it('normalizes input and creates a bounded excerpt around the match', () => {
expect(normalizeUnifiedSearchQuery(' 출시\n 계획 ')).toBe('출시 계획')
expect(normalizeUnifiedSearchQuery('a'.repeat(250))).toHaveLength(200)
expect(normalizeUnifiedSearchQuery(` ${'a'.repeat(199)} b`)).toBe('a'.repeat(199))
const excerpt = createUnifiedSearchExcerpt(
`앞부분 ${'x'.repeat(80)} 출시 계획 ${'y'.repeat(80)}`,
'출시 계획',
60,
)
expect(excerpt).toContain('출시 계획')
expect(excerpt.startsWith('…')).toBe(true)
expect(excerpt.endsWith('…')).toBe(true)
})
it('merges records and meeting transcripts by occurrence time and preserves source ids', () => {
const { db } = useFreshTestDb()
db.insert(history).values(makeHistoryRow({ id: 'record-1', createdAt: 100, updatedAt: 100 })).run()
db.insert(meetingSessions).values(makeMeetingRow({ id: 'meeting-1', startedAt: 200, createdAt: 200 })).run()
const response = getUnifiedSearchService().search({ query: '계획', limit: 10 })
expect(response.total).toBe(2)
expect(response.results.map(({ source, id }) => ({ source, id }))).toEqual([
{ source: 'meeting', id: 'meeting-1' },
{ source: 'record', id: 'record-1' },
])
expect(response.results[0]).toMatchObject({
matchedField: 'transcript',
excerpt: '출시 계획을 다음 주에 검토합니다.',
})
expect(response.results[1]).toMatchObject({ matchedField: 'content' })
})
it('returns immediately for an empty query without opening DB', () => {
expect(getUnifiedSearchService().search({ query: ' ' })).toEqual({
query: '',
results: [],
total: 0,
})
})
it.each([
null,
undefined,
{},
{ query: 42 },
{ query: '계획', limit: Number.NaN },
{ query: '계획', limit: Number.POSITIVE_INFINITY },
{ query: '계획', limit: '10' },
])('rejects malformed runtime parameters with ConfigInvalidValue: %o', (params) => {
expect(() => getUnifiedSearchService().search(params)).toThrowError(
expect.objectContaining({ code: ErrorCode.ConfigInvalidValue }),
)
})
it('maps database failures to the IPC error contract', () => {
expect(() => getUnifiedSearchService().search({ query: '계획' })).toThrowError(
expect.objectContaining({ code: ErrorCode.DBQueryFailed }),
)
})
it('includes meeting_memos and timed transcript segments in meeting search results', () => {
const { db } = useFreshTestDb()
db.insert(meetingSessions)
.values(
makeMeetingRow({
id: 'meeting-memo-1',
title: '설계 검토 회의',
startedAt: 400,
createdAt: 400,
rawTranscript: '[00:10] 아키텍처 개요 설명',
}),
)
.run()
db.insert(meetingMemos)
.values(
makeMemoRow({
id: 'memo-1',
sessionId: 'meeting-memo-1',
content: '마이그레이션 체크리스트 확인 필요',
timestampMs: 75_000,
createdAt: 410,
updatedAt: 410,
}),
)
.run()
const response = getUnifiedSearchService().search({ query: '체크리스트', limit: 10 })
expect(response.total).toBe(1)
expect(response.results).toEqual([
expect.objectContaining({
source: 'meeting',
id: 'meeting-memo-1',
title: '설계 검토 회의',
matchedField: 'content',
excerpt: '[01:15] 마이그레이션 체크리스트 확인 필요',
}),
])
})
it('search_oldLongMeetingMemoVsRecentShortMeeting_prioritizesRecentMeetingAndCreatedAtMemo', () => {
const { db } = useFreshTestDb()
// Old long meeting: high timestampMs (2 hours in), early createdAt/startedAt
db.insert(meetingSessions)
.values([
makeMeetingRow({
id: 'old-long-meeting',
title: '과거 장기 회의',
startedAt: 100,
createdAt: 100,
rawTranscript: '잡담 내용',
}),
makeMeetingRow({
id: 'recent-short-meeting',
title: '최신 짧은 회의',
startedAt: 900,
createdAt: 900,
rawTranscript: '일반 진행 상황',
}),
])
.run()
db.insert(meetingMemos)
.values([
makeMemoRow({
id: 'old-late-offset-memo',
sessionId: 'old-long-meeting',
content: '로드맵 1차 초안 메모',
timestampMs: 7_200_000,
createdAt: 110,
updatedAt: 110,
}),
makeMemoRow({
id: 'recent-early-offset-memo',
sessionId: 'recent-short-meeting',
content: '로드맵 최신 결정사항',
timestampMs: 5_000,
createdAt: 910,
updatedAt: 910,
}),
makeMemoRow({
id: 'recent-earlier-created-memo',
sessionId: 'recent-short-meeting',
content: '로드맵 중간 메모',
timestampMs: 60_000,
createdAt: 905,
updatedAt: 905,
}),
])
.run()
const limited = getUnifiedSearchService().search({ query: '로드맵', limit: 1 })
expect(limited.total).toBe(2)
expect(limited.results.map((r) => r.id)).toEqual(['recent-short-meeting'])
expect(limited.results[0].excerpt).toBe('[00:05] 로드맵 최신 결정사항')
})
it('search_meetingStartedAtDiffersFromCreatedAt_ordersByStartedAt', () => {
const { db } = useFreshTestDb()
db.insert(meetingSessions)
.values([
makeMeetingRow({
id: 'older-started-imported-later',
title: '과거 회의 사후 동기화',
startedAt: 500,
createdAt: 950,
rawTranscript: '분기 목표 리뷰',
}),
makeMeetingRow({
id: 'newer-started-created-earlier',
title: '최근 회의',
startedAt: 800,
createdAt: 200,
rawTranscript: '분기 목표 확정',
}),
])
.run()
const limited = getUnifiedSearchService().search({ query: '분기 목표', limit: 1 })
expect(limited.total).toBe(2)
expect(limited.results[0].id).toBe('newer-started-created-earlier')
expect(limited.results[0].occurredAt).toBe(800)
})
it('search_meetingMatchesDirectlyOutsideLimitAndViaMemos_countsDistinctTotalWithoutDoubleCounting', () => {
const { db } = useFreshTestDb()
db.insert(history)
.values(
makeHistoryRow({
id: 'hist-overlap',
title: '아키텍처 기록',
polishedText: '아키텍처 변경 공지',
createdAt: 1_000,
updatedAt: 1_000,
}),
)
.run()
db.insert(meetingSessions)
.values([
makeMeetingRow({
id: 'meet-both-recent',
title: '아키텍처 위원회',
startedAt: 900,
createdAt: 900,
rawTranscript: '아키텍처 리뷰',
}),
makeMeetingRow({
id: 'meet-both-old-outside-limit',
title: '초기 아키텍처 회의',
startedAt: 100,
createdAt: 100,
rawTranscript: '아키텍처 설계 초안',
}),
makeMeetingRow({
id: 'meet-memo-only-1',
title: '일반 스탠드업 1',
startedAt: 700,
createdAt: 700,
rawTranscript: '진행 보고',
}),
makeMeetingRow({
id: 'meet-memo-only-2',
title: '일반 스탠드업 2',
startedAt: 600,
createdAt: 600,
rawTranscript: '진행 보고',
}),
])
.run()
db.insert(meetingMemos)
.values([
makeMemoRow({
id: 'memo-m1',
sessionId: 'meet-both-recent',
content: '아키텍처 메모 1',
createdAt: 905,
}),
makeMemoRow({
id: 'memo-m2',
sessionId: 'meet-both-old-outside-limit',
content: '아키텍처 메모 2',
createdAt: 950,
}),
makeMemoRow({
id: 'memo-m3a',
sessionId: 'meet-memo-only-1',
content: '아키텍처 후속 과제 A',
createdAt: 710,
}),
makeMemoRow({
id: 'memo-m3b',
sessionId: 'meet-memo-only-1',
content: '아키텍처 후속 과제 B',
createdAt: 720,
}),
makeMemoRow({
id: 'memo-m4',
sessionId: 'meet-memo-only-2',
content: '아키텍처 후속 과제 C',
createdAt: 610,
}),
])
.run()
const response = getUnifiedSearchService().search({ query: '아키텍처', limit: 1 })
// 1 history + 4 distinct meetingSessions = 5 total, even though limit is 1 and meet-both-old matches both directly and via memo
expect(response.results).toHaveLength(1)
expect(response.total).toBe(5)
})
it('search_ftsTablesAbsent_fallsBackToLikeFilteringSafely', () => {
const { db, sqlite } = useFreshTestDb()
db.insert(history)
.values(
makeHistoryRow({
id: 'hist-legacy',
title: '레거시 노트',
polishedText: '트라이그램 없는 데이터베이스 검색 테스트',
createdAt: 300,
updatedAt: 300,
}),
)
.run()
db.insert(meetingSessions)
.values(
makeMeetingRow({
id: 'meet-legacy',
title: '레거시 회의',
startedAt: 400,
createdAt: 400,
rawTranscript: '일반 회의록',
}),
)
.run()
db.insert(meetingMemos)
.values(
makeMemoRow({
id: 'memo-legacy',
sessionId: 'meet-legacy',
content: '데이터베이스 백업 메모',
createdAt: 410,
}),
)
.run()
sqlite.exec('DROP TABLE IF EXISTS history_fts')
sqlite.exec('DROP TABLE IF EXISTS meeting_sessions_fts')
sqlite.exec('DROP TABLE IF EXISTS meeting_memos_fts')
const response = getUnifiedSearchService().search({ query: '데이터베이스', limit: 10 })
expect(response.total).toBe(2)
expect(response.results.map((r) => r.id)).toEqual(['meet-legacy', 'hist-legacy'])
})
it('search_ftsMatchThrowsAtRuntime_fallsBackToLikeFilteringSafely', () => {
const { db, sqlite } = useFreshTestDb()
db.insert(history)
.values(
makeHistoryRow({
id: 'hist-fts-broken',
title: '복구 테스트',
polishedText: '인덱스 손상 복구 검증',
createdAt: 500,
updatedAt: 500,
}),
)
.run()
// Replace history_fts with a plain non-FTS table so sqlite_master reports it exists, causing MATCH to fail at runtime
sqlite.exec('DROP TRIGGER IF EXISTS history_fts_ai')
sqlite.exec('DROP TRIGGER IF EXISTS history_fts_au')
sqlite.exec('DROP TRIGGER IF EXISTS history_fts_ad')
sqlite.exec('DROP TABLE history_fts')
sqlite.exec('CREATE TABLE history_fts (row_id TEXT)')
const response = getUnifiedSearchService().search({ query: '손상 복구', limit: 10 })
expect(response.total).toBe(1)
expect(response.results.map((r) => r.id)).toEqual(['hist-fts-broken'])
})
})