Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

11.4 KB
Raw Blame
import { readFileSync } from "node:fs";
import { resolve } from "node:path";

import { describe, expect, it, vi } from "vitest";
import {
  SESSION_ROUTE_NAME,
  findStackedSessionRoute,
  navigateToCollabSession,
  planCollabSessionNavigation,
  type CollabSessionNavigator,
  type CollabSessionRouteLike,
  type CollabSessionStateLike,
  type CollabSessionTarget,
} from "@/session/collabSessionNavigation";
import { recentTaskKey } from "@/session/recentTasks";
// 真实 router 实现:本 bug 的机制就在它的 PUSH 分支里,用真件跑一遍才能防回归。
import { StackRouter } from "expo-router/build/react-navigation/routers/StackRouter";

// Windows checkout 下源码可能是 CRLF;断言跨平台统一按 LF 归一。
const readTextLf = (...args: Parameters<typeof readFileSync>): string =>
  String(readFileSync(...args)).replace(/\r\n/g, "\n");

const lead: CollabSessionTarget = {
  sessionId: "lead-1",
  deviceId: "pc",
  deviceName: "PC",
};
const worker: CollabSessionTarget = {
  sessionId: "worker-1",
  deviceId: "pc",
  deviceName: "PC",
};
const deviceList: CollabSessionTarget = {
  sessionId: "device-list",
  deviceId: "pc",
  deviceName: "PC",
};

const route = (
  target: CollabSessionTarget,
  key: string,
): CollabSessionRouteLike => ({
  name: SESSION_ROUTE_NAME,
  key,
  params: target,
});

const stack = (
  ...routes: CollabSessionRouteLike[]
): CollabSessionStateLike => ({ routes });

function fakeNavigator(state: CollabSessionStateLike | undefined) {
  return {
    getState: () => state,
    push: vi.fn(),
    dismissTo: vi.fn(),
  };
}

describe("collaboration session navigation decision", () => {
  it("falls back (popTo) when the target session is already on the stack", () => {
    const navigator = fakeNavigator(
      stack(route(lead, "L"), route(worker, "W")),
    );

    expect(navigateToCollabSession(navigator, lead, "worker-1")).toBe("popTo");
    // 硬约束:栈里已有目标任务时绝不 push —— 那会把「返回 Lead」变成栈重排。
    expect(navigator.push).not.toHaveBeenCalled();
    expect(navigator.dismissTo).toHaveBeenCalledExactlyOnceWith(lead);
  });

  it("pushes only when the target session is not on the stack yet", () => {
    const navigator = fakeNavigator(
      stack(route(lead, "L"), route(worker, "W")),
    );
    const fresh: CollabSessionTarget = { ...lead, sessionId: "worker-2" };

    expect(navigateToCollabSession(navigator, fresh, "worker-1")).toBe("push");
    expect(navigator.dismissTo).not.toHaveBeenCalled();
    expect(navigator.push).toHaveBeenCalledExactlyOnceWith(fresh);
  });

  it("does nothing on the current session, a missing device or a missing session id", () => {
    const withState = fakeNavigator(stack(route(lead, "L")));

    expect(navigateToCollabSession(withState, lead, "lead-1")).toBe("noop");
    expect(
      navigateToCollabSession(withState, { ...worker, deviceId: "" }, "lead-1"),
    ).toBe("noop");
    expect(
      navigateToCollabSession(
        withState,
        { ...worker, sessionId: "" },
        "lead-1",
      ),
    ).toBe("noop");
    expect(withState.push).not.toHaveBeenCalled();
    expect(withState.dismissTo).not.toHaveBeenCalled();

    // 拿不到导航状态时退化成 push:这是旧行为,不会凭空回退到某个猜测的屏。
    const stateless = fakeNavigator(undefined);
    expect(navigateToCollabSession(stateless, lead, "worker-1")).toBe("push");
    expect(stateless.push).toHaveBeenCalledOnce();
  });

  it("matches the stacked route with the same id the Stack getId derives", () => {
    // 跨电脑的同名任务不算命中;嵌套 navigator 也要找得到。
    const nested: CollabSessionStateLike = {
      routes: [
        route(lead, "L"),
        { name: "tabs", state: stack(route(lead, "NESTED")) },
      ],
    };
    const otherDevice: CollabSessionTarget = { ...lead, deviceId: "other-pc" };

    expect(findStackedSessionRoute(nested, lead)).toBe(true);
    expect(findStackedSessionRoute(nested, otherDevice)).toBe(false);
    expect(planCollabSessionNavigation(nested, lead, "lead-1")).toBe("noop");
    expect(planCollabSessionNavigation(nested, otherDevice, "worker-1")).toBe(
      "push",
    );
    expect(recentTaskKey({ deviceId: "pc", sessionId: "lead-1" })).toBe(
      recentTaskKey(lead),
    );
  });
});

