348 lines
13 KiB
TypeScript
348 lines
13 KiB
TypeScript
// apps/desktop/tests/main/services/typo-live-punctuation.test.ts
|
|
// 실시간 타이핑(InputTelemetryService → TypoCorrectionService → TextInsertService)에서
|
|
// 문장부호 뒤 띄어쓰기 없는 한영 오타 감지와 후속 학습/커서 추적을 검증한다.
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
|
|
const BASE_NOW = Date.UTC(2026, 10, 14, 5, 0, 0)
|
|
|
|
const state = vi.hoisted(() => ({
|
|
now: 0,
|
|
config: {
|
|
typoAutoCorrectEnabled: true as boolean,
|
|
typoAutoCorrectUseModel: false as boolean,
|
|
typoIgnoredWords: [] as string[],
|
|
inputExcludedApps: [] as string[],
|
|
inputTelemetryEnabled: false as boolean,
|
|
inputTelemetryPaused: false as boolean,
|
|
inputLearnTypedText: false as boolean,
|
|
suggestionEnabled: false as boolean,
|
|
suggestionTriggerDelayMs: 600 as number,
|
|
suggestionMinPrefixChars: 8 as number
|
|
},
|
|
text: '',
|
|
caretOffset: 0 as number | null,
|
|
nativeTick: 100,
|
|
hwnd: 77,
|
|
appName: 'KakaoTalk.exe',
|
|
windowTitle: '채팅',
|
|
listeners: new Map<string, Array<(event: unknown) => void>>(),
|
|
learnedTexts: [] as string[]
|
|
}))
|
|
|
|
vi.mock('electron', () => ({ screen: { getPrimaryDisplay: () => ({ scaleFactor: 1 }) } }))
|
|
vi.mock('uiohook-napi', () => ({
|
|
uIOhook: {
|
|
on: vi.fn((event: string, listener: (payload: unknown) => void) => {
|
|
const list = state.listeners.get(event) ?? []
|
|
list.push(listener)
|
|
state.listeners.set(event, list)
|
|
}),
|
|
removeListener: vi.fn((event: string, listener: (payload: unknown) => void) => {
|
|
const list = state.listeners.get(event) ?? []
|
|
state.listeners.set(
|
|
event,
|
|
list.filter((entry) => entry !== listener)
|
|
)
|
|
})
|
|
}
|
|
}))
|
|
vi.mock('../../../src/main/db', () => ({
|
|
getDatabase: () => ({
|
|
insert: () => ({
|
|
values: () => ({
|
|
run: () => undefined,
|
|
onConflictDoUpdate: () => ({ run: () => undefined })
|
|
})
|
|
})
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/services/ConfigService', () => ({
|
|
configGet: vi.fn((key: keyof typeof state.config) => state.config[key]),
|
|
configSet: vi.fn((key: keyof typeof state.config, value: never) => {
|
|
state.config[key] = value
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/services/LoggerService', () => ({
|
|
getLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() })
|
|
}))
|
|
vi.mock('../../../src/main/services/global-input-hook', () => ({
|
|
acquireGlobalInputHook: () => () => undefined
|
|
}))
|
|
vi.mock('../../../src/main/services/KeyBindingService', () => ({
|
|
uiohookCodeToVk: (code: number) => code
|
|
}))
|
|
vi.mock('../../../src/main/services/UiaContextService', () => ({
|
|
getUiaContextService: () => ({
|
|
lastReason: null,
|
|
lastSuccessAt: 0,
|
|
isAvailable: () => true,
|
|
getSnapshot: vi.fn(async () => ({
|
|
available: true,
|
|
isPassword: false,
|
|
isEditable: true,
|
|
isComposing: false,
|
|
hasSelection: false,
|
|
controlType: 'Edit',
|
|
controlName: 'MessageInput',
|
|
textSource: 'value' as const,
|
|
text: state.text,
|
|
caretOffset: state.caretOffset,
|
|
caretRect: null,
|
|
elementRect: { x: 100, y: 100, width: 300, height: 40 },
|
|
windowTitle: state.windowTitle,
|
|
appName: state.appName,
|
|
processId: 1234,
|
|
capturedAt: state.now
|
|
}))
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/utils/win32-foreground', () => ({
|
|
getForegroundWindowInfo: () => ({
|
|
appName: state.appName,
|
|
title: state.windowTitle,
|
|
hwnd: state.hwnd
|
|
}),
|
|
isForegroundKoreanIme: () => false
|
|
}))
|
|
vi.mock('../../../src/main/utils/win32-input-activity', () => ({
|
|
getLastNativeInputTick: () => state.nativeTick
|
|
}))
|
|
vi.mock('../../../src/main/services/PersonalGraphService', () => ({
|
|
getPersonalGraphService: () => ({
|
|
indexText: vi.fn((text: string) => {
|
|
state.learnedTexts.push(text)
|
|
}),
|
|
observeTypedText: vi.fn(),
|
|
learnPhrase: vi.fn()
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/services/suggestion/PersonalNgramIndex', () => ({
|
|
getPersonalNgramIndex: () => ({
|
|
add: vi.fn()
|
|
})
|
|
}))
|
|
vi.mock('../../../src/main/services/text-insert/electron-clipboard-port', () => ({
|
|
electronClipboardPort: { readText: () => '', writeText: vi.fn() }
|
|
}))
|
|
|
|
import {
|
|
getInputTelemetryService,
|
|
resetInputTelemetryServiceForTests
|
|
} from '../../../src/main/services/InputTelemetryService'
|
|
import { TypoCorrectionService } from '../../../src/main/services/TypoCorrectionService'
|
|
import { TextInsertService } from '../../../src/main/services/TextInsertService'
|
|
|
|
function emitKeyDown(vk: number, shift = false): void {
|
|
const handlers = state.listeners.get('keydown') ?? []
|
|
for (const handler of handlers) {
|
|
handler({
|
|
keycode: vk,
|
|
ctrlKey: false,
|
|
altKey: false,
|
|
metaKey: false,
|
|
shiftKey: shift
|
|
})
|
|
}
|
|
}
|
|
|
|
async function advance(ms: number): Promise<void> {
|
|
let remaining = ms
|
|
while (remaining > 0) {
|
|
const step = Math.min(50, remaining)
|
|
state.now += step
|
|
remaining -= step
|
|
await vi.advanceTimersByTimeAsync(step)
|
|
}
|
|
}
|
|
|
|
function wireLivePipeline() {
|
|
const telemetry = getInputTelemetryService()
|
|
const keyboard = {
|
|
type: vi.fn(async () => undefined),
|
|
paste: vi.fn(async () => undefined),
|
|
backspace: vi.fn(async (count: number) => {
|
|
state.text = state.text.slice(0, -count)
|
|
}),
|
|
replaceBeforeCaret: vi.fn(async (count: number, insertText: string) => {
|
|
const idx = state.caretOffset ?? state.text.length
|
|
state.text = state.text.slice(0, idx - count) + insertText + state.text.slice(idx)
|
|
if (state.caretOffset !== null) {
|
|
state.caretOffset = idx - count + insertText.length
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
const insert = new TextInsertService({ keyboard })
|
|
const typo = new TypoCorrectionService({
|
|
replaceBeforeCaret: async (deleteCount, insertText, options) => {
|
|
let baseLength = telemetry.currentTerminalPrefixLength()
|
|
const result = await insert.replaceBeforeCaret(deleteCount, insertText, 'keyboard', {
|
|
...options,
|
|
beforeApply: () => {
|
|
options?.beforeApply?.()
|
|
baseLength = telemetry.currentTerminalPrefixLength()
|
|
telemetry.expectProgrammaticKeys(deleteCount + (options?.commitComposition ? 2 : 0))
|
|
}
|
|
})
|
|
if (result.success) {
|
|
telemetry.applyProgrammaticReplacement(deleteCount, insertText, baseLength)
|
|
}
|
|
return result.success
|
|
},
|
|
lastKeyAt: () => telemetry.lastKeyAt,
|
|
inputRevision: () => telemetry.inputRevision,
|
|
nativeInputTick: () => state.nativeTick,
|
|
foregroundHandle: () => state.hwnd,
|
|
expectProgrammaticKeys: (count) => telemetry.expectProgrammaticKeys(count),
|
|
expectProgrammaticInsert: (text) => telemetry.expectProgrammaticInsert(text),
|
|
recentTexts: () => [],
|
|
warmModel: () => null,
|
|
generate: async function* () {
|
|
yield '없음'
|
|
}
|
|
})
|
|
const contexts: Array<{ caretReliable?: boolean; prefix: string }> = []
|
|
telemetry.on('typed-context', (ctx) => {
|
|
contexts.push({ caretReliable: ctx.caretReliable, prefix: ctx.prefix })
|
|
typo.handleTypingContext(ctx, { trailingWordOnly: true })
|
|
})
|
|
telemetry.start()
|
|
return { telemetry, typo, insert, keyboard, contexts }
|
|
}
|
|
|
|
describe('실시간 타이핑 문장부호 경계 오타 교정 및 추적', () => {
|
|
beforeEach(() => {
|
|
vi.useFakeTimers()
|
|
state.now = BASE_NOW
|
|
vi.setSystemTime(BASE_NOW)
|
|
state.config = {
|
|
typoAutoCorrectEnabled: true,
|
|
typoAutoCorrectUseModel: false,
|
|
typoIgnoredWords: [],
|
|
inputExcludedApps: [],
|
|
inputTelemetryEnabled: false,
|
|
inputTelemetryPaused: false,
|
|
inputLearnTypedText: false,
|
|
suggestionEnabled: false,
|
|
suggestionTriggerDelayMs: 600,
|
|
suggestionMinPrefixChars: 8
|
|
}
|
|
state.text = '상황 잘 지켜보는중?'
|
|
state.caretOffset = state.text.length
|
|
state.nativeTick = 100
|
|
state.hwnd = 77
|
|
state.listeners.clear()
|
|
state.learnedTexts = []
|
|
resetInputTelemetryServiceForTests()
|
|
})
|
|
|
|
afterEach(() => {
|
|
resetInputTelemetryServiceForTests()
|
|
vi.useRealTimers()
|
|
vi.restoreAllMocks()
|
|
})
|
|
|
|
it('liveTyping_제안비활성상태에서물음표뒤공백없는영타멈춤_정지스냅샷으로교정한다', async () => {
|
|
const { typo, keyboard } = wireLivePipeline()
|
|
try {
|
|
// 초기 포커스 기준선: '?' 까지 이미 입력됨 -> 이어서 영타 'dbrlgkrhdlTwlsdksgwl' 입력 후 멈춤
|
|
state.text = '상황 잘 지켜보는중?dbrlgkrhdlTwlsdksgwl'
|
|
state.caretOffset = state.text.length
|
|
emitKeyDown(0x4c) // 'L' 키 입력 완료 시점
|
|
|
|
// 디바운스(380ms) → 정지 스냅샷(>=650ms)까지 진행
|
|
await advance(750)
|
|
|
|
expect(keyboard.replaceBeforeCaret).toHaveBeenCalledTimes(1)
|
|
expect(state.text).toBe('상황 잘 지켜보는중?유기하고있진않지')
|
|
} finally {
|
|
typo.dispose()
|
|
}
|
|
})
|
|
|
|
it('liveTyping_제안활성짧은접두나장문물음표뒤영타_경계와정지스냅샷에서놓치지않는다', async () => {
|
|
state.config.suggestionEnabled = true
|
|
state.config.suggestionTriggerDelayMs = 600
|
|
state.config.suggestionMinPrefixChars = 100
|
|
|
|
const { typo, keyboard } = wireLivePipeline()
|
|
try {
|
|
// 짧은 접두에서도 ? 뒤 23자 단일 오타는 경계 스냅샷(140ms)에서 즉시 교정된다
|
|
state.text = '왜?dbrlgkrhdlTwlsdksgwldy?'
|
|
state.caretOffset = state.text.length
|
|
emitKeyDown(0xbf, true) // '?'
|
|
await advance(150)
|
|
expect(state.text).toBe('왜?유기하고있진않지요?')
|
|
|
|
// 다중 단어 장문(>32자)도 minPrefixChars 미달과 무관하게 정지 스냅샷(<=800ms)에서 교정된다
|
|
keyboard.replaceBeforeCaret.mockClear()
|
|
state.text = '왜?dkssudgktpdy rkatkgkqslek rkatkgkqslek?'
|
|
state.caretOffset = state.text.length
|
|
emitKeyDown(0xbf, true)
|
|
await advance(850)
|
|
expect(state.text).toBe('왜?안녕하세요 감사합니다 감사합니다?')
|
|
expect(keyboard.replaceBeforeCaret).toHaveBeenCalledTimes(1)
|
|
} finally {
|
|
typo.dispose()
|
|
}
|
|
})
|
|
|
|
it('liveTyping_문장부호로끝나는치환후_잔여물음표로후속문장학습이나중간편집판정을망가뜨리지않는다', async () => {
|
|
state.config.inputLearnTypedText = true
|
|
state.caretOffset = null // caret-unknown 표면(RichEdit 등)
|
|
const { typo, contexts } = wireLivePipeline()
|
|
try {
|
|
// 기준선 형성
|
|
state.text = '상황 잘 지켜보는중?dbrlgkrhdlTwlsdksgwl?'
|
|
emitKeyDown(0xbf, true)
|
|
await advance(200)
|
|
expect(state.text).toBe('상황 잘 지켜보는중?유기하고있진않지?')
|
|
|
|
// 치환 반영 스냅샷 소비 (공통 접미사 '?' 가 남아 diff 는 '유기하고있진않지' 만 잡아냄)
|
|
await advance(450)
|
|
emitKeyDown(0x20)
|
|
state.text = '상황 잘 지켜보는중?유기하고있진않지? '
|
|
await advance(450)
|
|
// programmaticKeys TTL(3s) 경과 후 (expectedInserts TTL 10s 이내) 새 문장 입력
|
|
await advance(3100)
|
|
|
|
// 이후 사용자가 새로 '정말 이상한 상황인데?' 를 치면 '?' 가 예고 삽입 잔여물로 뜯겨 나가지 않고 온전히 학습된다
|
|
state.learnedTexts = []
|
|
state.text = '상황 잘 지켜보는중?유기하고있진않지? 정말 이상한 상황인데?'
|
|
emitKeyDown(0xbf, true)
|
|
await advance(450)
|
|
expect(state.learnedTexts.join(' ')).toContain('정말 이상한 상황인데?')
|
|
|
|
// 이후 문서 중간('상황' 앞)을 편집하면 caretReliable 이 false 여야 한다 ('?' 잔여물이 programmaticEdit 를 계속 true 로 만들지 않음)
|
|
state.text = '지금 상황 잘 지켜보는중?유기하고있진않지? 정말 이상한 상황인데?'
|
|
emitKeyDown(0x41)
|
|
await advance(450)
|
|
expect(contexts[contexts.length - 1]?.caretReliable).toBe(false)
|
|
} finally {
|
|
typo.dispose()
|
|
}
|
|
})
|
|
|
|
it('liveTyping_학습비활성상태에서도교정후3초경과시_예고삽입잔존이나만료된키카운트로중간편집판정이망가지지않는다', async () => {
|
|
state.config.inputLearnTypedText = false
|
|
state.caretOffset = null // caret-unknown 표면
|
|
const { typo, contexts } = wireLivePipeline()
|
|
try {
|
|
state.text = '상황 잘 지켜보는중?dbrlgkrhdlTwlsdksgwl?'
|
|
emitKeyDown(0xbf, true)
|
|
await advance(200)
|
|
expect(state.text).toBe('상황 잘 지켜보는중?유기하고있진않지?')
|
|
|
|
// 학습 비활성 경로에서도 치환 반영 스냅샷에서 expectedInserts 를 소진해야 한다
|
|
await advance(450)
|
|
// programmaticKeys TTL(3s) 경과 후 (expectedInserts TTL 10s 이내) 문서 중간 수정
|
|
await advance(3100)
|
|
state.text = '지금 상황 잘 지켜보는중?유기하고있진않지?'
|
|
emitKeyDown(0x41)
|
|
await advance(450)
|
|
expect(contexts[contexts.length - 1]?.caretReliable).toBe(false)
|
|
} finally {
|
|
typo.dispose()
|
|
}
|
|
})
|
|
})
|