@zhushanwen/pi-subagent-workflow 8.6.0 → 8.8.0

package/src/execution/__tests__/channel-registry-handshake.test.ts

@@ -1,243 +0,0 @@
-// src/execution/__tests__/channel-registry-handshake.test.ts
-//
-// 决策 D（修复 M4）：channel handshake 协议升级测试。
-//
-// 测试对象：extensions/universal/subagent-workflow/src/execution/channel-registry-access.ts
-//
-// 协议契约（与 ask-user 侧严格对齐）：
-//   key 字面量：     "@zhushanwen/pi-subagents.channelHandshake"
-//   handshake 形状： { version: 1, registry?: UiChannelRegistry, pending: [{channel,handler}] }
-//   canonical 唯一创建点：getOrCreateChannelRegistry（仅 subagent-workflow 侧创建）
-//
-// 关键不变量：
-//   1. canonical registry 永远由 subagent-workflow 创建
-//   2. ask-user 先到时只往 slot.pending 推，subagent-workflow 来时 flush
-//   3. 重复调用返回同一实例（===）
-//   4. version !== 1 时 warn + 丢弃重建
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-// Mock 共享 logger，让 logger.warn 可被 spy（源码已从 console.warn 改为 logger.warn）
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: {
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-  },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({
-  getLogger: () => loggerMock,
-}));
-
-import {
-  CHANNEL_HANDSHAKE_KEY,
-  getOrCreateChannelRegistry,
-  type ChannelRegistryHandshake,
-} from "../channel-registry-access.ts";
-
-// ── 用例隔离：每个用例前清空 globalThis 槽位 ─────────────────
-// handshake 是 globalThis 单例，跨用例污染会破坏测试确定性。
-function clearSlot(): void {
-  Reflect.deleteProperty(globalThis, CHANNEL_HANDSHAKE_KEY);
-}
-
-afterEach(() => {
-  clearSlot();
-  loggerMock.warn.mockClear();
-});
-
-/** 读取当前 slot（绕过本模块的 readHandshakeSlot，测试断言用）。 */
-function readRawSlot(): ChannelRegistryHandshake | undefined {
-  return Reflect.get(globalThis, CHANNEL_HANDSHAKE_KEY) as ChannelRegistryHandshake | undefined;
-}
-
-/** 手动塞一个 slot（模拟 ask-user 先到的场景）。 */
-function injectSlot(slot: ChannelRegistryHandshake): void {
-  Reflect.set(globalThis, CHANNEL_HANDSHAKE_KEY, slot);
-}
-
-describe("getOrCreateChannelRegistry — 空 globalThis 场景", () => {
-  it("空 slot → 创建 canonical + slot，返回的 registry 有 register/resolve/list，slot.version===1，pending 为 []", () => {
-    clearSlot();
-    const registry = getOrCreateChannelRegistry();
-
-    // registry 形状：canonical 三方法
-    expect(typeof registry.register).toBe("function");
-    expect(typeof registry.resolve).toBe("function");
-    expect(typeof registry.list).toBe("function");
-
-    // slot 被填充且形状正确
-    const slot = readRawSlot();
-    expect(slot).toBeDefined();
-    expect(slot!.version).toBe(1);
-    expect(slot!.registry).toBe(registry); // slot.registry 指向返回的 registry
-    expect(slot!.pending).toEqual([]);
-  });
-});
-
-describe("getOrCreateChannelRegistry — ask-user 先到（registry 未就绪 + pending 非空）", () => {
-  it("模拟 ask-user 先到塞 pending → getOrCreate 创建 canonical + flush pending（handler 注册成功 + pending 清空）", () => {
-    clearSlot();
-    // ask-user 先到：塞 version:1 slot，registry 未就绪，pending 有 1 条
-    const handler = vi.fn();
-    injectSlot({
-      version: 1,
-      pending: [{ channel: "ask_user", handler }],
-    });
-
-    const registry = getOrCreateChannelRegistry();
-
-    // canonical registry 被创建，pending 被 flush
-    expect(registry.resolve("ask_user")).toBe(handler);
-    // pending 已清空
-    const slot = readRawSlot();
-    expect(slot!.pending).toEqual([]);
-    // slot.registry 现在指向返回的 registry
-    expect(slot!.registry).toBe(registry);
-  });
-
-  it("flush 后 registry.resolve 能拿到 handler（集成验证 resolve 真的能取到）", () => {
-    clearSlot();
-    const handler = vi.fn();
-    injectSlot({
-      version: 1,
-      pending: [{ channel: "ask_user", handler }],
-    });
-
-    const registry = getOrCreateChannelRegistry();
-    // 调一次 resolve 拿到的 handler，确认是原始 handler 引用
-    const resolved = registry.resolve("ask_user");
-    expect(resolved).toBe(handler);
-  });
-});
-
-describe("getOrCreateChannelRegistry — 二次调用（registry 已就绪）", () => {
-  it("二次调用返回同一实例引用（===），不重建，不重复 flush", () => {
-    clearSlot();
-    const first = getOrCreateChannelRegistry();
-    const second = getOrCreateChannelRegistry();
-    expect(second).toBe(first); // 引用相等
-
-    // slot.registry 也仍指向同一实例
-    const slot = readRawSlot();
-    expect(slot!.registry).toBe(first);
-    expect(slot!.registry).toBe(second);
-  });
-
-  it("二次调用不重复 flush（pending 已清空，再次调用 pending 仍为 []）", () => {
-    clearSlot();
-    const handler = vi.fn();
-    injectSlot({
-      version: 1,
-      pending: [{ channel: "ask_user", handler }],
-    });
-
-    getOrCreateChannelRegistry(); // 第一次：flush + 清空 pending
-    getOrCreateChannelRegistry(); // 第二次：应跳过 flush 分支
-
-    const slot = readRawSlot();
-    expect(slot!.pending).toEqual([]);
-    // handler 仍只被注册一次（resolve 仍是原 handler）
-    const registry = slot!.registry!;
-    expect(registry.resolve("ask_user")).toBe(handler);
-    expect(registry.list()).toEqual(["ask_user"]);
-  });
-});
-
-describe("getOrCreateChannelRegistry — canonical registry 三方法（形状验证）", () => {
-  it("返回的 registry register 后 resolve 拿到 handler，list 列出 channel 名", () => {
-    clearSlot();
-    const registry = getOrCreateChannelRegistry();
-    const handler = vi.fn();
-    registry.register("custom_channel", handler);
-
-    expect(registry.resolve("custom_channel")).toBe(handler);
-    expect(registry.list()).toContain("custom_channel");
-  });
-
-  it("未注册的 channel resolve 返回 undefined", () => {
-    clearSlot();
-    const registry = getOrCreateChannelRegistry();
-    expect(registry.resolve("not_registered")).toBeUndefined();
-  });
-});
-
-describe("getOrCreateChannelRegistry — 多条 pending flush 顺序与覆盖", () => {
-  it("多条 pending（不同 channel）flush 后都被注册，list 顺序保留插入顺序", () => {
-    clearSlot();
-    const h1 = vi.fn();
-    const h2 = vi.fn();
-    const h3 = vi.fn();
-    injectSlot({
-      version: 1,
-      pending: [
-        { channel: "alpha", handler: h1 },
-        { channel: "beta", handler: h2 },
-        { channel: "gamma", handler: h3 },
-      ],
-    });
-
-    const registry = getOrCreateChannelRegistry();
-    expect(registry.resolve("alpha")).toBe(h1);
-    expect(registry.resolve("beta")).toBe(h2);
-    expect(registry.resolve("gamma")).toBe(h3);
-    expect(registry.list()).toEqual(["alpha", "beta", "gamma"]);
-  });
-
-  it("同名 channel 后者覆盖前者（pending 内重复 channel）", () => {
-    clearSlot();
-    const old = vi.fn();
-    const fresh = vi.fn();
-    injectSlot({
-      version: 1,
-      pending: [
-        { channel: "ask_user", handler: old },
-        { channel: "ask_user", handler: fresh }, // 后者覆盖
-      ],
-    });
-
-    const registry = getOrCreateChannelRegistry();
-    expect(registry.resolve("ask_user")).toBe(fresh);
-    // list 不重复（Map key 唯一）
-    expect(registry.list()).toEqual(["ask_user"]);
-  });
-});
-
-describe("getOrCreateChannelRegistry — version 校验（向前兼容）", () => {
-  it("version !== 1（如塞 {version:2,...}）→ warn + 重建为新 slot，旧 pending 数据丢弃", () => {
-    clearSlot();
-    loggerMock.warn.mockClear();
-    // 塞一个 version:2 的 slot，含旧数据
-    const staleHandler = vi.fn();
-    injectSlot({
-      version: 2 as unknown as 1, // 故意写错 version
-      registry: undefined,
-      pending: [{ channel: "ask_user", handler: staleHandler }],
-    });
-
-    const registry = getOrCreateChannelRegistry();
-
-    // warn 被调用
-    expect(loggerMock.warn).toHaveBeenCalled();
-    // 旧 pending 数据被丢弃（staleHandler 没被注册）
-    expect(registry.resolve("ask_user")).toBeUndefined();
-    // slot 被重建为 version:1，pending 为空
-    const slot = readRawSlot();
-    expect(slot!.version).toBe(1);
-    expect(slot!.pending).toEqual([]);
-    expect(slot!.registry).toBe(registry);
-  });
-
-  it("version !== 1 时 warn 消息包含 got/expected 字样", () => {
-    clearSlot();
-    loggerMock.warn.mockClear();
-    injectSlot({ version: 99 as unknown as 1, pending: [] });
-
-    getOrCreateChannelRegistry();
-
-    const msg = loggerMock.warn.mock.calls[0]?.[0] ?? "";
-    expect(String(msg)).toMatch(/got/);
-    expect(String(msg)).toMatch(/expected/);
-  });
-});