@uipath/data-fabric-tool 1.1.0 → 1.195.0

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

@@ -3,6 +3,7 @@ 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) => {
@@ -17,8 +18,11 @@ vi.mock("@uipath/common", async (importOriginal) => {
 });
 
 import { OutputFormatter } from "@uipath/common";
-import { createDataFabricClient } from "../utils/sdk-client";
-import { registerChoiceSetsCommand } from "./choice-sets";
+import { connectOrFail } from "../utils/sdk-client";
+import {
+    registerChoiceSetsCommand,
+    registerChoiceSetValuesCommand,
+} from "./choice-sets";
 
 function buildProgram(): Command {
     const program = new Command();
@@ -27,6 +31,13 @@ function buildProgram(): Command {
     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: {
@@ -36,11 +47,27 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
                     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(createDataFabricClient).mockResolvedValue(sdk as never);
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
     return sdk;
 }
 
@@ -50,18 +77,21 @@ describe("choice-sets list", () => {
         process.exitCode = undefined;
     });
 
-    it("should register the choice-sets command with list and get subcommands", () => {
+    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("get");
+        expect(subNames).toContain("list-values");
+        expect(subNames).toContain("create");
+        expect(subNames).toContain("update");
+        expect(subNames).toContain("delete");
     });
 
-    it("should list choice sets successfully and expose the runtime ID", async () => {
+    it("should list choice sets and return the verbatim SDK response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.choicesets.getAll).mockResolvedValue([
+        const rawList = [
             {
                 id: "cs-uuid-1",
                 name: "ExpenseTypes",
@@ -72,8 +102,11 @@ describe("choice-sets list", () => {
                 updatedBy: "u-2",
                 createdTime: "2026-01-01T00:00:00Z",
                 updatedTime: "2026-01-02T00:00:00Z",
-            } as never,
-        ]);
+            },
+        ];
+        vi.mocked(sdk.entities.choicesets.getAll).mockResolvedValue(
+            rawList as never,
+        );
 
         const program = buildProgram();
         await program.parseAsync(["node", "test", "choice-sets", "list"]);
@@ -82,13 +115,7 @@ describe("choice-sets list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "ChoiceSetList",
-                Data: expect.arrayContaining([
-                    expect.objectContaining({
-                        ID: "cs-uuid-1",
-                        Name: "ExpenseTypes",
-                        DisplayName: "Expense Types",
-                    }),
-                ]),
+                Data: rawList,
             }),
         );
     });
@@ -122,31 +149,25 @@ describe("choice-sets list", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on list", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    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(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.choicesets.getAll).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
-describe("choice-sets get", () => {
+describe("choice-sets list-values", () => {
     beforeEach(() => {
         vi.resetAllMocks();
         process.exitCode = undefined;
     });
 
-    it("should get values for a choice set", async () => {
+    it("should get values for a choice set and return the verbatim SDK response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+        const rawResponse = {
             items: [
                 {
                     id: "v-1",
@@ -159,14 +180,17 @@ describe("choice-sets get", () => {
             ],
             totalCount: 1,
             hasNextPage: false,
-        });
+        };
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue(
+            rawResponse as never,
+        );
 
         const program = buildProgram();
         await program.parseAsync([
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "cs-1",
         ]);
 
@@ -177,43 +201,28 @@ describe("choice-sets get", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "ChoiceSetValues",
-                Data: expect.objectContaining({
-                    TotalCount: 1,
-                    Values: expect.arrayContaining([
-                        expect.objectContaining({
-                            Id: "v-1",
-                            Name: "travel",
-                            DisplayName: "Travel",
-                            NumberId: 1,
-                        }),
-                    ]),
-                    HasNextPage: false,
-                }),
+                Data: rawResponse,
             }),
         );
     });
 
-    it("should pass cursor to choicesets.getById and include NextCursor", async () => {
+    it("should pass cursor to choicesets.getById and return the raw response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
-            items: [
-                {
-                    id: "v-1",
-                    name: "n",
-                    displayName: "N",
-                    numberId: 1,
-                },
-            ],
+        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",
-            "get",
+            "list-values",
             "cs-1",
             "--cursor",
             "prev",
@@ -227,8 +236,8 @@ describe("choice-sets get", () => {
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "next-cur",
+                    hasNextPage: true,
+                    nextCursor: "next-cur",
                 }),
             }),
         );
@@ -246,7 +255,7 @@ describe("choice-sets get", () => {
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "cs-1",
             "--offset",
             "20",
@@ -266,7 +275,7 @@ describe("choice-sets get", () => {
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "cs-1",
             "--offset",
             "10",
@@ -289,7 +298,7 @@ describe("choice-sets get", () => {
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "cs-1",
             "--limit",
             "0",
@@ -310,7 +319,7 @@ describe("choice-sets get", () => {
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "cs-1",
             "--offset",
             "-1",
@@ -334,7 +343,7 @@ describe("choice-sets get", () => {
             "node",
             "test",
             "choice-sets",
-            "get",
+            "list-values",
             "missing",
         ]);
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -346,49 +355,495 @@ describe("choice-sets get", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on get", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
+    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",
-            "get",
+            "update",
             "cs-1",
         ]);
+        expect(sdk.entities.choicesets.updateById).not.toHaveBeenCalled();
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "Error connecting to Data Fabric",
+                Message: "No update fields provided",
             }),
         );
         expect(process.exitCode).toBe(1);
     });
 
-    it("should normalise cursor object {value} to a plain string in NextCursor", async () => {
+    it("should output error when update fails", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
-            items: [{ id: "v-1", name: "n", displayName: "N", numberId: 1 }],
-            totalCount: 5,
-            hasNextPage: true,
-            nextCursor: { value: "cursor-as-object" } as unknown as string,
-        });
+        vi.mocked(sdk.entities.choicesets.updateById).mockRejectedValue(
+            new Error("404"),
+        );
         const program = buildProgram();
         await program.parseAsync([
             "node",
             "test",
             "choice-sets",
-            "get",
+            "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",
-            "--limit",
-            "2",
+            "--confirm",
+            "--reason",
+            "cleanup",
         ]);
-        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: { NextCursor: unknown };
-        };
-        expect(typeof call.Data.NextCursor).toBe("string");
-        expect(call.Data.NextCursor).toBe("cursor-as-object");
+        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);
     });
 });