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

package/test/client-diag.test.mjs

@@ -0,0 +1,165 @@
+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()
+  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)
+        for (const timer of intervals.values()) {
+          if (timer.at <= now) {
+            timer.at = now + timer.every
+            timer.fn()
+          }
+        }
+      }
+      now = target
+    },
+    intervalCount: () => intervals.size,
+  }
+}
+
+function fakeWindow(clock) {
+  const fetchCalls = []
+  const pendingProbes = []
+  const win = {
+    location: { pathname: '/chat' },
+    performance: { memory: { usedJSHeapSize: 64 * 1024 * 1024 } },
+    document: { querySelectorAll: () => ({ length: 42 }) },
+    fetch: (url, options) => {
+      fetchCalls.push({ url, options })
+      return Promise.resolve({ ok: true })
+    },
+    setTimeout: (fn) => { pendingProbes.push({ fn, startedAt: clock.now() }); return pendingProbes.length },
+    addEventListener: () => {},
+  }
+  return { win, fetchCalls, pendingProbes }
+}
+
+// Given 默认关闭, When 采样运行五分钟, Then 不发任何请求, 采样与阻塞探测仍工作
+test('诊断_默认关闭_只采样不上报', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls, pendingProbes } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  const reporting = plugin.__test.startDiagReporting({
+    win,
+    clock,
+    diag,
+    options: { enabled: false, reportEvery: 12 },
+  })
+  clock.advance(5 * 60 * 1000)
+  assert.equal(reporting.enabled, false)
+  assert.equal(diag.enabled, false)
+  assert.equal(fetchCalls.length, 0)
+  assert.ok(diag.samples.length >= 60)
+  clock.advance(plugin.__test.DIAG_PROBE_MS)
+  const probe = pendingProbes.shift()
+  assert.equal(typeof probe?.fn, 'function')
+  clock.advance(plugin.__test.DIAG_BLOCK_MS + 1)
+  probe.fn()
+  assert.equal(typeof diag.blockedAt, 'number')
+  assert.ok(diag.blockedMs >= plugin.__test.DIAG_BLOCK_MS)
+})
+
+// Given 开启, When 推进一个上报周期, Then 恰好一次请求且 payload 字段完整
+test('诊断_开启_按周期上报', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  const reporting = plugin.__test.startDiagReporting({ win, clock, diag, options: { enabled: true, reportEvery: 12 } })
+  assert.equal(reporting.enabled, true)
+  assert.equal(diag.enabled, true)
+  clock.advance(12 * plugin.__test.DIAG_SAMPLE_MS - 1)
+  assert.equal(fetchCalls.length, 0)
+  clock.advance(1)
+  assert.equal(fetchCalls.length, 1)
+  const { url, options } = fetchCalls[0]
+  assert.ok(url.startsWith('/api/dsh-bug-perf/diag?d='))
+  assert.equal(options.keepalive, true)
+  const payload = JSON.parse(decodeURIComponent(url.slice(url.indexOf('?d=') + 3)))
+  assert.equal(typeof payload.at, 'number')
+  assert.equal(payload.path, '/chat')
+  assert.equal(typeof payload.totals.opened, 'number')
+  assert.ok(Array.isArray(payload.last))
+  assert.ok(Array.isArray(payload.longTasks))
+  assert.ok(Array.isArray(payload.errors))
+  assert.equal('blockedMs' in payload, true)
+  assert.ok(payload.last.length > 0)
+})
+
+// Given reportEvery 改小, When 推进两个周期, Then 上报次数随周期增加
+test('诊断_上报间隔_随配置变化', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  plugin.__test.startDiagReporting({ win, clock, diag, options: { enabled: true, reportEvery: 2 } })
+  clock.advance(2 * plugin.__test.DIAG_SAMPLE_MS)
+  assert.equal(fetchCalls.length, 1)
+  clock.advance(2 * plugin.__test.DIAG_SAMPLE_MS)
+  assert.equal(fetchCalls.length, 2)
+})
+
+// Given fetch 缺失或抛错, When 到达上报点, Then 静默跳过且不抛
+test('诊断_上报失败_静默', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const missing = fakeWindow(clock)
+  delete missing.win.fetch
+  const missingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: missing.win, clock, diag: missingDiag, doc: missing.win.document })
+  plugin.__test.startDiagReporting({ win: missing.win, clock, diag: missingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+
+  const throwing = fakeWindow(clock)
+  throwing.win.fetch = () => { throw new Error('fetch boom') }
+  const throwingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: throwing.win, clock, diag: throwingDiag, doc: throwing.win.document })
+  plugin.__test.startDiagReporting({ win: throwing.win, clock, diag: throwingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+})
+
+// Given fetch 返回拒绝或非 2xx, When 到达上报点, Then 不产生未处理异常
+test('诊断_上报异步失败_静默', async () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const rejecting = fakeWindow(clock)
+  rejecting.win.fetch = () => Promise.reject(new Error('fetch rejected'))
+  const rejectingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: rejecting.win, clock, diag: rejectingDiag, doc: rejecting.win.document })
+  plugin.__test.startDiagReporting({ win: rejecting.win, clock, diag: rejectingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+  await Promise.resolve()
+
+  const notOk = fakeWindow(clock)
+  notOk.win.fetch = () => Promise.resolve({ ok: false })
+  const notOkDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: notOk.win, clock, diag: notOkDiag, doc: notOk.win.document })
+  plugin.__test.startDiagReporting({ win: notOk.win, clock, diag: notOkDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+  await Promise.resolve()
+})

