@uipath/data-fabric-tool 1.1.0 → 1.196.0

package/src/commands/records.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) => {
@@ -23,7 +24,7 @@ vi.mock("@uipath/filesystem", () => ({
 }));
 
 import { OutputFormatter } from "@uipath/common";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { connectOrFail } from "../utils/sdk-client";
 import { registerRecordsCommand } from "./records";
 
 function buildProgram(): Command {
@@ -66,7 +67,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             ...overrides,
         },
     };
-    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
     return sdk;
 }
 
@@ -83,13 +84,14 @@ describe("records list", () => {
         expect(cmd?.commands.map((c) => c.name())).toContain("list");
     });
 
-    it("should list records successfully", async () => {
+    it("should list records successfully (raw SDK shape)", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-1", name: "test" }],
             totalCount: 1,
             hasNextPage: false,
-        });
+        };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -107,22 +109,20 @@ describe("records list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordList",
-                Data: expect.objectContaining({
-                    TotalCount: 1,
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
 
-    it("should pass cursor to SDK and include NextCursor in output", async () => {
+    it("should pass cursor to SDK and return the raw paginated response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-2" }],
             totalCount: 100,
             hasNextPage: true,
-            nextCursor: "cursor-abc",
-        });
+            nextCursor: { value: "cursor-abc" },
+        };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -141,16 +141,15 @@ describe("records list", () => {
         });
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "cursor-abc",
-                }),
+                Data: rawResult,
             }),
         );
     });
 
