Skip to content
Python
9.0 KB
Raw Blame
// @vitest-environment jsdom

import type {
  AskMemoryResponse,
  GovernedMemory,
  MemoryDetail,
  MemoryGraphNode,
  MemoryGraphResponse,
} from "@one-memory/contracts";
import { cleanup, render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { afterEach, describe, expect, it, vi } from "vitest";
import { LANGUAGE_STORAGE_KEY, LanguageProvider } from "./gui-language";
import { OptionMenu } from "./OptionMenu";
import { Answer, NodeDetail } from "./Workbench";

it("localiza y mantiene cerrado el menú auxiliar sin opciones", async () => {
  window.localStorage.setItem(LANGUAGE_STORAGE_KEY, "es");
  render(
    <LanguageProvider>
      <OptionMenu value="" options={[]} onChange={vi.fn()} />
    </LanguageProvider>,
  );
  const menu = screen.getByRole("combobox", {
    name: "Selecciona una opción",
  });
  menu.focus();
  await userEvent.keyboard("{Enter}{ArrowDown}");
  expect(menu.getAttribute("aria-expanded")).toBe("false");
  expect(menu.getAttribute("aria-activedescendant")).toBeNull();
  window.localStorage.removeItem(LANGUAGE_STORAGE_KEY);
});

it("traduce la respuesta visible sin traducir la respuesta del modelo", () => {
  window.localStorage.setItem(LANGUAGE_STORAGE_KEY, "es");
  render(
    <LanguageProvider>
      <Answer
        answer={null}
        streaming={{ text: "Respuesta 中文 opaca", memories: [] }}
        onOpenMemory={vi.fn()}
        onSaveAnswer={vi.fn()}
        asPage={false}
      />
    </LanguageProvider>,
  );
  expect(screen.getByText("Respuesta 中文 opaca")).toBeTruthy();
  expect(screen.getByText("Se recuperaron 0 memorias")).toBeTruthy();
  window.localStorage.removeItem(LANGUAGE_STORAGE_KEY);
});

afterEach(cleanup);

function memory(
  id: string,
  overrides: Partial<GovernedMemory> = {},
): GovernedMemory {
  return {
    memory_id: id,
    user_id: "local",
    kind: "chat",
    status: "confirmed",
    content: `记忆 ${id}`,
    scopes: ["all-apps"],
    evidence_ids: [`ev-${id}`],
    origin: "extracted",
    tags: [],
    revision: 1,
    created_at: "2026-09-01T00:00:00Z",
    updated_at: "2026-09-01T00:00:00Z",
    deleted_at: null,
    ...overrides,
  };
}

const detail: MemoryDetail = {
  memory: memory("memory-1", { content: "统一用 axios 封装" }),
  evidence: [],
  history: [],
  index_sync: null,
} as MemoryDetail;

function nodeDetail(props: Partial<Parameters<typeof NodeDetail>[0]> = {}) {
  const handlers = {
    onDraft: vi.fn(),
    onSave: vi.fn(),
    onDelete: vi.fn(),
    onClose: vi.fn(),
  };
  render(
    <NodeDetail
      node={null}
      graph={null}
      detail={null}
      draft=""
      busy={false}
      matterLabel="全部"
      requestIds={{ current: new Map() }}
      {...handlers}
      {...props}
    />,
  );
  return handlers;
}

describe("记忆可以改也可以删", () => {
  it("选中一条记忆后,改写和删除都在手边", async () => {
    const user = userEvent.setup();
    const { onDelete } = nodeDetail({ detail, draft: "统一用 axios 封装" });

    expect(screen.getByLabelText("记忆内容")).toBeTruthy();
    expect(screen.getByRole("button", { name: "保存纠正" })).toBeTruthy();

    await user.click(screen.getByRole("button", { name: "删除" }));
    expect(onDelete).toHaveBeenCalledTimes(1);
  });

  it("没有撤销,也没有索引同步:SDK 记忆没有版本可退", () => {
    nodeDetail({
      detail: {
        ...detail,
        history: [
          { ...detail.memory, revision: 1, action: "create" },
          { ...detail.memory, revision: 2, action: "correct" },
        ],
      } as unknown as MemoryDetail,
      draft: "统一用 axios 封装",
    });

    expect(screen.queryByRole("button", { name: "撤销上次修改" })).toBeNull();
    expect(screen.queryByRole("button", { name: /重试同步/ })).toBeNull();
  });

  it("改动文字会作废预备好的请求 id,避免用旧 id 提交新内容", async () => {
    const user = userEvent.setup();
    const requestIds = { current: new Map([["memory-1:correct:1", "old"]]) };
    nodeDetail({ detail, draft: "统一用 axios 封装", requestIds });

    await user.type(screen.getByLabelText("记忆内容"), "改");

    expect(requestIds.current.size).toBe(0);
  });

  it("已删除的记忆不再摆一个删除按钮", () => {
    nodeDetail({
      detail: {
        ...detail,
        memory: { ...detail.memory, status: "deleted" },
      } as MemoryDetail,
      draft: "统一用 axios 封装",
    });

    expect(screen.queryByRole("button", { name: "删除" })).toBeNull();
    expect(screen.queryByLabelText("记忆内容")).toBeNull();
  });
});

describe("节点详情说得出每条线的来头", () => {
  const node = (id: string, type: string, label: string) =>
    ({ node_id: id, node_type: type, label }) as unknown as MemoryGraphNode;

  it("一个主题挂着的记忆和这条线的来头都说得出来", () => {
    // edgeOriginLabel 是一条 if 链、以「原话来源」兜底,所以漏掉一种来源不会
    // 报错,只会把主题的线说成是原话来源。
    nodeDetail({
      node: node("topic:axios", "topic", "axios"),
      graph: {
        total_memories: 2,
        projected_memories: 2,
        hy_graph_available: false,
        nodes: [
          node("topic:axios", "topic", "axios"),
          node("memory:a", "memory", "统一走 axios"),
          node("memory:b", "memory", "测试先行"),
        ],
        edges: [
          {
            edge_id: "e1",
            source_node_id: "topic:axios",
            target_node_id: "memory:a",
            relation: "shared_tag",
            origin: "shared_tag",
          },
          {
            edge_id: "e2",
            source_node_id: "topic:axios",
            target_node_id: "memory:b",
            relation: "shared_tag",
            origin: "shared_tag",
          },
        ],
      } as MemoryGraphResponse,
    });

    const panel = screen.getByLabelText("这个节点");
    expect(panel.textContent).toContain("主题");
    expect(panel.textContent).toContain("统一走 axios");
    expect(panel.textContent).toContain("同一个主题");
    expect(panel.textContent).not.toContain("原话来源");
  });

  it("Core 送来未知的节点类型或连线来头时,仍然说得出一个词而不是留空", () => {
    nodeDetail({
      node: node("future:x", "future_kind", "新节点"),
      graph: {
        total_memories: 1,
        projected_memories: 1,
        hy_graph_available: false,
        nodes: [
          node("future:x", "future_kind", "新节点"),
          node("memory:a", "memory", "统一走 axios"),
        ],
        edges: [
          {
            edge_id: "e1",
            source_node_id: "future:x",
            target_node_id: "memory:a",
            relation: "related_to",
            origin: "future_origin",
          },
        ],
      } as unknown as MemoryGraphResponse,
    });

    const panel = screen.getByLabelText("这个节点");
    expect(panel.querySelector(".wb-status")?.textContent).toBe("记忆");
    expect(panel.querySelector(".wb-trace-origin")?.textContent).toBe(
      "原话来源",
    );
  });
});

const ANSWER = {
  answer: "综合起来,你在前端一律走 axios 封装。",
  memories: [
    memory("m1", { evidence_ids: ["ev-a", "ev-b"] }),
    memory("m2", { evidence_ids: ["ev-b", "ev-c"] }),
  ],
  mode: "generated",
} as AskMemoryResponse;

function answer(props: Partial<Parameters<typeof Answer>[0]> = {}) {
  const onSaveAnswer = vi.fn();
  render(
    <Answer
      answer={null}
      streaming={null}
      onOpenMemory={vi.fn()}
      onSaveAnswer={onSaveAnswer}
      asPage={false}
      {...props}
    />,
  );
  return { onSaveAnswer };
}

describe("问出来的东西留得下来", () => {
  it("存下来带着它依据的那几条记忆的出处", async () => {
    const user = userEvent.setup();
    const { onSaveAnswer } = answer({ answer: ANSWER });

    await user.click(screen.getByRole("button", { name: "存为记忆" }));

    await waitFor(() =>
      expect(onSaveAnswer).toHaveBeenCalledWith({
        content: "综合起来,你在前端一律走 axios 封装。",
        evidence_ids: ["ev-a", "ev-b", "ev-c"],
      }),
    );
  });

  it("没命中任何记忆的回答存不下来", () => {
    answer({
      answer: {
        answer: "没有找到相关记忆。",
        memories: [],
        mode: "empty",
      } as AskMemoryResponse,
    });

    expect(screen.queryByRole("button", { name: "存为记忆" })).toBeNull();
  });

  it("还在流式输出的时候不给存,存下来的得是完整那一份", () => {
    answer({ streaming: { text: "综合起", memories: [memory("m1")] } });

    expect(screen.queryByRole("button", { name: "存为记忆" })).toBeNull();
  });

  it("答案长到不像一条记忆时,不硬塞进库", () => {
    answer({
      answer: { ...ANSWER, answer: "很".repeat(601) } as AskMemoryResponse,
    });

    expect(screen.queryByRole("button", { name: "存为记忆" })).toBeNull();
    expect(screen.getByText(/太长/)).toBeTruthy();
  });
});