897 lines
27 KiB
JavaScript
897 lines
27 KiB
JavaScript
/**
|
||
* LoveLiveMusicPlayer-Next · 复杂 Monkey 测试
|
||
*
|
||
* 层级：
|
||
* A. 协议 / 数据模型 fuzz
|
||
* B. 渲染进程 IPC 压力（经 Playwright evaluate）
|
||
* C. 场景流（歌单/搜索/传歌/设置/歌词）
|
||
* D. 混沌乱点（侧栏、hash 风暴、连点、滚轮、键盘）
|
||
*
|
||
* 用法:
|
||
* node scripts/monkey-test.mjs --actions=200 --seed=42 --complex
|
||
* npm run monkey:build -- --actions=200 --complex
|
||
*/
|
||
import { createRequire } from 'module'
|
||
import { spawn } from 'child_process'
|
||
import { fileURLToPath } from 'url'
|
||
import path from 'path'
|
||
import fs from 'fs'
|
||
import { createHash } from 'crypto'
|
||
|
||
const require = createRequire(import.meta.url)
|
||
const __dirname = path.dirname(fileURLToPath(import.meta.url))
|
||
const root = path.resolve(__dirname, '..')
|
||
|
||
const args = Object.fromEntries(
|
||
process.argv.slice(2).map((a) => {
|
||
const m = a.match(/^--([^=]+)=(.*)$/)
|
||
return m ? [m[1], m[2]] : [a.replace(/^--/, ''), true]
|
||
})
|
||
)
|
||
const COMPLEX = args.complex !== false && args.simple !== true
|
||
const ACTIONS = Number(args.actions || (COMPLEX ? 200 : 80))
|
||
const SEED = Number(args.seed || Date.now() % 1e9)
|
||
const STORM = Number(args.storm || (COMPLEX ? 40 : 10))
|
||
|
||
function mulberry32(a) {
|
||
return function () {
|
||
let t = (a += 0x6d2b79f5)
|
||
t = Math.imul(t ^ (t >>> 15), t | 1)
|
||
t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
|
||
return ((t ^ (t >>> 14)) >>> 0) / 4294967296
|
||
}
|
||
}
|
||
const rand = mulberry32(SEED)
|
||
const pick = (arr) => arr[Math.floor(rand() * arr.length)]
|
||
const chance = (p) => rand() < p
|
||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
|
||
|
||
const report = {
|
||
startedAt: new Date().toISOString(),
|
||
seed: SEED,
|
||
actions: ACTIONS,
|
||
complex: COMPLEX,
|
||
storm: STORM,
|
||
logic: { passed: 0, failed: 0, cases: [] },
|
||
ipc: { calls: 0, errors: [], samples: [] },
|
||
scenarios: { ran: [], failed: [] },
|
||
ui: {
|
||
launched: false,
|
||
actionsDone: 0,
|
||
consoleErrors: [],
|
||
pageErrors: [],
|
||
crashes: [],
|
||
navigation: [],
|
||
dialogs: { accepted: 0, dismissed: 0 },
|
||
notes: []
|
||
},
|
||
verdict: 'UNKNOWN'
|
||
}
|
||
|
||
function logicCase(name, fn) {
|
||
try {
|
||
fn()
|
||
report.logic.passed++
|
||
report.logic.cases.push({ name, ok: true })
|
||
} catch (e) {
|
||
report.logic.failed++
|
||
report.logic.cases.push({ name, ok: false, error: String(e?.message || e).slice(0, 300) })
|
||
}
|
||
}
|
||
|
||
async function scenario(name, fn) {
|
||
try {
|
||
await fn()
|
||
report.scenarios.ran.push(name)
|
||
} catch (e) {
|
||
report.scenarios.failed.push({ name, error: String(e?.message || e).slice(0, 300) })
|
||
}
|
||
}
|
||
|
||
/* ======================== A. 协议 / 模型 ======================== */
|
||
|
||
const DOWNLOAD_BODY_SEPARATOR = ' === '
|
||
const encodeFtpCmd = (cmd, body = '') => JSON.stringify({ cmd, body: String(body) })
|
||
const decodeFtpCmd = (raw) => {
|
||
const obj = JSON.parse(raw)
|
||
return { cmd: String(obj.cmd), body: obj.body == null ? '' : String(obj.body) }
|
||
}
|
||
|
||
function parseTransData(body) {
|
||
const raw = JSON.parse(body)
|
||
const love = (raw.love || [])
|
||
.map((o) => ({
|
||
musicId: String(o.musicId ?? o.musicUId ?? ''),
|
||
timestamp: Number(o.timestamp ?? o.createTime ?? Date.now()) || Date.now()
|
||
}))
|
||
.filter((l) => l.musicId)
|
||
const menu = (raw.menu || [])
|
||
.map((o) => {
|
||
let list = o.musicList ?? o.musicUIds ?? o.music ?? []
|
||
if (typeof list === 'string') {
|
||
try {
|
||
list = JSON.parse(list)
|
||
} catch {
|
||
list = [list]
|
||
}
|
||
}
|
||
return {
|
||
menuId: Number(o.menuId ?? o.id ?? 0),
|
||
name: String(o.name ?? o.title ?? ''),
|
||
date: String(o.date ?? ''),
|
||
musicList: (Array.isArray(list) ? list : []).map(String).filter(Boolean)
|
||
}
|
||
})
|
||
.filter((m) => Number.isFinite(m.menuId) && m.menuId > 0)
|
||
return { love, menu, isCover: !!raw.isCover }
|
||
}
|
||
|
||
function mediaAbsPath(rootDir, baseUrl, musicPath) {
|
||
const parts = [rootDir, baseUrl, musicPath]
|
||
.map((p) => String(p).replace(/[/\\]+/g, '/').replace(/^\/+|\/+$/g, ''))
|
||
.filter(Boolean)
|
||
const joined = parts.join('/')
|
||
return rootDir.includes('\\') ? joined.replace(/\//g, '\\') : joined
|
||
}
|
||
|
||
function runLogicMonkey() {
|
||
logicCase('encode/decode roundtrip', () => {
|
||
const d = decodeFtpCmd(encodeFtpCmd('prepare', '[{"a":1}] === false'))
|
||
if (d.cmd !== 'prepare' || !d.body.includes(' === ')) throw new Error('mismatch')
|
||
})
|
||
|
||
logicCase('unicode + emoji body', () => {
|
||
const body = JSON.stringify([{ musicName: '幻影ノメゾン🎤', path: 'a/b [c].flac' }])
|
||
JSON.parse(decodeFtpCmd(encodeFtpCmd('ready', body)).body)
|
||
})
|
||
|
||
logicCase('prepare 3000 tracks', () => {
|
||
const list = Array.from({ length: 3000 }, (_, i) => ({
|
||
albumUId: `a${i}`,
|
||
musicUId: `m${i}`,
|
||
musicName: `曲${i}`,
|
||
musicPath: `${i}.flac`,
|
||
baseUrl: 'LoveLive/test/',
|
||
coverPath: 'c.jpg',
|
||
albumId: i % 50,
|
||
albumName: 'A',
|
||
date: '2020-01-01',
|
||
category: 'single',
|
||
group: "μ's",
|
||
musicId: i,
|
||
artist: 'x',
|
||
artistBin: '1e7',
|
||
totalTime: '03:00',
|
||
existFile: true
|
||
}))
|
||
const body = `${JSON.stringify(list)}${DOWNLOAD_BODY_SEPARATOR}true`
|
||
const [json, flag] = decodeFtpCmd(encodeFtpCmd('prepare', body)).body.split(
|
||
DOWNLOAD_BODY_SEPARATOR
|
||
)
|
||
if (JSON.parse(json).length !== 3000 || flag !== 'true') throw new Error('prepare broken')
|
||
})
|
||
|
||
logicCase('download body separator edge', () => {
|
||
const uid = 'abc === def'
|
||
const raw = `${uid}${DOWNLOAD_BODY_SEPARATOR}false`
|
||
const parts = raw.split(DOWNLOAD_BODY_SEPARATOR)
|
||
// 协议本身对 uid 含分隔符不健壮——记录行为即可
|
||
if (parts.length < 2) throw new Error('split failed')
|
||
})
|
||
|
||
logicCase('transData phone wire format', () => {
|
||
const wire = JSON.stringify({
|
||
love: [{ musicId: 'm1', timestamp: 1 }],
|
||
menu: [{ menuId: 101, name: '手机歌单', date: '2024-01-01', musicList: ['m1', 'm2'] }],
|
||
isCover: false
|
||
})
|
||
const d = parseTransData(wire)
|
||
if (d.menu[0].menuId !== 101 || d.love[0].musicId !== 'm1') throw new Error('parse')
|
||
})
|
||
|
||
logicCase('transData legacy field aliases', () => {
|
||
const wire = JSON.stringify({
|
||
love: [{ musicUId: 'x', createTime: 9 }],
|
||
menu: [{ id: 102, title: 'T', musicUIds: ['a'] }],
|
||
isCover: true
|
||
})
|
||
const d = parseTransData(wire)
|
||
if (d.love[0].musicId !== 'x' || d.menu[0].name !== 'T') throw new Error('alias')
|
||
})
|
||
|
||
logicCase('transData musicList as JSON string', () => {
|
||
const wire = JSON.stringify({
|
||
love: [],
|
||
menu: [{ menuId: 103, name: 'S', date: '', musicList: '["u1","u2"]' }],
|
||
isCover: false
|
||
})
|
||
const d = parseTransData(wire)
|
||
if (d.menu[0].musicList.length !== 2) throw new Error('string list')
|
||
})
|
||
|
||
logicCase('menu id boundaries', () => {
|
||
const ids = [1, 100, 101, 200, 0, -1, NaN, 1.5]
|
||
const kept = ids.map(Number).filter((n) => Number.isFinite(n) && n > 0)
|
||
if (!kept.includes(101) || kept.includes(0)) throw new Error('boundary')
|
||
})
|
||
|
||
logicCase('path join windows/posix', () => {
|
||
const a = mediaAbsPath('E:\\Music', "LoveLive/μ's/", '01. song.flac')
|
||
const b = mediaAbsPath('/home/m', 'LoveLive/x/', 'a.flac')
|
||
// 实现会裁掉首尾分隔符，posix 根可能变成 home/m/...
|
||
if (!a.includes('01. song.flac') || !String(a).includes('Music')) throw new Error(`win:${a}`)
|
||
if (!b.includes('a.flac') || !b.includes('LoveLive')) throw new Error(`posix:${b}`)
|
||
})
|
||
|
||
logicCase('malformed raw rejected', () => {
|
||
let threw = false
|
||
try {
|
||
decodeFtpCmd('{bad')
|
||
} catch {
|
||
threw = true
|
||
}
|
||
if (!threw) throw new Error('expected throw')
|
||
})
|
||
|
||
// 大批量随机 fuzz
|
||
const cmds = [
|
||
'version',
|
||
'prepare',
|
||
'ready',
|
||
'download',
|
||
'phone2pc',
|
||
'pc2phone',
|
||
'system',
|
||
'port',
|
||
'',
|
||
'💥',
|
||
'download success'
|
||
]
|
||
for (let i = 0; i < (COMPLEX ? 80 : 40); i++) {
|
||
logicCase(`fuzz#${i}`, () => {
|
||
const cmd = pick(cmds)
|
||
const body = pick([
|
||
'',
|
||
'1',
|
||
'true',
|
||
'[]',
|
||
'{}',
|
||
'null',
|
||
'a === true',
|
||
'm1 === false === extra',
|
||
JSON.stringify({
|
||
love: Array.from({ length: Math.floor(rand() * 5) }, (_, j) => ({
|
||
musicId: `m${j}`,
|
||
timestamp: j
|
||
})),
|
||
menu: Array.from({ length: Math.floor(rand() * 3) }, (_, j) => ({
|
||
menuId: 101 + j,
|
||
name: `歌单${j}`,
|
||
date: '',
|
||
musicList: [`m${j}`]
|
||
})),
|
||
isCover: chance(0.5)
|
||
}),
|
||
'\u0000\u0001',
|
||
'中文'.repeat(Math.floor(rand() * 30)),
|
||
'<script>alert(1)</script>',
|
||
"' OR 1=1 --",
|
||
'../'.repeat(20) + 'etc/passwd'
|
||
])
|
||
const d = decodeFtpCmd(encodeFtpCmd(cmd, body))
|
||
if (typeof d.cmd !== 'string' || typeof d.body !== 'string') throw new Error('type')
|
||
if (cmd === 'phone2pc' || cmd === 'pc2phone') {
|
||
try {
|
||
parseTransData(d.body)
|
||
} catch {
|
||
/* 畸形可解析失败 */
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
// 哈希稳定性 / 路由怪值
|
||
logicCase('hostile routes hash', () => {
|
||
for (const r of [
|
||
'/',
|
||
'/playlists',
|
||
'/../../../etc/passwd',
|
||
'/playlists?x=<script>',
|
||
'/' + 'a'.repeat(8000),
|
||
'/albums/' + encodeURIComponent("μ's"),
|
||
'/lyric#frag'
|
||
]) {
|
||
createHash('sha1').update(r).digest('hex')
|
||
}
|
||
})
|
||
}
|
||
|
||
/* ======================== Build ======================== */
|
||
|
||
async function ensureBuild() {
|
||
const mainJs = path.join(root, 'out', 'main', 'index.js')
|
||
if (fs.existsSync(mainJs) && !args.rebuild) {
|
||
report.ui.notes.push('reuse existing out/ build')
|
||
return
|
||
}
|
||
report.ui.notes.push('running electron-vite build…')
|
||
await new Promise((resolve, reject) => {
|
||
const p = spawn('npx', ['electron-vite', 'build'], {
|
||
cwd: root,
|
||
shell: true,
|
||
stdio: 'inherit'
|
||
})
|
||
p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`build exit ${code}`))))
|
||
})
|
||
}
|
||
|
||
/* ======================== UI helpers ======================== */
|
||
|
||
async function gotoHash(win, route) {
|
||
await win.evaluate((r) => {
|
||
window.location.hash = `#${r}`
|
||
}, route)
|
||
await sleep(180)
|
||
report.ui.navigation.push(`hash:${route}`)
|
||
}
|
||
|
||
async function clickText(win, label) {
|
||
const el = win.locator(`text=${label}`).first()
|
||
if ((await el.count()) === 0) return false
|
||
await el.click({ timeout: 2500 })
|
||
report.ui.navigation.push(label)
|
||
return true
|
||
}
|
||
|
||
async function randomClickables(win, n = 1) {
|
||
for (let i = 0; i < n; i++) {
|
||
const label = await win.evaluate(() => {
|
||
const nodes = [
|
||
...document.querySelectorAll(
|
||
'button, a, [role="button"], input[type="checkbox"], label, .sidebar-item'
|
||
)
|
||
].filter((el) => {
|
||
const s = getComputedStyle(el)
|
||
const r = el.getBoundingClientRect()
|
||
return (
|
||
s.visibility !== 'hidden' &&
|
||
s.display !== 'none' &&
|
||
!el.disabled &&
|
||
r.width > 2 &&
|
||
r.height > 2
|
||
)
|
||
})
|
||
if (!nodes.length) return null
|
||
const el = nodes[Math.floor(Math.random() * nodes.length)]
|
||
el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }))
|
||
return (el.innerText || el.getAttribute('aria-label') || el.tagName || '').slice(0, 48)
|
||
})
|
||
if (label) report.ui.navigation.push(`click:${label}`)
|
||
}
|
||
}
|
||
|
||
/* ======================== B. IPC 压力 ======================== */
|
||
|
||
async function runIpcMonkey(win) {
|
||
const results = await win.evaluate(async () => {
|
||
const out = { calls: 0, errors: [], samples: [] }
|
||
const api = window.api
|
||
if (!api) {
|
||
out.errors.push('window.api missing')
|
||
return out
|
||
}
|
||
|
||
const safe = async (name, fn) => {
|
||
out.calls++
|
||
try {
|
||
const r = await fn()
|
||
out.samples.push({ name, ok: true, preview: JSON.stringify(r)?.slice(0, 80) })
|
||
} catch (e) {
|
||
out.errors.push(`${name}: ${String(e).slice(0, 120)}`)
|
||
out.samples.push({ name, ok: false })
|
||
}
|
||
}
|
||
|
||
// 正常读
|
||
await safe('store.get volume', () => api.store.get('volume'))
|
||
await safe('http.status', () => api.http.status())
|
||
await safe('net.lanIps', () => api.net.lanIps())
|
||
await safe('library.dataVersion', () => api.library.dataVersion())
|
||
await safe('db.query album', () => api.db.query('SELECT COUNT(*) as c FROM album'))
|
||
await safe('db.query music', () => api.db.query('SELECT COUNT(*) as c FROM music'))
|
||
await safe('db.query menu', () => api.db.query('SELECT * FROM menu ORDER BY id DESC LIMIT 20'))
|
||
|
||
// 写读往返（monkey userData）
|
||
const key = `__monkey_${Date.now()}`
|
||
await safe('store.set', () => api.store.set(key, { n: 1, s: '测' }))
|
||
await safe('store.get', () => api.store.get(key))
|
||
await safe('store.delete', () => api.store.delete(key))
|
||
|
||
// 歌单 CRUD 压力
|
||
const mid = 150 + Math.floor(Math.random() * 40)
|
||
await safe('menu upsert', () =>
|
||
api.db.exec('INSERT OR REPLACE INTO menu (id, title, cover, createTime) VALUES (?,?,?,?)', [
|
||
mid,
|
||
`Monkey歌单${mid}`,
|
||
null,
|
||
Date.now()
|
||
])
|
||
)
|
||
await safe('playlist link', () =>
|
||
api.db.exec(
|
||
'INSERT OR IGNORE INTO playlist_music (menuId, musicUId, "order") VALUES (?,?,?)',
|
||
[mid, 'nonexistent-uid-monkey', 0]
|
||
)
|
||
)
|
||
await safe('menu delete', async () => {
|
||
await api.db.exec('DELETE FROM playlist_music WHERE menuId = ?', [mid])
|
||
await api.db.exec('DELETE FROM menu WHERE id = ?', [mid])
|
||
})
|
||
|
||
// 并发风暴
|
||
const storm = []
|
||
for (let i = 0; i < 30; i++) {
|
||
storm.push(api.db.query('SELECT musicUId FROM music LIMIT 5'))
|
||
storm.push(api.store.get('volume'))
|
||
storm.push(api.http.status())
|
||
}
|
||
out.calls += storm.length
|
||
try {
|
||
await Promise.all(storm)
|
||
out.samples.push({ name: 'concurrent x90', ok: true })
|
||
} catch (e) {
|
||
out.errors.push(`concurrent: ${String(e).slice(0, 120)}`)
|
||
}
|
||
|
||
// 故意坏 SQL：期望抛错且进程不崩
|
||
out.calls++
|
||
try {
|
||
await api.db.query('SELECT * FROM not_a_table_monkey')
|
||
out.errors.push('bad sql: expected throw')
|
||
} catch {
|
||
out.samples.push({ name: 'bad sql expected fail', ok: true })
|
||
}
|
||
|
||
// 传歌/同步服务启停连打
|
||
await safe('musicServer.start', () => api.musicServer.start())
|
||
await safe('musicServer.send offline', () => api.musicServer.send('prepare', '[] === false'))
|
||
await safe('musicServer.stop', () => api.musicServer.stop())
|
||
await safe('dataServer.start', () => api.dataServer.start())
|
||
await safe('dataServer.send offline', () =>
|
||
api.dataServer.send('phone2pc', JSON.stringify({ love: [], menu: [], isCover: false }))
|
||
)
|
||
await safe('dataServer.stop', () => api.dataServer.stop())
|
||
|
||
// 快速启停
|
||
for (let i = 0; i < 5; i++) {
|
||
await safe(`music bounce ${i}`, async () => {
|
||
await api.musicServer.start()
|
||
await api.musicServer.stop()
|
||
})
|
||
}
|
||
|
||
return out
|
||
})
|
||
|
||
report.ipc.calls += results.calls || 0
|
||
report.ipc.errors.push(...(results.errors || []))
|
||
report.ipc.samples = (results.samples || []).slice(0, 40)
|
||
}
|
||
|
||
/* ======================== C. 场景流 ======================== */
|
||
|
||
async function runScenarios(win) {
|
||
await scenario('home groups + play attempt', async () => {
|
||
await gotoHash(win, '/')
|
||
await sleep(300)
|
||
for (const g of ["μ's", 'Aqours', 'Liella!', '全部']) {
|
||
await clickText(win, g).catch(() => false)
|
||
await sleep(80)
|
||
}
|
||
await randomClickables(win, 3)
|
||
})
|
||
|
||
await scenario('search hostile queries', async () => {
|
||
await gotoHash(win, '/search')
|
||
const box = win.locator('input[placeholder*="搜索"]').first()
|
||
if ((await box.count()) === 0) return
|
||
for (const q of [
|
||
'μ',
|
||
'Aqours',
|
||
'zzz_not_exist_9x',
|
||
'<script>',
|
||
"' OR 1=1",
|
||
' ',
|
||
'❤️',
|
||
'a'.repeat(200)
|
||
]) {
|
||
await box.fill(q)
|
||
await sleep(120)
|
||
}
|
||
await randomClickables(win, 2)
|
||
await box.fill('')
|
||
})
|
||
|
||
await scenario('playlist create cancel escape', async () => {
|
||
await gotoHash(win, '/playlists')
|
||
await sleep(250)
|
||
const created = await clickText(win, '新建')
|
||
if (created) {
|
||
const input = win.locator('input[placeholder*="歌单"]').first()
|
||
if (await input.count()) {
|
||
await input.fill(`Monkey-${SEED}`)
|
||
await win.keyboard.press('Escape')
|
||
await sleep(100)
|
||
// 再开一次并确认
|
||
await clickText(win, '新建')
|
||
if (await input.count()) {
|
||
await input.fill(`Monkey-OK-${SEED % 1000}`)
|
||
await win.keyboard.press('Enter')
|
||
await sleep(200)
|
||
}
|
||
}
|
||
}
|
||
await randomClickables(win, 2)
|
||
})
|
||
|
||
await scenario('favorites / history churn', async () => {
|
||
await gotoHash(win, '/favorites')
|
||
await sleep(200)
|
||
await randomClickables(win, 2)
|
||
await gotoHash(win, '/history')
|
||
await sleep(200)
|
||
await randomClickables(win, 2)
|
||
})
|
||
|
||
await scenario('transfer checkbox spam', async () => {
|
||
await gotoHash(win, '/transfer')
|
||
await sleep(400)
|
||
// 勾选框连点
|
||
await win.evaluate(() => {
|
||
document.querySelectorAll('input[type="checkbox"]').forEach((el, i) => {
|
||
if (i < 25) el.click()
|
||
})
|
||
})
|
||
await clickText(win, '全选').catch(() => false)
|
||
await clickText(win, '仅推荐').catch(() => false)
|
||
await sleep(150)
|
||
await randomClickables(win, 2)
|
||
})
|
||
|
||
await scenario('sync page connect UI', async () => {
|
||
await gotoHash(win, '/sync')
|
||
await sleep(400)
|
||
await randomClickables(win, 2)
|
||
})
|
||
|
||
await scenario('settings source toggles', async () => {
|
||
await gotoHash(win, '/settings')
|
||
await sleep(300)
|
||
await clickText(win, '本地').catch(() => false)
|
||
await clickText(win, '远程').catch(() => false)
|
||
await clickText(win, '本地').catch(() => false)
|
||
const remote = win.locator('input[placeholder*="http"]').first()
|
||
if (await remote.count()) {
|
||
await remote.fill('http://127.0.0.1:9/')
|
||
await sleep(50)
|
||
await remote.fill('')
|
||
}
|
||
await randomClickables(win, 3)
|
||
})
|
||
|
||
await scenario('lyric overlay open/close', async () => {
|
||
await gotoHash(win, '/')
|
||
await sleep(200)
|
||
// 尝试点播放条区域打开歌词（若有封面/标题）
|
||
await win.evaluate(() => {
|
||
const bar = document.querySelector('footer, [class*="Player"], [class*="player"]')
|
||
if (bar) bar.dispatchEvent(new MouseEvent('click', { bubbles: true }))
|
||
})
|
||
await gotoHash(win, '/lyric')
|
||
await sleep(300)
|
||
await win.keyboard.press('Escape')
|
||
await sleep(100)
|
||
await gotoHash(win, '/')
|
||
})
|
||
|
||
await scenario('hash storm', async () => {
|
||
const routes = [
|
||
'/',
|
||
'/playlists',
|
||
'/favorites',
|
||
'/history',
|
||
'/transfer',
|
||
'/sync',
|
||
'/settings',
|
||
'/search',
|
||
'/albums/not-exist-id'
|
||
]
|
||
for (let i = 0; i < STORM; i++) {
|
||
await gotoHash(win, pick(routes))
|
||
}
|
||
})
|
||
|
||
await scenario('server start storm via pages', async () => {
|
||
for (let i = 0; i < 6; i++) {
|
||
await gotoHash(win, chance(0.5) ? '/transfer' : '/sync')
|
||
await sleep(120)
|
||
await gotoHash(win, '/')
|
||
await sleep(80)
|
||
}
|
||
})
|
||
}
|
||
|
||
/* ======================== D. 混沌循环 ======================== */
|
||
|
||
async function runChaosLoop(win) {
|
||
const sidebar = ['音乐馆', '我喜欢', '歌单', '最近播放', '传歌', '数据同步', '设置']
|
||
const routes = [
|
||
'/',
|
||
'/playlists',
|
||
'/favorites',
|
||
'/history',
|
||
'/transfer',
|
||
'/sync',
|
||
'/settings',
|
||
'/search'
|
||
]
|
||
|
||
for (let i = 0; i < ACTIONS; i++) {
|
||
if (!win) break
|
||
const kind = pick([
|
||
'sidebar',
|
||
'hash',
|
||
'click',
|
||
'dblclick',
|
||
'scroll',
|
||
'keys',
|
||
'search',
|
||
'wheel',
|
||
'resize',
|
||
'burst'
|
||
])
|
||
try {
|
||
if (kind === 'sidebar') {
|
||
await clickText(win, pick(sidebar))
|
||
} else if (kind === 'hash') {
|
||
await gotoHash(win, pick(routes))
|
||
} else if (kind === 'click') {
|
||
await randomClickables(win, 1)
|
||
} else if (kind === 'dblclick') {
|
||
await win.evaluate(() => {
|
||
const nodes = [...document.querySelectorAll('button, img, .apple-card')].filter((el) => {
|
||
const r = el.getBoundingClientRect()
|
||
return r.width > 8 && r.height > 8
|
||
})
|
||
if (!nodes.length) return
|
||
const el = nodes[Math.floor(Math.random() * nodes.length)]
|
||
el.dispatchEvent(
|
||
new MouseEvent('dblclick', { bubbles: true, cancelable: true, view: window })
|
||
)
|
||
})
|
||
} else if (kind === 'scroll') {
|
||
await win.evaluate(() => {
|
||
const el =
|
||
document.querySelector('[class*="overflow"]') ||
|
||
document.scrollingElement ||
|
||
document.body
|
||
el.scrollBy(0, (Math.random() - 0.5) * 800)
|
||
})
|
||
} else if (kind === 'wheel') {
|
||
await win.mouse.wheel(0, (rand() - 0.5) * 1200)
|
||
} else if (kind === 'keys') {
|
||
const combo = pick([
|
||
['Escape'],
|
||
['Tab'],
|
||
['ArrowDown'],
|
||
['ArrowUp'],
|
||
['Enter'],
|
||
['Space'],
|
||
['Control', 'a'],
|
||
['F5']
|
||
])
|
||
for (const k of combo) await win.keyboard.down(k)
|
||
for (const k of [...combo].reverse()) await win.keyboard.up(k)
|
||
} else if (kind === 'search') {
|
||
const box = win.locator('input[placeholder*="搜索"]').first()
|
||
if (await box.count()) {
|
||
await box.fill(pick(['μ', 'Liella', 'xxx', '!', ' ']))
|
||
}
|
||
} else if (kind === 'resize') {
|
||
const [w, h] = pick([
|
||
[1377, 887],
|
||
[1400, 900],
|
||
[1600, 1000],
|
||
[1377, 887]
|
||
])
|
||
await win.setViewportSize({ width: w, height: h }).catch(() => {})
|
||
} else if (kind === 'burst') {
|
||
await randomClickables(win, 5)
|
||
await gotoHash(win, pick(routes))
|
||
}
|
||
report.ui.actionsDone++
|
||
} catch (e) {
|
||
report.ui.pageErrors.push(`chaos#${i} ${kind}: ${String(e).slice(0, 180)}`)
|
||
}
|
||
if (i % 15 === 14) await sleep(80)
|
||
}
|
||
}
|
||
|
||
/* ======================== Launch ======================== */
|
||
|
||
async function runUiMonkey() {
|
||
const { _electron: electron } = await import('playwright')
|
||
const electronPath = require('electron')
|
||
|
||
let app
|
||
try {
|
||
app = await electron.launch({
|
||
executablePath: electronPath,
|
||
args: [root],
|
||
cwd: root,
|
||
env: {
|
||
...process.env,
|
||
ELECTRON_DISABLE_SECURITY_WARNINGS: 'true',
|
||
LLMP_MONKEY: '1'
|
||
},
|
||
timeout: 90000
|
||
})
|
||
} catch (e) {
|
||
report.ui.crashes.push(`launch failed: ${e}`)
|
||
return
|
||
}
|
||
|
||
report.ui.launched = true
|
||
await sleep(1500)
|
||
|
||
const win = await app.firstWindow({ timeout: 60000 }).catch((e) => {
|
||
report.ui.crashes.push(`firstWindow: ${e}`)
|
||
return null
|
||
})
|
||
if (!win) {
|
||
await app.close().catch(() => {})
|
||
return
|
||
}
|
||
|
||
// 原生 confirm / alert
|
||
win.on('dialog', async (dialog) => {
|
||
try {
|
||
if (chance(0.55)) {
|
||
await dialog.accept()
|
||
report.ui.dialogs.accepted++
|
||
} else {
|
||
await dialog.dismiss()
|
||
report.ui.dialogs.dismissed++
|
||
}
|
||
} catch {
|
||
/* ignore */
|
||
}
|
||
})
|
||
|
||
win.on('console', (msg) => {
|
||
if (msg.type() === 'error') report.ui.consoleErrors.push(msg.text())
|
||
})
|
||
win.on('pageerror', (err) => {
|
||
report.ui.pageErrors.push(String(err))
|
||
})
|
||
|
||
await sleep(2200)
|
||
try {
|
||
await win.waitForSelector('text=LoveLiveMusicPlayer', { timeout: 20000 })
|
||
} catch {
|
||
report.ui.notes.push('sidebar title slow; continue')
|
||
}
|
||
|
||
// 顺序：IPC → 场景 → 混沌
|
||
if (COMPLEX) {
|
||
await runIpcMonkey(win).catch((e) => report.ipc.errors.push(String(e)))
|
||
await runScenarios(win)
|
||
}
|
||
await runChaosLoop(win)
|
||
|
||
// 终局健康检查
|
||
try {
|
||
const health = await win.evaluate(async () => {
|
||
const api = window.api
|
||
return {
|
||
hasApi: !!api,
|
||
path: location.hash,
|
||
albumCount: api
|
||
? (await api.db.query('SELECT COUNT(*) as c FROM album'))[0]?.c
|
||
: null,
|
||
musicServerPing: api ? await api.http.status() : null
|
||
}
|
||
})
|
||
report.ui.notes.push(`health: ${JSON.stringify(health)}`)
|
||
} catch (e) {
|
||
report.ui.crashes.push(`health check: ${e}`)
|
||
}
|
||
|
||
try {
|
||
const alive = !!app.process() && !app.process().killed
|
||
if (!alive) report.ui.crashes.push('process dead after monkey')
|
||
await app.close()
|
||
} catch (e) {
|
||
report.ui.crashes.push(`close: ${e}`)
|
||
}
|
||
}
|
||
|
||
function finalize() {
|
||
report.ui.consoleErrors = [...new Set(report.ui.consoleErrors)].slice(0, 50)
|
||
report.ui.pageErrors = [...new Set(report.ui.pageErrors)].slice(0, 50)
|
||
report.ipc.errors = [...new Set(report.ipc.errors)].slice(0, 40)
|
||
|
||
const hardUi =
|
||
report.ui.crashes.length +
|
||
report.ui.pageErrors.filter((e) => !/Timeout|waiting for|Target closed/i.test(e)).length
|
||
const softIpc = report.ipc.errors.filter((e) => !/bad sql|no such table|not_a_table/i.test(e))
|
||
const scenarioFails = report.scenarios.failed.length
|
||
|
||
if (
|
||
report.logic.failed === 0 &&
|
||
report.ui.launched &&
|
||
hardUi === 0 &&
|
||
softIpc.length === 0 &&
|
||
scenarioFails === 0 &&
|
||
report.ui.actionsDone > 0
|
||
) {
|
||
report.verdict = 'PASS'
|
||
} else if (
|
||
report.logic.failed === 0 &&
|
||
report.ui.launched &&
|
||
hardUi === 0 &&
|
||
report.ui.actionsDone > 0
|
||
) {
|
||
report.verdict = 'PASS_WITH_WARNINGS'
|
||
} else if (!report.ui.launched && report.logic.failed === 0) {
|
||
report.verdict = 'LOGIC_PASS_UI_SKIP'
|
||
} else {
|
||
report.verdict = 'FAIL'
|
||
}
|
||
|
||
const outDir = path.join(root, 'monkey-results')
|
||
fs.mkdirSync(outDir, { recursive: true })
|
||
const outFile = path.join(outDir, `monkey-complex-${Date.now()}.json`)
|
||
fs.writeFileSync(outFile, JSON.stringify(report, null, 2), 'utf8')
|
||
fs.writeFileSync(path.join(outDir, 'latest.json'), JSON.stringify(report, null, 2), 'utf8')
|
||
|
||
// 摘要
|
||
const summary = {
|
||
verdict: report.verdict,
|
||
seed: report.seed,
|
||
logic: `${report.logic.passed}/${report.logic.passed + report.logic.failed}`,
|
||
uiActions: report.ui.actionsDone,
|
||
ipcCalls: report.ipc.calls,
|
||
ipcErrors: report.ipc.errors.length,
|
||
scenariosOk: report.scenarios.ran.length,
|
||
scenariosFail: report.scenarios.failed.length,
|
||
crashes: report.ui.crashes.length,
|
||
consoleErrors: report.ui.consoleErrors.length,
|
||
pageErrors: report.ui.pageErrors.length,
|
||
dialogs: report.ui.dialogs,
|
||
outFile
|
||
}
|
||
console.log('\n========== COMPLEX MONKEY SUMMARY ==========')
|
||
console.log(JSON.stringify(summary, null, 2))
|
||
if (report.scenarios.failed.length) {
|
||
console.log('\nScenario failures:', report.scenarios.failed)
|
||
}
|
||
if (softIpc.length) console.log('\nIPC warnings:', softIpc.slice(0, 10))
|
||
if (report.ui.crashes.length) console.log('\nCrashes:', report.ui.crashes)
|
||
console.log(`\nFull report: ${outFile}`)
|
||
}
|
||
|
||
async function main() {
|
||
runLogicMonkey()
|
||
try {
|
||
await ensureBuild()
|
||
await runUiMonkey()
|
||
} catch (e) {
|
||
report.ui.crashes.push(String(e?.stack || e))
|
||
}
|
||
finalize()
|
||
process.exit(report.verdict === 'FAIL' ? 1 : 0)
|
||
}
|
||
|
||
main()
|