@mzzsfy/dsh-cron-board 0.1.0

package/test/index.test.mjs

@@ -0,0 +1,214 @@
+// 装配测试:数据目录解析 + webServer prefix 注册 + settings/timer 接线 + 装配后请求可用。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const mod = await import('../src/index.js')
+const { apply, resolveDataDir } = mod
+
+test('index:数据目录默认 ~/.dsh/cron-board,env 可覆盖', () => {
+  assert.equal(resolveDataDir({}), join(homedir(), '.dsh', 'cron-board'))
+  assert.equal(resolveDataDir({ DSH_CRON_BOARD_DATA_DIR: 'X:\\tmp\\cb' }), 'X:\\tmp\\cb')
+  // 空白覆盖不生效,回默认
+  assert.equal(resolveDataDir({ DSH_CRON_BOARD_DATA_DIR: '   ' }), join(homedir(), '.dsh', 'cron-board'))
+})
+
+test('index:apply 注册 prefix 路由且请求走通(列表接口)', async () => {
+  // Given webServer 桩:收集注册路由(sessionController 属性桩满足 inject 门控后环境)
+  const routes = new Map()
+  const ctx = {
+    effect(fn) {
+      fn()
+    },
+    inject() {},
+    sessionController: { create: async () => ({ sessionId: 's-x' }), prompt: async () => ({ accepted: true }) },
+    get: () => undefined,
+    webServer: {
+      register(route) {
+        routes.set(route.path, route.handler)
+        return () => {}
+      },
+    },
+  }
+  // When apply(装配)
+  apply(ctx)
+  // Then prefix 路由已注册
+  const handler = routes.get('/api/cron-board')
+  assert.ok(handler)
+  // When 调用未匹配的子路径(数据目录未初始化也可得到 404 JSON)
+  const res = { status: null, payload: null }
+  res.writeHead = (status) => { res.status = status }
+  res.end = (text) => { res.payload = JSON.parse(text) }
+  const req = { method: 'GET', url: 'http://localhost/api/cron-board/__nope__' }
+  await handler(req, res)
+  assert.equal(res.status, 404)
+  assert.ok(res.payload.error)
+})
+
+// 装配桩:webServer + settings + timer + 会话服务,记录注册与 interval 形态
+function makeFullCtx({ timerAvailable = true } = {}) {
+  const routes = new Map()
+  const registered = []
+  let value = {}
+  const settingsService = {
+    register(ns, schema, options) {
+      registered.push(ns)
+      return { get: () => value, watch() {} }
+    },
+    get: () => value,
+  }
+  const sessions = new Map()
+  let nextId = 0
+  const sessionController = {
+    async create() {
+      const sessionId = 's-' + (++nextId)
+      sessions.set(sessionId, { id: sessionId, status: 'running' })
+      return { sessionId }
+    },
+    async prompt(args) {
+      queueMicrotask(() => {
+        const entry = sessions.get(args.sessionId)
+        if (entry) entry.status = 'idle'
+      })
+      return { accepted: true }
+    },
+  }
+  const intervals = []
+  const ctx = {
+    effect(fn) {
+      fn()
+    },
+    sessionController,
+    get(name) {
+      if (name === 'settings') return settingsService
+      if (name === 'sessionController') return sessionController
+      if (name === 'agents') return { get: (id) => sessions.get(id) }
+      if (name === 'sessionQuery') return { listSessions: async () => [...sessions.values()].map((entry) => ({ id: entry.id })) }
+      return undefined
+    },
+    inject(deps, fn) {
+      if (deps[0] === 'timer') {
+        fn({
+          interval(intervalFn, ms) {
+            intervals.push({ fn: intervalFn, ms })
+            return () => {}
+          },
+        })
+      }
+      if (deps[0] === 'settings') {
+        fn({ settings: settingsService })
+      }
+    },
+    webServer: {
+      register(route) {
+        routes.set(route.path, route.handler)
+        return () => {}
+      },
+    },
+  }
+  return { ctx, routes, registered, intervals, settingsService, sessions }
+}
+
+test('index:inject 声明 webServer+sessionController(cordis 门控整体禁用的唯一形态)', async () => {
+  // Given 宿主会话服务走 cordis 硬依赖门控:缺失时 fiber 不激活,apply 不执行
+  // Then 静态锁定 inject 声明(修复 mce 同款「apply 内同步探测误判缺失」事故形态)
+  assert.deepEqual(mod.inject, ['webServer', 'sessionController'])
+})
+
+test('index:settings 注册 cron-board 命名空间且 timer 承载默认周期 tick', async () => {
+  // Given 全服务桩
+  const { ctx, registered, intervals } = makeFullCtx()
+  // When apply
+  apply(ctx)
+  // Then 命名空间注册,默认周期 30s 的 interval 建立
+  assert.deepEqual(registered, ['cron-board'])
+  assert.deepEqual(intervals.map((entry) => entry.ms), [30 * 1000])
+})
+
+test('index:tickSeconds 设置变更经 watch 重建 interval', async () => {
+  // Given 全服务桩,settings.register 的 watch 回调被捕获
+  let watchFn = null
+  const { ctx, intervals, settingsService } = makeFullCtx()
+  settingsService.register = () => ({ get: () => ({}), watch(fn) { watchFn = fn } })
+  apply(ctx)
+  assert.deepEqual(intervals.map((entry) => entry.ms), [30 * 1000])
+  // When 设置变更触发 watch
+  watchFn()
+  // Then interval 重建
+  assert.equal(intervals.length, 2)
+})
+
+test('index:tick 到期任务被调度执行(端到端装配)', async (t) => {
+  // Given 全服务桩 + 临时数据目录 + 一个已到期任务
+  const dir = await mkdtemp(join(tmpdir(), 'cron-board-idx-'))
+  t.after(async () => {
+    delete process.env.DSH_CRON_BOARD_DATA_DIR
+    await rm(dir, { recursive: true, force: true })
+  })
+  process.env.DSH_CRON_BOARD_DATA_DIR = dir
+  const { ctx, routes, intervals } = makeFullCtx()
+  const { apply: applyFresh } = await import('../src/index.js?' + Date.now())
+  applyFresh(ctx)
+  const handler = routes.get('/api/cron-board')
+  const post = (path, body) => {
+    const res = { status: null, payload: null }
+    res.writeHead = (status) => { res.status = status }
+    res.end = (text) => { res.payload = JSON.parse(text) }
+    const req = new EventEmitter()
+    req.method = 'POST'
+    req.url = 'http://localhost' + path
+    // 装配层初始化后才挂读体监听:桩事件须延后发射(真实 http 流自带缓冲,无此问题)
+    setTimeout(() => {
+      req.emit('data', Buffer.from(JSON.stringify(body)))
+      req.emit('end')
+    }, 80)
+    return handler(req, res).then(() => res)
+  }
+  await post('/api/cron-board/jobs', {
+    name: 'idx-e2e', kind: 'shell',
+    command: `${process.execPath} -e "console.log('idx-marker')"`,
+    schedule: '* * * * *', enabled: true, nextRunAt: Date.now() - 100,
+  })
+  // When 触发一次 tick(等价 timer 到点回调)
+  assert.equal(intervals.length, 1)
+  intervals[0].fn()
+  // Then cron 触发记录产生且状态终态
+  const record = await waitForRecord(() => pollRuns(handler))
+  assert.equal(record.trigger, 'cron')
+  assert.equal(record.status, 'success')
+})
+
+async function pollRuns(handler) {
+  const res = { status: null, payload: null }
+  res.writeHead = (status) => { res.status = status }
+  res.end = (text) => { res.payload = JSON.parse(text) }
+  const req = { method: 'GET', url: 'http://localhost/api/cron-board/runs' }
+  await handler(req, res)
+  return res.payload.items
+}
+
+function waitForRecord(poll, timeoutMs = 10 * 1000) {
+  return new Promise((resolve, reject) => {
+    const started = Date.now()
+    const tick = () => {
+      void poll().then((items) => {
+        const row = items.find((item) => item.trigger === 'cron')
+        if (row && row.status !== 'queued' && row.status !== 'running') {
+          resolve(row)
+          return
+        }
+        if (Date.now() - started > timeoutMs) {
+          reject(new Error('waitForRecord 超时'))
+          return
+        }
+        setTimeout(tick, 50)
+      }).catch(reject)
+    }
+    tick()
+  })
+}

