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

package/test/client-watchdog.test.mjs

@@ -0,0 +1,186 @@
+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 fakeTimers() {
+  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) {
+      now += ms
+      for (const [id, timer] of [...intervals]) {
+        if (timer.at <= now) {
+          timer.at = now + timer.every
+          timer.fn()
+        }
+      }
+    },
+    intervalCount: () => intervals.size,
+  }
+}
+
+function fakeView({ writable = false, phase = 'connected', revision = 1, pendingRender, hasStream = true } = {}) {
+  const snapshot = { phase, writable }
+  return {
+    sessionId: 'session-a',
+    id: 'term-a',
+    revision,
+    pendingRender,
+    stream: hasStream ? {} : undefined,
+    connects: 0,
+    lifetime: { signal: { addEventListener() {} } },
+    state: { getSnapshot: () => snapshot },
+    snapshot,
+    connect() { this.connects += 1 },
+  }
+}
+
+const OPTIONS = { checkMs: 2000, stallMs: 8000, cooldownMs: 60000 }
+
+function stateFor(view, now = 0) {
+  return { revision: view.revision, changedAt: now, armed: false, healedAt: -Infinity }
+}
+
+// Given 视图从未可写(旁观只读), When 长时间无输出, Then 不触发重连
+test('看门狗_未武装_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: false })
+  const state = stateFor(view)
+  const result = plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 30000, visible: true })
+  assert.equal(result, 'idle')
+  assert.equal(state.armed, false)
+})
+
+// Given 视图曾接管输入随后卡住, When 停滞超过阈值, Then 触发一次重连并释放武装
+test('看门狗_已武装停滞_触发重连', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true }), 'progress')
+  assert.equal(state.armed, true)
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 5000, visible: true }), 'idle')
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 10500, visible: true }), 'heal')
+  assert.equal(state.armed, false)
+  assert.equal(state.healedAt, 10500)
+})
+
+// Given 视图持续有新帧, When 每轮检查, Then 只报进度不触发
+test('看门狗_持续有新帧_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  for (let i = 1; i <= 6; i++) {
+    view.revision = i
+    const result = plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: i * 10000, visible: true })
+    assert.equal(result, 'progress')
+  }
+})
+
+// Given 刚自愈过, When 再次停滞进入冷却期, Then 不重复重连
+test('看门狗_冷却期_不重复', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true })
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 9500, visible: true }), 'heal')
+  state.armed = true
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: true }), 'cooldown')
+})
+
+// Given 页面隐藏, When 停滞判定到期, Then 不触发(隐藏期的停顿不是故障)
+test('看门狗_页面隐藏_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true }), 'progress')
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: false }), 'hidden')
+})
+
+// Given 视图正在等渲染或没有 attach 流, When 检查, Then 不当作冻结处理
+test('看门狗_待渲染或无流_不触发', () => {
+  const plugin = loadPlugin()
+  const pending = fakeView({ writable: true, pendingRender: {} })
+  const pendingState = stateFor(pending)
+  plugin.__test.watchdogTick({ view: pending, state: pendingState, options: OPTIONS, now: 1000, visible: true })
+  pending.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view: pending, state: pendingState, options: OPTIONS, now: 20000, visible: true }), 'pending-render')
+
+  const detached = fakeView({ writable: true, hasStream: false })
+  const detachedState = stateFor(detached)
+  plugin.__test.watchdogTick({ view: detached, state: detachedState, options: OPTIONS, now: 1000, visible: true })
+  detached.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view: detached, state: detachedState, options: OPTIONS, now: 20000, visible: true }), 'no-stream')
+})
+
+// Given 视图已断开重连中, When 检查, Then 只报未连接, 不叠加重连
+test('看门狗_未连接_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true, phase: 'connecting' })
+  const state = stateFor(view)
+  plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true })
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: true }), 'not-connected')
+})
+
+// Given 新视图由官方服务创建, When 看门狗安装后推进到停滞阈值, Then 自动调用 connect 恢复输出
+test('看门狗_新建视图_自动重连', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const holder = { view() { return this.created }, created: fakeView({ writable: true }), views: new Map() }
+  const result = plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  assert.equal(result.installed, true)
+  const view = holder.view('session-a', 'tab-1', 'content-1')
+  timers.advance(2000)
+  view.snapshot.writable = false
+  timers.advance(8000)
+  assert.equal(view.connects, 1)
+})
+
+// Given 已存在的视图, When 安装时遍历 views, Then 同样进入监控
+test('看门狗_既有视图_进入监控', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const existing = fakeView({ writable: true })
+  const holder = { view: () => existing, views: new Map([['session-a', new Map([['tab-1', existing]])]]) }
+  plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  timers.advance(2000)
+  existing.snapshot.writable = false
+  timers.advance(8000)
+  assert.equal(existing.connects, 1)
+})
+
+// Given 宿主版本没有 webTerminals.view, When 安装, Then 跳过并不抛错
+test('看门狗_服务结构缺失_跳过不抛', () => {
+  const plugin = loadPlugin()
+  const missing = plugin.__test.installTerminalWatchdog({ holder: {}, options: OPTIONS, timers: fakeTimers(), isVisible: () => true })
+  assert.equal(missing.installed, false)
+  const alsoMissing = plugin.__test.installTerminalWatchdog({ holder: undefined, options: OPTIONS, timers: fakeTimers(), isVisible: () => true })
+  assert.equal(alsoMissing.installed, false)
+})
+
+// Given 已安装, When 再次安装, Then 幂等不重复挂定时器
+test('看门狗_重复安装_幂等', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const holder = { view: () => fakeView({ writable: true }), views: new Map() }
+  plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  const again = plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  assert.equal(again.installed, false)
+  assert.equal(timers.intervalCount() <= 1, true)
+})

