yaoyao/desktop/lifecycle.test.mjs

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { mkdtemp, readFile, rm, mkdir } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join, resolve } from 'node:path'
import { createServer } from 'node:net'
import { spawn } from 'node:child_process'
import { _electron as electron } from '@playwright/test'
import { localJSON, DesktopServiceManager } from './service-manager.mjs'

const root = resolve(import.meta.dirname, '..')
async function freePort() {
  const server = createServer(); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
  const port = server.address().port; await new Promise(resolve => server.close(resolve));return port
}
async function until(read, accept, timeout = 30000) {
  const end = Date.now() + timeout;let value
  while (Date.now() < end) {
    try { value = await read(); if (accept(value)) return value } catch {}
    await new Promise(resolve => setTimeout(resolve, 100))
  }
  throw new Error('等待验收状态超时')
}

test('real desktop launches its bundled service, survives window close and recovers its own crashed child', { timeout: 90000 }, async () => {
  const home = await mkdtemp(join(tmpdir(), 'yaoyao-desktop-e2e-'))
  const port = await freePort(), upstreamPort = await freePort()
  const upstream = spawn(process.execPath, [join(root, 'tests/fixtures/fake-hermes.mjs')], {
    cwd: root, env: { ...process.env, FAKE_HERMES_PORT: String(upstreamPort), FAKE_HERMES_LOCAL_AUTH: '1' }, stdio: 'ignore',
  })
  let desktop
  let servicePID
  try {
    await until(() => localJSON(`http://127.0.0.1:${upstreamPort}/api/status`), Boolean)
    desktop = await electron.launch({ ...(process.env.DESKTOP_TEST_EXECUTABLE ? { executablePath: process.env.DESKTOP_TEST_EXECUTABLE } : {}),
      args: process.env.DESKTOP_TEST_EXECUTABLE ? [] : [root], cwd: root, env: { ...process.env,
      HERMES_YAOYAO_DESKTOP_TEST_HOME: home, HERMES_YAOYAO_DESKTOP_PORT: String(port),
      HERMES_YAOYAO_UPSTREAM: `http://127.0.0.1:${upstreamPort}` }, timeout: 30000 })
    desktop.process().stderr.on('data', b => { if (process.env.DESKTOP_TEST_LOGS) process.stderr.write(b) })
    const page = await desktop.firstWindow()
    await page.waitForURL(`http://127.0.0.1:${port}/**`, { timeout: 30000 })
    const owner = await until(async () => JSON.parse(await readFile(join(home, 'service-instance.json'), 'utf8')), r => r.url)
    servicePID = owner.pid
    const identity = await localJSON(`http://127.0.0.1:${port}/desktop/service`, { 'x-yaoyao-desktop-token': owner.token })
    assert.equal(identity.pid, owner.pid);assert.equal(identity.desktopOwned, true)
    assert.equal(identity.token, undefined)
    assert.ok((await localJSON(`http://127.0.0.1:${port}/healthz`)).ok)
    const denied = await page.evaluate(async () => {
      try { await window.yaoyaoDesktop.retry();return false } catch { return true }
    })
    assert.equal(denied, true, 'the web app must not have the boot screen native control privilege')
    await desktop.evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows()[0].close())
    assert.equal(await desktop.evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows()[0].isVisible()), false)
    assert.ok((await localJSON(`http://127.0.0.1:${port}/healthz`)).ok)
    await desktop.evaluate(({ app }) => app.emit('activate'))
    assert.equal(await desktop.evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows()[0].isVisible()), true)
    await mkdir(join(root, 'test-results/desktop'), { recursive: true })
    await page.screenshot({ path: join(root, 'test-results/desktop/first-launch.png') })
    process.kill(owner.pid, 'SIGKILL')
    const replacement = await until(async () => JSON.parse(await readFile(join(home, 'service-instance.json'), 'utf8')), r => r.pid !== owner.pid && r.url)
    servicePID = replacement.pid
    await until(() => localJSON(`http://127.0.0.1:${port}/healthz`), r => r.ok)
    assert.notEqual(replacement.instanceId, owner.instanceId)
    const external = new DesktopServiceManager({ home, port, fork: () => { throw new Error('must not fork a second service') } })
    assert.equal((await external.start()).external, true)
    await external.stop()
    assert.ok((await localJSON(`http://127.0.0.1:${port}/healthz`)).ok, 'a connected client must not stop the owned service')
    await desktop.close();desktop = null
    await until(async () => { try { process.kill(replacement.pid, 0);return false } catch { return true } }, Boolean, 10000)
  } finally {
    await desktop?.close().catch(() => {})
    if (servicePID) { try { process.kill(servicePID, 'SIGTERM') } catch {} }
    upstream.kill('SIGTERM')
    await rm(home, { recursive: true, force: true })
  }
})