package/test/logger.test.mjs

@@ -0,0 +1,98 @@
+// logger 测试:日志文件按 logs/<jobId>/<runId>.log 落盘。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { createLogger } from '../src/logger.mjs'
+
+async function makeLogger(t) {
+  const root = await mkdtemp(join(tmpdir(), 'cron-board-logs-'))
+  t.after(() => rm(root, { recursive: true, force: true }))
+  return { root, logger: createLogger({ rootDir: root }) }
+}
+
+test('logger:追加后按任务按次读回,任务间目录隔离', async (t) => {
+  // Given 两个任务各一次运行
+  const { logger } = await makeLogger(t)
+  // When 各写一行输出
+  await logger.append('j1', 'r1', 'hello from j1\n')
+  await logger.append('j2', 'r9', 'hello from j2\n')
+  // Then 各自读回互不串
+  assert.equal(await logger.read('j1', 'r1'), 'hello from j1\n')
+  assert.equal(await logger.read('j2', 'r9'), 'hello from j2\n')
+})
+
+test('logger:tail 只读尾部 N 行', async (t) => {
+  // Given 一个 5 行日志
+  const { logger } = await makeLogger(t)
+  await logger.append('j1', 'r1', 'l1\nl2\nl3\nl4\nl5\n')
+  // When 读尾部 2 行
+  const text = await logger.read('j1', 'r1', { tailLines: 2 })
+  // Then 仅最后两行
+  assert.equal(text, 'l4\nl5\n')
+})
+
+test('logger:不存在的日志读为空字符串', async (t) => {
+  // Given 无任何日志
+  const { logger } = await makeLogger(t)
+  // When 读
+  // Then 空串
+  assert.equal(await logger.read('none', 'none'), '')
+})
+
+test('logger:清空单条日志后读回为空', async (t) => {
+  // Given 已有日志
+  const { logger } = await makeLogger(t)
+  await logger.append('j1', 'r1', 'content\n')
+  // When 清空
+  await logger.clear('j1', 'r1')
+  // Then 读回空
+  assert.equal(await logger.read('j1', 'r1'), '')
+})
+
+test('logger:prune 按文件修改时间裁剪,字典序倒挂不误删(runId 为随机 UUID 与时间无关)', async (t) => {
+  // Given 三份日志按时间序写入,名字典序与写入序刻意相反;写入间隔保证 mtime 可分
+  const { logger } = await makeLogger(t)
+  await logger.append('j1', 'z-oldest', 'z-oldest\n')
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await logger.append('j1', 'a-middle', 'a-middle\n')
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await logger.append('j1', 'm-newest', 'm-newest\n')
+  // When 保留最新 2 份
+  await logger.prune('j1', 2)
+  // Then 最早写入的 z-oldest 被裁,名字典序最小的 a-middle 保留(旧字典序实现会反着删)
+  assert.equal(await logger.read('j1', 'z-oldest'), '')
+  assert.equal(await logger.read('j1', 'a-middle'), 'a-middle\n')
+  assert.equal(await logger.read('j1', 'm-newest'), 'm-newest\n')
+})
+
+test('logger:超出保留数裁掉最旧日志文件', async (t) => {
+  // Given 同任务 3 份日志,保留上限 2
+  const { logger } = await makeLogger(t)
+  for (const runId of ['r1', 'r2', 'r3']) {
+    await logger.append('j1', runId, runId + '\n')
+  }
+  // When 写第 4 份触发裁剪
+  await logger.append('j1', 'r4', 'r4\n')
+  await logger.prune('j1', 2)
+  // Then 最旧两份消失,最新两份保留
+  assert.equal(await logger.read('j1', 'r1'), '')
+  assert.equal(await logger.read('j1', 'r2'), '')
+  assert.equal(await logger.read('j1', 'r3'), 'r3\n')
+  assert.equal(await logger.read('j1', 'r4'), 'r4\n')
+})
+
+test('logger:删除任务连带删除整个日志目录', async (t) => {
+  // Given 两任务各一份日志
+  const { logger } = await makeLogger(t)
+  await logger.append('j1', 'r1', 'a\n')
+  await logger.append('j2', 'r1', 'b\n')
+  // When 删除 j1
+  await logger.removeJob('j1')
+  // Then j1 目录消失,j2 不受影响
+  assert.equal(await logger.read('j1', 'r1'), '')
+  assert.equal(await logger.read('j2', 'r1'), 'b\n')
+})