package/test/config.test.mjs

@@ -0,0 +1,118 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { DEFAULT_CONFIG, normalizeConfig } from '../src/config.mjs'
+
+// Given 无配置, When 归一化, Then 两个功能默认开启且阈值取默认
+test('配置_缺省_默认全开', () => {
+  const config = normalizeConfig(undefined)
+  assert.deepEqual(config, DEFAULT_CONFIG)
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.restartCoalesce.windowMs, 100)
+  assert.equal(config.terminalWatchdog.enabled, true)
+  assert.equal(config.terminalWatchdog.checkMs, 2000)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 60000)
+})
+
+// Given 只覆盖一个字段, When 归一化, Then 其余字段保持默认
+test('配置_部分覆盖_其余保持默认', () => {
+  const config = normalizeConfig({ restartCoalesce: { windowMs: 250 } })
+  assert.equal(config.restartCoalesce.windowMs, 250)
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+})
+
+// Given 功能关闭, When 归一化, Then 关闭语义原样保留而阈值仍可取
+test('配置_功能关闭_保留阈值', () => {
+  const config = normalizeConfig({ terminalWatchdog: { enabled: false, stallMs: 4000 } })
+  assert.equal(config.terminalWatchdog.enabled, false)
+  assert.equal(config.terminalWatchdog.stallMs, 4000)
+})
+
+// Given 非法类型与越界值, When 归一化, Then 回退默认而不是把坏值带进运行时
+test('配置_非法值_回退默认', () => {
+  const config = normalizeConfig({
+    restartCoalesce: { enabled: 'yes', windowMs: -1 },
+    terminalWatchdog: { checkMs: 0, stallMs: 'soon', cooldownMs: Number.NaN },
+  })
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.restartCoalesce.windowMs, 100)
+  assert.equal(config.terminalWatchdog.checkMs, 2000)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 60000)
+})
+
+// Given 超上限的阈值, When 归一化, Then 收敛到上限(防止错误配置把功能变成滥用)
+test('配置_越界上限_收敛', () => {
+  const config = normalizeConfig({
+    restartCoalesce: { windowMs: 60000 },
+    terminalWatchdog: { checkMs: 600000, stallMs: 999999999, cooldownMs: 999999999 },
+  })
+  assert.equal(config.restartCoalesce.windowMs, 2000)
+  assert.equal(config.terminalWatchdog.checkMs, 60000)
+  assert.equal(config.terminalWatchdog.stallMs, 600000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 3600000)
+})
+
+// Given 未知字段, When 归一化, Then 被丢弃(配置面只认已声明字段)
+test('配置_未知字段_丢弃', () => {
+  const config = normalizeConfig({ unknown: 1, restartCoalesce: { windowMs: 150 } })
+  assert.equal(config.unknown, undefined)
+  assert.equal(config.restartCoalesce.windowMs, 150)
+})
+
+// Given 无配置, When 归一化, Then 保活与停滞兜底默认开启且阈值取默认
+test('配置_保活与停滞_默认值', () => {
+  const config = normalizeConfig(undefined)
+  assert.deepEqual(config.socketKeepAlive, { enabled: true, intervalMs: 1500 })
+  assert.deepEqual(config.stuckSession, {
+    enabled: true,
+    checkMs: 2000,
+    stallMs: 8000,
+    reconnect: true,
+    maxReconnectAttempts: 5,
+    reconnectIntervalMs: 15000,
+  })
+  assert.deepEqual(config.jobStreamLimit, { enabled: true, base: 32, max: 48 })
+})
+
+// Given 新增补丁的非法值, When 归一化, Then 回退默认而不是把坏值带进运行时
+test('配置_保活与停滞_非法值回退', () => {
+  const config = normalizeConfig({
+    socketKeepAlive: { enabled: 'on', intervalMs: 0 },
+    stuckSession: { checkMs: -5, stallMs: 'slow', reconnect: 1, maxReconnectAttempts: Number.NaN, reconnectIntervalMs: 0 },
+  })
+  assert.equal(config.socketKeepAlive.enabled, true)
+  assert.equal(config.socketKeepAlive.intervalMs, 1500)
+  assert.equal(config.stuckSession.checkMs, 2000)
+  assert.equal(config.stuckSession.stallMs, 8000)
+  assert.equal(config.stuckSession.reconnect, true)
+  assert.equal(config.stuckSession.maxReconnectAttempts, 5)
+  assert.equal(config.stuckSession.reconnectIntervalMs, 15000)
+})
+
+// Given 超上限的阈值, When 归一化, Then 收敛到上限
+test('配置_保活与停滞_越界收敛', () => {
+  const config = normalizeConfig({
+    socketKeepAlive: { intervalMs: 999999 },
+    stuckSession: { checkMs: 999999, stallMs: 999999999, maxReconnectAttempts: 999999, reconnectIntervalMs: 999999999 },
+  })
+  assert.equal(config.socketKeepAlive.intervalMs, 60000)
+  assert.equal(config.stuckSession.checkMs, 60000)
+  assert.equal(config.stuckSession.stallMs, 600000)
+  assert.equal(config.stuckSession.maxReconnectAttempts, 20)
+  assert.equal(config.stuckSession.reconnectIntervalMs, 600000)
+})
+
+// Given 任务流上限被关掉或给了非法值, When 归一化, Then 关闭生效、非法值回退默认
+test('配置_任务流上限_开关与回退', () => {
+  const off = normalizeConfig({ jobStreamLimit: { enabled: false } })
+  assert.equal(off.jobStreamLimit.enabled, false)
+  const bad = normalizeConfig({ jobStreamLimit: { base: 0, max: 0 } })
+  assert.equal(bad.jobStreamLimit.base, 32)
+  assert.equal(bad.jobStreamLimit.max, 48)
+  const capped = normalizeConfig({ jobStreamLimit: { max: 99999 } })
+  assert.equal(capped.jobStreamLimit.max, 512)
+  const inverted = normalizeConfig({ jobStreamLimit: { base: 200, max: 10 } })
+  assert.equal(inverted.jobStreamLimit.base, 10)
+})