// 用真实 StackRouter 跑一遍 Lead <-> Worker 往返,把生产现象钉成断言:
// 旧口径(每次 push)返回手势落回 Worker;新口径(dismissTo 回退)返回手势落回列表。
describe("collaboration navigation against the real StackRouter", () => {
  const getId = ({ params }: { params?: Record<string, unknown> }) =>
    recentTaskKey(params ?? {});
  const routerConfig = {
    routeNames: [SESSION_ROUTE_NAME],
    routeParamList: {},
    routeGetIdList: { [SESSION_ROUTE_NAME]: getId },
  };
  interface TestRoute {
    key: string;
    name: string;
    params?: Record<string, unknown>;
    state?: unknown;
  }
  interface TestState {
    index: number;
    key: string;
    routeNames: string[];
    routes: TestRoute[];
    preloadedRoutes: TestRoute[];
    stale: boolean;
    type: "stack";
  }
  const startState = (): TestState => ({
    index: 0,
    key: "Stack-root",
    routeNames: [SESSION_ROUTE_NAME],
    routes: [{ ...(route(deviceList, "DEVICES") as TestRoute) }],
    preloadedRoutes: [],
    stale: false,
    type: "stack",
  });
  const sessionIds = (state: TestState) =>
    state.routes.map((item) => String((item.params ?? {}).sessionId));
  const toParams = (target: CollabSessionTarget) => ({
    sessionId: target.sessionId,
    deviceId: target.deviceId,
    deviceName: target.deviceName,
  });

  /** 真 router + 真 action:供 navigator 的 push / dismissTo 落地。 */
  const createDriver = () => {
    const router = StackRouter({});
    let state = startState();
    const apply = (action: unknown) => {
      const next = router.getStateForAction(
        state as never,
        action as never,
        routerConfig as never,
      );
      if (next) state = next as TestState;
    };
    return {
      get state() {
        return state;
      },
      apply,
      push: (target: CollabSessionTarget) =>
        apply({
          type: "PUSH",
          payload: { name: SESSION_ROUTE_NAME, params: toParams(target) },
        }),
      dismissTo: (target: CollabSessionTarget) =>
        apply({
          type: "POP_TO",
          payload: { name: SESSION_ROUTE_NAME, params: toParams(target) },
        }),
    };
  };

  /**
   * 生产路径:每次跳转都由 navigateToCollabSession 自己读栈决定动作,测试不复刻
   * 判断逻辑 —— 否则决策口改成 push 也不会让这里变红。`currentSessionId` 跟着前进,
   * 与真实会话页传入的是同一个值。每一步都录一帧栈快照,供逐步断言。
   */
  const driveThroughDecision = () => {
    const driver = createDriver();
    const navigator: CollabSessionNavigator = {
      getState: () => driver.state as unknown as CollabSessionStateLike,
      push: driver.push,
      dismissTo: driver.dismissTo,
    };
    const steps: { plan: string; stack: string[] }[] = [];
    const open = (target: CollabSessionTarget, currentSessionId: string) => {
      const plan = navigateToCollabSession(navigator, target, currentSessionId);
      steps.push({ plan, stack: [...sessionIds(driver.state)] });
    };

    open(lead, deviceList.sessionId);
    open(worker, lead.sessionId);
    open(lead, worker.sessionId);
    open(worker, lead.sessionId);
    open(lead, worker.sessionId);
    const beforeBack = [...sessionIds(driver.state)];
    driver.apply({ type: "GO_BACK" });
    return { steps, beforeBack, afterBack: sessionIds(driver.state) };
  };

  /**
   * 回归对照:故意绕过决策口,把每次跳转都做成旧的裸 PUSH,用来证明上面的断言确实
   * 能捕捉这个缺陷(若哪天 push 行为不再改写历史,这条会一起变绿,说明对照组该重写)。
   * 它不是生产路径。同样逐步录快照。
   */
  const driveWithLegacyPush = () => {
    const driver = createDriver();
    const steps: { stack: string[] }[] = [];
    const open = (target: CollabSessionTarget) => {
      driver.push(target);
      steps.push({ stack: [...sessionIds(driver.state)] });
    };
    open(lead);
    open(worker);
    open(lead);
    open(worker);
    open(lead);
    const beforeBack = [...sessionIds(driver.state)];
    driver.apply({ type: "GO_BACK" });
    return { steps, beforeBack, afterBack: sessionIds(driver.state) };
  };

  it("reproduces the reordered history when a stacked session is pushed again", () => {
    const legacy = driveWithLegacyPush();
    // 逐步对账:前两步正常压栈,第一次「返回 Lead」开始把顺序对调。
    expect(legacy.steps.map((step) => step.stack)).toEqual([
      ["device-list", "lead-1"],
      ["device-list", "lead-1", "worker-1"],
      ["device-list", "worker-1", "lead-1"],
      ["device-list", "lead-1", "worker-1"],
      ["device-list", "worker-1", "lead-1"],
    ]);
    // 「返回 Lead」把 Lead 提到顶、Worker 掉到它下面 —— 用户看到的「右滑又进了 Worker」。
    expect(legacy.beforeBack).toEqual(["device-list", "worker-1", "lead-1"]);
    expect(legacy.afterBack).toEqual(["device-list", "worker-1"]);
  });

  it("keeps the history truthful when a stacked session is popped back to", () => {
    const fixed = driveThroughDecision();
    // 逐步对账:两轮都真的发生了(Worker 先压栈、返回时回退),首次进 Worker 与
    // 复位后的二次进 Worker 各自可验,不会因为只看末态而漏掉中间跳转。
    expect(fixed.steps.map((step) => step.plan)).toEqual([
      "push",
      "push",
      "popTo",
      "push",
      "popTo",
    ]);
    expect(fixed.steps.map((step) => step.stack)).toEqual([
      ["device-list", "lead-1"],
      ["device-list", "lead-1", "worker-1"],
      ["device-list", "lead-1"],
      ["device-list", "lead-1", "worker-1"],
      ["device-list", "lead-1"],
    ]);
    expect(fixed.beforeBack).toEqual(["device-list", "lead-1"]);
    expect(fixed.afterBack).toEqual(["device-list"]);
  });
});

