113 lines
3.0 KiB
TypeScript
113 lines
3.0 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { OpenClawConfig } from "../../config/config.js";
|
|
|
|
const loadConfig = vi.hoisted(() => vi.fn(() => ({}) as OpenClawConfig));
|
|
const resolveDefaultAgentId = vi.hoisted(() => vi.fn(() => "main"));
|
|
const getMemorySearchManager = vi.hoisted(() => vi.fn());
|
|
|
|
vi.mock("../../config/config.js", () => ({
|
|
loadConfig,
|
|
}));
|
|
|
|
vi.mock("../../agents/agent-scope.js", () => ({
|
|
resolveDefaultAgentId,
|
|
}));
|
|
|
|
vi.mock("../../memory/index.js", () => ({
|
|
getMemorySearchManager,
|
|
}));
|
|
|
|
import { doctorHandlers } from "./doctor.js";
|
|
|
|
const invokeDoctorMemoryStatus = async (respond: ReturnType<typeof vi.fn>) => {
|
|
await doctorHandlers["doctor.memory.status"]({
|
|
req: {} as never,
|
|
params: {} as never,
|
|
respond: respond as never,
|
|
context: {} as never,
|
|
client: null,
|
|
isWebchatConnect: () => false,
|
|
});
|
|
};
|
|
|
|
const expectEmbeddingErrorResponse = (respond: ReturnType<typeof vi.fn>, error: string) => {
|
|
expect(respond).toHaveBeenCalledWith(
|
|
true,
|
|
{
|
|
agentId: "main",
|
|
embedding: {
|
|
ok: false,
|
|
error,
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
};
|
|
|
|
describe("doctor.memory.status", () => {
|
|
beforeEach(() => {
|
|
loadConfig.mockClear();
|
|
resolveDefaultAgentId.mockClear();
|
|
getMemorySearchManager.mockReset();
|
|
});
|
|
|
|
it("returns gateway embedding probe status for the default agent", async () => {
|
|
const close = vi.fn().mockResolvedValue(undefined);
|
|
getMemorySearchManager.mockResolvedValue({
|
|
manager: {
|
|
status: () => ({ provider: "gemini" }),
|
|
probeEmbeddingAvailability: vi.fn().mockResolvedValue({ ok: true }),
|
|
close,
|
|
},
|
|
});
|
|
const respond = vi.fn();
|
|
|
|
await invokeDoctorMemoryStatus(respond);
|
|
|
|
expect(getMemorySearchManager).toHaveBeenCalledWith({
|
|
cfg: expect.any(Object),
|
|
agentId: "main",
|
|
purpose: "status",
|
|
});
|
|
expect(respond).toHaveBeenCalledWith(
|
|
true,
|
|
{
|
|
agentId: "main",
|
|
provider: "gemini",
|
|
embedding: { ok: true },
|
|
},
|
|
undefined,
|
|
);
|
|
expect(close).toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns unavailable when memory manager is missing", async () => {
|
|
getMemorySearchManager.mockResolvedValue({
|
|
manager: null,
|
|
error: "memory search unavailable",
|
|
});
|
|
const respond = vi.fn();
|
|
|
|
await invokeDoctorMemoryStatus(respond);
|
|
|
|
expectEmbeddingErrorResponse(respond, "memory search unavailable");
|
|
});
|
|
|
|
it("returns probe failure when manager probe throws", async () => {
|
|
const close = vi.fn().mockResolvedValue(undefined);
|
|
getMemorySearchManager.mockResolvedValue({
|
|
manager: {
|
|
status: () => ({ provider: "openai" }),
|
|
probeEmbeddingAvailability: vi.fn().mockRejectedValue(new Error("timeout")),
|
|
close,
|
|
},
|
|
});
|
|
const respond = vi.fn();
|
|
|
|
await invokeDoctorMemoryStatus(respond);
|
|
|
|
expectEmbeddingErrorResponse(respond, "gateway memory probe failed: timeout");
|
|
expect(close).toHaveBeenCalled();
|
|
});
|
|
});
|