heartbeat-company-scoped.test.js 8.8 KB
/**
 * 28 号改造遗留项 —— 心跳设置是**公司级**状态,不许落到全系统共享的本体上。
 *
 * 改之前 `PUT/POST /api/company/:cid/agents/:aid/heartbeat*` 三个端点读改写的是
 * `system/agents/{aid}/config.json`:本体只有一份,所以 A 公司把某角色调成 30 分钟,
 * 雇了同一个本体的 B 公司会跟着变。而且危害不止「用户点了开关」—— 端点是
 * **读的时候补默认值再整份回写**,28 号 E2E 全程没人碰过心跳设置,
 * `system/agents/orggraph-planning/config.json` 照样多出一行 `"intervalMinutes": 15`
 * (这条 diff 就是本测试的出处)。同类事故第一轮已经修过一次:公司对话内容写进共享 SKILL.md。
 *
 * 三条断言各锁一个方向:
 *   ① 写 co-A 之后**本体 config.json 的 mtime 与内容一个字节没变**(危害全在磁盘上,只看响应码看不出来);
 *   ② co-B 读到的是它自己的值,不是 co-A 的(跨公司串味);
 *   ③ 没设置过的公司回落到本体的缺省值(本体仍可携带「这个角色建议多久心跳一次」,只是只读)。
 *
 * 隔离手法:
 *   - GRAPH_DB_PATH 指向一次性 sqlite,真实 data/graph.sqlite 全程不碰;
 *   - 端点的本体根硬编码在 `<repo>/system/agents`(无 env 覆盖口),只能在真目录下建具名本体。
 *     **本体建完不删**:测试建出来的 agent 也是正式注册表条目,删掉与「尽量复用 agent」相悖;
 *     afterAll 只清公司态目录(`system/agents/{aid}/{cid}/`,本来就 gitignore)。
 *   - 固定 id、不带随机后缀:随机后缀等于每跑一次单测就往注册表里丢一个再也没人认领的本体。
 */
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import fs from 'fs';
import path from 'path';
import express from 'express';
import { createRequire } from 'node:module';

const require_ = createRequire(import.meta.url);
const REPO_ROOT = path.resolve(__dirname, '../../..');
const AGENTS_ROOT = path.join(REPO_ROOT, 'system', 'agents');

const BODY_ID = 'zz-heartbeat-scoped';               // 本体 id(正式注册表条目,留在仓库里)
const ROLE = 'zz-hb-role';                            // 角色名故意 ≠ 本体 id:顺带锁住 role_name → system_agent_id 的映射
const CO_A = 'zz-hb-co-a';
const CO_B = 'zz-hb-co-b';
const BODY_DIR = path.join(AGENTS_ROOT, BODY_ID);
const BODY_CONFIG = path.join(BODY_DIR, 'config.json');
const TEST_DB_PATH = '/tmp/test-heartbeat-company-scoped.sqlite';

// 本体自带的缺省:42 是个谁也不会碰巧写出来的数,回落断言才有区分度(默认兜底是 15)
const BODY_CONFIG_TEXT = JSON.stringify(
  { id: BODY_ID, name: '心跳公司级化测试本体', type: 'skill', status: 'enabled',
    heartbeat: { enabled: false, intervalMinutes: 42 } },
  null, 2
) + '\n';

