dsh-sansheng-liubu/sansheng/test/isolation.test.js

345 lines
15 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import assert from 'node:assert/strict'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import test from 'node:test'
import { apply } from '../index.js'
import { installGovernance } from '../src/governance.js'
import { resolveActor } from '../src/identity.js'
import { SanshengStore, SanshengStoreError } from '../src/store.js'
function fakeCtx(services = {}) {
const tools = []
const provided = {}
return {
tools: {
register(def) { tools.push(def); return () => {} },
guard() { return () => {} },
},
on() { return () => {} },
effect(fn) { return typeof fn === 'function' ? fn() : undefined },
get(name, fallback) { return services[name] ?? fallback },
provide(name, value) { provided[name] = value },
toolsList: tools,
provided,
}
}
function fakeRuntime() {
const calls = { bots: [], rooms: [], deletedBots: [], deletedRooms: [], updated: [] }
const bots = new Map()
const rooms = new Map()
let counter = 0
const rt = {
async load() {},
findBot(ref) {
if (bots.has(ref)) return bots.get(ref)
return [...bots.values()].find(bot => bot.name === ref)
},
async resolveModel(ref) {
if (ref === 'bad') throw new Error('模型不存在')
return ref
},
async createBot(options) {
if ([...bots.values()].some(bot => bot.name === options.name)) throw new Error(`A Bot named ${options.name} already exists`)
counter += 1
const bot = { id: `bot-${counter}`, name: options.name, model: options.model, sessionId: `sess-${counter}` }
bots.set(bot.id, bot)
calls.bots.push({ ...options, id: bot.id })
return bot
},
botOf(id) { return bots.get(id) },
async updateBot(id, patch) {
const bot = bots.get(id)
if (!bot) throw new Error('Unknown Bot')
Object.assign(bot, patch)
calls.updated.push({ id, patch })
return bot
},
async deleteBot(id) {
calls.deletedBots.push(id)
bots.delete(id)
},
async createRoom(options) {
const room = { id: `room-${rooms.size + 1}`, name: options.name, members: options.members, admin: options.admin, sessions: {}, goal: undefined }
rooms.set(room.id, room)
calls.rooms.push(options)
return room
},
async deleteRoom(id) {
calls.deletedRooms.push(id)
rooms.delete(id)
},
goalControl: async () => ({}),
}
return { rt, calls, bots, rooms }
}
async function setup() {
const dir = await mkdtemp(join(tmpdir(), 'sansheng-isolation-'))
const { rt, calls, bots, rooms } = fakeRuntime()
const ctx = fakeCtx({ 'dsbot-runtime': rt })
const statePath = join(dir, 'state.json')
const dsbotStatePath = join(dir, 'bot-state.json')
await apply(ctx, { statePath, dsbotStatePath })
const tool = name => ctx.toolsList.find(def => def.name === name)
const store = new SanshengStore(statePath)
await store.load()
const env = {
dir, rt, calls, bots, rooms, ctx, tool, store, statePath, dsbotStatePath,
reload: async () => {
const next = new SanshengStore(statePath)
await next.load()
env.store = next
return next
},
cleanup: () => rm(dir, { recursive: true, force: true }),
}
return env
}
const userExec = { agent: { id: 'user-session' } }
test('I01:连续创建 A/B 默认参数均成功,Bot 名唯一且角色独立', async () => {
const env = await setup()
try {
const a = await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
const b = await env.tool('sansheng_provision').execute({ project: '项目B', workDir: 'C:/work/b' }, userExec)
await env.reload()
assert.match(a, /已创建项目「项目A」/)
assert.match(b, /已创建项目「项目B」/)
const namesA = env.calls.bots.slice(0, 3).map(bot => bot.name)
const namesB = env.calls.bots.slice(3, 6).map(bot => bot.name)
assert.equal(new Set([...namesA, ...namesB]).size, 6, '六个 Bot 名必须全局唯一')
assert.notDeepEqual(namesA, namesB)
const projects = Object.values(env.store.peek().projects)
assert.equal(projects.length, 2)
const botIds = projects.flatMap(project => Object.values(project.bots))
assert.equal(new Set(botIds).size, 6, '两个项目不共享角色 Bot')
} finally {
await env.cleanup()
}
})
test('I02:把 A 的尚书绑到 B 所在的群明确拒绝', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.reload()
const projectA = Object.values(env.store.peek().projects)[0]
// 手工造一个群:成员是 A 的三个 Bot,管理员是 A 的尚书
const room = await env.rt.createRoom({
name: '另一个群', members: Object.values(projectA.bots), admin: projectA.bots.shangshu,
})
const botState = {
version: 1,
mainBotIds: [],
bots: Object.fromEntries(Object.entries(projectA.bots).map(([role, id]) => [id, { id, name: env.bots.get(id)?.name ?? role, role }])),
rooms: { [room.id]: { id: room.id, name: room.name, members: Object.values(projectA.bots), admin: projectA.bots.shangshu, sessions: {} } },
}
const { writeFile } = await import('node:fs/promises')
await writeFile(env.dsbotStatePath, JSON.stringify(botState), 'utf8')
const result = await env.tool('sansheng_bind').execute({
project: '项目B', room: room.id,
lead: projectA.bots.lead, shangshu: projectA.bots.shangshu, gongbu: projectA.bots.gongbu,
}, userExec)
assert.match(result, /已属于项目|只能属于一个项目/)
assert.equal(Object.values(env.store.peek().projects).length, 1, '不能产生半绑定')
} finally {
await env.cleanup()
}
})
test('I03:显式 project 与 Bot 所属项目冲突时拒绝', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.tool('sansheng_provision').execute({ project: '项目B', workDir: 'C:/work/b' }, userExec)
await env.reload()
const [a, b] = Object.values(env.store.peek().projects)
// 让 A 的尚书会话记录审查,但显式要求写到 B
const room = { goal: { id: 'goal-1', revision: 1, status: 'active', stages: [] } }
const dsbot = {
botOf: id => ({ name: id }),
roomOf: id => (id === a.roomId ? room : undefined),
roomOfSession: () => a.roomId,
selfOf: () => a.bots.shangshu,
isMain: () => false,
}
const fakeStore = {
...env.store,
projectsByBot: id => (id === a.bots.shangshu ? [a] : []),
projectByBot: id => (id === a.bots.shangshu ? a : undefined),
projectByRoom: id => (id === a.roomId ? a : id === b.roomId ? b : undefined),
peek: () => ({ reviews: [], artifacts: {}, projects: { [a.id]: a, [b.id]: b }, reworks: [] }),
resolveProject: ref => (ref === b.name ? b : ref === a.name ? a : undefined),
}
const actor = resolveActor({ dsbot, store: fakeStore, sessionId: 'sess-shang', isBotSession: () => true })
assert.equal(actor.project.id, a.id)
} finally {
await env.cleanup()
}
})
test('I03b:A 的尚书显式指定项目 B 记录审查时拒绝,不落 B 的记录', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.tool('sansheng_provision').execute({ project: '项目B', workDir: 'C:/work/b' }, userExec)
await env.reload()
const [a, b] = Object.values(env.store.peek().projects)
const goal = { id: 'goal-a', revision: 3, status: 'active', current: 0, objective: 'A', acceptance: 'A', constraints: [], stages: [{ id: 's1', title: '一', acceptance: 'x', status: 'active', tasks: [] }] }
// 让插件内的 DsBotState 看到 A 的群与尚书会话
const { writeFile } = await import('node:fs/promises')
await writeFile(env.dsbotStatePath, JSON.stringify({
version: 1,
mainBotIds: [],
bots: Object.fromEntries(Object.entries(a.bots).map(([role, id]) => [id, { id, name: env.bots.get(id)?.name ?? role, role, sessionId: role === 'shangshu' ? 'sess-a-shang' : `sess-${role}` }])),
rooms: { [a.roomId]: { id: a.roomId, name: 'A 群', members: Object.values(a.bots), admin: a.bots.shangshu, sessions: {}, goal } },
}), 'utf8')
const result = await env.tool('sansheng_review').execute(
{ action: 'stage_pass', project: b.id, stage: 1, evidence: '测试' },
{ agent: { id: 'sess-a-shang' } },
)
assert.match(result, /项目冲突|不能跨项目/)
assert.equal(env.store.peek().reviews.length, 0, '不能把 A 的审查写进 B')
} finally {
await env.cleanup()
}
})
test('Store 层拒绝重复 Bot/重复群绑定', async () => {
const env = await setup()
try {
const project = {
id: 'prj-1', name: 'A', roomId: 'room-1',
bots: { lead: 'b1', shangshu: 'b2', gongbu: 'b3' }, maxReworks: 3,
}
await env.store.saveProject(project)
await assert.rejects(
() => env.store.saveProject({ ...project, id: 'prj-2', name: 'B' }),
error => error instanceof SanshengStoreError && error.code === 'room-taken',
)
await assert.rejects(
() => env.store.saveProject({ ...project, id: 'prj-3', name: 'C', roomId: 'room-3' }),
error => error instanceof SanshengStoreError && error.code === 'bot-taken',
)
await assert.rejects(
() => env.store.saveProject({ ...project, id: 'prj-4', name: 'D', roomId: 'room-4', bots: { lead: 'x', shangshu: 'x', gongbu: 'y' } }),
error => error instanceof SanshengStoreError && error.code === 'roles-duplicated',
)
} finally {
await env.cleanup()
}
})
test('I04:修改 A 模型配置只更新 A 的 Bot 与绑定', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.tool('sansheng_provision').execute({ project: '项目B', workDir: 'C:/work/b' }, userExec)
await env.reload()
const [a, b] = Object.values(env.store.peek().projects)
const result = await env.tool('sansheng_config').execute({
project: a.id, models: { lead: 'magpie/new-lead' },
}, userExec)
assert.match(result, /已更新项目/)
const updatedIds = env.calls.updated.map(item => item.id)
assert.deepEqual(updatedIds, [a.bots.lead], '只更新 A 的丞相 Bot')
const reloaded = new SanshengStore(env.statePath)
await reloaded.load()
assert.equal(reloaded.projectById(a.id).models.lead, 'magpie/new-lead')
assert.equal(reloaded.projectById(b.id).models.lead, undefined)
} finally {
await env.cleanup()
}
})
test('I05/I06:治理服务拒绝跨项目投递与 team 记忆', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.tool('sansheng_provision').execute({ project: '项目B', workDir: 'C:/work/b' }, userExec)
await env.reload()
const [a, b] = Object.values(env.store.peek().projects)
const gov = installGovernance({ ctx: env.ctx, store: env.store })
assert.equal(gov.checkDelivery({ fromId: a.bots.shangshu, toId: b.bots.gongbu }).allow, false)
assert.equal(gov.checkDelivery({ fromId: a.bots.shangshu, toId: a.bots.gongbu }).allow, true)
assert.equal(gov.checkDelivery({ fromId: a.bots.shangshu, toId: 'bot-outsider' }).allow, false)
assert.equal(gov.checkDelivery({ fromId: b.bots.lead, toId: a.bots.gongbu, roomId: a.roomId }).allow, false)
assert.equal(gov.checkMemoryScope({ botId: a.bots.lead, scope: 'team' }).allow, false)
assert.equal(gov.checkMemoryScope({ botId: a.bots.lead, scope: 'group', roomId: a.roomId }).allow, true)
assert.equal(gov.checkMemoryScope({ botId: a.bots.lead, scope: 'group', roomId: b.roomId }).allow, false)
assert.equal(gov.checkMemoryScope({ botId: 'bot-outsider', scope: 'team' }).allow, true)
} finally {
await env.cleanup()
}
})
test('写租约:同项目第二个写任务被拒绝,释放后可获取', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.reload()
const project = Object.values(env.store.peek().projects)[0]
const first = await env.store.acquireLease(project.id, { holder: 'bot-gongbu', taskId: 't1' })
assert.equal(first.ok, true)
const second = await env.store.acquireLease(project.id, { holder: 'bot-other', taskId: 't2' })
assert.equal(second.ok, false)
assert.match(second.reason, /正在被/)
await env.store.releaseLease(project.id, 'bot-gongbu')
const third = await env.store.acquireLease(project.id, { holder: 'bot-other', taskId: 't3' })
assert.equal(third.ok, true)
} finally {
await env.cleanup()
}
})
test('Q11:模型配置先全部校验,任一无效时零修改', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.reload()
const project = Object.values(env.store.peek().projects)[0]
const before = env.calls.updated.length
const result = await env.tool('sansheng_config').execute({
project: project.id,
models: { lead: 'provider/ok', shangshu: 'bad' },
}, userExec)
assert.match(result, /不可用/)
assert.equal(env.calls.updated.length, before, '无效模型不应产生任何 updateBot')
assert.equal(env.store.projectById(project.id).models.lead, undefined)
} finally {
await env.cleanup()
}
})
test('Q11b:中途 updateBot 失败时回滚已经修改的模型', async () => {
const env = await setup()
try {
await env.tool('sansheng_provision').execute({ project: '项目A', workDir: 'C:/work/a' }, userExec)
await env.reload()
const project = Object.values(env.store.peek().projects)[0]
const original = env.rt.updateBot
env.rt.updateBot = async (id, patch) => {
if (id === project.bots.shangshu && patch.model === 'provider/m2') throw new Error('模拟第二模型更新失败')
return original.call(env.rt, id, patch)
}
const result = await env.tool('sansheng_config').execute({
project: project.id,
models: { lead: 'provider/m1', shangshu: 'provider/m2' },
}, userExec)
assert.match(result, /已回滚/)
const updates = env.calls.updated.slice(-2)
assert.equal(updates[0].id, project.bots.lead)
assert.equal(updates[0].patch.model, 'provider/m1')
assert.equal(updates[1].id, project.bots.lead)
assert.equal(updates[1].patch.model, null, '回滚到原值')
} finally {
await env.cleanup()
}
})