package/test/host.test.mjs

@@ -0,0 +1,141 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { DEFAULT_CONFIG } from '../src/config.mjs'
+import { apply, Config, name } from '../src/index.js'
+
+function makeRes() {
+  return {
+    status: undefined,
+    headers: undefined,
+    body: undefined,
+    writeHead(status, headers) { this.status = status; this.headers = headers },
+    end(body) { this.body = body },
+  }
+}
+
+function makeCtx({ server, registerError } = {}) {
+  const registrations = []
+  const disposed = []
+  const ctx = {
+    get: (service) => (service === 'webServer' ? server : undefined),
+    effect: (factory) => {
+      const dispose = factory()
+      ctx.effects.push(dispose)
+      return dispose
+    },
+    effects: [],
+    registrations,
+    disposed,
+  }
+  if (server !== undefined) {
+    server.register = (route) => {
+      if (registerError !== undefined) throw registerError
+      registrations.push(route)
+      return () => disposed.push(route.path)
+    }
+  }
+  return ctx
+}
+
+async function request(route, config) {
+  const res = makeRes()
+  await route.handler({ url: '/api/dsh-bug-perf/config', method: 'GET' }, res)
+  return res
+}
+
+async function requestDiag(route, query) {
+  const res = makeRes()
+  await route.handler({ url: `/api/dsh-bug-perf/diag${query}`, method: 'GET' }, res)
+  return res
+}
+
+// Given 插件声明注入, When 装载器解析, Then 等待 webServer 就绪后再激活(不是同步探测)
+test('宿主_注入声明_等待webServer', async () => {
+  const index = await import('../src/index.js')
+  assert.deepEqual(index.inject, ['webServer'])
+})
+
+// Given 宿主提供 webServer, When 插件激活, Then 注册只读配置路由且路径固定
+test('宿主_激活_注册配置路由', () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  assert.equal(name, 'dsh-bug-perf')
+  assert.equal(ctx.registrations.length, 2)
+  assert.equal(ctx.registrations[0].kind, 'exact')
+  assert.equal(ctx.registrations[0].path, '/api/dsh-bug-perf/config')
+  assert.equal(ctx.registrations[1].path, '/api/dsh-bug-perf/diag')
+})
+
+// Given 行配置为缺省, When 客户端读取配置, Then 返回默认配置 JSON
+test('宿主_缺省配置_返回默认值', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = await request(ctx.registrations[0])
+  assert.equal(res.status, 200)
+  const json = JSON.parse(res.body)
+  assert.deepEqual(json.config, DEFAULT_CONFIG)
+})
+
+// Given 行配置部分覆盖, When 客户端读取, Then 覆盖项生效且其余为默认
+test('宿主_部分覆盖_返回归一化结果', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, { restartCoalesce: { enabled: false }, terminalWatchdog: { stallMs: 12000 } })
+  const json = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.equal(json.config.restartCoalesce.enabled, false)
+  assert.equal(json.config.restartCoalesce.windowMs, 100)
+  assert.equal(json.config.terminalWatchdog.stallMs, 12000)
+})
+
+// Given 0.1.7 宿主把整节配置包成 volatile ref, When 读取, Then 解箱后返回
+test('宿主_volatile配置_解箱', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, { get: () => ({ terminalWatchdog: { enabled: false } }) })
+  const json = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.equal(json.config.terminalWatchdog.enabled, false)
+})
+
+// Given 宿主没有 webServer 服务, When 插件激活, Then 不注册不抛错(旧宿主/无 web 场景)
+test('宿主_无webServer_干净跳过', () => {
+  const ctx = makeCtx()
+  assert.doesNotThrow(() => apply(ctx, undefined))
+  assert.equal(ctx.registrations.length, 0)
+  assert.equal(ctx.effects.length, 0)
+})
+
+// Given 路由注册抛错, When 插件激活, Then 错误被记录而不是拖垮页面
+test('宿主_注册失败_不抛', () => {
+  const ctx = makeCtx({ server: {}, registerError: new Error('route table frozen') })
+  assert.doesNotThrow(() => apply(ctx, undefined))
+  assert.equal(ctx.registrations.length, 0)
+})
+
+// Given 插件导出 Config, When 取各节默认值, Then 与共享默认值一致(设置页与运行时同源)
+test('宿主_Config默认值_与共享默认一致', () => {
+  const restart = Config.dict.restartCoalesce({})
+  const watchdog = Config.dict.terminalWatchdog({})
+  assert.equal(restart.enabled, DEFAULT_CONFIG.restartCoalesce.enabled)
+  assert.equal(restart.windowMs, DEFAULT_CONFIG.restartCoalesce.windowMs)
+  assert.equal(watchdog.enabled, DEFAULT_CONFIG.terminalWatchdog.enabled)
+  assert.equal(watchdog.checkMs, DEFAULT_CONFIG.terminalWatchdog.checkMs)
+  assert.equal(watchdog.stallMs, DEFAULT_CONFIG.terminalWatchdog.stallMs)
+  assert.equal(watchdog.cooldownMs, DEFAULT_CONFIG.terminalWatchdog.cooldownMs)
+})
+
+// Given 浏览器上报采样, When 宿主收到合法载荷, Then 返回 ok 并落盘
+test('宿主_采样上报_接受合法载荷', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = await requestDiag(ctx.registrations[1], `?d=${encodeURIComponent(JSON.stringify({ at: 1, totals: { opened: 1 } }))}`)
+  assert.equal(res.status, 200)
+  assert.deepEqual(JSON.parse(res.body), { ok: true })
+})
+
+// Given 缺少载荷或载荷不是 JSON, When 上报, Then 返回 400 且不抛出
+test('宿主_采样上报_拒绝坏载荷', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const missing = await requestDiag(ctx.registrations[1], '')
+  assert.equal(missing.status, 400)
+  const broken = await requestDiag(ctx.registrations[1], '?d=not-json')
+  assert.equal(broken.status, 400)
+})