functions.test.ts

import { beforeEach, describe, expect, it, vi } from "vitest";
import {
  buildFunctionOperationErrorMessage,
  buildFunctionQueryErrorMessage,
  DEFAULT_RUNTIME,
  registerFunctionTools,
  resolveEventFunctionRuntime,
  shouldInstallDependencyForFunction,
} from "./functions.js";
import type { ExtendedMcpServer } from "../server.js";

const {
  mockCreateFunction,
  mockCreateAccess,
  mockGetCloudBaseManager,
  mockLogCloudBaseResult,
  mockIsCloudMode,
} = vi.hoisted(() => ({
  mockCreateFunction: vi.fn(),
  mockCreateAccess: vi.fn(),
  mockGetCloudBaseManager: vi.fn(),
  mockLogCloudBaseResult: vi.fn(),
  mockIsCloudMode: vi.fn(),
}));

vi.mock("../cloudbase-manager.js", () => ({
  getCloudBaseManager: mockGetCloudBaseManager,
  logCloudBaseResult: mockLogCloudBaseResult,
}));

vi.mock("../utils/cloud-mode.js", () => ({
  isCloudMode: mockIsCloudMode,
}));

vi.mock("../utils/logger.js", () => ({
  debug: vi.fn(),
}));

function createMockServer() {
  const tools: Record<
    string,
    {
      meta: any;
      handler: (args: any) => Promise<any>;
    }
  > = {};

  const server: ExtendedMcpServer = {
    cloudBaseOptions: { envId: "env-test", region: "ap-guangzhou" },
    logger: vi.fn(),
    registerTool: vi.fn(
      (name: string, meta: any, handler: (args: any) => Promise<any>) => {
        tools[name] = { meta, handler };
      },
    ),
  } as unknown as ExtendedMcpServer;

  registerFunctionTools(server);

  return { tools };
}

describe("functions tool helpers", () => {
  let tools: ReturnType<typeof createMockServer>["tools"];

  beforeEach(() => {
    vi.clearAllMocks();
    mockIsCloudMode.mockReturnValue(false);
    mockCreateFunction.mockResolvedValue({
      RequestId: "req-create-function",
      FunctionName: "httpDemo",
    });
    mockCreateAccess.mockResolvedValue({
      RequestId: "req-create-access",
    });
    mockGetCloudBaseManager.mockResolvedValue({
      functions: {
        createFunction: mockCreateFunction,
      },
      access: {
        createAccess: mockCreateAccess,
      },
    });

    ({ tools } = createMockServer());
  });

  it("keeps HTTP functions from forcing dependency install when package.json is absent", () => {
    expect(shouldInstallDependencyForFunction("HTTP", false)).toBe(false);
    expect(shouldInstallDependencyForFunction("HTTP", true)).toBe(true);
  });

  it("returns a clearer HTTP path hint for undefined paths[0] failures", () => {
    const message = buildFunctionOperationErrorMessage(
      "createFunction",
      "httpDemo",
      "/tmp/project/cloudfunctions",
      new Error('[createFunction] The "paths[0]" argument must be of type string. Received undefined'),
    );

    expect(message).toContain("functionRootPath");
    expect(message).toContain("zipFile");
  });

  it("adds dependency-install guidance for HTTP function failures", () => {
    const message = buildFunctionOperationErrorMessage(
      "createFunction",
      "httpDemo",
      "/tmp/project/cloudfunctions",
      new Error("[httpDemo] 函数代码更新失败：云函数创建失败\n状态描述: 依赖安装失败"),
    );

    expect(message).toContain("原生 Node.js API");
    expect(message).toContain("package.json");
  });

  it("warns when functionRootPath looks like project root on path-not-found errors", () => {
    const message = buildFunctionOperationErrorMessage(
      "createFunction",
      "hello",
      "/home/user/my-project",
      new Error("路径不存在"),
    );

    expect(message).toContain("functionRootPath");
    expect(message).toContain("cloudfunctions");
    expect(message).toContain("functions");
    expect(message).toContain("/home/user/my-project/cloudfunctions");
    expect(message).toContain("/home/user/my-project/functions");
  });

  it("does not warn about project root when functionRootPath already ends with cloudfunctions", () => {
    const message = buildFunctionOperationErrorMessage(
      "createFunction",
      "hello",
      "/home/user/my-project/cloudfunctions",
      new Error("路径不存在"),
    );

    expect(message).not.toContain("functionRootPath 应该是直接包含函数文件夹的目录");
  });

  it("normalizes supported Event runtimes with whitespace", () => {
    expect(resolveEventFunctionRuntime("Python 3.9")).toBe("Python3.9");
    expect(resolveEventFunctionRuntime("Php 7.4")).toBe("Php7.4");
  });

  it("falls back to the default runtime when Event runtime is omitted", () => {
    expect(resolveEventFunctionRuntime(undefined)).toBe(DEFAULT_RUNTIME);
  });

  it("rejects unsupported Event runtimes with a helpful message", () => {
    expect(() => resolveEventFunctionRuntime("Ruby3.2")).toThrow(/不支持的运行时环境/);
    expect(() => resolveEventFunctionRuntime("Ruby3.2")).toThrow(/Python3.9/);
  });

  it("provides specific parameter guidance for invalid parameter errors", () => {
    const message = buildFunctionQueryErrorMessage(
      "getFunctionDetail",
      { action: "getFunctionDetail" },
      new Error("400 invalid parameter value"),
    );

    expect(message).toContain("getFunctionDetail");
    expect(message).toContain("functionName");
    expect(message).toContain("必填");
  });

  it("shows current input parameters when reporting errors", () => {
    const message = buildFunctionQueryErrorMessage(
      "getFunctionDetail",
      { action: "getFunctionDetail", functionName: "testFunc" },
      new Error("invalid parameter"),
    );

    expect(message).toContain("testFunc");
    expect(message).toContain("当前传入的参数");
  });

  it("suggests listFunctions when function is not found", () => {
    const message = buildFunctionQueryErrorMessage(
      "getFunctionDetail",
      { action: "getFunctionDetail", functionName: "nonExistentFunc" },
      new Error("Function not found"),
    );

    expect(message).toContain("listFunctions");
    expect(message).toContain("nonExistentFunc");
  });

  it("guides HTTP functions through anonymous-access follow-up without auto-creating gateway access", async () => {
    const result = await tools.manageFunctions.handler({
      action: "createFunction",
      func: {
        name: "httpDemo",
        type: "HTTP",
        runtime: "Nodejs18.15",
      },
      functionRootPath: "/tmp/cloudfunctions",
    });

    const payload = JSON.parse(result.content[0].text);

    expect(mockCreateFunction).toHaveBeenCalledWith({
      func: expect.objectContaining({
        name: "httpDemo",
        type: "HTTP",
        installDependency: false,
      }),
      functionRootPath: "/tmp/cloudfunctions",
      force: false,
    });
    expect(mockCreateAccess).not.toHaveBeenCalled();
    expect(payload.message).toContain("manageGateway(action=\"createAccess\")");
    expect(payload.message).toContain("type=\"HTTP\"");
    expect(payload.message).toContain("匿名身份访问");
    expect(payload.message).toContain("EXCEED_AUTHORITY");
    expect(payload.nextActions).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          tool: "manageGateway",
          action: "createAccess",
        }),
        expect.objectContaining({
          tool: "queryPermissions",
          action: "getResourcePermission",
        }),
        expect.objectContaining({
          tool: "managePermissions",
          action: "updateResourcePermission",
        }),
      ]),
    );
  });
});