// 调用点契约:协同跳转必须经过上面的决策口,不能再有裸 push。
describe("collaboration navigation wiring", () => {
  const source = readTextLf(
    resolve(process.cwd(), "app/sessions/[sessionId].tsx"),
    "utf8",
  );
  const start = source.indexOf("const openCollabSession = useCallback");
  const end = source.indexOf("// 来源目录在协同 hook 之后才取得", start);

  it("routes collab navigation through the popTo/push decision", () => {
    expect(start).toBeGreaterThan(-1);
    expect(end).toBeGreaterThan(start);
    const block = source.slice(start, end);
    expect(source).toContain("} from '@/session/collabSessionNavigation';");
    expect(source).toContain("navigateToCollabSession,");
    expect(source).toContain("type CollabSessionStateLike,");
    expect(block).toContain("navigateToCollabSession(");
    expect(block).toContain("getState: () => navigation.getState(),");
    expect(block).toContain("push: (target) => router.push({");
    expect(block).toContain("dismissTo: (target) => router.dismissTo({");
    // 旧的裸 push(直接拿目标 id 组 params)已不存在:那正是命中「同 id 复用 + 移到栈顶」的那一行。
    expect(block).not.toContain(
      "params: { sessionId: targetSessionId, deviceId, deviceName }",
    );
    // getRootState 只存在于容器 ref,useNavigation 返回的对象上没有:写了就是运行时 TypeError。
    expect(source).not.toContain("navigation.getRootState()");
  });
});