package/test/client-jobs.test.mjs

@@ -0,0 +1,220 @@
+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 fakeJobs() {
+  const watched = []
+  const released = []
+  return {
+    watched,
+    released,
+    watchRows(sessionId) {
+      watched.push(sessionId)
+      return () => released.push(sessionId)
+    },
+  }
+}
+
+function fakeDoc() {
+  const listeners = new Map()
+  return {
+    addEventListener(type, listener) { listeners.set(type, listener) },
+    removeEventListener(type) { listeners.delete(type) },
+    clickOn(sessionId) {
+      const target = { closest: (selector) => (selector === '[data-row-key]' ? { getAttribute: () => `session:${sessionId}` } : null) }
+      listeners.get('click')?.({ target })
+    },
+    clickOnBlank() {
+      listeners.get('click')?.({ target: { closest: () => null } })
+    },
+  }
+}
+
+const fakeSessions = (summaries) => {
+  const snapshot = { byId: Object.fromEntries(summaries.map((item) => [item.sessionId, item])) }
+  return { list: { getSnapshot: () => snapshot } }
+}
+
+// s1..s9 是主会话, c1..c3 是 s1 的子 agent 会话
+const SESSIONS = fakeSessions([
+  { sessionId: 's1' },
+  { sessionId: 'c1', origin: 'subagent', parentSessionId: 's1' },
+  { sessionId: 'c2', origin: 'subagent', parentSessionId: 's1' },
+  { sessionId: 'c3', origin: 'subagent', parentSessionId: 's1' },
+  { sessionId: 's2' },
+  { sessionId: 's3' },
+  { sessionId: 's4' },
+  { sessionId: 's5' },
+  { sessionId: 's6' },
+])
+
+const install = ({ jobs = fakeJobs(), sessions = SESSIONS, doc = fakeDoc(), options = {} } = {}) => {
+  const plugin = loadPlugin()
+  const result = plugin.__test.installJobStreamLimit({
+    jobs,
+    sessionsOf: () => sessions,
+    doc,
+    options: { enabled: true, base: 3, max: 5, ...options },
+  })
+  return { plugin, jobs, doc, result }
+}
+
+// Given 主会话数量未到默认窗口, When 列表逐行订阅, Then 都建立流
+test('任务流_主会话_窗口内放行', () => {
+  const { jobs, result } = install()
+  for (const id of ['s1', 's2', 's3']) jobs.watchRows(id)
+  assert.deepEqual(jobs.watched, ['s1', 's2', 's3'])
+  assert.equal(result.state.main, 3)
+  assert.equal(result.state.rejected, 0)
+})
+
+// Given 默认窗口已满, When 第 4 个主会话订阅, Then 拒绝且不建流
+test('任务流_主会话_超出窗口拒绝', () => {
+  const { jobs, result } = install()
+  for (const id of ['s1', 's2', 's3', 's4']) jobs.watchRows(id)
+  assert.deepEqual(jobs.watched, ['s1', 's2', 's3'])
+  assert.equal(result.state.rejected, 1)
+})
+
+// Given 默认窗口还有空位, When 子 agent 会话自动订阅, Then 不占用窗口
+test('任务流_子会话_不占窗口', () => {
+  const { jobs, result } = install()
+  jobs.watchRows('c1')
+  jobs.watchRows('s1')
+  jobs.watchRows('s2')
+  jobs.watchRows('s3')
+  assert.deepEqual(jobs.watched, ['s1', 's2', 's3'])
+  assert.equal(result.state.subagent, 0)
+  assert.equal(result.state.rejected, 1)
+})
+
+// Given 点击子 agent 会话, When 窗口已满, Then 仍然为它建立流
+test('任务流_点击子会话_放行', () => {
+  const { jobs, doc, result } = install()
+  for (const id of ['s1', 's2', 's3']) jobs.watchRows(id)
+  doc.clickOn('c1')
+  assert.ok(jobs.watched.includes('c1'))
+  assert.equal(result.state.subagent, 1)
+  assert.equal(result.state.clicked, 1)
+})
+
+// Given 点击的主会话不在窗口内, When 点击, Then 同样放行
+test('任务流_点击主会话_放行', () => {
+  const { jobs, doc } = install()
+  for (const id of ['s1', 's2', 's3']) jobs.watchRows(id)
+  doc.clickOn('s6')
+  assert.ok(jobs.watched.includes('s6'))
+})
+
+// Given 总数已到上限, When 再点击一个会话, Then 淘汰最老的一条, 总数不变
+test('任务流_达到上限_淘汰最老', () => {
+  const { jobs, doc, result } = install()
+  for (const id of ['s1', 's2', 's3']) jobs.watchRows(id)
+  doc.clickOn('c1')
+  doc.clickOn('c2')
+  assert.equal(result.state.main + result.state.subagent, 5)
+  const watchedBefore = jobs.watched.length
+  doc.clickOn('c3')
+  assert.equal(jobs.watched.length, watchedBefore + 1)
+  assert.deepEqual(jobs.released, ['s1'])
+  assert.equal(result.state.evicted, 1)
+  assert.equal(result.state.main + result.state.subagent, 5)
+})
+
+// Given 点击的行已经在窗口内, When 点击, Then 不重复建流, 只标记
+test('任务流_点击已在窗口_不重复建流', () => {
+  const { jobs, doc, result } = install()
+  jobs.watchRows('s1')
+  const before = jobs.watched.length
+  doc.clickOn('s1')
+  assert.equal(jobs.watched.length, before)
+  assert.equal(result.state.clicked, 0)
+})
+
+// Given 点击了非会话行, When 触发点击, Then 忽略
+test('任务流_点击非会话行_忽略', () => {
+  const { jobs, doc } = install()
+  doc.clickOnBlank()
+  assert.deepEqual(jobs.watched, [])
+})
+
+// Given 行组件卸载, When 调用释放, Then 额度回收, 新的主会话可以进入窗口
+test('任务流_释放后_额度回收', () => {
+  const { jobs, result } = install()
+  const release = jobs.watchRows('s1')
+  jobs.watchRows('s2')
+  jobs.watchRows('s3')
+  jobs.watchRows('s4')
+  assert.equal(result.state.rejected, 1)
+  release()
+  jobs.watchRows('s4')
+  assert.deepEqual(jobs.watched, ['s1', 's2', 's3', 's4'])
+  assert.equal(result.state.main, 3)
+})
+
+// Given 同一行重复释放, When 调用两次, Then 只扣一次
+test('任务流_重复释放_只扣一次', () => {
+  const { jobs, result } = install()
+  const release = jobs.watchRows('s1')
+  release()
+  release()
+  assert.equal(result.state.main, 0)
+  assert.deepEqual(jobs.released, ['s1'])
+})
+
+// Given 包装已安装, When 再次安装, Then 幂等
+test('任务流_重复安装_幂等', () => {
+  const { jobs, plugin } = install()
+  const second = plugin.__test.installJobStreamLimit({ jobs, sessionsOf: () => SESSIONS, doc: fakeDoc(), options: { enabled: true, base: 3, max: 5 } })
+  assert.equal(second.installed, false)
+  assert.equal(second.reason, 'already installed')
+})
+
+// Given 宿主没有 jobs 服务, When 安装, Then 跳过并记录原因
+test('任务流_服务缺失_跳过', () => {
+  const plugin = loadPlugin()
+  const result = plugin.__test.installJobStreamLimit({ jobs: undefined, sessionsOf: () => SESSIONS, doc: fakeDoc(), options: { enabled: true, base: 3, max: 5 } })
+  assert.equal(result.installed, false)
+  assert.equal(result.reason, 'jobs unavailable')
+})
+
+// Given 会话摘要尚未就绪, When 订阅, Then 按主会话处理, 不误判为子会话
+test('任务流_摘要缺失_按主会话处理', () => {
+  const { jobs, result } = install({ sessions: null })
+  jobs.watchRows('s1')
+  jobs.watchRows('s2')
+  jobs.watchRows('c1')
+  jobs.watchRows('s4')
+  assert.deepEqual(jobs.watched, ['s1', 's2', 'c1'])
+  assert.equal(result.state.rejected, 1)
+})
+
+// Given 子会话已被点击放行, When 该会话从摘要里变为普通会话, Then 不重复建流
+test('任务流_重复订阅同一会话_只建一次', () => {
+  const { jobs, doc } = install()
+  doc.clickOn('c1')
+  jobs.watchRows('c1')
+  jobs.watchRows('c1')
+  assert.deepEqual(jobs.watched, ['c1'])
+})
+
+// Given 补丁卸载, When 调用 dispose, Then 所有流被释放且点击监听移除
+test('任务流_卸载_释放全部流', () => {
+  const { jobs, doc, result } = install()
+  jobs.watchRows('s1')
+  jobs.watchRows('s2')
+  doc.clickOn('c1')
+  result.dispose()
+  assert.deepEqual(jobs.released.sort(), ['c1', 's1', 's2'])
+  doc.clickOn('s5')
+  assert.equal(jobs.watched.length, 3)
+})

