416 lines
16 KiB
TypeScript
416 lines
16 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
|
|
const config = vi.hoisted(() => ({
|
|
suggestionEnabled: true as boolean,
|
|
suggestionModelId: 'model-a' as string | null,
|
|
llmModelId: 'model-a' as string | null,
|
|
inputExcludedApps: [] as string[],
|
|
suggestionTriggerDelayMs: 600,
|
|
suggestionMinPrefixChars: 8,
|
|
suggestionMaxRequestsPerMinute: 12,
|
|
suggestionDailyBudget: 500,
|
|
suggestionRequestTimeoutMs: 8000,
|
|
inputLearnTypedText: false,
|
|
inputTelemetryEnabled: false,
|
|
suggestionOverlayInteractive: true,
|
|
insertMethod: 'clipboard'
|
|
}))
|
|
const harness = vi.hoisted(() => ({
|
|
isAvailable: vi.fn(() => true),
|
|
streamGenerate: vi.fn(),
|
|
insertText: vi.fn(async (text: string) => ({ success: true, method: 'clipboard', textLength: text.length })),
|
|
continuations: [] as string[]
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/ConfigService', () => ({
|
|
configGet: vi.fn((key: keyof typeof config) => config[key]),
|
|
configSet: vi.fn()
|
|
}))
|
|
vi.mock('../../../src/main/services/LoggerService', () => ({
|
|
getLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() })
|
|
}))
|
|
vi.mock('../../../src/main/services/LocalLLMService', () => ({
|
|
getLocalLLMService: () => ({ isAvailable: harness.isAvailable, streamGenerate: harness.streamGenerate })
|
|
}))
|
|
vi.mock('../../../src/main/services/InputTelemetryService', () => ({
|
|
getInputTelemetryService: () => ({ listPhrases: () => [] })
|
|
}))
|
|
vi.mock('../../../src/main/services/PersonalGraphService', () => ({
|
|
getPersonalGraphService: () => ({
|
|
retrieveContext: () => ({ continuations: harness.continuations, related: [] })
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/services/TextInsertService', () => ({
|
|
getTextInsertService: () => ({ insertText: harness.insertText })
|
|
}))
|
|
vi.mock('../../../src/main/services/modifier-state', () => ({ waitForModifiersReleased: async () => true }))
|
|
vi.mock('../../../src/main/utils/win32-foreground', () => ({ getForegroundWindowInfo: () => null }))
|
|
vi.mock('../../../src/main/db', () => ({ getDatabase: vi.fn() }))
|
|
vi.mock('../../../src/main/db/schema', () => ({ suggestions: {} }))
|
|
|
|
import { SuggestionService, type SuggestionServiceDeps } from '../../../src/main/services/SuggestionService'
|
|
import { SuggestionBudget } from '../../../src/main/services/suggestion/SuggestionBudget'
|
|
import { ModelWarmTracker } from '../../../src/main/services/suggestion/ModelWarmTracker'
|
|
import type { TypingContext } from '../../../src/main/services/InputTelemetryService'
|
|
|
|
const SHORT_PREFIX = '오늘 회의에서 논의한 내용을 정리해서'
|
|
const LONG_PREFIX = `${'가나다라 '.repeat(100)}${SHORT_PREFIX}`
|
|
|
|
function typingContext(overrides: Partial<TypingContext> = {}): TypingContext {
|
|
const prefix = overrides.prefix ?? SHORT_PREFIX
|
|
return {
|
|
prefix,
|
|
fullText: prefix,
|
|
caretOffset: prefix.length,
|
|
anchor: null,
|
|
anchorKind: null,
|
|
isPassword: false,
|
|
isEditable: true,
|
|
isComposing: false,
|
|
hasSelection: false,
|
|
available: true,
|
|
appName: 'chrome.exe',
|
|
windowTitle: 'Gmail',
|
|
windowHandle: 101,
|
|
idleMs: 2000,
|
|
capturedAt: Date.now(),
|
|
editedSinceFocus: true,
|
|
typedRecently: true,
|
|
...overrides
|
|
}
|
|
}
|
|
|
|
interface Fakes {
|
|
deps: SuggestionServiceDeps
|
|
record: ReturnType<typeof vi.fn>
|
|
foregroundHandle: { value: number | null }
|
|
expectInsert: ReturnType<typeof vi.fn>
|
|
cancelInsert: ReturnType<typeof vi.fn>
|
|
recordAccepted: ReturnType<typeof vi.fn>
|
|
}
|
|
|
|
function fakes(): Fakes {
|
|
const record = vi.fn()
|
|
const foregroundHandle = { value: 101 as number | null }
|
|
const cancelInsert = vi.fn()
|
|
const expectInsert = vi.fn(() => cancelInsert)
|
|
const recordAccepted = vi.fn()
|
|
return {
|
|
record,
|
|
foregroundHandle,
|
|
expectInsert,
|
|
cancelInsert,
|
|
recordAccepted,
|
|
deps: {
|
|
repository: { record, markAccepted: vi.fn(), list: vi.fn(() => []) },
|
|
budget: new SuggestionBudget(),
|
|
warmth: new ModelWarmTracker(),
|
|
foreground: { currentWindowHandle: () => foregroundHandle.value },
|
|
learning: { expectProgrammaticInsert: expectInsert, recordAccepted }
|
|
}
|
|
}
|
|
}
|
|
|
|
function streamOf(text: string) {
|
|
return (async function* () {
|
|
yield text
|
|
})()
|
|
}
|
|
|
|
let services: SuggestionService[] = []
|
|
function create(deps: SuggestionServiceDeps): SuggestionService {
|
|
const service = new SuggestionService(deps)
|
|
services.push(service)
|
|
return service
|
|
}
|
|
|
|
interface Internal {
|
|
_generate(prefix: string, context: TypingContext, maxCandidates: number, maxChars: number): Promise<void>
|
|
_warmUpPromise: Promise<void> | null
|
|
_lastSkipReason: string | null
|
|
}
|
|
|
|
beforeEach(() => {
|
|
config.suggestionEnabled = true
|
|
config.suggestionModelId = 'model-a'
|
|
config.llmModelId = 'model-a'
|
|
harness.isAvailable.mockReset()
|
|
harness.isAvailable.mockReturnValue(true)
|
|
harness.streamGenerate.mockReset()
|
|
harness.insertText.mockClear()
|
|
harness.continuations = []
|
|
})
|
|
|
|
afterEach(() => {
|
|
for (const service of services) service.dispose()
|
|
services = []
|
|
vi.useRealTimers()
|
|
})
|
|
|
|
describe('버그 1: 400자 넘는 접두에서 세션이 stale 로 닫히지 않는다', () => {
|
|
it('같은 긴 접두의 다음 스냅샷에서도 세션이 유지되고 재생성하지 않는다', async () => {
|
|
harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
|
|
const { deps } = fakes()
|
|
deps.warmth.noteWarm('model-a', Date.now() + 600_000)
|
|
const service = create(deps)
|
|
const internal = service as unknown as Internal
|
|
const context = typingContext({ prefix: LONG_PREFIX })
|
|
expect(LONG_PREFIX.length).toBeGreaterThan(400)
|
|
|
|
await internal._generate(LONG_PREFIX, context, 3, 160)
|
|
expect(service.isVisible).toBe(true)
|
|
|
|
service.handleTypingContext(context)
|
|
|
|
expect(service.isVisible).toBe(true)
|
|
expect(service.getState().lastSkipReason).not.toBe('stale')
|
|
// 세션이 유지되므로 새 첫 요청(예산 소비)이 일어나지 않는다.
|
|
expect(deps.budget.minuteCount).toBe(1)
|
|
})
|
|
|
|
it('긴 접두에서도 이어 치면 세션을 끝낸다', async () => {
|
|
harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
|
|
const { deps } = fakes()
|
|
deps.warmth.noteWarm('model-a', Date.now() + 600_000)
|
|
const service = create(deps)
|
|
await (service as unknown as Internal)._generate(LONG_PREFIX, typingContext({ prefix: LONG_PREFIX }), 3, 160)
|
|
|
|
service.handleTypingContext(typingContext({ prefix: `${LONG_PREFIX} 그리고`, idleMs: 100 }))
|
|
|
|
expect(service.isVisible).toBe(false)
|
|
expect(service.getState().lastSkipReason).toBe('stale')
|
|
})
|
|
})
|
|
|
|
describe('버그 2: 쿨다운 중 표시된 로컬 기억 세션', () => {
|
|
function coolingService(): { service: SuggestionService; fake: Fakes } {
|
|
const fake = fakes()
|
|
fake.deps.budget.noteFailure(Date.now())
|
|
fake.deps.budget.noteFailure(Date.now())
|
|
expect(fake.deps.budget.isCoolingDown(Date.now())).toBe(true)
|
|
harness.continuations = ['첫 번째 이어쓰기 문장입니다', '두 번째 이어쓰기 문장입니다']
|
|
const service = create(fake.deps)
|
|
service.handleTypingContext(typingContext())
|
|
expect(service.getState()).toMatchObject({ visible: true, provenance: { mode: 'local-memory' } })
|
|
expect(fake.record).toHaveBeenCalledTimes(1)
|
|
return { service, fake }
|
|
}
|
|
|
|
it('다음 후보 단축키(키 입력 직후 스냅샷)로 세션이 닫히지 않는다', () => {
|
|
const { service } = coolingService()
|
|
service.next()
|
|
service.handleTypingContext(typingContext({ idleMs: 100 }))
|
|
expect(service.getState()).toMatchObject({ visible: true, activeIndex: 1 })
|
|
})
|
|
|
|
it('멈춘 상태의 주기 스냅샷이 선택을 초기화하거나 이력을 중복 기록하지 않는다', () => {
|
|
const { service, fake } = coolingService()
|
|
service.next()
|
|
service.handleTypingContext(typingContext({ idleMs: 2000 }))
|
|
service.handleTypingContext(typingContext({ idleMs: 2800 }))
|
|
expect(service.getState().activeIndex).toBe(1)
|
|
expect(fake.record).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('타이핑이 끊긴 뒤(not-typing)에도 읽는 중인 세션을 닫지 않는다', () => {
|
|
const { service } = coolingService()
|
|
service.handleTypingContext(typingContext({ typedRecently: false, idleMs: 9000 }))
|
|
expect(service.isVisible).toBe(true)
|
|
})
|
|
|
|
it('비밀번호 칸으로 옮기면 쿨다운 중에도 닫는다', () => {
|
|
const { service } = coolingService()
|
|
service.handleTypingContext(typingContext({ isPassword: true }))
|
|
expect(service.isVisible).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('버그 4: 모델 변경 뒤 콜드 모델로 바로 생성하지 않는다', () => {
|
|
it('이전 모델이 warm 이어도 새 모델은 워밍업부터 한다', async () => {
|
|
harness.streamGenerate.mockImplementation(() => streamOf('ok'))
|
|
const { deps } = fakes()
|
|
deps.warmth.noteWarm('model-a', Date.now() + 600_000)
|
|
const service = create(deps)
|
|
const internal = service as unknown as Internal
|
|
const generateSpy = vi.spyOn(internal, '_generate')
|
|
|
|
config.suggestionModelId = 'model-b'
|
|
service.handleTypingContext(typingContext())
|
|
|
|
expect(generateSpy).not.toHaveBeenCalled()
|
|
expect(harness.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ model: 'model-b', maxTokens: 1 }))
|
|
expect(service.getState().lastSkipReason).toBe('model-unavailable')
|
|
await internal._warmUpPromise
|
|
expect(deps.warmth.isWarm('model-b', Date.now())).toBe(true)
|
|
})
|
|
|
|
it('handleModelChanged 는 새 콜드 모델을 미리 워밍업한다', async () => {
|
|
harness.streamGenerate.mockImplementation(() => streamOf('ok'))
|
|
const { deps } = fakes()
|
|
deps.warmth.noteWarm('model-a', Date.now() + 600_000)
|
|
const service = create(deps)
|
|
|
|
service.handleModelChanged()
|
|
expect(harness.streamGenerate).not.toHaveBeenCalled()
|
|
|
|
config.suggestionModelId = 'model-b'
|
|
service.handleModelChanged()
|
|
await (service as unknown as Internal)._warmUpPromise
|
|
expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
|
|
expect(harness.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ model: 'model-b' }))
|
|
})
|
|
})
|
|
|
|
describe('버그 5: 실패한 워밍업은 실패로 센다', () => {
|
|
it('워밍업 실패 뒤 다음 멈춤에서 워밍업을 바로 다시 쏘지 않고, 두 번째 실패로 쿨다운에 들어간다', async () => {
|
|
vi.useFakeTimers()
|
|
harness.streamGenerate.mockImplementation(() =>
|
|
(async function* () {
|
|
throw new Error('Ollama responded with 404')
|
|
})()
|
|
)
|
|
const { deps } = fakes()
|
|
const service = create(deps)
|
|
const internal = service as unknown as Internal
|
|
|
|
service.handleTypingContext(typingContext())
|
|
await internal._warmUpPromise
|
|
expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
|
|
expect(deps.budget.consecutiveFailures).toBe(1)
|
|
expect(service.getState().lastSkipReason).toBe('generation-failed')
|
|
|
|
// 800ms 뒤 샘플 — 실패 직후라 워밍업을 다시 쏘지 않는다.
|
|
vi.advanceTimersByTime(800)
|
|
service.handleTypingContext(typingContext())
|
|
expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
|
|
expect(service.getState()).toMatchObject({ warmingUp: false, lastSkipReason: 'generation-failed' })
|
|
|
|
// 물러서기 시간이 지나면 한 번 더 시도하고, 그 실패로 쿨다운에 들어간다.
|
|
vi.advanceTimersByTime(5000)
|
|
service.handleTypingContext(typingContext())
|
|
await internal._warmUpPromise
|
|
expect(harness.streamGenerate).toHaveBeenCalledTimes(2)
|
|
expect(deps.budget.isCoolingDown(Date.now())).toBe(true)
|
|
expect(service.getState().coolingDown).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('버그 6: 수락 직전 대상 창 확인', () => {
|
|
async function visibleService(fake: Fakes): Promise<SuggestionService> {
|
|
harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
|
|
fake.deps.warmth.noteWarm('model-a', Date.now() + 600_000)
|
|
const service = create(fake.deps)
|
|
await (service as unknown as Internal)._generate(SHORT_PREFIX, typingContext({ windowHandle: 101 }), 3, 160)
|
|
expect(service.isVisible).toBe(true)
|
|
return service
|
|
}
|
|
|
|
it('포커스가 다른 창으로 옮겨 갔으면 붙여넣지 않는다', async () => {
|
|
const fake = fakes()
|
|
const service = await visibleService(fake)
|
|
fake.foregroundHandle.value = 202
|
|
|
|
const result = await service.accept()
|
|
|
|
expect(result).toEqual({ ok: false, reason: 'stale' })
|
|
expect(harness.insertText).not.toHaveBeenCalled()
|
|
expect(fake.expectInsert).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('같은 창이면 삽입하고, 삽입 예고와 수락 학습을 한 번씩 알린다', async () => {
|
|
const fake = fakes()
|
|
const service = await visibleService(fake)
|
|
|
|
const result = await service.accept()
|
|
|
|
expect(result).toEqual({ ok: true })
|
|
// 접두('…정리해서')와 후보 사이에 구분 공백을 붙여 넣는다(joinSuggestion).
|
|
expect(harness.insertText).toHaveBeenCalledWith(' 다음 단계도 확인하겠습니다.', 'clipboard')
|
|
expect(fake.expectInsert).toHaveBeenCalledWith(' 다음 단계도 확인하겠습니다.')
|
|
expect(fake.recordAccepted).toHaveBeenCalledTimes(1)
|
|
expect(fake.cancelInsert).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('삽입이 실패하면 삽입 예고를 취소한다', async () => {
|
|
const fake = fakes()
|
|
const service = await visibleService(fake)
|
|
harness.insertText.mockResolvedValueOnce({ success: false, method: 'clipboard', textLength: 0 })
|
|
|
|
const result = await service.accept()
|
|
|
|
expect(result.ok).toBe(false)
|
|
expect(fake.cancelInsert).toHaveBeenCalledTimes(1)
|
|
expect(fake.recordAccepted).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('창을 알 수 없으면(포그라운드 조회 실패) 기존처럼 삽입한다', async () => {
|
|
const fake = fakes()
|
|
const service = await visibleService(fake)
|
|
fake.foregroundHandle.value = null
|
|
|
|
expect(await service.accept()).toEqual({ ok: true })
|
|
})
|
|
})
|
|
|
|
describe('SuggestionBudget', () => {
|
|
it('consume 은 창을 먼저 굴린다 — 오래 쉰 뒤의 요청도 예산에 잡힌다', () => {
|
|
const budget = new SuggestionBudget()
|
|
const t0 = new Date(2026, 8, 28, 10, 0, 0).getTime()
|
|
budget.consume(t0)
|
|
const later = t0 + 120_000
|
|
budget.consume(later)
|
|
// 직후의 상태 조회(창 굴리기)가 방금 소비를 지우면 안 된다.
|
|
expect(budget.snapshot(later + 10)).toMatchObject({ requestsThisMinute: 1, requestsToday: 2 })
|
|
})
|
|
|
|
it('창이 바뀐 뒤의 환급은 새 창의 카운트를 깎지 않는다', () => {
|
|
const budget = new SuggestionBudget()
|
|
const t0 = new Date(2026, 8, 28, 10, 0, 0).getTime()
|
|
budget.consume(t0)
|
|
budget.consume(t0 + 61_000)
|
|
budget.snapshot(t0 + 61_000)
|
|
budget.consume(t0 + 62_000)
|
|
budget.refund()
|
|
expect(budget.snapshot(t0 + 62_000)).toMatchObject({ requestsThisMinute: 1 })
|
|
expect(budget.lastRequestAt).toBe(t0 + 61_000)
|
|
|
|
const other = new SuggestionBudget()
|
|
other.consume(t0)
|
|
other.snapshot(t0 + 61_000)
|
|
other.refund()
|
|
expect(other.minuteCount).toBe(0)
|
|
expect(other.dayCount).toBe(0)
|
|
})
|
|
|
|
it('연속 실패 임계에서 쿨다운, 성공이면 초기화, relaxInterval 은 최소 간격만 푼다', () => {
|
|
const budget = new SuggestionBudget({ failureCooldownThreshold: 2, failureCooldownMs: 60_000 })
|
|
expect(budget.noteFailure(1000)).toBe(false)
|
|
expect(budget.noteFailure(2000)).toBe(true)
|
|
expect(budget.isCoolingDown(61_999)).toBe(true)
|
|
expect(budget.isCoolingDown(62_000)).toBe(false)
|
|
budget.noteSuccess()
|
|
expect(budget.isCoolingDown(3000)).toBe(false)
|
|
|
|
budget.consume(100_000)
|
|
budget.relaxInterval(101_000, 5000)
|
|
expect(budget.snapshot(101_000)).toMatchObject({ sinceLastRequestMs: 5000, requestsThisMinute: 1 })
|
|
})
|
|
})
|
|
|
|
describe('ModelWarmTracker', () => {
|
|
it('온기와 워밍업 실패를 모델별로 기억한다', () => {
|
|
const tracker = new ModelWarmTracker()
|
|
tracker.noteWarm('a', 10_000)
|
|
expect(tracker.isWarm('a', 9_999)).toBe(true)
|
|
expect(tracker.isWarm('a', 10_000)).toBe(false)
|
|
expect(tracker.isWarm('b', 5_000)).toBe(false)
|
|
expect(tracker.isWarm(null, 5_000)).toBe(false)
|
|
|
|
tracker.noteWarmUpFailure('b', 1_000)
|
|
expect(tracker.isBackingOff('b', 5_999, 5_000)).toBe(true)
|
|
expect(tracker.isBackingOff('b', 6_000, 5_000)).toBe(false)
|
|
expect(tracker.isBackingOff('a', 2_000, 5_000)).toBe(false)
|
|
tracker.noteWarm('b', 20_000)
|
|
expect(tracker.isBackingOff('b', 2_000, 5_000)).toBe(false)
|
|
})
|
|
})
|