-    it("should return empty list when no records exist", async () => {
-        mockSdk();
+    it("should return empty list when no records exist (raw SDK shape)", async () => {
+        const sdk = mockSdk();
+        const rawResult = { items: [], totalCount: 0 };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -165,7 +164,7 @@ describe("records list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordList",
-                Data: expect.objectContaining({ TotalCount: 0, Records: [] }),
+                Data: rawResult,
             }),
         );
         expect(process.exitCode).not.toBe(1);
@@ -361,10 +360,9 @@ describe("records list client error", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on list", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on list", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -373,20 +371,14 @@ describe("records list client error", () => {
             "list",
             "entity-id",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getAllRecords).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
-    it("should handle list result without items/totalCount (uses defaults)", async () => {
+    it("should pass through the raw list result verbatim", async () => {
+        const rawResult = { items: [], hasNextPage: false };
         const sdk = mockSdk({
-            getAllRecords: vi
-                .fn()
-                .mockResolvedValue({ items: [], hasNextPage: false }),
+            getAllRecords: vi.fn().mockResolvedValue(rawResult),
         });
         const program = buildProgram();
         await program.parseAsync([
@@ -399,11 +391,7 @@ describe("records list client error", () => {
         expect(sdk.entities.getAllRecords).toHaveBeenCalled();
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    TotalCount: 0,
-                    Records: [],
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -496,10 +484,9 @@ describe("records get client error", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on get", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on get", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -509,13 +496,8 @@ describe("records get client error", () => {
             "entity-id",
             "rec-1",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -630,10 +612,9 @@ describe("records insert", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on insert", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on insert", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -644,13 +625,8 @@ describe("records insert", () => {
             "--body",
             '{"amount":100}',
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.insertRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should handle batch insert result without successRecords/failureRecords", async () => {
@@ -977,10 +953,9 @@ describe("records update client/batch errors", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on update", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on update", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -991,13 +966,8 @@ describe("records update client/batch errors", () => {
             "--body",
             '{"Id":"rec-1"}',
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.updateRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should handle batch update result without successRecords/failureRecords", async () => {
@@ -1097,6 +1067,9 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
@@ -1123,6 +1096,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalled();
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1149,6 +1125,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -1172,6 +1151,9 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1185,18 +1167,38 @@ describe("records delete", () => {
         );
         expect(process.exitCode).toBe(1);
     });
-});
 
-describe("records delete client error", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        process.exitCode = undefined;
-    });
+    it("should accept --confirm as a deprecated alias for --yes", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--confirm",
+            "--reason",
+            "test cleanup",
+        ]);
 
-    it("should error when SDK connection fails on delete", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
+        expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            ["rec-1"],
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "RecordsDeleted",
+            }),
         );
+    });
+
+    it("should require confirmation: without --yes, exit 1 and SDK not called", async () => {
+        const sdk = mockSdk();
+
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -1205,17 +1207,63 @@ describe("records delete client error", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--reason",
+            "test cleanup",
         ]);
+
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --reason when confirmation is present", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--yes",
+        ]);
+
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "Error connecting to Data Fabric",
+                Message: "Reason required for destructive operation",
             }),
         );
         expect(process.exitCode).toBe(1);
     });
 });
 
+describe("records delete client error", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should bail when SDK connection fails on delete", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+        ]);
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+    });
+});
+
 describe("records insert via --file", () => {
     beforeEach(() => {
         vi.resetAllMocks();
@@ -1305,13 +1353,14 @@ describe("records query", () => {
         process.exitCode = undefined;
     });
 
-    it("should query records without filters (no --body)", async () => {
+    it("should query records without filters (no --body) and return raw shape", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-1", title: "test" }],
             totalCount: 1,
             hasNextPage: false,
-        });
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1330,10 +1379,7 @@ describe("records query", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordQuery",
-                Data: expect.objectContaining({
-                    TotalCount: 1,
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -1421,7 +1467,7 @@ describe("records query", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordQuery",
-                Data: expect.objectContaining({ TotalCount: 2 }),
+                Data: expect.objectContaining({ totalCount: 2 }),
             }),
         );
     });
@@ -1470,8 +1516,8 @@ describe("records query", () => {
                 Result: "Success",
                 Code: "RecordQuery",
                 Data: expect.objectContaining({
-                    TotalCount: 2,
-                    Records: [
+                    totalCount: 2,
+                    items: [
                         { status: "Open", total: 12 },
                         { status: "Closed", total: 5 },
                     ],
@@ -1527,12 +1573,13 @@ describe("records query", () => {
 
     it("should pass custom --limit and --cursor to queryRecordsById", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-3" }],
             totalCount: 100,
             hasNextPage: true,
-            nextCursor: "next-cursor-xyz",
-        });
+            nextCursor: { value: "next-cursor-xyz" },
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1556,10 +1603,7 @@ describe("records query", () => {
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "next-cursor-xyz",
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -1627,10 +1671,9 @@ describe("records query", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on query", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on query", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -1639,13 +1682,8 @@ describe("records query", () => {
             "query",
             "entity-id",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.queryRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when query API fails", async () => {
@@ -1877,10 +1915,9 @@ describe("records import", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on import", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on import", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const { getFileSystem } = await import("@uipath/filesystem");
         vi.mocked(getFileSystem).mockReturnValue({
@@ -1900,13 +1937,8 @@ describe("records import", () => {
             "data.csv",
         ]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.importRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -1940,14 +1972,14 @@ describe("records query — pagination", () => {
         const call = vi.mocked(OutputFormatter.success).mock
             .calls[0][0] as unknown as {
             Data: {
-                TotalCount: number;
-                Records: unknown[];
-                HasNextPage: boolean;
+                totalCount: number;
+                items: unknown[];
+                hasNextPage: boolean;
             };
         };
-        expect(call.Data.TotalCount).toBe(3);
-        expect(call.Data.Records).toHaveLength(3);
-        expect(call.Data.HasNextPage).toBe(false);
+        expect(call.Data.totalCount).toBe(3);
+        expect(call.Data.items).toHaveLength(3);
+        expect(call.Data.hasNextPage).toBe(false);
     });
 
     it("should return first page with cursor when paginated", async () => {
@@ -1956,7 +1988,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r1" }, { Id: "r2" }],
             totalCount: 5,
             hasNextPage: true,
-            nextCursor: "cursor-page2",
+            nextCursor: { value: "cursor-page2" },
         });
 
         const program = buildProgram();
@@ -1977,16 +2009,16 @@ describe("records query — pagination", () => {
         const call = vi.mocked(OutputFormatter.success).mock
             .calls[0][0] as unknown as {
             Data: {
-                TotalCount: number;
-                Records: unknown[];
-                HasNextPage: boolean;
-                NextCursor: string;
+                totalCount: number;
+                items: unknown[];
+                hasNextPage: boolean;
+                nextCursor: { value: string };
             };
         };
-        expect(call.Data.TotalCount).toBe(5);
-        expect(call.Data.Records).toHaveLength(2);
-        expect(call.Data.HasNextPage).toBe(true);
-        expect(call.Data.NextCursor).toBe("cursor-page2");
+        expect(call.Data.totalCount).toBe(5);
+        expect(call.Data.items).toHaveLength(2);
+        expect(call.Data.hasNextPage).toBe(true);
+        expect(call.Data.nextCursor).toEqual({ value: "cursor-page2" });
     });
 
     it("should pass cursor to second page request", async () => {
@@ -1995,7 +2027,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r3" }, { Id: "r4" }],
             totalCount: 5,
             hasNextPage: true,
-            nextCursor: "cursor-page3",
+            nextCursor: { value: "cursor-page3" },
         });
 
         const program = buildProgram();
@@ -2021,8 +2053,8 @@ describe("records query — pagination", () => {
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "cursor-page3",
+                    hasNextPage: true,
+                    nextCursor: { value: "cursor-page3" },
                 }),
             }),
         );
@@ -2034,7 +2066,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r1", status: "active" }],
             totalCount: 10,
             hasNextPage: true,
-            nextCursor: "cur-next",
+            nextCursor: { value: "cur-next" },
         });
 
         const body = JSON.stringify({
@@ -2074,67 +2106,14 @@ describe("records query — pagination", () => {
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Data: expect.objectContaining({
-                    TotalCount: 10,
-                    HasNextPage: true,
-                    NextCursor: "cur-next",
+                    totalCount: 10,
+                    hasNextPage: true,
+                    nextCursor: { value: "cur-next" },
                 }),
             }),
         );
     });
 
-    it("should omit NextCursor when hasNextPage is false", async () => {
-        const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
-            items: [{ Id: "r1" }],
-            totalCount: 1,
-            hasNextPage: false,
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "records",
-            "query",
-            "entity-id",
-        ]);
-
-        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: Record<string, unknown>;
-        };
-        expect(call.Data).not.toHaveProperty("NextCursor");
-    });
-
-    it("should normalise cursor object {value} returned by SDK to a plain string", async () => {
-        const sdk = mockSdk();
-        // SDK may return PaginationCursor = { value: string } instead of a raw string
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
-            items: [{ Id: "r1" }, { Id: "r2" }],
-            totalCount: 4,
-            hasNextPage: true,
-            nextCursor: { value: "cursor-as-object" } as unknown as string,
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "records",
-            "query",
-            "entity-id",
-            "--limit",
-            "2",
-        ]);
-
-        const call = vi.mocked(OutputFormatter.success).mock
-            .calls[0][0] as unknown as {
-            Data: { NextCursor: unknown };
-        };
-        // Must be a plain string, not the object
-        expect(typeof call.Data.NextCursor).toBe("string");
-        expect(call.Data.NextCursor).toBe("cursor-as-object");
-    });
-
     it("should use default limit 50 when --cursor is given without --limit", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
@@ -2240,14 +2219,14 @@ describe("records query — pagination", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should handle last page correctly — no NextCursor even if SDK emits undefined", async () => {
+    it("should pass cursor through on the last page and return the raw result", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "r5" }],
             totalCount: 5,
             hasNextPage: false,
-            nextCursor: undefined,
-        });
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -2269,11 +2248,11 @@ describe("records query — pagination", () => {
                 cursor: { value: "cursor-page2" },
             }),
         );
-        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: Record<string, unknown>;
-        };
-        expect(call.Data.HasNextPage).toBe(false);
-        expect(call.Data).not.toHaveProperty("NextCursor");
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: rawResult,
+            }),
+        );
     });
 });
 
@@ -2347,6 +2326,9 @@ describe("records — negative scenarios", () => {
             "delete",
             "entity-id",
             "nonexistent-record-id",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(