package/test/client-keepalive.test.mjs

@@ -0,0 +1,227 @@
+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 fakeWebSocketClass() {
+  return class FakeSocket {
+    static CONNECTING = 0
+    static OPEN = 1
+    static CLOSING = 2
+    static CLOSED = 3
+    constructor(url) {
+      this.url = String(url)
+      this.readyState = 1
+      this.sent = []
+      this.listeners = new Map()
+    }
+    send(data) { this.sent.push(String(data)) }
+    addEventListener(type, fn) {
+      const list = this.listeners.get(type) ?? []
+      list.push(fn)
+      this.listeners.set(type, list)
+    }
+    removeEventListener(type, fn) {
+      const list = this.listeners.get(type) ?? []
+      this.listeners.set(type, list.filter((item) => item !== fn))
+    }
+    dispatch(type, event) {
+      for (const fn of this.listeners.get(type) ?? []) fn(event)
+    }
+  }
+}
+
+function install({ intervalMs = 1500, enabled = true } = {}) {
+  const plugin = loadPlugin()
+  const FakeSocket = fakeWebSocketClass()
+  const win = { WebSocket: FakeSocket, location: { href: 'https://dsh.example/' } }
+  const clock = fakeClock()
+  const disabled = []
+  const result = plugin.__test.installSocketKeepAlive({
+    win,
+    options: { enabled, intervalMs },
+    clock,
+    onDisabled: (reason) => disabled.push(reason),
+  })
+  return { plugin, win, clock, result, Native: FakeSocket, disabled }
+}
+
+const keepaliveFrames = (socket) => socket.sent.filter((raw) => raw.includes('dsh-bug-perf-keepalive'))
+
+// Given 页面创建 /api/remote.mux 连接, When 空闲到达保活间隔, Then 发出一条合法 item 帧
+test('保活_空闲_发出合法item帧', () => {
+  const { win, clock } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  assert.equal(socket.sent.length, 0)
+  clock.advance(1500)
+  const frames = keepaliveFrames(socket)
+  assert.equal(frames.length, 1)
+  const frame = JSON.parse(frames[0])
+  assert.equal(frame.type, 'item')
+  assert.equal(typeof frame.streamId, 'string')
+  assert.ok(frame.streamId.length > 0)
+})
+
+// Given 保活已生效, When 继续空闲多个间隔, Then 每个间隔各一条,持续保活
+test('保活_持续_按间隔重复发送', () => {
+  const { win, clock } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  clock.advance(1500)
+  clock.advance(1500)
+  clock.advance(1500)
+  const frames = keepaliveFrames(socket)
+  assert.equal(frames.length, 3)
+  assert.equal(new Set(frames.map((raw) => JSON.parse(raw).streamId)).size, 3)
+})
+
+// Given 连接上客户端自己刚发过上行帧, When 尚未到保活间隔, Then 不补保活帧
+test('保活_有上行活动_不补帧', () => {
+  const { win, clock } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  socket.send('{"type":"open"}')
+  clock.advance(1000)
+  assert.equal(keepaliveFrames(socket).length, 0)
+  clock.advance(1000)
+  assert.equal(keepaliveFrames(socket).length, 1)
+})
+
+// Given 配置改了保活间隔, When 连接已存在, Then 既有连接按新间隔发送,不需要重建
+test('保活_间隔重配_既有连接生效', () => {
+  const { win, clock, result } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  result.setIntervalMs(4000)
+  clock.advance(2500)
+  assert.equal(keepaliveFrames(socket).length, 0)
+  clock.advance(2000)
+  assert.equal(keepaliveFrames(socket).length, 1)
+})
+
+// Given 连接不在 OPEN 态, When 到达检查点, Then 不发送
+test('保活_非OPEN_不发送', () => {
+  const { win, clock } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  socket.readyState = 3
+  clock.advance(1500)
+  assert.equal(socket.sent.length, 0)
+})
+
+// Given 非 remote.mux 连接, When 空闲到达间隔, Then 不发送(只补会话流)
+test('保活_其他连接_不发送', () => {
+  const { win, clock } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/bus/ws')
+  clock.advance(1500)
+  assert.equal(socket.sent.length, 0)
+})
+
+// Given 开关关闭, When 创建连接, Then 全局 WebSocket 不被包装且无任何帧
+test('保活_关闭_不包装', () => {
+  const { win, clock, Native } = install({ enabled: false })
+  assert.equal(win.WebSocket, Native)
+  clock.advance(5000)
+})
+
+// Given 连接关闭, When 连接已断, Then 保活定时器随连接清理,不再发送
+test('保活_连接关闭_清理定时器', () => {
+  const { win, clock, result } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  socket.dispatch('close', { code: 1000 })
+  clock.advance(5000)
+  assert.equal(socket.sent.length, 0)
+  assert.equal(result.state.timers.size, 0)
+})
+
+// Given 普通断线与主动关闭, When 连续发生多次, Then 不计入熔断,补丁继续工作
+test('保活_普通断线_不熔断', () => {
+  const { win, clock, Native, disabled } = install()
+  for (const code of [1000, 1001, 1006, 1006]) {
+    const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+    clock.advance(1500)
+    socket.dispatch('close', { code })
+  }
+  assert.equal(win.WebSocket === Native, false)
+  assert.deepEqual(disabled, [])
+})
+
+// Given 宿主以协议错误码关闭连接, When 连续命中熔断阈值, Then 补丁自行禁用并恢复原始构造器
+test('保活_协议关闭_熔断', () => {
+  const { win, clock, Native, disabled } = install()
+  for (let round = 0; round < 2; round++) {
+    const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+    clock.advance(1500)
+    assert.equal(keepaliveFrames(socket).length, 1)
+    socket.dispatch('close', { code: 1008 })
+  }
+  assert.equal(win.WebSocket, Native)
+  assert.equal(disabled.length, 1)
+  clock.advance(9000)
+})
+
+// Given 连接从未发过保活帧, When 以协议错误码关闭, Then 不计入熔断(与应用自身协议错误区分)
+test('保活_未发保活帧_协议关闭不计数', () => {
+  const { win, clock, Native } = install()
+  for (let round = 0; round < 3; round++) {
+    const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+    socket.dispatch('close', { code: 1008 })
+  }
+  assert.equal(win.WebSocket === Native, false)
+  clock.advance(5000)
+})
+
+// Given 连接健康存活超过恢复窗口, When 之后才发生协议关闭, Then 历史累计已清零
+test('保活_健康存活_清零累计', () => {
+  const { win, clock, Native } = install()
+  const first = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  clock.advance(1500)
+  first.dispatch('close', { code: 1008 })
+  const second = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  clock.advance(20000)
+  second.dispatch('close', { code: 1008 })
+  assert.equal(win.WebSocket === Native, false)
+})
+
+// Given 已被包装的连接, When 查看全局构造器, Then 仍是 WebSocket 语义且实例可判定
+test('保活_包装后_保持实例语义', () => {
+  const { win, Native } = install()
+  const socket = new win.WebSocket('wss://dsh.example/api/remote.mux')
+  assert.ok(socket instanceof Native)
+  assert.ok(socket instanceof win.WebSocket)
+  assert.equal(win.WebSocket.OPEN, 1)
+})