@mzzsfy/dsh-bug-perf 0.0.0-stage → 0.2.0

package/test/client-restart.test.mjs

@@ -0,0 +1,182 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+// 客户端半区以模块加载器自注册,测试用最小 window 捕获 factory 后取 __test 纯逻辑
+function loadPlugin({ modules = {} } = {}) {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  const requireImpl = (id) => {
+    if (Object.hasOwn(modules, id)) return modules[id]
+    throw new Error(`module not registered: ${id}`)
+  }
+  return registered.factory(requireImpl)
+}
+
+function fakeTimers() {
+  let now = 0
+  let nextId = 0
+  const pending = new Map()
+  return {
+    now: () => now,
+    setTimeout: (fn, ms) => { const id = ++nextId; pending.set(id, { fn, at: now + ms }); return id },
+    clearTimeout: (id) => { pending.delete(id) },
+    advance(ms) {
+      now += ms
+      for (const [id, timer] of [...pending]) {
+        if (timer.at <= now) {
+          pending.delete(id)
+          timer.fn()
+        }
+      }
+    },
+    pendingCount: () => pending.size,
+  }
+}
+
+function installCoalesce(plugin, { timers, windowMs = 100 } = {}) {
+  class RemoteStream {}
+  RemoteStream.prototype.restart = function restart() { this.restarts = (this.restarts ?? 0) + 1 }
+  const result = plugin.__test.installRestartCoalesce({ RemoteStream, windowMs, timers })
+  return { result, RemoteStream }
+}
+
+// Given 同一实例在合并窗口内连续重启, When 时间推进到窗口结束, Then 只实际重开一次
+test('重启合并_窗口内连发_尾随一次', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const { result, RemoteStream } = installCoalesce(plugin, { timers })
+  assert.equal(result.installed, true)
+  const stream = new RemoteStream()
+  for (let i = 0; i < 5; i++) {
+    stream.restart()
+    timers.advance(10)
+  }
+  assert.equal(stream.restarts, 1)
+  timers.advance(100)
+  assert.equal(stream.restarts, 2)
+  assert.equal(timers.pendingCount(), 0)
+})
+
+// Given 两次重启间隔超过窗口, When 依次调用, Then 各自立即生效, 不被合并
+test('重启合并_窗口外_逐次生效', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const { RemoteStream } = installCoalesce(plugin, { timers })
+  const stream = new RemoteStream()
+  for (let i = 0; i < 3; i++) {
+    stream.restart()
+    timers.advance(150)
+  }
+  assert.equal(stream.restarts, 3)
+})
+
+// Given 两个实例各自连发, When 推进时间, Then 合并状态按实例隔离, 不互相吞掉
+test('重启合并_实例隔离_各自一次', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const { RemoteStream } = installCoalesce(plugin, { timers })
+  const a = new RemoteStream()
+  const b = new RemoteStream()
+  a.restart(); b.restart()
+  timers.advance(10)
+  a.restart(); b.restart()
+  timers.advance(120)
+  assert.equal(a.restarts, 2)
+  assert.equal(b.restarts, 2)
+})
+
+// Given 原型已被本插件包装, When 再次安装, Then 幂等返回未安装且不叠加包装
+test('重启合并_重复安装_幂等', () => {
+  const plugin = loadPlugin()
+  const { result, RemoteStream } = installCoalesce(plugin, { timers: fakeTimers() })
+  assert.equal(result.installed, true)
+  const again = plugin.__test.installRestartCoalesce({ RemoteStream, windowMs: 100, timers: fakeTimers() })
+  assert.equal(again.installed, false)
+  const stream = new RemoteStream()
+  stream.restart()
+  assert.equal(stream.restarts, 1)
+})
+
+// Given 宿主版本没有 RemoteStream.restart, When 安装, Then 跳过且不抛错(跨版本宿主不受影响)
+test('重启合并_结构缺失_跳过不抛', () => {
+  const plugin = loadPlugin()
+  const missing = plugin.__test.installRestartCoalesce({ RemoteStream: undefined, windowMs: 100, timers: fakeTimers() })
+  assert.equal(missing.installed, false)
+  const noRestart = plugin.__test.installRestartCoalesce({ RemoteStream: class {}, windowMs: 100, timers: fakeTimers() })
+  assert.equal(noRestart.installed, false)
+})
+
+// Given 尾随时间触发时实例已释放并抛错, When 定时器到期, Then 错误被吞掉不影响页面
+test('重启合并_释放后触发_不抛', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const { RemoteStream } = installCoalesce(plugin, { timers })
+  const stream = new RemoteStream()
+  stream.restart()
+  Object.defineProperty(stream, 'restarts', { get() { throw new Error('already disposed') }, configurable: true })
+  stream.restart()
+  assert.doesNotThrow(() => timers.advance(120))
+})
+
+// Given 客户端内联默认配置, When 与宿主共享配置对表, Then 两边默认值一致(防漂移)
+test('配置_客户端内联_与宿主同源', async () => {
+  const plugin = loadPlugin()
+  const host = await import('../src/config.mjs')
+  assert.deepEqual(plugin.__test.DEFAULT_CONFIG, host.DEFAULT_CONFIG)
+  assert.deepEqual(plugin.__test.LIMITS, host.LIMITS)
+  assert.deepEqual(plugin.__test.normalizeConfig({}), host.normalizeConfig({}))
+  const raw = { diag: { enabled: true, reportEvery: 0 } }
+  assert.deepEqual(plugin.__test.normalizeConfig(raw), host.normalizeConfig(raw))
+  assert.deepEqual(
+    plugin.__test.normalizeConfig({ diag: { reportEvery: 99999 } }),
+    host.normalizeConfig({ diag: { reportEvery: 99999 } }),
+  )
+})
+
+// Given 远程配置缺失, When 客户端归一化, Then 落在与宿主一致的默认值上
+test('配置_客户端缺失_默认值', () => {
+  const plugin = loadPlugin()
+  const config = plugin.__test.normalizeConfig(undefined)
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.terminalWatchdog.enabled, true)
+})
+
+// Given 宿主模块表没有 gateway 客户端, When 安装合并, Then 记录原因而不是让插件装载失败
+test('重启合并_缺模块_记录原因', () => {
+  const plugin = loadPlugin()
+  const result = plugin.__test.installRestartCoalesceFromRequire({
+    requireImpl: () => { throw new Error('module not registered') },
+    windowMs: 100,
+    timers: fakeTimers(),
+  })
+  assert.equal(result.installed, false)
+  assert.match(result.reason, /module not registered/)
+})
+
+// Given 模块存在, When 经 require 安装, Then 走包装且记录 installed
+test('重启合并_经模块表_安装成功', () => {
+  const plugin = loadPlugin()
+  class RemoteStream {}
+  RemoteStream.prototype.restart = function restart() { this.restarts = (this.restarts ?? 0) + 1 }
+  const result = plugin.__test.installRestartCoalesceFromRequire({
+    requireImpl: (id) => ({ RemoteStream }),
+    windowMs: 100,
+    timers: fakeTimers(),
+  })
+  assert.equal(result.installed, true)
+})
+
+// Given 合并窗口为 0, When 同一 tick 内连发, Then 每次都立即执行(等价关闭合并但保留开关语义)
+test('重启合并_窗口为零_不合并', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const { RemoteStream } = installCoalesce(plugin, { timers, windowMs: 0 })
+  const stream = new RemoteStream()
+  stream.restart()
+  stream.restart()
+  assert.equal(stream.restarts, 2)
+})