package/test/parity.test.mjs

@@ -0,0 +1,72 @@
+// parity 测试:client.js LOGIC 标记段与 src/status-meta.mjs 同源对照(turn-notify 模式)。
+// 状态元数据双实现同源是规约要求:改一侧必须同步另一侧,测试锁定。
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+import { STATUS_META as coreStatusMeta, TRIGGER_META as coreTriggerMeta } from '../src/status-meta.mjs'
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+// 从 client.js 提取 LOGIC 标记段,构造纯逻辑实现
+function clientLogic() {
+  const source = readFileSync(join(PKG_ROOT, 'src', 'client.js'), 'utf8')
+  const begin = source.indexOf('/* LOGIC-BEGIN */')
+  const end = source.indexOf('/* LOGIC-END */')
+  assert.ok(begin >= 0 && end > begin, 'client.js 缺少 LOGIC 标记段')
+  const section = source.slice(begin + '/* LOGIC-BEGIN */'.length, end)
+  const factory = new Function(
+    section + '; return { STATUS_META, TRIGGER_META, KIND_LABELS, MODE_LABELS, ONMISS_LABELS, relativeTime, formatDateTime, formatDuration, statusMeta };',
+  )
+  return factory()
+}
+
+const client = clientLogic()
+const MINUTE = 60 * 1000
+const HOUR = 60 * MINUTE
+const NOW = 1750000000000
+
+test('parity:STATUS_META 与 core 同源', () => {
+  assert.deepEqual(client.STATUS_META, coreStatusMeta)
+})
+
+test('parity:TRIGGER_META 与 core 同源', () => {
+  assert.deepEqual(client.TRIGGER_META, coreTriggerMeta)
+})
+
+test('parity:STATUS_META 覆盖全部落库状态', () => {
+  // store/scheduler/executor 可能落库的状态必须都有展示元数据
+  for (const status of ['success', 'fail', 'timeout', 'skipped', 'interrupted', 'running']) {
+    assert.ok(coreStatusMeta[status], '缺少状态元数据: ' + status)
+  }
+})
+
+test('parity:relativeTime 未来/过去方向与粒度', () => {
+  assert.equal(client.relativeTime(NOW + 3 * HOUR, NOW), '3 小时后')
+  assert.equal(client.relativeTime(NOW - 5 * MINUTE, NOW), '5 分钟前')
+  assert.equal(client.relativeTime(NOW + 2 * 24 * HOUR, NOW), '2 天后')
+  assert.equal(client.relativeTime(undefined, NOW), '-')
+})
+
+test('parity:formatDuration 分级呈现', () => {
+  assert.equal(client.formatDuration(500), '500ms')
+  assert.equal(client.formatDuration(1500), '1.5s')
+  assert.equal(client.formatDuration(90 * MINUTE), '90min')
+  assert.equal(client.formatDuration(undefined), '-')
+})
+
+test('parity:statusMeta 未知状态回退 mute', () => {
+  assert.equal(client.statusMeta('whatever').tone, 'mute')
+  assert.equal(client.statusMeta(undefined).label, '-')
+})
+
+test('parity:maskValue 同源——client LOGIC 段不存在独立实现(API 列表与 prompt 折叠共用 core)', () => {
+  // client.js 打码仅经服务端列表返回的已打码值呈现,LOGIC 段不得再出现本地 maskValue 实现
+  const source = readFileSync(join(PKG_ROOT, 'src', 'client.js'), 'utf8')
+  const begin = source.indexOf('/* LOGIC-BEGIN */')
+  const end = source.indexOf('/* LOGIC-END */')
+  assert.doesNotMatch(source.slice(begin, end), /maskValue/, 'LOGIC 段出现独立打码实现,违反双实现同源')
+})