@uipath/data-fabric-tool 0.9.0

package/src/commands/entities.spec.ts

@@ -0,0 +1,970 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../utils/sdk-client", () => ({
+    createDataFabricClient: 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(),
+        },
+    };
+});
+
+vi.mock("../utils/input", () => ({
+    readJsonInput: vi.fn(),
+}));
+
+import { OutputFormatter } from "@uipath/common";
+import { readJsonInput } from "../utils/input";
+import { createDataFabricClient } from "../utils/sdk-client";
+import { registerEntitiesCommand } from "./entities";
+
+function buildProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerEntitiesCommand(program);
+    return program;
+}
+
+function mockSdk(overrides: Record<string, unknown> = {}) {
+    const sdk = {
+        entities: {
+            getAll: vi.fn().mockResolvedValue([]),
+            getById: vi.fn().mockResolvedValue({}),
+            create: vi.fn().mockResolvedValue("new-entity-id"),
+            updateById: vi.fn().mockResolvedValue(undefined),
+            ...overrides,
+        },
+    };
+    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    return sdk;
+}
+
+describe("entities list", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should register the entities command with list, get, create, and update subcommands", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "entities");
+        expect(cmd).toBeDefined();
+        expect(cmd?.commands.map((c) => c.name())).toContain("list");
+        expect(cmd?.commands.map((c) => c.name())).toContain("get");
+        expect(cmd?.commands.map((c) => c.name())).toContain("create");
+        expect(cmd?.commands.map((c) => c.name())).toContain("update");
+        expect(cmd?.commands.map((c) => c.name())).not.toContain("delete");
+    });
+
+    it("should list entities successfully", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getAll).mockResolvedValue([
+            {
+                id: "uuid-1",
+                name: "invoice",
+                displayName: "Invoice",
+                entityType: "Local",
+                description: "Invoice entity",
+                fields: [{ name: "amount" }, { name: "date" }],
+                externalFields: [],
+            },
+        ]);
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "list"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityList",
+                Data: expect.arrayContaining([
+                    expect.objectContaining({
+                        Name: "invoice",
+                        ID: "uuid-1",
+                        FieldCount: 2,
+                        Source: "Native",
+                    }),
+                ]),
+            }),
+        );
+    });
+
+    it("should label federated entity with connector name", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getAll).mockResolvedValue([
+            {
+                id: "uuid-2",
+                name: "contacts",
+                displayName: "Contacts",
+                entityType: "Federated",
+                description: "",
+                fields: [],
+                externalFields: [
+                    {
+                        externalConnectionDetail: {
+                            connectorName: "Salesforce",
+                        },
+                    },
+                ],
+            },
+        ]);
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "list"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.arrayContaining([
+                    expect.objectContaining({
+                        Source: "Federated (Salesforce)",
+                    }),
+                ]),
+            }),
+        );
+    });
+
+    it("should filter out federated entities with --native-only", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getAll).mockResolvedValue([
+            {
+                id: "uuid-1",
+                name: "invoice",
+                fields: [],
+                externalFields: [],
+            },
+            {
+                id: "uuid-2",
+                name: "contacts",
+                fields: [],
+                externalFields: [{ externalConnectionDetail: {} }],
+            },
+        ]);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "list",
+            "--native-only",
+        ]);
+
+        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
+            Data: { ID: string }[];
+        };
+        expect(call.Data).toHaveLength(1);
+        expect(call.Data[0].ID).toBe("uuid-1");
+    });
+
+    it("should return empty list when no entities exist", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "list"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityList",
+                Data: [],
+            }),
+        );
+    });
+
+    it("should error when SDK connection fails", async () => {
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "list"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when list API fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getAll).mockRejectedValue(
+            new Error("Server error"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "list"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing entities",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("entities get", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should return entity schema with fields", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getById).mockResolvedValue({
+            id: "uuid-1",
+            name: "invoice",
+            displayName: "Invoice",
+            entityType: "Local",
+            description: "Invoice entity",
+            fields: [
+                {
+                    id: "field-uuid-1",
+                    name: "amount",
+                    displayName: "Amount",
+                    fieldDataType: { name: "DECIMAL" },
+                    isRequired: true,
+                    isPrimaryKey: false,
+                    isSystemField: false,
+                },
+                {
+                    id: "field-uuid-2",
+                    name: "duedate",
+                    displayName: "Due Date",
+                    fieldDataType: { name: "date" },
+                    isRequired: false,
+                    isPrimaryKey: false,
+                    isSystemField: false,
+                },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntitySchema",
+                Data: expect.objectContaining({
+                    ID: "uuid-1",
+                    Name: "invoice",
+                    Fields: expect.arrayContaining([
+                        expect.objectContaining({
+                            ID: "field-uuid-1",
+                            Name: "amount",
+                            Type: "DECIMAL",
+                            Required: true,
+                        }),
+                    ]),
+                }),
+            }),
+        );
+    });
+
+    it("should use name as DisplayName when displayName is missing", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getById).mockResolvedValue({
+            id: "uuid-1",
+            name: "invoice",
+            fields: [],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.objectContaining({ DisplayName: "invoice" }),
+            }),
+        );
+    });
+
+    it("should error when SDK connection fails", async () => {
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when entity is not found (SDK throws)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getById).mockRejectedValue(
+            new Error("Not found"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "entities", "get", "bad-id"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error getting entity schema 'bad-id'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when entity returns null (not found)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.getById).mockResolvedValue(null as never);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "get",
+            "missing-id",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Entity 'missing-id' not found",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("entities create", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should create an entity with fields via --body", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("new-entity-id");
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "title", type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "MyEntity",
+            [{ fieldName: "title", type: "STRING" }],
+            undefined,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityCreated",
+                Data: expect.objectContaining({ ID: "new-entity-id" }),
+            }),
+        );
+    });
+
+    it("should create entity with displayName, description, and isRbacEnabled", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("entity-with-opts");
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "amount", type: "DECIMAL" }],
+            displayName: "My Entity",
+            description: "A test entity",
+            isRbacEnabled: true,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"amount","type":"DECIMAL"}],"displayName":"My Entity","description":"A test entity","isRbacEnabled":true}',
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "MyEntity",
+            [{ fieldName: "amount", type: "DECIMAL" }],
+            expect.objectContaining({
+                displayName: "My Entity",
+                description: "A test entity",
+                isRbacEnabled: true,
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityCreated",
+            }),
+        );
+    });
+
+    it("should create entity with only displayName (partial options)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("entity-partial");
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "name", type: "STRING" }],
+            displayName: "Partial Entity",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "PartialEntity",
+            "--body",
+            '{"fields":[{"fieldName":"name","type":"STRING"}],"displayName":"Partial Entity"}',
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "PartialEntity",
+            expect.any(Array),
+            expect.objectContaining({ displayName: "Partial Entity" }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
+    it("should error when no --body or --file provided", async () => {
+        vi.mocked(readJsonInput).mockRejectedValue(
+            new Error("Provide entity definition via --file or --body."),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error parsing entity definition",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when body is not a JSON object (array)", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue([
+            { fields: [] },
+        ] as unknown as Record<string, unknown>);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '[{"fields":[]}]',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Entity definition must be a JSON object",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when fields array is missing", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "No Fields Entity",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"displayName":"No Fields Entity"}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Entity definition must include a 'fields' array",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when a field has an invalid type", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "title", type: "text" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"title","type":"text"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid field type in fields",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when SDK connection fails on create", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "title", type: "STRING" }],
+        });
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when create API fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockRejectedValue(
+            new Error("Entity already exists"),
+        );
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ fieldName: "title", type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error creating entity",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("entities update", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should update entity by adding new fields (addFields)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "newField", type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"newField","type":"STRING"}]}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: [{ fieldName: "newField", type: "STRING" }],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+                Data: expect.objectContaining({ ID: "entity-id" }),
+            }),
+        );
+    });
+
+    it("should update entity by modifying existing fields (updateFields)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            updateFields: [
+                {
+                    id: "field-uuid-1",
+                    displayName: "Total Amount",
+                    isRequired: true,
+                },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"updateFields":[{"id":"field-uuid-1","displayName":"Total Amount","isRequired":true}]}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                updateFields: [
+                    {
+                        id: "field-uuid-1",
+                        displayName: "Total Amount",
+                        isRequired: true,
+                    },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+            }),
+        );
+    });
+
+    it("should update entity metadata only (displayName and description)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "Updated Name",
+            description: "Updated description",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"Updated Name","description":"Updated description"}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                displayName: "Updated Name",
+                description: "Updated description",
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+            }),
+        );
+    });
+
+    it("should update entity with combined addFields, updateFields, and metadata", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "newField", type: "STRING" }],
+            updateFields: [{ id: "field-uuid-1", isRequired: false }],
+            displayName: "Combined Update",
+            isRbacEnabled: true,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"newField","type":"STRING"}],"updateFields":[{"id":"field-uuid-1","isRequired":false}],"displayName":"Combined Update","isRbacEnabled":true}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: expect.any(Array),
+                updateFields: expect.any(Array),
+                displayName: "Combined Update",
+                isRbacEnabled: true,
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+            }),
+        );
+    });
+
+    it("should reject addFields items missing fieldName", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"type":"STRING"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message:
+                    "Each field in addFields must include a 'fieldName' string",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when addFields has an invalid type", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "price", type: "text" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"price","type":"text"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid field type in addFields",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject updateFields items missing id", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            updateFields: [{ displayName: "Total Amount" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"updateFields":[{"displayName":"Total Amount"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message:
+                    "Each field in updateFields must include an 'id' string",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject removeFields with explicit error", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: ["oldField"],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":["oldField"]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "removeFields is not supported",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when no --body or --file provided", async () => {
+        vi.mocked(readJsonInput).mockRejectedValue(
+            new Error("Provide update options via --file or --body."),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error parsing update options",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when update options body is not a JSON object", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue([
+            "addFields",
+        ] as unknown as Record<string, unknown>);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '["addFields"]',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Update options must be a JSON object",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when SDK connection fails on update", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "New Name",
+        });
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"New Name"}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when updateById API fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.updateById).mockRejectedValue(
+            new Error("Update failed"),
+        );
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "newField", type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"newField","type":"STRING"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error updating entity",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});