package/test/client-settings.test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+function loadPlugin({ modules = {} } = {}) {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  const requireImpl = (id) => {
+    if (Object.hasOwn(modules, id)) return modules[id]
+    throw new Error(`module not registered: ${id}`)
+  }
+  return registered.factory(requireImpl)
+}
+
+const reactStub = {
+  createElement: (type, props, ...children) => ({ type, props, children }),
+  useState: () => [undefined, () => {}],
+  useEffect: () => {},
+}
+
+// Given React 与 slots 就绪, When 注册设置 UI, Then 两个官方插槽都登记且 key 正确
+test('设置UI_注册官方插槽', () => {
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  const registrations = []
+  const injected = []
+  const styleEffects = []
+  const scope = {
+    slots: {
+      inject: (name, callback) => { injected.push(name); callback() },
+      register: (options, component) => registrations.push({ options, component }),
+    },
+    effect: (factory) => { styleEffects.push(factory) },
+  }
+  const ctx = { inject: (services, callback) => { if (services.includes('slots')) callback(scope) } }
+  plugin.__test.registerSettingsUi(ctx)
+  assert.deepEqual(injected.sort(), ['plugins.bundle.config', 'settings.plugin.item'])
+  const byName = Object.fromEntries(registrations.map((entry) => [entry.options.name, entry.options]))
+  assert.equal(byName['settings.plugin.item'].key, 'bug-perf')
+  assert.equal(byName['plugins.bundle.config'].key, '@mzzsfy/dsh-bug-perf')
+  assert.equal(styleEffects.length, 1)
+})
+
+// Given 无 React 或 slots, When 注册, Then 静默跳过,不影响其它补丁
+test('设置UI_缺依赖_静默跳过', () => {
+  const noReact = loadPlugin()
+  let called = false
+  noReact.__test.registerSettingsUi({ inject: () => { called = true } })
+  assert.equal(called, false)
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  assert.doesNotThrow(() => plugin.__test.registerSettingsUi({}))
+})
+
+// Given 设置节定义, When 检查字段, Then 各节与共享配置的键一致
+test('设置UI_节字段与配置同源', () => {
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  const keys = plugin.__test.UI_SECTIONS.map((section) => section.key)
+  assert.deepEqual(keys, Object.keys(plugin.__test.DEFAULT_CONFIG))
+  for (const section of plugin.__test.UI_SECTIONS) {
+    for (const field of section.fields) {
+      assert.equal(typeof plugin.__test.DEFAULT_CONFIG[section.key][field.name], 'number')
+    }
+  }
+})
+
+// Given 客户端注入设置样式, When 检查注入契约, Then data-plugin 与样式创建点数一致且开关选择器锚定 checkbox
+test('设置UI_样式注入契约', () => {
+  const creates = (source.match(/createElement\('style'\)/g) ?? []).length
+  const markers = (source.match(/style\.setAttribute\('data-plugin'/g) ?? []).length
+  assert.equal(creates, 2)
+  assert.equal(markers, creates)
+  assert.match(source, /input\[type="checkbox"\]:checked \+ \.bp-switch__track/)
+  assert.match(source, /input\[type="checkbox"\]:focus-visible \+ \.bp-switch__track/)
+})

package/test/client-stuck.test.mjs

@@ -0,0 +1,350 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+function loadPlugin() {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  return registered.factory(() => { throw new Error('no modules') })
+}
+
+function fakeClock() {
+  let now = 0
+  let nextId = 0
+  const intervals = new Map()
+  const fireDue = () => {
+    for (const [id, timer] of [...intervals]) {
+      if (timer.at <= now) {
+        timer.at = now + timer.every
+        timer.fn()
+      }
+    }
+  }
+  return {
+    now: () => now,
+    setInterval: (fn, ms) => { const id = ++nextId; intervals.set(id, { fn, every: ms, at: now + ms }); return id },
+    clearInterval: (id) => { intervals.delete(id) },
+    advance(ms) {
+      const target = now + ms
+      while (true) {
+        const due = [...intervals.values()].map((timer) => timer.at).filter((at) => at <= target)
+        if (due.length === 0) break
+        now = Math.min(...due)
+        fireDue()
+      }
+      now = target
+    },
+    intervalCount: () => intervals.size,
+  }
+}
+
+function fakeNode(tag) {
+  const node = {
+    tag,
+    attrs: {},
+    children: [],
+    listeners: {},
+    textContent: '',
+    className: '',
+    type: '',
+    style: {},
+    setAttribute(key, value) { node.attrs[key] = String(value) },
+    appendChild(child) { node.children.push(child); child.parent = node; return child },
+    remove() { const parent = node.parent; if (parent !== undefined) parent.children = parent.children.filter((item) => item !== node) },
+    addEventListener(type, fn) { (node.listeners[type] ??= []).push(fn) },
+    click() { for (const fn of node.listeners.click ?? []) fn({}) },
+    get childElementCount() { return node.children.length },
+    hasAttribute(name) { return node.attrs[name] !== undefined },
+    getAttribute(name) { return node.attrs[name] ?? null },
+    closest(selector) {
+      const attribute = selector.startsWith('[') && selector.endsWith(']') ? selector.slice(1, -1) : null
+      if (attribute === null) return null
+      let current = node
+      while (current !== undefined) {
+        if (current.attrs?.[attribute] !== undefined) return current
+        current = current.parent
+      }
+      return null
+    },
+    querySelectorAll(selector) {
+      const attribute = selector.startsWith('[') && selector.endsWith(']') ? selector.slice(1, -1) : null
+      const found = []
+      const walk = (current) => {
+        for (const child of current.children ?? []) {
+          if (attribute !== null && child.attrs?.[attribute] !== undefined) found.push(child)
+          walk(child)
+        }
+      }
+      walk(node)
+      return found
+    },
+    querySelector(selector) {
+      if (!selector.startsWith('[') || !selector.endsWith(']')) return null
+      const attribute = selector.slice(1, -1)
+      const walk = (current) => {
+        for (const child of current.children ?? []) {
+          if (child.attrs?.[attribute] !== undefined) return child
+          const found = walk(child)
+          if (found !== null) return found
+        }
+        return null
+      }
+      return walk(node)
+    },
+    allText() { return node.textContent + node.children.map((child) => child.allText()).join('') },
+  }
+  return node
+}
+
+const HINT_TEXT = '载入历史…'
+
+function fakePage({ loading = true, hasFlow = true, messages = false } = {}) {
+  const head = fakeNode('head')
+  const body = fakeNode('body')
+  const flow = fakeNode('div')
+  const hint = fakeNode('div')
+  hint.textContent = HINT_TEXT
+  const message = fakeNode('div')
+  message.attrs['data-chat-flow-key'] = 'turn-1'
+  message.textContent = '为什么一直显示载入历史…'
+  const setFlow = (value) => { flow.children = value ? [hint] : (messages ? [message] : []) }
+  setFlow(loading)
+  const doc = {
+    head,
+    body,
+    querySelector(selector) {
+      if (selector === '[data-chat-flow]') return hasFlow ? flow : null
+      if (selector.startsWith('style[data-plugin=')) {
+        const plugin = selector.match(/data-plugin="([^"]+)"/)?.[1]
+        return head.children.find((node) => node.tag === 'style' && node.attrs['data-plugin'] === plugin) ?? null
+      }
+      return null
+    },
+    createElement(tag) { return fakeNode(tag) },
+    getElementById(id) { return [...body.children, ...head.children].find((node) => node.attrs.id === id) ?? null },
+  }
+  const reloads = { count: 0 }
+  const win = {
+    document: doc,
+    location: { reload() { reloads.count += 1 } },
+  }
+  return { doc, win, flow, hint, reloads, setLoading: (value) => setFlow(value) }
+}
+
+const OPTIONS = { checkMs: 2000, stallMs: 8000, reconnect: true, maxReconnectAttempts: 3, reconnectIntervalMs: 4000 }
+
+function fakeConnection() {
+  const calls = []
+  return {
+    calls,
+    reconnect() { calls.push(true) },
+  }
+}
+
+function install({ options = {}, page = fakePage(), connection = fakeConnection() } = {}) {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const result = plugin.__test.installStuckSession({ win: page.win, options: { ...OPTIONS, ...options }, clock, connection })
+  return { plugin, clock, result, page, connection }
+}
+
+const noticeOf = (page) => page.doc.getElementById('dsh-bug-perf-stuck')
+
+// Given 会话停在加载态, When 未到停滞阈值, Then 不请求重连
+test('停滞_未到阈值_不重连', () => {
+  const { clock, connection } = install()
+  clock.advance(2000 * 3)
+  assert.equal(connection.calls.length, 0)
+})
+
+// Given 会话停滞超过阈值, When 轮询, Then 请求宿主重建连接一次
+test('停滞_超过阈值_请求重连', () => {
+  const { clock, connection } = install()
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+})
+
+// Given 刚请求过重连, When 仍在重连间隔内, Then 不重复请求
+test('停滞_重连间隔内_不重复', () => {
+  const { clock, connection } = install()
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+  clock.advance(2000)
+  assert.equal(connection.calls.length, 1)
+  clock.advance(2000 * 2)
+  assert.equal(connection.calls.length, 2)
+})
+
+// Given 多次重连仍未恢复, When 用尽重连次数, Then 停止重连并显示提示
+test('停滞_用尽次数_显示提示', () => {
+  const { clock, page, connection } = install()
+  clock.advance(2000 * 40)
+  assert.equal(connection.calls.length, 3)
+  assert.ok(noticeOf(page) !== null)
+})
+
+// Given 提示已出现, When 会话恢复, Then 提示移除且重连计数清零
+test('停滞_恢复_重置并隐藏', () => {
+  const { clock, page, connection } = install()
+  clock.advance(2000 * 40)
+  assert.ok(noticeOf(page) !== null)
+  page.setLoading(false)
+  clock.advance(2000)
+  assert.equal(noticeOf(page), null)
+  page.setLoading(true)
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 4)
+})
+
+// Given 页面正常但主线程被长时间占满, When 阻塞持续超过阈值, Then 同样请求重连
+test('停滞_主线程阻塞_请求重连', () => {
+  const page = fakePage({ loading: false, messages: true })
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const connection = fakeConnection()
+  const diag = {}
+  plugin.__test.installStuckSession({ win: page.win, options: OPTIONS, clock, connection, diag })
+  clock.advance(2000)
+  diag.blockedAt = clock.now()
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+})
+
+// Given 没有 connection 服务, When 会话停滞, Then 不重连,直接显示提示
+test('停滞_无连接服务_直接提示', () => {
+  const page = fakePage()
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  plugin.__test.installStuckSession({ win: page.win, options: OPTIONS, clock, connection: undefined })
+  clock.advance(2000 * 6)
+  assert.ok(noticeOf(page) !== null)
+})
+
+// Given 宿主拒绝重连调用, When 会话停滞, Then 不抛出,退化为提示
+test('停滞_重连抛错_退化为提示', () => {
+  const page = fakePage()
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const connection = { reconnect() { throw new Error('boom') } }
+  plugin.__test.installStuckSession({ win: page.win, options: OPTIONS, clock, connection })
+  clock.advance(2000 * 6)
+  assert.ok(noticeOf(page) !== null)
+})
+
+// Given 配置关闭主动重连, When 会话停滞, Then 不调用 reconnect,只显示提示
+test('停滞_关闭重连_只提示', () => {
+  const { clock, page, connection } = install({ options: { reconnect: false } })
+  clock.advance(2000 * 40)
+  assert.equal(connection.calls.length, 0)
+  assert.ok(noticeOf(page) !== null)
+})
+
+// Given 普通会话已有消息节点, When 正文里出现加载文案的字样, Then 不判定停滞
+test('停滞_正文含文案_不触发', () => {
+  const page = fakePage({ loading: false, messages: true })
+  const { clock, connection } = install({ page })
+  clock.advance(2000 * 60)
+  assert.equal(connection.calls.length, 0)
+  assert.equal(noticeOf(page), null)
+})
+
+// Given 加载态里残留的只是分组行, When 持续超过阈值, Then 仍判定停滞(分组行不算有效消息)
+test('停滞_仅分组行_仍触发', () => {
+  const page = fakePage()
+  const group = fakeNode('div')
+  group.attrs['data-chat-flow-key'] = 'group-1'
+  group.attrs['data-chat-group-key'] = 'group-1'
+  group.textContent = '第 1 轮'
+  page.flow.appendChild(group)
+  const { clock, connection } = install({ page })
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+})
+
+// Given 加载态里残留的是隐藏行或空行, When 持续超过阈值, Then 仍判定停滞
+test('停滞_隐藏或空行_仍触发', () => {
+  const page = fakePage()
+  const hidden = fakeNode('div')
+  hidden.attrs['data-chat-flow-key'] = 'turn-hidden'
+  hidden.attrs.hidden = 'hidden'
+  hidden.textContent = '旧消息'
+  const empty = fakeNode('div')
+  empty.attrs['data-chat-flow-key'] = 'turn-empty'
+  page.flow.appendChild(hidden)
+  page.flow.appendChild(empty)
+  const { clock, connection } = install({ page })
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+})
+
+// Given 残留行在隐藏容器里, When 持续超过阈值, Then 仍判定停滞(隐藏子树不算有效消息)
+test('停滞_隐藏祖先内的行_仍触发', () => {
+  const page = fakePage()
+  const wrapper = fakeNode('div')
+  wrapper.attrs.hidden = 'hidden'
+  const row = fakeNode('div')
+  row.attrs['data-chat-flow-key'] = 'turn-collapsed'
+  row.textContent = '折叠起来的旧消息'
+  wrapper.appendChild(row)
+  page.flow.appendChild(wrapper)
+  const { clock, connection } = install({ page })
+  clock.advance(2000 * 5)
+  assert.equal(connection.calls.length, 1)
+})
+
+// Given 非会话视图(没有 chat 容器), When 长时间无加载文案, Then 不插入提示、不重连
+test('停滞_无会话视图_不触发', () => {
+  const page = fakePage({ hasFlow: false })
+  const { clock, connection } = install({ page })
+  clock.advance(2000 * 60)
+  assert.equal(noticeOf(page), null)
+  assert.equal(connection.calls.length, 0)
+})
+
+// Given 补丁已安装, When 再次安装(HMR 重放), Then 拒绝重复安装,不叠加定时器
+test('停滞_重复安装_幂等', () => {
+  const page = fakePage()
+  const { plugin, clock } = install({ page })
+  const second = plugin.__test.installStuckSession({ win: page.win, options: OPTIONS, clock, connection: fakeConnection() })
+  assert.equal(second.installed, false)
+  assert.equal(second.reason, 'already installed')
+  clock.advance(2000 * 5)
+  const notices = page.doc.body.children.filter((node) => node.attrs.id === 'dsh-bug-perf-stuck')
+  assert.equal(notices.length, 0)
+  const styles = page.doc.head.children.filter((node) => node.tag === 'style')
+  assert.equal(styles.length, 1)
+})
+
+// Given 提示重复轮询, When 页面渲染多次, Then 提示节点只有一个(幂等)
+test('停滞_重复轮询_提示幂等', () => {
+  const page = fakePage()
+  const { clock } = install({ page, options: { reconnect: false } })
+  clock.advance(2000 * 12)
+  clock.advance(2000 * 3)
+  const notices = page.doc.body.children.filter((node) => node.attrs.id === 'dsh-bug-perf-stuck')
+  assert.equal(notices.length, 1)
+})
+
+// Given 样式注入, When 安装补丁, Then style 节点带 data-plugin 标记
+test('停滞_样式注入_带插件标记', () => {
+  const { page } = install()
+  const styles = page.doc.head.children.filter((node) => node.tag === 'style')
+  assert.equal(styles.length, 1)
+  assert.equal(styles[0].attrs['data-plugin'], '@mzzsfy/dsh-bug-perf')
+})
+
+// Given 宿主重建删掉了本插件样式, When 再次安装, Then 样式重新注入且不叠加定时器
+test('停滞_样式被删后重装_重新注入', () => {
+  const page = fakePage()
+  const { plugin, clock } = install({ page })
+  page.doc.head.children = []
+  const second = plugin.__test.installStuckSession({ win: page.win, options: OPTIONS, clock, connection: fakeConnection() })
+  assert.equal(second.installed, false)
+  assert.equal(second.reason, 'already installed')
+  const styles = page.doc.head.children.filter((node) => node.tag === 'style')
+  assert.equal(styles.length, 1)
+  assert.equal(styles[0].attrs['data-plugin'], '@mzzsfy/dsh-bug-perf')
+})