create.test.ts

/**
 * Dashboard Create Command Tests
 *
 * Tests for the dashboard create command in src/commands/dashboard/create.ts.
 * Uses spyOn pattern to mock API client and resolve-target.
 */

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

import { createCommand } from "../../../src/commands/dashboard/create.js";
// biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
import * as apiClient from "../../../src/lib/api-client.js";
import { ContextError, ValidationError } from "../../../src/lib/errors.js";
// biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
import * as resolveTarget from "../../../src/lib/resolve-target.js";
import type { DashboardDetail } from "../../../src/types/dashboard.js";
import { useAuthMock } from "../../helpers.js";

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function createMockContext(cwd = "/tmp") {
  const stdoutWrite = mock(() => true);
  return {
    context: {
      stdout: { write: stdoutWrite },
      stderr: { write: mock(() => true) },
      cwd,
    },
    stdoutWrite,
  };
}

// ---------------------------------------------------------------------------
// Test data
// ---------------------------------------------------------------------------

const sampleDashboard: DashboardDetail = {
  id: "123",
  title: "My Dashboard",
  widgets: [],
  dateCreated: "2026-03-01T10:00:00Z",
};

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

useAuthMock();

describe("dashboard create", () => {
  let createDashboardSpy: ReturnType<typeof spyOn>;
  let resolveOrgSpy: ReturnType<typeof spyOn>;
  let resolveAllTargetsSpy: ReturnType<typeof spyOn>;
  let fetchProjectIdSpy: ReturnType<typeof spyOn>;

  beforeEach(() => {
    createDashboardSpy = spyOn(apiClient, "createDashboard");
    resolveOrgSpy = spyOn(resolveTarget, "resolveOrg");
    resolveAllTargetsSpy = spyOn(resolveTarget, "resolveAllTargets");
    fetchProjectIdSpy = spyOn(resolveTarget, "fetchProjectId");

    // Default mocks
    resolveOrgSpy.mockResolvedValue({ org: "acme-corp" });
    resolveAllTargetsSpy.mockResolvedValue({ targets: [] });
    createDashboardSpy.mockResolvedValue(sampleDashboard);
    fetchProjectIdSpy.mockResolvedValue(999);
  });

  afterEach(() => {
    createDashboardSpy.mockRestore();
    resolveOrgSpy.mockRestore();
    resolveAllTargetsSpy.mockRestore();
    fetchProjectIdSpy.mockRestore();
  });

  test("creates dashboard with title and verifies API args", async () => {
    const { context } = createMockContext();
    const func = await createCommand.loader();
    await func.call(context, { json: false }, "My Dashboard");

    expect(createDashboardSpy).toHaveBeenCalledWith("acme-corp", {
      title: "My Dashboard",
      widgets: [],
      projects: undefined,
    });
  });

  test("JSON output contains dashboard data and url", async () => {
    const { context, stdoutWrite } = createMockContext();
    const func = await createCommand.loader();
    await func.call(context, { json: true }, "My Dashboard");

    const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
    const parsed = JSON.parse(output);
    expect(parsed.id).toBe("123");
    expect(parsed.title).toBe("My Dashboard");
    expect(parsed.url).toContain("dashboard/123");
  });

  test("human output contains 'Created dashboard' and title", async () => {
    const { context, stdoutWrite } = createMockContext();
    const func = await createCommand.loader();
    await func.call(context, { json: false }, "My Dashboard");

    const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
    expect(output).toContain("Created dashboard");
    expect(output).toContain("My Dashboard");
  });

  test("throws ValidationError when title is missing", async () => {
    const { context } = createMockContext();
    const func = await createCommand.loader();

    const err = await func
      .call(context, { json: false })
      .catch((e: Error) => e);
    expect(err).toBeInstanceOf(ValidationError);
    expect(err.message).toContain("Dashboard title is required");
  });

  test("two args parses target + title correctly", async () => {
    const { context } = createMockContext();
    const func = await createCommand.loader();
    await func.call(context, { json: false }, "my-org/", "My Dashboard");

    expect(createDashboardSpy).toHaveBeenCalledWith("my-org", {
      title: "My Dashboard",
      widgets: [],
      projects: undefined,
    });
  });

  test("throws ContextError when org cannot be resolved", async () => {
    resolveOrgSpy.mockResolvedValue(null);

    const { context } = createMockContext();
    const func = await createCommand.loader();

    await expect(
      func.call(context, { json: false }, "My Dashboard")
    ).rejects.toThrow(ContextError);
  });

  test("explicit org/project target calls fetchProjectId", async () => {
    const { context } = createMockContext();
    const func = await createCommand.loader();
    await func.call(
      context,
      { json: false },
      "my-org/my-project",
      "My Dashboard"
    );

    expect(fetchProjectIdSpy).toHaveBeenCalledWith("my-org", "my-project");
  });
});