claude-code/src/tools/AgentTool/__tests__/agentDisplay.test.ts

import { mock, describe, expect, test } from "bun:test";

// Mock heavy deps
mock.module("../../utils/model/agent.js", () => ({
  getDefaultSubagentModel: () => undefined,
}));

mock.module("../../utils/settings/constants.js", () => ({
  getSourceDisplayName: (source: string) => source,
}));

const {
  resolveAgentOverrides,
  compareAgentsByName,
  AGENT_SOURCE_GROUPS,
} = await import("../agentDisplay");

function makeAgent(agentType: string, source: string): any {
  return { agentType, source, name: agentType };
}

describe("resolveAgentOverrides", () => {
  test("marks no overrides when all agents active", () => {
    const agents = [makeAgent("builder", "userSettings")];
    const result = resolveAgentOverrides(agents, agents);
    expect(result).toHaveLength(1);
    expect(result[0].overriddenBy).toBeUndefined();
  });

  test("marks inactive agent as overridden", () => {
    const allAgents = [
      makeAgent("builder", "projectSettings"),
      makeAgent("builder", "userSettings"),
    ];
    const activeAgents = [makeAgent("builder", "userSettings")];
    const result = resolveAgentOverrides(allAgents, activeAgents);
    const projectAgent = result.find(
      (a: any) => a.source === "projectSettings",
    );
    expect(projectAgent?.overriddenBy).toBe("userSettings");
  });

  test("overriddenBy shows the overriding agent source", () => {
    const allAgents = [makeAgent("tester", "localSettings")];
    const activeAgents = [makeAgent("tester", "policySettings")];
    const result = resolveAgentOverrides(allAgents, activeAgents);
    expect(result[0].overriddenBy).toBe("policySettings");
  });

  test("deduplicates agents by (agentType, source)", () => {
    const agents = [
      makeAgent("builder", "userSettings"),
      makeAgent("builder", "userSettings"), // duplicate
    ];
    const result = resolveAgentOverrides(agents, agents.slice(0, 1));
    expect(result).toHaveLength(1);
  });

  test("preserves agent definition properties", () => {
    const agents = [{ agentType: "a", source: "userSettings", name: "Agent A" }];
    const result = resolveAgentOverrides(agents, agents);
    expect(result[0].name).toBe("Agent A");
    expect(result[0].agentType).toBe("a");
  });

  test("handles empty arrays", () => {
    expect(resolveAgentOverrides([], [])).toEqual([]);
  });

  test("handles agent from git worktree (duplicate detection)", () => {
    const agents = [
      makeAgent("builder", "projectSettings"),
      makeAgent("builder", "projectSettings"),
      makeAgent("builder", "localSettings"),
    ];
    const result = resolveAgentOverrides(agents, agents.slice(0, 1));
    // Deduped: projectSettings appears once, localSettings once
    expect(result).toHaveLength(2);
  });
});

describe("compareAgentsByName", () => {
  test("sorts alphabetically ascending", () => {
    const a = makeAgent("alpha", "userSettings");
    const b = makeAgent("beta", "userSettings");
    expect(compareAgentsByName(a, b)).toBeLessThan(0);
  });

  test("returns negative when a.name < b.name", () => {
    const a = makeAgent("a", "s");
    const b = makeAgent("b", "s");
    expect(compareAgentsByName(a, b)).toBeLessThan(0);
  });

  test("returns positive when a.name > b.name", () => {
    const a = makeAgent("z", "s");
    const b = makeAgent("a", "s");
    expect(compareAgentsByName(a, b)).toBeGreaterThan(0);
  });

  test("returns 0 for same name", () => {
    const a = makeAgent("same", "s");
    const b = makeAgent("same", "s");
    expect(compareAgentsByName(a, b)).toBe(0);
  });

  test("is case-insensitive (sensitivity: base)", () => {
    const a = makeAgent("Alpha", "s");
    const b = makeAgent("alpha", "s");
    expect(compareAgentsByName(a, b)).toBe(0);
  });
});

describe("AGENT_SOURCE_GROUPS", () => {
  test("contains expected source groups in order", () => {
    expect(AGENT_SOURCE_GROUPS).toHaveLength(7);
    expect(AGENT_SOURCE_GROUPS[0]).toEqual({
      label: "User agents",
      source: "userSettings",
    });
    expect(AGENT_SOURCE_GROUPS[6]).toEqual({
      label: "Built-in agents",
      source: "built-in",
    });
  });

  test("has unique labels", () => {
    const labels = AGENT_SOURCE_GROUPS.map((g) => g.label);
    expect(new Set(labels).size).toBe(labels.length);
  });

  test("has unique sources", () => {
    const sources = AGENT_SOURCE_GROUPS.map((g) => g.source);
    expect(new Set(sources).size).toBe(sources.length);
  });
});