describe('心跳设置按公司隔离(28 遗留项)', () => {
  let base;
  let srv;
  let heartbeatService;

  const companyStateDir = (cid) => path.join(BODY_DIR, cid);
  const putHeartbeat = (cid, body) =>
    fetch(`${base}/api/company/${cid}/agents/${ROLE}/heartbeat`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(body),
    });

  beforeAll(async () => {
    // 1. 本体(缺 agent.md / soul.md 的目录不算合格本体,一并写上)
    fs.mkdirSync(BODY_DIR, { recursive: true });
    fs.writeFileSync(path.join(BODY_DIR, 'agent.md'), '# 心跳公司级化测试本体\n\n只用来验证心跳设置不写本体。\n');
    fs.writeFileSync(path.join(BODY_DIR, 'soul.md'), '# 人格\n\n沉默寡言,只负责被测试。\n');
    fs.writeFileSync(BODY_CONFIG, BODY_CONFIG_TEXT);
    // 上一轮跑剩的公司态不能留,否则③的回落断言会读到旧值而空过
    for (const cid of [CO_A, CO_B]) fs.rmSync(companyStateDir(cid), { recursive: true, force: true });

    // 2. 一次性 graph.sqlite + 两家公司的雇佣关系
    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
    for (const m of ['../../services/graph-db', '../../services/graph-service',
      '../../services/org-graph-service', '../../services/company-service',
      '../../services/heartbeat-service', '../../routes/company']) {
      delete require_.cache[require_.resolve(m)];
    }
    const graphDb = require_('../../services/graph-db');
    heartbeatService = require_('../../services/heartbeat-service');
    const db = graphDb.getDb();
    const now = new Date().toISOString();
    db.prepare(`
      INSERT OR REPLACE INTO system_agents (id, name, scope, owner_company_id, source_kind, legacy_path, status, benchmark_score, created_at, updated_at)
      VALUES (?, ?, 'public', NULL, 'template', ?, 'active', NULL, ?, ?)
    `).run(BODY_ID, BODY_ID, `system/agents/${BODY_ID}`, now, now);
    for (const cid of [CO_A, CO_B]) {
      db.prepare(`INSERT OR REPLACE INTO company_agents (company_id, system_agent_id, role_name, status, hired_at)
                  VALUES (?, ?, ?, 'active', ?)`).run(cid, BODY_ID, ROLE, now);
    }

    // 3. 只挂 company 路由,不起真服务器进程(3010 上另有一个在跑)
    const app = express();
    app.use(express.json());
    app.use('/api/company', require_('../../routes/company'));
    await new Promise((resolve) => {
      srv = app.listen(0, '127.0.0.1', () => {
        base = `http://127.0.0.1:${srv.address().port}`;
        resolve();
      });
    });
  });

  afterAll(async () => {
    if (srv) await new Promise((r) => srv.close(r));
    heartbeatService?.stop(); // 端点挂上的 setInterval 会吊住 vitest 进程
    // 只清公司态(运行态、gitignore);本体留在 system/agents/ 里当正式注册表条目
    for (const cid of [CO_A, CO_B]) fs.rmSync(companyStateDir(cid), { recursive: true, force: true });
    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
    delete process.env.GRAPH_DB_PATH;
  });

  it('没设置过的公司回落到本体的缺省心跳(本体可以带缺省,但只读)', () => {
    expect(fs.existsSync(path.join(companyStateDir(CO_A), 'heartbeat.json'))).toBe(false);
    expect(heartbeatService.readHeartbeatConfig(`${CO_A}:${ROLE}`)).toMatchObject({
      enabled: false,
      intervalMinutes: 42,
    });
  });

  it('co-A 改心跳 → 本体 config.json 的 mtime 与内容都没变,值落在公司态目录里', async () => {
    const before = fs.statSync(BODY_CONFIG);

    const res = await putHeartbeat(CO_A, { intervalMinutes: 30, enabled: false });
    expect(res.status).toBe(200);
    expect((await res.json()).heartbeat).toMatchObject({ intervalMinutes: 30 });

    // 危害全在磁盘上:响应码曾经也是 200,脏的是本体那份共享文件
    expect(fs.readFileSync(BODY_CONFIG, 'utf-8')).toBe(BODY_CONFIG_TEXT);
    expect(fs.statSync(BODY_CONFIG).mtimeMs).toBe(before.mtimeMs);

    // 值确实落了盘(否则上一条可以靠「什么都没写」空过)
    const own = JSON.parse(fs.readFileSync(path.join(companyStateDir(CO_A), 'heartbeat.json'), 'utf-8'));
    expect(own.intervalMinutes).toBe(30);
  });

  it('co-B 读到的是自己的值,不跟着 co-A 变', async () => {
    // 此刻 co-A 已是 30,co-B 还没设置过 → 必须仍是本体缺省 42
    expect(heartbeatService.readHeartbeatConfig(`${CO_B}:${ROLE}`).intervalMinutes).toBe(42);

    const res = await putHeartbeat(CO_B, { intervalMinutes: 7, enabled: false });
    expect(res.status).toBe(200);

    expect(heartbeatService.readHeartbeatConfig(`${CO_B}:${ROLE}`).intervalMinutes).toBe(7);
    expect(heartbeatService.readHeartbeatConfig(`${CO_A}:${ROLE}`).intervalMinutes).toBe(30);
    expect(fs.readFileSync(BODY_CONFIG, 'utf-8')).toBe(BODY_CONFIG_TEXT);
  });

  it('start / stop 端点同样只写公司态', async () => {
    const before = fs.statSync(BODY_CONFIG);
    for (const action of ['start', 'stop']) {
      const res = await fetch(`${base}/api/company/${CO_A}/agents/${ROLE}/heartbeat/${action}`, { method: 'POST' });
      expect(res.status).toBe(200);
    }
    expect(fs.readFileSync(BODY_CONFIG, 'utf-8')).toBe(BODY_CONFIG_TEXT);
    expect(fs.statSync(BODY_CONFIG).mtimeMs).toBe(before.mtimeMs);
    // 开关落在公司态,且不影响 co-A 自己的间隔
    expect(heartbeatService.readHeartbeatConfig(`${CO_A}:${ROLE}`)).toMatchObject({
      enabled: false,
      intervalMinutes: 30,
    });
  });

  it('没雇过这个角色的公司 → 404;非法 intervalMinutes → 400(都不落盘)', async () => {
    const res404 = await putHeartbeat('zz-hb-co-never', { enabled: true });
    expect(res404.status).toBe(404);

    const res400 = await putHeartbeat(CO_A, { intervalMinutes: 'abc' });
    expect(res400.status).toBe(400);
    expect(heartbeatService.readHeartbeatConfig(`${CO_A}:${ROLE}`).intervalMinutes).toBe(30);
  });
});