mirror of
https://wget.la/https://github.com/Wxw-Gu/WechatExplorer
synced 2026-10-04 03:01:42 +08:00
422 lines
15 KiB
TypeScript
422 lines
15 KiB
TypeScript
import { fireEvent, render, screen, waitFor } from '@testing-library/react'
|
|
import userEvent from '@testing-library/user-event'
|
|
import type React from 'react'
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { PersonalWechatSendDialog } from '../../src/renderer/src/components/chat/PersonalWechatSendDialog'
|
|
|
|
vi.mock('../../src/renderer/src/utils/runtime-environment', () => ({
|
|
isMac: true,
|
|
isWindows: false,
|
|
runtimePlatform: 'darwin',
|
|
supportsPersonalWechatSend: true
|
|
}))
|
|
|
|
const getStatus = vi.fn()
|
|
const getRuntimeStatus = vi.fn()
|
|
const downloadRuntime = vi.fn()
|
|
const onRuntimeProgress = vi.fn(() => vi.fn())
|
|
const rebind = vi.fn()
|
|
const selectImage = vi.fn()
|
|
const selectVoice = vi.fn()
|
|
const sendMessage = vi.fn()
|
|
const getTextToSpeechSettings = vi.fn()
|
|
const listTextToSpeechVoices = vi.fn()
|
|
const synthesizeTextToSpeech = vi.fn()
|
|
const removeGeneratedTextToSpeechAudio = vi.fn()
|
|
const getPersonalWechatVoiceDiagnostic = vi.fn()
|
|
const copyText = vi.fn()
|
|
|
|
const contact = {
|
|
m_nsUsrName: 'fixture-room@chatroom',
|
|
m_nsNickName: '技术交流群',
|
|
md5: 'fixture-md5',
|
|
type: 'group' as const
|
|
}
|
|
const readyStatus = {
|
|
state: 'online' as const,
|
|
platform: 'darwin',
|
|
arch: 'arm64',
|
|
sipDisabled: true,
|
|
wechatRunning: true,
|
|
wechatPid: 4668,
|
|
boundWechatPid: 4668,
|
|
oneBotPid: 5401,
|
|
endpoint: '127.0.0.1:58080',
|
|
endpointReady: true,
|
|
wechatVersion: '4.1.11.53',
|
|
runtimeReady: true,
|
|
attachReady: true,
|
|
baseAddress: '0x114ef8000',
|
|
baseAddressReady: true,
|
|
textHookInstalled: true,
|
|
textHookReady: true,
|
|
imageHookInstalled: true,
|
|
imageHookReady: true,
|
|
messageListenerReady: true,
|
|
canSend: true,
|
|
canSendText: true,
|
|
canSendImage: true,
|
|
canSendVoice: true,
|
|
message: '个人微信已绑定'
|
|
}
|
|
const readyRuntime = {
|
|
version: 'v0.0.18',
|
|
state: 'ready' as const,
|
|
downloadedBytes: 1,
|
|
totalBytes: 1,
|
|
progress: 1,
|
|
platform: 'darwin' as NodeJS.Platform,
|
|
architecture: 'arm64',
|
|
supported: true,
|
|
removable: true
|
|
}
|
|
|
|
function renderDialog(
|
|
props: Partial<React.ComponentProps<typeof PersonalWechatSendDialog>> = {}
|
|
): React.ReactElement {
|
|
return render(
|
|
<PersonalWechatSendDialog contact={contact} isGroupChat onClose={vi.fn()} {...props} />
|
|
)
|
|
}
|
|
|
|
async function startComposer(): Promise<void> {
|
|
await screen.findByText('绑定个人微信')
|
|
const bind = screen.queryByRole('button', { name: '绑定微信' })
|
|
if (bind) {
|
|
fireEvent.click(bind)
|
|
await screen.findByText('✓ 微信已绑定')
|
|
}
|
|
const detect = await screen.findByRole('button', { name: '重新检测' })
|
|
fireEvent.click(detect)
|
|
const start = await screen.findByRole('button', { name: '开始发送' })
|
|
fireEvent.click(start)
|
|
}
|
|
|
|
describe('PersonalWechatSendDialog', () => {
|
|
beforeEach(() => {
|
|
getStatus.mockReset().mockResolvedValue(readyStatus)
|
|
getRuntimeStatus.mockReset().mockResolvedValue(readyRuntime)
|
|
downloadRuntime.mockReset().mockResolvedValue({ success: true, status: readyRuntime })
|
|
onRuntimeProgress.mockReset().mockReturnValue(vi.fn())
|
|
rebind.mockReset().mockResolvedValue(readyStatus)
|
|
selectImage
|
|
.mockReset()
|
|
.mockResolvedValue({ canceled: false, path: '/Users/fixture/test.png', name: 'test.png' })
|
|
selectVoice
|
|
.mockReset()
|
|
.mockResolvedValue({ canceled: false, path: '/Users/fixture/test.silk', name: 'test.silk' })
|
|
sendMessage.mockReset().mockResolvedValue({ success: true, status: readyStatus })
|
|
getTextToSpeechSettings.mockReset().mockResolvedValue({
|
|
success: true,
|
|
settings: {
|
|
provider: 'fish-audio',
|
|
hasApiKey: true,
|
|
encryptionAvailable: true,
|
|
selectedVoiceId: 'fish-warm-female',
|
|
outputFormat: 'mp3',
|
|
model: 's2.1-pro-free',
|
|
phase: 'ready'
|
|
},
|
|
voices: []
|
|
})
|
|
listTextToSpeechVoices.mockReset().mockResolvedValue({
|
|
success: true,
|
|
items: [
|
|
{
|
|
id: 'fish-warm-female',
|
|
name: '暖阳女声',
|
|
description: '自然温和',
|
|
tags: ['女声'],
|
|
languages: ['中文'],
|
|
source: 'fish-audio'
|
|
}
|
|
],
|
|
total: 1,
|
|
pageNumber: 1,
|
|
pageSize: 24,
|
|
hasMore: false
|
|
})
|
|
synthesizeTextToSpeech.mockReset().mockResolvedValue({
|
|
success: true,
|
|
filePath: '/tmp/generated.mp3',
|
|
audioDataUrl: 'data:audio/mpeg;base64,fixture'
|
|
})
|
|
removeGeneratedTextToSpeechAudio.mockReset().mockResolvedValue({ success: true })
|
|
getPersonalWechatVoiceDiagnostic.mockReset().mockResolvedValue(null)
|
|
copyText.mockReset().mockResolvedValue({ success: true })
|
|
Object.defineProperty(window, 'api', {
|
|
configurable: true,
|
|
value: {
|
|
getPersonalWechatSenderStatus: getStatus,
|
|
getPersonalWechatRuntimeStatus: getRuntimeStatus,
|
|
downloadPersonalWechatRuntime: downloadRuntime,
|
|
onPersonalWechatRuntimeProgress: onRuntimeProgress,
|
|
rebindPersonalWechatSender: rebind,
|
|
selectPersonalWechatImage: selectImage,
|
|
selectPersonalWechatVoice: selectVoice,
|
|
sendPersonalWechatMessage: sendMessage,
|
|
getTextToSpeechSettings,
|
|
listTextToSpeechVoices,
|
|
synthesizeTextToSpeech,
|
|
removeGeneratedTextToSpeechAudio,
|
|
getPersonalWechatVoiceDiagnostic,
|
|
copyText
|
|
}
|
|
})
|
|
})
|
|
|
|
it('shows a user-facing four-step setup and keeps diagnostics collapsed', async () => {
|
|
getRuntimeStatus
|
|
.mockResolvedValueOnce({ ...readyRuntime, state: 'missing', progress: 0 })
|
|
.mockResolvedValue(readyRuntime)
|
|
getStatus.mockResolvedValue({
|
|
...readyStatus,
|
|
state: 'stopped',
|
|
runtimeReady: false,
|
|
canSend: false,
|
|
canSendText: false,
|
|
canSendImage: false,
|
|
canSendVoice: false,
|
|
message: '尚未绑定当前微信'
|
|
})
|
|
renderDialog()
|
|
expect(await screen.findByText('准备 OneBot 运行时')).toBeInTheDocument()
|
|
expect(screen.getByRole('button', { name: '下载运行时' })).toBeEnabled()
|
|
expect(screen.getByText('绑定个人微信')).toBeInTheDocument()
|
|
expect(screen.getByText('验证消息能力')).toBeInTheDocument()
|
|
expect(screen.getByText('能力检测')).toBeInTheDocument()
|
|
expect(screen.getByText('图片和语音消息')).toBeInTheDocument()
|
|
expect(screen.getByRole('note')).toHaveTextContent(
|
|
'绑定微信可能导致当前微信异常闪退，这是正常现象。若微信退出，请重新启动微信后，再回到这里重新检测/绑定。'
|
|
)
|
|
fireEvent.click(screen.getByRole('button', { name: '查看支持的微信版本' }))
|
|
const versionsDialog = screen.getByRole('dialog', { name: '支持的微信版本' })
|
|
expect(versionsDialog).toBeInTheDocument()
|
|
expect(versionsDialog).toHaveTextContent('4.1.11.53')
|
|
expect(screen.queryByLabelText('消息列表')).not.toBeInTheDocument()
|
|
expect(screen.queryByText('TraceMemo 消息发送')).not.toBeInTheDocument()
|
|
expect(screen.queryByText('PID 4668')).not.toBeVisible()
|
|
fireEvent.click(screen.getByText('高级诊断'))
|
|
expect(screen.getByText('PID 4668')).toBeInTheDocument()
|
|
})
|
|
|
|
it('sends text through the existing message API and echoes it in the chat', async () => {
|
|
renderDialog()
|
|
await startComposer()
|
|
await userEvent
|
|
.setup()
|
|
.type(screen.getByRole('textbox', { name: '消息内容' }), '你好 TraceMemo')
|
|
fireEvent.click(screen.getByRole('button', { name: '发送消息' }))
|
|
await waitFor(() =>
|
|
expect(sendMessage).toHaveBeenCalledWith({
|
|
type: 'text',
|
|
to: 'fixture-room@chatroom',
|
|
text: '你好 TraceMemo',
|
|
isGroup: true
|
|
})
|
|
)
|
|
expect(
|
|
screen.getByLabelText('消息列表').querySelector('.personal-wechat-message-bubble')
|
|
).toHaveTextContent('你好 TraceMemo')
|
|
})
|
|
|
|
it('supports local image and voice selection', async () => {
|
|
renderDialog()
|
|
await startComposer()
|
|
fireEvent.click(screen.getByRole('radio', { name: '图片' }))
|
|
fireEvent.click(screen.getByRole('button', { name: '选择图片' }))
|
|
expect(await screen.findByText('test.png')).toBeInTheDocument()
|
|
fireEvent.click(screen.getByRole('button', { name: '发送消息' }))
|
|
await waitFor(() =>
|
|
expect(sendMessage).toHaveBeenCalledWith({
|
|
type: 'image',
|
|
to: 'fixture-room@chatroom',
|
|
filePath: '/Users/fixture/test.png',
|
|
isGroup: true
|
|
})
|
|
)
|
|
|
|
fireEvent.click(screen.getByRole('radio', { name: '语音' }))
|
|
fireEvent.click(screen.getByRole('radio', { name: '选择本地文件' }))
|
|
fireEvent.click(screen.getByRole('button', { name: '选择语音' }))
|
|
expect(await screen.findByText('test.silk')).toBeInTheDocument()
|
|
fireEvent.click(screen.getByRole('button', { name: '发送消息' }))
|
|
await waitFor(() =>
|
|
expect(sendMessage).toHaveBeenCalledWith({
|
|
type: 'voice',
|
|
to: 'fixture-room@chatroom',
|
|
filePath: '/Users/fixture/test.silk',
|
|
isGroup: true
|
|
})
|
|
)
|
|
})
|
|
|
|
it('sends the same generated voice through the comparison path', async () => {
|
|
renderDialog()
|
|
await startComposer()
|
|
fireEvent.click(screen.getByRole('radio', { name: '语音' }))
|
|
fireEvent.change(screen.getByRole('textbox', { name: '语音文字' }), {
|
|
target: { value: '入口2语音测试' }
|
|
})
|
|
fireEvent.click(screen.getByRole('button', { name: '生成语音' }))
|
|
await waitFor(() => expect(screen.getByText('语音已生成')).toBeInTheDocument())
|
|
fireEvent.click(screen.getByRole('button', { name: '空白语音？重新处理' }))
|
|
await waitFor(() =>
|
|
expect(sendMessage).toHaveBeenCalledWith({
|
|
type: 'voice',
|
|
to: 'fixture-room@chatroom',
|
|
filePath: '/tmp/generated.mp3',
|
|
isGroup: true,
|
|
voiceSendMode: 'legacy'
|
|
})
|
|
)
|
|
})
|
|
|
|
it('uses the existing runtime, binding and detection IPC actions', async () => {
|
|
getRuntimeStatus
|
|
.mockResolvedValueOnce({ ...readyRuntime, state: 'missing', progress: 0 })
|
|
.mockResolvedValue(readyRuntime)
|
|
getStatus
|
|
.mockResolvedValueOnce({
|
|
...readyStatus,
|
|
state: 'stopped',
|
|
runtimeReady: false,
|
|
canSend: false,
|
|
canSendText: false,
|
|
canSendImage: false,
|
|
canSendVoice: false
|
|
})
|
|
.mockResolvedValue({
|
|
...readyStatus,
|
|
state: 'stopped',
|
|
runtimeReady: true,
|
|
canSend: false,
|
|
canSendText: false,
|
|
canSendImage: false,
|
|
canSendVoice: false
|
|
})
|
|
renderDialog()
|
|
await screen.findByRole('button', { name: '下载运行时' })
|
|
fireEvent.click(screen.getByRole('button', { name: '下载运行时' }))
|
|
await waitFor(() => expect(downloadRuntime).toHaveBeenCalledOnce())
|
|
fireEvent.click(screen.getByRole('button', { name: '绑定微信' }))
|
|
await waitFor(() => expect(rebind).toHaveBeenCalledOnce())
|
|
})
|
|
|
|
it('shows a stable bound state after binding', async () => {
|
|
getRuntimeStatus.mockResolvedValue(readyRuntime)
|
|
getStatus
|
|
.mockResolvedValueOnce({
|
|
...readyStatus,
|
|
state: 'stopped',
|
|
canSend: false,
|
|
canSendText: false,
|
|
canSendImage: false,
|
|
canSendVoice: false
|
|
})
|
|
.mockResolvedValue(readyStatus)
|
|
renderDialog()
|
|
await screen.findByRole('button', { name: '绑定微信' })
|
|
fireEvent.click(screen.getByRole('button', { name: '绑定微信' }))
|
|
expect(await screen.findByText('✓ 微信已绑定')).toBeInTheDocument()
|
|
expect(screen.queryByRole('button', { name: '绑定微信' })).not.toBeInTheDocument()
|
|
})
|
|
|
|
it('treats image and voice readiness as one media capability', async () => {
|
|
getStatus.mockResolvedValue({
|
|
...readyStatus,
|
|
canSendImage: false,
|
|
canSendVoice: true
|
|
})
|
|
renderDialog()
|
|
expect(await screen.findByText('图片和语音消息')).toBeInTheDocument()
|
|
const bind = screen.queryByRole('button', { name: '绑定微信' })
|
|
if (bind) {
|
|
fireEvent.click(bind)
|
|
await screen.findByText('✓ 微信已绑定')
|
|
}
|
|
fireEvent.click(await screen.findByRole('button', { name: '重新检测' }))
|
|
expect(screen.getByText('微信消息发送已配置完成')).toBeInTheDocument()
|
|
expect(screen.getByRole('button', { name: '开始发送' })).toBeEnabled()
|
|
expect(screen.queryByText('图片消息')).not.toBeInTheDocument()
|
|
expect(screen.queryByText('语音消息')).not.toBeInTheDocument()
|
|
})
|
|
|
|
it('keeps re-detection available and explains when no new messages are found', async () => {
|
|
getRuntimeStatus.mockResolvedValue(readyRuntime)
|
|
getStatus.mockResolvedValue({
|
|
...readyStatus,
|
|
canSend: false,
|
|
canSendText: false,
|
|
canSendImage: false,
|
|
canSendVoice: false,
|
|
message: '等待消息初始化'
|
|
})
|
|
renderDialog()
|
|
await screen.findByText('绑定个人微信')
|
|
const bind = screen.queryByRole('button', { name: '绑定微信' })
|
|
if (bind) {
|
|
fireEvent.click(bind)
|
|
await screen.findByText('✓ 微信已绑定')
|
|
}
|
|
const detect = await screen.findByRole('button', { name: '重新检测' })
|
|
expect(detect).toBeEnabled()
|
|
fireEvent.click(detect)
|
|
expect(
|
|
await screen.findByText(
|
|
'暂未检测到新的消息，请确认已在手机微信中发送文字和图片，然后再次检测。'
|
|
)
|
|
).toBeInTheDocument()
|
|
expect(screen.getAllByText('未检测').length).toBe(2)
|
|
})
|
|
|
|
it('keeps the dialog and controls stable while sending', async () => {
|
|
const user = userEvent.setup()
|
|
sendMessage.mockImplementation(() => new Promise(() => undefined))
|
|
renderDialog()
|
|
await startComposer()
|
|
await screen.findByRole('textbox', { name: '消息内容' })
|
|
await user.type(screen.getByRole('textbox', { name: '消息内容' }), '发送中')
|
|
await user.click(screen.getByRole('button', { name: '发送消息' }))
|
|
expect(screen.getByRole('button', { name: '正在发送…' })).toBeDisabled()
|
|
expect(screen.getByRole('radio', { name: '图片' })).toBeDisabled()
|
|
})
|
|
|
|
it('shows and copies the latest redacted voice diagnostic JSON', async () => {
|
|
getPersonalWechatVoiceDiagnostic.mockResolvedValue({
|
|
request_id: 'request-1',
|
|
voice_id: 'request-1',
|
|
phase: 'completed',
|
|
encoder_name: 'go-silk',
|
|
encoder_version: 'wechat_chatter-v0.0.18',
|
|
input_bytes: 35107,
|
|
normalized_input_bytes: 69804,
|
|
pcm_size: 69760,
|
|
sample_rate: 16000,
|
|
channels: 1,
|
|
input_duration_ms: 2180,
|
|
upload_result: '0',
|
|
upload_data_len: 4380,
|
|
silk_duration_ms: 2180,
|
|
send_result: '1'
|
|
})
|
|
renderDialog()
|
|
await startComposer()
|
|
fireEvent.click(screen.getByRole('button', { name: '语音发送诊断' }))
|
|
const diagnosticDialog = await screen.findByRole('dialog', { name: '语音发送诊断' })
|
|
expect(diagnosticDialog).toHaveTextContent('"encoder_name": "go-silk"')
|
|
expect(diagnosticDialog).not.toHaveTextContent('aesKey')
|
|
fireEvent.click(screen.getByRole('button', { name: '复制诊断 JSON' }))
|
|
await waitFor(() => expect(copyText).toHaveBeenCalledWith(expect.stringContaining('request-1')))
|
|
expect(screen.getByRole('button', { name: '已复制' })).toBeInTheDocument()
|
|
})
|
|
|
|
it('shows an empty state when no voice diagnostic exists', async () => {
|
|
renderDialog()
|
|
await startComposer()
|
|
fireEvent.click(screen.getByRole('button', { name: '语音发送诊断' }))
|
|
expect(await screen.findByText('暂无诊断信息')).toBeInTheDocument()
|
|
expect(screen.getByRole('button', { name: '复制诊断 JSON' })).toBeDisabled()
|
|
})
|
|
})
|