Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
5.7 KB
Raw Blame
import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
import http from "node:http";
import { HccClient } from "../src/hccClient";
import { ProxyConfig } from "../src/types";

function makeConfig(overrides: Partial<ProxyConfig> = {}): ProxyConfig {
  return {
    port: 8083,
    hccApiUrl: "",
    hccPollInterval: 30000,
    hccCacheTTL: 120000,
    hccCacheExpiry: 300000,
    requestTimeout: 30000,
    maxResponseSize: 10485760,
    devMode: false,
    devServers: [],
    logLevel: "info",
    ...overrides,
  };
}

describe("HccClient", () => {
  let mockServer: http.Server;
  let baseUrl: string;
  let responseBody: unknown;
  let responseStatus: number;

  beforeEach(async () => {
    responseBody = { servers: [], contextRef: "*", timestamp: new Date().toISOString() };
    responseStatus = 200;

    await new Promise<void>((resolve) => {
      mockServer = http.createServer((_, res) => {
        res.writeHead(responseStatus, { "Content-Type": "application/json" });
        res.end(JSON.stringify(responseBody));
      });
      mockServer.listen(0, () => {
        const addr = mockServer.address();
        if (addr && typeof addr !== "string") {
          baseUrl = `http://127.0.0.1:${addr.port}`;
        }
        resolve();
      });
    });
  });

  afterEach(async () => {
    await new Promise<void>((resolve) => mockServer.close(() => resolve()));
  });

  it("should fetch servers from HCC API", async () => {
    responseBody = { servers: [
      {
        name: "mongo-mcp",
        contextRef: "ctx1",
        transport: { type: "streamableHttp", url: "http://mongo.mcp-server:3000/mcp" },
        enabled: true,
        status: { deployed: true, ready: true },
      },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl }));
    const servers = await client.fetchServers();

    expect(servers).toHaveLength(1);
    expect(servers[0].name).toBe("mongo-mcp");
    expect(servers[0].port).toBe(3000);
    expect(servers[0].managed).toBe(true);
  });

  it("should use cache when HCC fails", async () => {
    responseBody = { servers: [
      {
        name: "server-a",
        contextRef: "ctx1",
        transport: { type: "streamableHttp", url: "http://a:3000/mcp" },
        enabled: true,
        status: { deployed: true, ready: true },
      },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl }));
    await client.fetchServers();

    // Now make HCC fail
    responseStatus = 500;
    const servers = await client.fetchServers();
    expect(servers).toHaveLength(1);
    expect(servers[0].name).toBe("server-a");
  });

  it("should detect server addition", async () => {
    responseBody = { servers: [
      { name: "a", contextRef: "c", transport: { type: "streamableHttp", url: "http://a:3000/mcp" }, enabled: true, status: { deployed: true, ready: true } },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl }));
    let servers = await client.fetchServers();
    expect(servers).toHaveLength(1);

    responseBody = { servers: [
      { name: "a", contextRef: "c", transport: { type: "streamableHttp", url: "http://a:3000/mcp" }, enabled: true, status: { deployed: true, ready: true } },
      { name: "b", contextRef: "c", transport: { type: "streamableHttp", url: "http://b:3000/mcp" }, enabled: false, status: { deployed: true, ready: true } },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    servers = await client.fetchServers();
    expect(servers).toHaveLength(2);
  });

  it("should report cache stale when TTL exceeded", async () => {
    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl, hccCacheTTL: 1 }));

    responseBody = { servers: [
      { name: "a", contextRef: "c", transport: { type: "streamableHttp", url: "http://a:3000/mcp" }, enabled: true, status: { deployed: true, ready: true } },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    await client.fetchServers();

    // Wait for TTL to expire
    await new Promise((r) => setTimeout(r, 10));
    expect(client.isCacheStale()).toBe(true);
  });

  it("should report cache expired when expiry exceeded", async () => {
    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl, hccCacheExpiry: 1 }));

    responseBody = { servers: [
      { name: "a", contextRef: "c", transport: { type: "streamableHttp", url: "http://a:3000/mcp" }, enabled: true, status: { deployed: true, ready: true } },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    await client.fetchServers();

    await new Promise((r) => setTimeout(r, 10));
    expect(client.isCacheExpired()).toBe(true);
  });

  it("should report stale=true when no poll has occurred", () => {
    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl }));
    expect(client.isCacheStale()).toBe(true);
    expect(client.isCacheExpired()).toBe(true);
  });

  it("should extract port from URL", async () => {
    responseBody = { servers: [
      { name: "custom-port", contextRef: "c", transport: { type: "streamableHttp", url: "http://x:8080/mcp" }, enabled: true, status: { deployed: true, ready: true } },
    ], contextRef: "*", timestamp: new Date().toISOString() };

    const client = new HccClient(makeConfig({ hccApiUrl: baseUrl }));
    const servers = await client.fetchServers();
    expect(servers[0].port).toBe(8080);
  });

  it("should handle connection refused gracefully", async () => {
    const client = new HccClient(makeConfig({ hccApiUrl: "http://127.0.0.1:1" }));
    const servers = await client.fetchServers();
    expect(servers).toEqual([]);
  });
});