@uipath/data-fabric-tool 1.198.0 → 1.199.0-preview.104

package/tests/choice-sets-lifecycle.e2e.test.ts

@@ -0,0 +1,741 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    extractJson,
+    localCliRawWithArgs,
+    readManifest,
+    SETUP_TIMEOUT,
+} from "../../../tests/e2e-shared/helpers";
+
+const manifest = readManifest<E2EManifest>(MANIFEST_PATH);
+const { tempDir } = manifest.sharedInstall;
+
+// Owning e2e suite for scenarios/data-fabric-tool/choice-sets-lifecycle.md.
+//
+// Same runtime pattern as packages/integrationservice-tool/tests: `beforeAll`
+// probes DF access and creates a shared scratch choice-set (used by S3 for
+// list-values and by S11/S13/S15/S16 as the parent of scratch values). Each
+// mutating scenario creates its own transient scratch and cleans it up inline
+// so it doesn't rely on ordering. `afterAll` deletes the shared scratch.
+//
+// The command is `df choice-set-values ...`, NOT `df choice-sets values ...`
+// — the two are separate top-level commands under `df`. Value-delete uses
+// `--ids <id,id,...>` (comma-separated), not positional varargs.
+
+// noExplicitAny is off for test files (biome.json); e2e parses dynamic CLI JSON.
+type Json = any;
+
+const AUTH_MARKERS = [
+    "forbidden",
+    "403",
+    "401",
+    "unauthorized",
+    "not logged in",
+    "auth_token",
+    "authentication",
+    "insufficient_scope",
+];
+
+function isAuthDenial(res: { stdout: string; exitCode: number }): boolean {
+    if (res.exitCode === 0) return false;
+    const parsed = tryParse(res.stdout);
+    const hay =
+        `${parsed.Message ?? ""} ${parsed.Instructions ?? ""}`.toLowerCase();
+    return AUTH_MARKERS.some((m) => hay.includes(m));
+}
+
+function runDf(argv: string[]): { stdout: string; exitCode: number } {
+    const res = localCliRawWithArgs(tempDir, [
+        "df",
+        ...argv,
+        "--output",
+        "json",
+    ]);
+    return { stdout: res.stdout, exitCode: res.exitCode };
+}
+
+function cli(argv: string[]): Json {
+    const res = runDf(argv);
+    if (res.exitCode !== 0) {
+        throw new Error(
+            `[df ${argv.join(" ")}] exited ${res.exitCode}\n${res.stdout}`,
+        );
+    }
+    return extractJson(res.stdout) as Json;
+}
+
+function tryParse(stdout: string): Json {
+    try {
+        return extractJson(stdout) as Json;
+    } catch {
+        return {};
+    }
+}
+
+function expectFailure(
+    result: { stdout: string; exitCode: number },
+    label: string,
+): Json {
+    if (result.exitCode !== 1) {
+        throw new Error(
+            `[${label}] expected exit 1, got ${result.exitCode}. stdout:\n${result.stdout}`,
+        );
+    }
+    const parsed = extractJson(result.stdout) as Json;
+    expect(parsed.Result, label).toBe("Failure");
+    return parsed;
+}
+
+function runOrc(argv: string[]): { stdout: string; exitCode: number } {
+    const res = localCliRawWithArgs(tempDir, [
+        "or",
+        ...argv,
+        "--output",
+        "json",
+    ]);
+    return { stdout: res.stdout, exitCode: res.exitCode };
+}
+
+let dfAccessDenied = false;
+let scratchCsId: string | undefined;
+// Scratch folder for S17 — created via `uip or folders create`, matches the
+// repo-wide pattern (see e.g. orchestrator-tool/tests/assets.e2e.test.ts).
+let scratchFolderKey: string | undefined;
+// Unique-per-run suffix. Repo convention (see orchestrator-tool/tests/*)
+// uses Date.now(); process.pid alone can repeat across sequential runs and
+// collide with orphans a prior failed run left behind.
+const RUN_ID = `${process.pid}_${Date.now()}`;
+const scratchBaseName = `E2eDfCs${RUN_ID}`;
+const scratchFolderName = `e2e-df-choice-sets-folder-${RUN_ID}`;
+
+describe("df choice-sets — choice sets lifecycle", () => {
+    beforeAll(() => {
+        const probe = runDf(["choice-sets", "list"]);
+        if (probe.exitCode !== 0) {
+            dfAccessDenied = isAuthDenial(probe);
+            if (!dfAccessDenied) {
+                console.warn(
+                    `[df choice-sets e2e] Probe failed for a non-auth reason; live scenarios will run and assert.\n${probe.stdout}`,
+                );
+            }
+            return;
+        }
+        // Shared scratch choice-set — doubles as the write-scope probe. Read
+        // passed but the token lacks choice-set-write scope → mark
+        // dfAccessDenied so every live test soft-skips together.
+        const create = runDf([
+            "choice-sets",
+            "create",
+            `${scratchBaseName}Shared`,
+            "--display-name",
+            `E2E Shared ${RUN_ID}`,
+            "--description",
+            "shared scratch for value tests",
+        ]);
+        if (isAuthDenial(create)) {
+            dfAccessDenied = true;
+            return;
+        }
+        if (create.exitCode === 0) {
+            scratchCsId = (extractJson(create.stdout) as Json).Data?.Id;
+        }
+
+        // Scratch folder for S17. Failure here (Orchestrator not enabled or
+        // no folder-create permission) leaves S17 in ctx.skip() — the rest
+        // of the suite is unaffected.
+        const createFolder = runOrc(["folders", "create", scratchFolderName]);
+        if (createFolder.exitCode === 0) {
+            scratchFolderKey = (extractJson(createFolder.stdout) as Json).Data
+                ?.Key;
+        }
+    }, SETUP_TIMEOUT);
+
+    afterAll(() => {
+        if (scratchCsId) {
+            runDf([
+                "choice-sets",
+                "delete",
+                scratchCsId,
+                "--yes",
+                "--reason",
+                "e2e cleanup",
+            ]);
+        }
+        if (scratchFolderKey) {
+            runOrc(["folders", "delete", scratchFolderKey, "--yes"]);
+        }
+    });
+
+    // ── S1 ── list ──────────────────────────────────────────────────────────
+    it(
+        "S1: list tenant-level choice sets",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const out = cli(["choice-sets", "list"]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("ChoiceSetList");
+            expect(Array.isArray(out.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S2 ── folder-scope guard on list, pre-network ───────────────────────
+    it(
+        "S2: --folder-key and --include-folders are mutually exclusive on list",
+        () => {
+            const parsed = expectFailure(
+                runDf([
+                    "choice-sets",
+                    "list",
+                    "--folder-key",
+                    "pre-network",
+                    "--include-folders",
+                ]),
+                "list mutex",
+            );
+            expect(parsed.Message).toBe(
+                "--folder-key and --include-folders are mutually exclusive",
+            );
+            expect(parsed.Instructions.length).toBeGreaterThan(0);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S3 ── list-values on the shared scratch (empty is fine) ─────────────
+    it(
+        "S3: list the values inside a choice set with pagination",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchCsId) return ctx.skip();
+            const out = cli([
+                "choice-sets",
+                "list-values",
+                scratchCsId,
+                "--limit",
+                "50",
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("ChoiceSetValues");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S4 ── list-values paging guards, pre-network ────────────────────────
+    it(
+        "S4: list-values rejects invalid paging before the API call",
+        () => {
+            const rows: Array<{
+                label: string;
+                argv: string[];
+                message: string;
+            }> = [
+                {
+                    label: "--limit 0",
+                    argv: [
+                        "choice-sets",
+                        "list-values",
+                        "pre-network",
+                        "--limit",
+                        "0",
+                    ],
+                    message: "Invalid --limit value",
+                },
+                {
+                    label: "--limit abc",
+                    argv: [
+                        "choice-sets",
+                        "list-values",
+                        "pre-network",
+                        "--limit",
+                        "abc",
+                    ],
+                    message: "Invalid --limit value",
+                },
+                {
+                    label: "--offset -5",
+                    argv: [
+                        "choice-sets",
+                        "list-values",
+                        "pre-network",
+                        "--offset=-5",
+                    ],
+                    message: "Invalid --offset value",
+                },
+                {
+                    label: "--offset + --cursor",
+                    argv: [
+                        "choice-sets",
+                        "list-values",
+                        "pre-network",
+                        "--offset",
+                        "5",
+                        "--cursor",
+                        "XYZ",
+                    ],
+                    message: "--offset and --cursor are mutually exclusive",
+                },
+            ];
+
+            for (const row of rows) {
+                const parsed = expectFailure(runDf(row.argv), row.label);
+                expect(parsed.Message, row.label).toBe(row.message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S5 ── create a transient scratch choice-set ─────────────────────────
+    it(
+        "S5: create a tenant-level choice set",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchBaseName}S5`;
+            const created = cli([
+                "choice-sets",
+                "create",
+                name,
+                "--display-name",
+                `Priority ${RUN_ID}`,
+                "--description",
+                "S5 scratch",
+            ]);
+            try {
+                expect(created.Result).toBe("Success");
+                expect(created.Code).toBe("ChoiceSetCreated");
+                expect(typeof created.Data.Id).toBe("string");
+            } finally {
+                if (created.Data?.Id) {
+                    runDf([
+                        "choice-sets",
+                        "delete",
+                        created.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S5 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S6 ── create name validator, pre-network ────────────────────────────
+    it(
+        "S6: create rejects invalid names before the API call",
+        () => {
+            const rows: Array<{ name: string; message: string }> = [
+                {
+                    name: "1abc",
+                    message: "Invalid choice set name '1abc'",
+                },
+                {
+                    name: "class",
+                    message:
+                        "Choice set name 'class' is a reserved C# or VB keyword",
+                },
+                { name: "Id", message: "Invalid choice set name 'Id'" },
+            ];
+
+            for (const row of rows) {
+                const parsed = expectFailure(
+                    runDf(["choice-sets", "create", row.name]),
+                    row.name,
+                );
+                expect(parsed.Message, row.name).toBe(row.message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S7 ── update both-required guard, pre-network ───────────────────────
+    it(
+        "S7: update requires both --display-name and --description",
+        () => {
+            const message =
+                "choice-sets update requires both --display-name and --description";
+
+            for (const argv of [
+                ["choice-sets", "update", "pre-network", "--display-name", "X"],
+                ["choice-sets", "update", "pre-network", "--description", "Y"],
+                ["choice-sets", "update", "pre-network"],
+            ]) {
+                const parsed = expectFailure(runDf(argv), argv.join(" "));
+                expect(parsed.Message, argv.join(" ")).toBe(message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S8 ── update a transient scratch with both fields ───────────────────
+    it(
+        "S8: update a choice set with both fields",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchBaseName}S8`;
+            const created = cli([
+                "choice-sets",
+                "create",
+                name,
+                "--display-name",
+                `Old ${RUN_ID}`,
+                "--description",
+                "Old desc",
+            ]);
+            const id: string = created.Data.Id;
+            try {
+                const out = cli([
+                    "choice-sets",
+                    "update",
+                    id,
+                    "--display-name",
+                    `New ${RUN_ID}`,
+                    "--description",
+                    "New desc",
+                ]);
+                expect(out.Result).toBe("Success");
+                expect(out.Code).toBe("ChoiceSetUpdated");
+                expect(out.Data.Id).toBe(id);
+            } finally {
+                runDf([
+                    "choice-sets",
+                    "delete",
+                    id,
+                    "--yes",
+                    "--reason",
+                    "S8 cleanup",
+                ]);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S9 ── delete confirmation guard, pre-network ────────────────────────
+    it(
+        "S9: delete requires confirmation and a reason",
+        () => {
+            const noFlags = expectFailure(
+                runDf(["choice-sets", "delete", "pre-network"]),
+                "no flags",
+            );
+            expect(noFlags.Message).toContain("Confirmation required");
+
+            const yesNoReason = expectFailure(
+                runDf(["choice-sets", "delete", "pre-network", "--yes"]),
+                "--yes without --reason",
+            );
+            expect(yesNoReason.Message).toBe(
+                "Reason required for destructive operation",
+            );
+
+            const reasonNoYes = expectFailure(
+                runDf([
+                    "choice-sets",
+                    "delete",
+                    "pre-network",
+                    "--reason",
+                    "cleanup",
+                ]),
+                "--reason without --yes",
+            );
+            expect(reasonNoYes.Message).toContain("Confirmation required");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S10 ── delete a transient scratch ───────────────────────────────────
+    it(
+        "S10: delete a choice set",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchBaseName}S10`;
+            const created = cli([
+                "choice-sets",
+                "create",
+                name,
+                "--display-name",
+                `For delete ${RUN_ID}`,
+                "--description",
+                "S10 scratch",
+            ]);
+            const id: string = created.Data.Id;
+            const out = cli([
+                "choice-sets",
+                "delete",
+                id,
+                "--yes",
+                "--reason",
+                "S10 test",
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("ChoiceSetDeleted");
+            expect(out.Data.Id).toBe(id);
+            expect(out.Data.Reason).toBe("S10 test");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S11 ── add a value on the shared scratch ────────────────────────────
+    it(
+        "S11: add a value to a choice set",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchCsId) return ctx.skip();
+            const created = cli([
+                "choice-set-values",
+                "create",
+                scratchCsId,
+                `s11_${process.pid}`,
+                "--display-name",
+                "S11",
+            ]);
+            try {
+                expect(created.Result).toBe("Success");
+                expect(created.Code).toBe("ChoiceSetValueCreated");
+                expect(typeof created.Data.Id).toBe("string");
+            } finally {
+                if (created.Data?.Id) {
+                    runDf([
+                        "choice-set-values",
+                        "delete",
+                        scratchCsId,
+                        "--ids",
+                        created.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S11 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S12 ── value-create name validator, pre-network ─────────────────────
+    it(
+        "S12: value-create rejects invalid names before the API call",
+        () => {
+            const rows: Array<{ name: string; message: string }> = [
+                {
+                    name: "1abc",
+                    message: "Invalid choice-set value name '1abc'",
+                },
+                {
+                    name: "internal",
+                    message:
+                        "Choice-set value name 'internal' is a reserved C# keyword",
+                },
+            ];
+
+            for (const row of rows) {
+                const parsed = expectFailure(
+                    runDf([
+                        "choice-set-values",
+                        "create",
+                        "pre-network",
+                        row.name,
+                    ]),
+                    row.name,
+                );
+                expect(parsed.Message, row.name).toBe(row.message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S13 ── update a value's display name on a transient value ───────────
+    it(
+        "S13: update a value's display name",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchCsId) return ctx.skip();
+            const valueName = `s13_${process.pid}`;
+            const created = cli([
+                "choice-set-values",
+                "create",
+                scratchCsId,
+                valueName,
+                "--display-name",
+                "S13 Old",
+            ]);
+            const valueId: string = created.Data.Id;
+            try {
+                const out = cli([
+                    "choice-set-values",
+                    "update",
+                    scratchCsId,
+                    valueId,
+                    "S13 New",
+                ]);
+                expect(out.Result).toBe("Success");
+                expect(out.Code).toBe("ChoiceSetValueUpdated");
+                expect(out.Data.DisplayName).toBe("S13 New");
+            } finally {
+                runDf([
+                    "choice-set-values",
+                    "delete",
+                    scratchCsId,
+                    "--ids",
+                    valueId,
+                    "--yes",
+                    "--reason",
+                    "S13 cleanup",
+                ]);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S14 ── value-delete missing --ids, pre-network ──────────────────────
+    it(
+        "S14: value-delete rejects missing --ids before the API call",
+        () => {
+            const parsed = expectFailure(
+                runDf(["choice-set-values", "delete", "pre-network"]),
+                "missing --ids",
+            );
+            expect(parsed.Message).toBe("No value IDs provided");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S15 ── value-delete confirmation guard, pre-network ─────────────────
+    it(
+        "S15: value-delete requires confirmation and a reason",
+        () => {
+            const base = [
+                "choice-set-values",
+                "delete",
+                "pre-network",
+                "--ids",
+                "v-pre-network",
+            ];
+
+            const noFlags = expectFailure(runDf(base), "no flags");
+            expect(noFlags.Message).toContain("Confirmation required");
+
+            const yesNoReason = expectFailure(
+                runDf([...base, "--yes"]),
+                "--yes without --reason",
+            );
+            expect(yesNoReason.Message).toBe(
+                "Reason required for destructive operation",
+            );
+
+            const reasonNoYes = expectFailure(
+                runDf([...base, "--reason", "renamed"]),
+                "--reason without --yes",
+            );
+            expect(reasonNoYes.Message).toContain("Confirmation required");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S16 ── delete transient values on the shared scratch ────────────────
+    it(
+        "S16: delete one or more values with a shared confirmation",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchCsId) return ctx.skip();
+            const a = cli([
+                "choice-set-values",
+                "create",
+                scratchCsId,
+                `s16a_${process.pid}`,
+                "--display-name",
+                "S16a",
+            ]);
+            const b = cli([
+                "choice-set-values",
+                "create",
+                scratchCsId,
+                `s16b_${process.pid}`,
+                "--display-name",
+                "S16b",
+            ]);
+            const ids = `${a.Data.Id},${b.Data.Id}`;
+            const out = cli([
+                "choice-set-values",
+                "delete",
+                scratchCsId,
+                "--ids",
+                ids,
+                "--yes",
+                "--reason",
+                "S16 test",
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("ChoiceSetValuesDeleted");
+            expect(out.Data.ChoiceSetId).toBe(scratchCsId);
+            expect(out.Data.DeletedIds).toEqual([a.Data.Id, b.Data.Id]);
+            expect(out.Data.Reason).toBe("S16 test");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S17 ── create + delete a folder-scoped choice set ───────────────────
+    it(
+        "S17: create and delete a folder-scoped choice set",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchFolderKey) return ctx.skip();
+
+            const name = `${scratchBaseName}S17`;
+            const created = cli([
+                "choice-sets",
+                "create",
+                name,
+                "--display-name",
+                `Folder-scoped S17 ${RUN_ID}`,
+                "--description",
+                "S17 scratch",
+                "--folder-key",
+                scratchFolderKey,
+            ]);
+            const id: string = created.Data.Id;
+            try {
+                expect(created.Result).toBe("Success");
+                expect(created.Code).toBe("ChoiceSetCreated");
+
+                const deleted = cli([
+                    "choice-sets",
+                    "delete",
+                    id,
+                    "--folder-key",
+                    scratchFolderKey,
+                    "--yes",
+                    "--reason",
+                    "S17 cleanup",
+                ]);
+                expect(deleted.Result).toBe("Success");
+                expect(deleted.Code).toBe("ChoiceSetDeleted");
+
+                const list = cli([
+                    "choice-sets",
+                    "list",
+                    "--folder-key",
+                    scratchFolderKey,
+                ]);
+                const ids = (list.Data as Json[]).map((c) => c.Id);
+                expect(ids).not.toContain(id);
+            } catch (err) {
+                // Best-effort cleanup if an assertion failed after create.
+                runDf([
+                    "choice-sets",
+                    "delete",
+                    id,
+                    "--folder-key",
+                    scratchFolderKey,
+                    "--yes",
+                    "--reason",
+                    "S17 cleanup after failure",
+                ]);
+                throw err;
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+});