@uipath/data-fabric-tool 1.0.4 → 1.195.0

package/src/commands/choice-sets.spec.ts

@@ -0,0 +1,849 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../utils/sdk-client", () => ({
+    createDataFabricClient: vi.fn(),
+    connectOrFail: vi.fn(),
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: {
+            success: vi.fn(),
+            error: vi.fn(),
+        },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import { connectOrFail } from "../utils/sdk-client";
+import {
+    registerChoiceSetsCommand,
+    registerChoiceSetValuesCommand,
+} from "./choice-sets";
+
+function buildProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerChoiceSetsCommand(program);
+    return program;
+}
+
+function buildValuesProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerChoiceSetValuesCommand(program);
+    return program;
+}
+
+function mockSdk(overrides: Record<string, unknown> = {}) {
+    const sdk = {
+        entities: {
+            choicesets: {
+                getAll: vi.fn().mockResolvedValue([]),
+                getById: vi.fn().mockResolvedValue({
+                    items: [],
+                    totalCount: 0,
+                }),
+                create: vi.fn().mockResolvedValue("new-choice-set-id"),
+                updateById: vi.fn().mockResolvedValue(undefined),
+                deleteById: vi.fn().mockResolvedValue(undefined),
+                insertValueById: vi.fn().mockResolvedValue({
+                    id: "v-new",
+                    name: "travel",
+                    displayName: "Travel",
+                    numberId: 1,
+                }),
+                updateValueById: vi.fn().mockResolvedValue({
+                    id: "v-1",
+                    name: "travel",
+                    displayName: "Business Travel",
+                    numberId: 1,
+                }),
+                deleteValuesById: vi.fn().mockResolvedValue(undefined),
+                ...overrides,
+            },
+        },
+    };
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
+    return sdk;
+}
+
+describe("choice-sets list", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should register the choice-sets command with list, list-values, create, update, and delete subcommands", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "choice-sets");
+        expect(cmd).toBeDefined();
+        const subNames = cmd?.commands.map((c) => c.name()) ?? [];
+        expect(subNames).toContain("list");
+        expect(subNames).toContain("list-values");
+        expect(subNames).toContain("create");
+        expect(subNames).toContain("update");
+        expect(subNames).toContain("delete");
+    });
+
+    it("should list choice sets and return the verbatim SDK response", async () => {
+        const sdk = mockSdk();
+        const rawList = [
+            {
+                id: "cs-uuid-1",
+                name: "ExpenseTypes",
+                displayName: "Expense Types",
+                description: "Categories of expenses",
+                folderId: "f-1",
+                createdBy: "u-1",
+                updatedBy: "u-2",
+                createdTime: "2026-01-01T00:00:00Z",
+                updatedTime: "2026-01-02T00:00:00Z",
+            },
+        ];
+        vi.mocked(sdk.entities.choicesets.getAll).mockResolvedValue(
+            rawList as never,
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetList",
+                Data: rawList,
+            }),
+        );
+    });
+
+    it("should return empty list when no choice sets exist", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetList",
+                Data: [],
+            }),
+        );
+    });
+
+    it("should output error when list fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getAll).mockRejectedValue(
+            new Error("forbidden"),
+        );
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing choice sets",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should not proceed with list when the client connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(sdk.entities.choicesets.getAll).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+    });
+});
+
+describe("choice-sets list-values", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should get values for a choice set and return the verbatim SDK response", async () => {
+        const sdk = mockSdk();
+        const rawResponse = {
+            items: [
+                {
+                    id: "v-1",
+                    name: "travel",
+                    displayName: "Travel",
+                    numberId: 1,
+                    createdTime: "2026-01-01T00:00:00Z",
+                    updatedTime: "2026-01-02T00:00:00Z",
+                },
+            ],
+            totalCount: 1,
+            hasNextPage: false,
+        };
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue(
+            rawResponse as never,
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+        ]);
+
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 50,
+        });
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetValues",
+                Data: rawResponse,
+            }),
+        );
+    });
+
+    it("should pass cursor to choicesets.getById and return the raw response", async () => {
+        const sdk = mockSdk();
+        const rawResponse = {
+            items: [{ id: "v-1", name: "n", displayName: "N", numberId: 1 }],
+            totalCount: 100,
+            hasNextPage: true,
+            nextCursor: "next-cur",
+        };
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue(
+            rawResponse as never,
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--cursor",
+            "prev",
+            "--limit",
+            "10",
+        ]);
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 10,
+            cursor: { value: "prev" },
+        });
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.objectContaining({
+                    hasNextPage: true,
+                    nextCursor: "next-cur",
+                }),
+            }),
+        );
+    });
+
+    it("should pass jumpToPage to choicesets.getById when --offset is given", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+            items: [],
+            totalCount: 100,
+            hasNextPage: false,
+        });
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--offset",
+            "20",
+            "--limit",
+            "10",
+        ]);
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 10,
+            jumpToPage: 3,
+        });
+    });
+
+    it("should error when --offset and --cursor are both given", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--offset",
+            "10",
+            "--cursor",
+            "x",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "--offset and --cursor are mutually exclusive",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --limit is invalid", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--limit",
+            "0",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --limit value",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --offset is negative", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--offset",
+            "-1",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --offset value",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should output error when get fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockRejectedValue(
+            new Error("404"),
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "missing",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error getting choice set 'missing'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should not proceed with get when the client connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+        ]);
+        expect(sdk.entities.choicesets.getById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+    });
+});
+
+describe("choice-sets create", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should create a choice set with options and return the ID", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "create",
+            "ExpenseTypes",
+            "--display-name",
+            "Expense Types",
+            "--description",
+            "Categories",
+            "--folder-key",
+            "folder-1",
+        ]);
+
+        expect(sdk.entities.choicesets.create).toHaveBeenCalledWith(
+            "ExpenseTypes",
+            {
+                displayName: "Expense Types",
+                description: "Categories",
+                folderKey: "folder-1",
+            },
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetCreated",
+                Data: { ID: "new-choice-set-id" },
+            }),
+        );
+    });
+
+    it("should create a choice set with no options (undefined opts)", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "create",
+            "ExpenseTypes",
+        ]);
+        expect(sdk.entities.choicesets.create).toHaveBeenCalledWith(
+            "ExpenseTypes",
+            undefined,
+        );
+    });
+
+    it("should output error when create fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.create).mockRejectedValue(
+            new Error("conflict"),
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "create",
+            "X",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error creating choice set",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("choice-sets update", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should update a choice set's metadata", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "update",
+            "cs-1",
+            "--display-name",
+            "New Name",
+        ]);
+        expect(sdk.entities.choicesets.updateById).toHaveBeenCalledWith(
+            "cs-1",
+            {
+                displayName: "New Name",
+            },
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetUpdated",
+                Data: { ID: "cs-1" },
+            }),
+        );
+    });
+
+    it("should error when no update fields are provided", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "update",
+            "cs-1",
+        ]);
+        expect(sdk.entities.choicesets.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "No update fields provided",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should output error when update fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.updateById).mockRejectedValue(
+            new Error("404"),
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "update",
+            "missing",
+            "--description",
+            "x",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error updating choice set 'missing'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("choice-sets delete", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should delete a choice set with --confirm and --reason", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "delete",
+            "cs-1",
+            "--confirm",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteById).toHaveBeenCalledWith("cs-1");
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetDeleted",
+                Data: { ID: "cs-1", Reason: "cleanup" },
+            }),
+        );
+    });
+
+    it("should require --confirm", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "delete",
+            "cs-1",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Confirmation required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --reason", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "delete",
+            "cs-1",
+            "--confirm",
+        ]);
+        expect(sdk.entities.choicesets.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("choice-set-values", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should register the choice-set-values command with create, update, and delete subcommands", () => {
+        const program = buildValuesProgram();
+        const cmd = program.commands.find(
+            (c) => c.name() === "choice-set-values",
+        );
+        expect(cmd).toBeDefined();
+        const subNames = cmd?.commands.map((c) => c.name()) ?? [];
+        expect(subNames).toContain("create");
+        expect(subNames).toContain("update");
+        expect(subNames).toContain("delete");
+    });
+
+    it("should create a value and project the response", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "travel",
+            "--display-name",
+            "Travel",
+        ]);
+        expect(sdk.entities.choicesets.insertValueById).toHaveBeenCalledWith(
+            "cs-1",
+            "travel",
+            { displayName: "Travel" },
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetValueCreated",
+                Data: expect.objectContaining({
+                    id: "v-new",
+                    name: "travel",
+                    displayName: "Travel",
+                    numberId: 1,
+                }),
+            }),
+        );
+    });
+
+    it("should create a value with no display name (undefined opts)", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "travel",
+        ]);
+        expect(sdk.entities.choicesets.insertValueById).toHaveBeenCalledWith(
+            "cs-1",
+            "travel",
+            undefined,
+        );
+    });
+
+    it("should output error when value create fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.insertValueById).mockRejectedValue(
+            new Error("conflict"),
+        );
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "travel",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error creating value in choice set 'cs-1'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should update a value's display name", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "update",
+            "cs-1",
+            "v-1",
+            "Business Travel",
+        ]);
+        expect(sdk.entities.choicesets.updateValueById).toHaveBeenCalledWith(
+            "cs-1",
+            "v-1",
+            "Business Travel",
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetValueUpdated",
+                Data: expect.objectContaining({
+                    id: "v-1",
+                    displayName: "Business Travel",
+                }),
+            }),
+        );
+    });
+
+    it("should output error when value update fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.updateValueById).mockRejectedValue(
+            new Error("404"),
+        );
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "update",
+            "cs-1",
+            "missing",
+            "X",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error updating value 'missing' in choice set 'cs-1'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should delete values from a comma-separated --ids list", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--ids",
+            "v-1, v-2 ,v-3",
+            "--confirm",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).toHaveBeenCalledWith(
+            "cs-1",
+            ["v-1", "v-2", "v-3"],
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetValuesDeleted",
+                Data: {
+                    ChoiceSetId: "cs-1",
+                    DeletedIds: ["v-1", "v-2", "v-3"],
+                    Reason: "cleanup",
+                },
+            }),
+        );
+    });
+
+    it("should error when --ids is missing or empty", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--confirm",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "No value IDs provided",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --confirm for value delete", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--ids",
+            "v-1",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Confirmation required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --reason for value delete", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--ids",
+            "v-1",
+            "--confirm",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});