@indigoai-us/hq-cli 5.17.0 → 5.18.0

package/src/commands/sync-mode.test.ts

@@ -0,0 +1,366 @@
+/**
+ * Unit tests for `hq sync mode` (sync-mode.ts).
+ *
+ * Stubs VaultClient with the minimal `SyncModeVaultClient` interface — no
+ * network. Coverage:
+ *   - validateMode happy + reject path
+ *   - parseCustomPaths edge cases
+ *   - readActiveCompanySlug reads `.hq/config.json`
+ *   - setSyncMode resolves slug → membershipId, calls PUT, returns audit
+ *   - setSyncMode rejects when slug doesn't match any membership
+ *   - showSyncModes fans out across memberships, sorts by slug
+ *   - formatShowTable renders headers + rows
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  LEGAL_SYNC_MODES,
+  formatShowTable,
+  parseCustomPaths,
+  readActiveCompanySlug,
+  setSyncMode,
+  showSyncModes,
+  validateMode,
+  type ShowSyncModesRow,
+  type SyncModeVaultClient,
+} from "./sync-mode.js";
+import type { Membership, MembershipSyncConfig } from "@indigoai-us/hq-cloud";
+
+// ── Fixtures ────────────────────────────────────────────────────────────────
+
+function fakeMembership(overrides: Partial<Membership> = {}): Membership {
+  return {
+    membershipKey: "mbr_acme_123",
+    personUid: "prs_alice",
+    companyUid: "cmp_acme",
+    role: "member" as Membership["role"],
+    status: "active" as Membership["status"],
+    invitedBy: "prs_admin",
+    invitedAt: "2026-01-01T00:00:00Z",
+    ...overrides,
+  } as Membership;
+}
+
+function fakeConfig(
+  overrides: Partial<MembershipSyncConfig> = {},
+): MembershipSyncConfig {
+  return {
+    membershipId: "mbr_acme_123",
+    syncMode: "shared",
+    isDefault: true,
+    ...overrides,
+  };
+}
+
+interface StubOpts {
+  memberships?: Membership[];
+  configs?: Record<string, MembershipSyncConfig>;
+  setResult?: MembershipSyncConfig;
+  entities?: Record<string, { uid: string; slug: string; name?: string }>;
+  failGetConfig?: Set<string>;
+}
+
+function makeStubClient(opts: StubOpts): {
+  client: SyncModeVaultClient;
+  spies: {
+    listMyMemberships: ReturnType<typeof vi.fn>;
+    getMembershipSyncConfig: ReturnType<typeof vi.fn>;
+    setMembershipSyncConfig: ReturnType<typeof vi.fn>;
+    entityGet: ReturnType<typeof vi.fn>;
+  };
+} {
+  const listMyMemberships = vi
+    .fn<[], Promise<Membership[]>>()
+    .mockResolvedValue(opts.memberships ?? []);
+  const getMembershipSyncConfig = vi
+    .fn<[string], Promise<MembershipSyncConfig>>()
+    .mockImplementation(async (id: string) => {
+      if (opts.failGetConfig?.has(id)) {
+        throw new Error(`fake getMembershipSyncConfig failure for ${id}`);
+      }
+      const cfg = opts.configs?.[id];
+      if (cfg) return cfg;
+      return { membershipId: id, syncMode: "shared", isDefault: true };
+    });
+  const setMembershipSyncConfig = vi
+    .fn<
+      [string, { syncMode: MembershipSyncConfig["syncMode"]; customPaths?: string[] }],
+      Promise<MembershipSyncConfig>
+    >()
+    .mockImplementation(async (id, partial) => {
+      if (opts.setResult) return opts.setResult;
+      return {
+        membershipId: id,
+        syncMode: partial.syncMode,
+        customPaths: partial.customPaths,
+        isDefault: false,
+        updatedAt: "2026-05-20T12:00:00Z",
+        updatedBy: "prs_alice",
+      };
+    });
+  const entityGet = vi
+    .fn<
+      [string],
+      Promise<{ uid: string; slug: string; name?: string }>
+    >()
+    .mockImplementation(async (uid: string) => {
+      const e = opts.entities?.[uid];
+      if (!e) throw new Error(`unknown entity ${uid}`);
+      return e;
+    });
+
+  return {
+    client: {
+      listMyMemberships,
+      getMembershipSyncConfig,
+      setMembershipSyncConfig,
+      entity: { get: entityGet },
+    },
+    spies: {
+      listMyMemberships,
+      getMembershipSyncConfig,
+      setMembershipSyncConfig,
+      entityGet,
+    },
+  };
+}
+
+// ── Pure helpers ────────────────────────────────────────────────────────────
+
+describe("validateMode", () => {
+  it("accepts all three legal modes", () => {
+    for (const m of LEGAL_SYNC_MODES) {
+      expect(validateMode(m)).toBe(m);
+    }
+  });
+
+  it("rejects unknown modes with the legal set in the error", () => {
+    expect(() => validateMode("none")).toThrow(/Invalid sync mode 'none'/);
+    expect(() => validateMode("none")).toThrow(/shared, all, custom/);
+  });
+
+  it("rejects empty string", () => {
+    expect(() => validateMode("")).toThrow(/Invalid sync mode/);
+  });
+});
+
+describe("parseCustomPaths", () => {
+  it("returns undefined for undefined/empty", () => {
+    expect(parseCustomPaths(undefined)).toBeUndefined();
+    expect(parseCustomPaths("")).toBeUndefined();
+    expect(parseCustomPaths(",,")).toBeUndefined();
+  });
+
+  it("trims + drops empty entries", () => {
+    expect(parseCustomPaths(" a/, b/c/ , ,d/")).toEqual(["a/", "b/c/", "d/"]);
+  });
+});
+
+describe("readActiveCompanySlug", () => {
+  let tmpRoot: string;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-sync-mode-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it("returns undefined when .hq/config.json is missing", () => {
+    expect(readActiveCompanySlug(tmpRoot)).toBeUndefined();
+  });
+
+  it("reads activeCompany when present", () => {
+    fs.mkdirSync(path.join(tmpRoot, ".hq"));
+    fs.writeFileSync(
+      path.join(tmpRoot, ".hq", "config.json"),
+      JSON.stringify({ activeCompany: "acme" }),
+    );
+    expect(readActiveCompanySlug(tmpRoot)).toBe("acme");
+  });
+
+  it("returns undefined on bad JSON", () => {
+    fs.mkdirSync(path.join(tmpRoot, ".hq"));
+    fs.writeFileSync(path.join(tmpRoot, ".hq", "config.json"), "not json");
+    expect(readActiveCompanySlug(tmpRoot)).toBeUndefined();
+  });
+
+  it("returns undefined when activeCompany isn't a string", () => {
+    fs.mkdirSync(path.join(tmpRoot, ".hq"));
+    fs.writeFileSync(
+      path.join(tmpRoot, ".hq", "config.json"),
+      JSON.stringify({ activeCompany: 42 }),
+    );
+    expect(readActiveCompanySlug(tmpRoot)).toBeUndefined();
+  });
+});
+
+// ── setSyncMode orchestrator ────────────────────────────────────────────────
+
+describe("setSyncMode", () => {
+  it("resolves slug → membership, PUTs new mode, returns audit", async () => {
+    const { client, spies } = makeStubClient({
+      memberships: [
+        fakeMembership({ membershipKey: "mbr_acme_123", companyUid: "cmp_acme" }),
+        fakeMembership({ membershipKey: "mbr_other_999", companyUid: "cmp_other" }),
+      ],
+      configs: {
+        mbr_acme_123: fakeConfig({ syncMode: "shared", isDefault: true }),
+      },
+      entities: {
+        cmp_acme: { uid: "cmp_acme", slug: "acme", name: "Acme" },
+        cmp_other: { uid: "cmp_other", slug: "other" },
+      },
+    });
+
+    const result = await setSyncMode({
+      mode: "all",
+      companySlug: "acme",
+      vaultClient: client,
+    });
+
+    expect(result.membershipId).toBe("mbr_acme_123");
+    expect(result.companySlug).toBe("acme");
+    expect(result.previousMode).toBe("shared");
+    expect(result.previousWasDefault).toBe(true);
+    expect(result.newMode).toBe("all");
+    expect(result.newConfig.isDefault).toBe(false);
+
+    expect(spies.listMyMemberships).toHaveBeenCalledTimes(1);
+    expect(spies.getMembershipSyncConfig).toHaveBeenCalledWith("mbr_acme_123");
+    expect(spies.setMembershipSyncConfig).toHaveBeenCalledWith(
+      "mbr_acme_123",
+      { syncMode: "all", customPaths: undefined },
+    );
+  });
+
+  it("forwards customPaths on `custom` mode", async () => {
+    const { client, spies } = makeStubClient({
+      memberships: [fakeMembership()],
+      entities: { cmp_acme: { uid: "cmp_acme", slug: "acme" } },
+    });
+
+    await setSyncMode({
+      mode: "custom",
+      companySlug: "acme",
+      customPaths: ["projects/", "knowledge/"],
+      vaultClient: client,
+    });
+
+    expect(spies.setMembershipSyncConfig).toHaveBeenCalledWith(
+      "mbr_acme_123",
+      { syncMode: "custom", customPaths: ["projects/", "knowledge/"] },
+    );
+  });
+
+  it("throws a helpful error when slug doesn't match any membership", async () => {
+    const { client } = makeStubClient({
+      memberships: [fakeMembership()],
+      entities: { cmp_acme: { uid: "cmp_acme", slug: "acme" } },
+    });
+
+    await expect(
+      setSyncMode({ mode: "all", companySlug: "ghost", vaultClient: client }),
+    ).rejects.toThrow(/No membership found for company 'ghost'.*acme/);
+  });
+
+  it("throws (none) when the caller has zero memberships", async () => {
+    const { client } = makeStubClient({});
+    await expect(
+      setSyncMode({ mode: "all", companySlug: "acme", vaultClient: client }),
+    ).rejects.toThrow(/\(none\)/);
+  });
+});
+
+// ── showSyncModes orchestrator ──────────────────────────────────────────────
+
+describe("showSyncModes", () => {
+  it("returns rows sorted by company slug", async () => {
+    const { client } = makeStubClient({
+      memberships: [
+        fakeMembership({ membershipKey: "mbr_z", companyUid: "cmp_z" }),
+        fakeMembership({ membershipKey: "mbr_a", companyUid: "cmp_a" }),
+      ],
+      configs: {
+        mbr_z: { membershipId: "mbr_z", syncMode: "all", isDefault: false, updatedAt: "2026-05-20T00:00:00Z" },
+        mbr_a: { membershipId: "mbr_a", syncMode: "shared", isDefault: true },
+      },
+      entities: {
+        cmp_a: { uid: "cmp_a", slug: "alpha", name: "Alpha" },
+        cmp_z: { uid: "cmp_z", slug: "zeta" },
+      },
+    });
+
+    const rows = await showSyncModes({ vaultClient: client });
+    expect(rows.map((r) => r.companySlug)).toEqual(["alpha", "zeta"]);
+    expect(rows[0]).toMatchObject({
+      companySlug: "alpha",
+      syncMode: "shared",
+      isDefault: true,
+    });
+    expect(rows[1]).toMatchObject({
+      companySlug: "zeta",
+      syncMode: "all",
+      isDefault: false,
+      updatedAt: "2026-05-20T00:00:00Z",
+    });
+  });
+
+  it("returns empty array when caller has no memberships", async () => {
+    const { client } = makeStubClient({});
+    expect(await showSyncModes({ vaultClient: client })).toEqual([]);
+  });
+
+  it("falls back to default config when getMembershipSyncConfig throws", async () => {
+    const { client } = makeStubClient({
+      memberships: [fakeMembership()],
+      failGetConfig: new Set(["mbr_acme_123"]),
+      entities: { cmp_acme: { uid: "cmp_acme", slug: "acme" } },
+    });
+
+    const rows = await showSyncModes({ vaultClient: client });
+    expect(rows).toHaveLength(1);
+    expect(rows[0].syncMode).toBe("shared");
+    expect(rows[0].isDefault).toBe(true);
+  });
+});
+
+// ── formatShowTable ────────────────────────────────────────────────────────
+
+describe("formatShowTable", () => {
+  it("renders a helpful message when there are no rows", () => {
+    expect(formatShowTable([])).toMatch(/No memberships found/);
+  });
+
+  it("includes headers + every row's slug + mode", () => {
+    const rows: ShowSyncModesRow[] = [
+      {
+        companySlug: "alpha",
+        membershipId: "mbr_a",
+        syncMode: "shared",
+        isDefault: true,
+      },
+      {
+        companySlug: "zeta",
+        membershipId: "mbr_z",
+        syncMode: "all",
+        isDefault: false,
+        updatedAt: "2026-05-20T00:00:00Z",
+      },
+    ];
+    const out = formatShowTable(rows);
+    expect(out).toContain("COMPANY");
+    expect(out).toContain("MODE");
+    expect(out).toContain("alpha");
+    expect(out).toContain("zeta");
+    expect(out).toContain("shared (default)");
+    expect(out).toContain("all");
+    expect(out).toContain("mbr_a");
+    expect(out).toContain("mbr_z");
+  });
+});