chatgpt-mcp/test/providers/openai.test.js

import { describe, it, expect, vi, beforeEach } from "vitest";

// Use module-level mock objects that we can mutate between tests.
// vi.mock() hoists to top-of-file, so these functions are set once and
// their closure captures persist across the whole test file execution.
// We reset call history in beforeEach but leave impl as-is (or update per-test).

const _impl = { client: null, send: null };

function createOpenAIClientMock(config) {
  if (_impl.client) return _impl.client(config);
  return { apiKey: config?.openaiApiKey || "default-key" };
}

async function sendOpenAIResponseMock(client, params) {
  if (_impl.send) return _impl.send(client, params);
  return { content: "mocked response from openaiProvider.send" };
}

vi.mock("../../src/openai/client.js", () => ({
  createOpenAIClient: createOpenAIClientMock,
}));

vi.mock("../../src/openai/responses.js", () => ({
  sendOpenAIResponse: sendOpenAIResponseMock,
}));

const { openaiProvider } = await import("../../src/providers/openai.js");

function resetImpl() {
  _impl.client = null;
  _impl.send = null;
}

describe("openaiProvider.send", () => {
  beforeEach(resetImpl);

  it("calls createOpenAIClient with the full config", async () => {
    const config = { openaiApiKey: "sk-test", openaiModel: "gpt-5.1" };
    let capturedConfig = null;
    _impl.client = (cfg) => { capturedConfig = cfg; return { apiKey: cfg?.openaiApiKey }; };

    await openaiProvider.send("test input", config);

    expect(capturedConfig).toBe(config);
  });

  it("passes input as system message in the requests array", async () => {
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: "hello world" }]);
      return { content: "ok" };
    };

    await openaiProvider.send("hello world", { openaiApiKey: "sk-test" });
  });

  it("passes model from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.model).toBe("gpt-5.1-preview");
      return { content: "ok" };
    };

    await openaiProvider.send("test", { openaiApiKey: "sk-test", openaiModel: "gpt-5.1-preview" });
  });

  it("passes temperature from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.temperature).toBe(0.7);
      return { content: "ok" };
    };

    await openaiProvider.send("test", { openaiApiKey: "sk-test", temperature: 0.7 });
  });

  it("passes maxOutputTokens from config", async () => {
    _impl.send = async (client, params) => {
      expect(params.maxOutputTokens).toBe(4096);
      return { content: "ok" };
    };

    await openaiProvider.send("test", { openaiApiKey: "sk-test", maxOutputTokens: 4096 });
  });

  it("returns { content } from sendOpenAIResponse result", async () => {
    _impl.send = async () => ({ content: "hello AI" });
    const config = { openaiApiKey: "sk-test" };
    const result = await openaiProvider.send("test input", config);
    expect(result).toEqual({ content: "hello AI" });
  });

  it("calls createOpenAIClient before sendOpenAIResponse (order)", async () => {
    const callOrder = [];
    _impl.client = (cfg) => { callOrder.push("client"); return { apiKey: cfg?.openaiApiKey }; };
    _impl.send = async () => { callOrder.push("send"); return { content: "ok" }; };

    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
    expect(callOrder).toEqual(["client", "send"]);
  });

  it("passes client as first arg to sendOpenAIResponse", async () => {
    _impl.send = async (client, params) => {
      expect(client.apiKey).toBe("sk-test");
      return { content: "ok" };
    };

    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
  });

  it("creates a new client on each send call (no reuse)", async () => {
    let count = 0;
    _impl.client = () => { count++; return { apiKey: "sk-test" }; };
    const config = { openaiApiKey: "sk-test" };
    await openaiProvider.send("test 1", config);
    await openaiProvider.send("test 2", config);
    expect(count).toBe(2);
  });

  it("returns the raw content string wrapped in { content } object", async () => {
    _impl.send = async () => ({ content: "raw AI output" });
    const config = { openaiApiKey: "sk-test" };
    const result = await openaiProvider.send("test", config);
    expect(result.content).toBe("raw AI output");
  });

  it("works with empty input string", async () => {
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: "" }]);
      return { content: "ok" };
    };

    await openaiProvider.send("", { openaiApiKey: "sk-test" });
  });

  it("works with multi-line input", async () => {
    const multiline = "line 1\nline 2\nline 3";
    _impl.send = async (client, params) => {
      expect(params.input).toEqual([{ role: "system", content: multiline }]);
      return { content: "ok" };
    };

    await openaiProvider.send(multiline, { openaiApiKey: "sk-test" });
  });

  it("uses undefined values when config fields are missing", async () => {
    _impl.send = async (client, params) => {
      expect(params.model).toBeUndefined();
      expect(params.temperature).toBeUndefined();
      expect(params.maxOutputTokens).toBeUndefined();
      return { content: "ok" };
    };

    await openaiProvider.send("test", { openaiApiKey: "sk-test" });
  });

  it("throws when createOpenAIClient throws", async () => {
    _impl.client = () => { throw new Error("No API key"); };
    const config = {};
    await expect(openaiProvider.send("test", config)).rejects.toThrow("No API key");
  });

  it("passes through sendOpenAIResponse errors", async () => {
    _impl.send = async () => { throw new Error("API error"); };
    const config = { openaiApiKey: "sk-test" };
    await expect(openaiProvider.send("test", config)).rejects.toThrow("API error");
  });

  it("is idempotent — same input produces same call pattern", async () => {
    let capturedModel, capturedContent;
    _impl.send = async (client, params) => {
      capturedModel = params.model;
      capturedContent = params.input[0].content;
      return { content: "ok" };
    };

    await openaiProvider.send("identical input", { openaiApiKey: "sk-test", openaiModel: "gpt-5.1" });
    expect(capturedModel).toBe("gpt-5.1");
    expect(capturedContent).toBe("identical input");
  });

  it("handles special characters in input", async () => {
    const specialInput = '<script>alert("xss")</script>';
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(specialInput);
      return { content: "ok" };
    };

    await openaiProvider.send(specialInput, { openaiApiKey: "sk-test" });
  });

  it("handles unicode in input", async () => {
    const unicodeInput = "こんにちは世界 🌍";
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(unicodeInput);
      return { content: "ok" };
    };

    await openaiProvider.send(unicodeInput, { openaiApiKey: "sk-test" });
  });

  it("handles very long input", async () => {
    const longInput = "a".repeat(50000);
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBe(longInput);
      return { content: "ok" };
    };

    await openaiProvider.send(longInput, { openaiApiKey: "sk-test" });
  });

  it("does not modify the input parameter", async () => {
    const input = "original";
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send(input, { openaiApiKey: "sk-test" });
    expect(input).toBe("original");
  });

  it("does not modify the config object", async () => {
    const config = { openaiApiKey: "sk-test", temperature: 0.2 };
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send("test", config);
    expect(config.temperature).toBe(0.2);
  });

  it("returns mocked response when no custom impl set", async () => {
    const result = await openaiProvider.send("any input", { openaiApiKey: "sk-test" });
    expect(result.content).toBe("mocked response from openaiProvider.send");
  });

  it("works with null input", async () => {
    _impl.send = async (client, params) => {
      expect(params.input[0].content).toBeNull();
      return { content: "ok" };
    };

    await openaiProvider.send(null, { openaiApiKey: "sk-test" });
  });

  it("works with object input", async () => {
    const objInput = { foo: "bar" };
    _impl.send = async (client, params) => {
      expect(params.input[0].role).toBe("system");
      return { content: "ok" };
    };

    await openaiProvider.send(objInput, { openaiApiKey: "sk-test" });
  });

  it("passes the correct config through createOpenAIClient", async () => {
    let captured = null;
    _impl.client = (cfg) => { captured = cfg; return { apiKey: cfg.openaiApiKey }; };
    _impl.send = async () => ({ content: "ok" });

    const config = { openaiApiKey: "sk-specific", temperature: 0.9, maxOutputTokens: 8192 };
    await openaiProvider.send("test", config);
    expect(captured.openaiApiKey).toBe("sk-specific");
    expect(captured.temperature).toBe(0.9);
    expect(captured.maxOutputTokens).toBe(8192);
  });

  it("does not share state between send calls", async () => {
    let clientCalls = [];
    _impl.client = (cfg) => { clientCalls.push(cfg.openaiApiKey); return { apiKey: cfg.openaiApiKey }; };
    _impl.send = async () => ({ content: "ok" });

    await openaiProvider.send("test 1", { openaiApiKey: "key-1" });
    await openaiProvider.send("test 2", { openaiApiKey: "key-2" });
    expect(clientCalls).toEqual(["key-1", "key-2"]);
  });

  it("handles undefined config gracefully (no crashes)", async () => {
    _impl.send = async () => ({ content: "ok" });
    await openaiProvider.send("test", {});
  });
});