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

package/tests/entities-lifecycle.e2e.test.ts

@@ -0,0 +1,614 @@
+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/entities-lifecycle.md.
+//
+// Every S<n> in that scenario file maps one-to-one to an it() here (see
+// scenarios/README.md — "Scenario ↔ e2e mapping"). Same runtime pattern as
+// packages/integrationservice-tool/tests: `beforeAll` probes DF access, derives
+// read fixtures from what the tenant already has, and creates a scratch write
+// fixture with a unique name. Live scenarios skip via `ctx.skip()` when the
+// probe was denied or the derived fixture is missing. Pre-network guard
+// scenarios always run. `afterAll` cleans up the scratch entity.
+//
+// The shared install's client-credentials login is enough — DF accepts
+// application tokens (unlike IS design-time). No user-auth bridge needed.
+
+// 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 };
+}
+
+// Runtime-derived fixtures.
+let dfAccessDenied = false;
+let anyEntity: Json | undefined;
+let scratchEntityId: string | undefined;
+// Scratch folder + folder-scoped entity for S3 — created via `uip or folders
+// create`, matches the repo-wide pattern used by every folder-scoped e2e
+// (see e.g. orchestrator-tool/tests/assets.e2e.test.ts).
+let scratchFolderKey: string | undefined;
+let folderScopedEntityId: 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 scratchName = `E2eDfEntities${RUN_ID}`;
+const folderScopedEntityName = `E2eDfEntitiesFolder${RUN_ID}`;
+const scratchFolderName = `e2e-df-entities-folder-${RUN_ID}`;
+
+describe("df entities — entities lifecycle", () => {
+    beforeAll(() => {
+        const probe = runDf(["entities", "list"]);
+        if (probe.exitCode !== 0) {
+            dfAccessDenied = isAuthDenial(probe);
+            if (!dfAccessDenied) {
+                console.warn(
+                    `[df entities e2e] Probe failed for a non-auth reason; live scenarios will run and assert.\n${probe.stdout}`,
+                );
+            }
+            return;
+        }
+        const list = extractJson(probe.stdout) as Json;
+        const entities: Json[] = Array.isArray(list.Data) ? list.Data : [];
+        anyEntity = entities[0];
+
+        // Scratch tenant-level entity — doubles as the write-scope probe.
+        // Read passed but the token lacks entity-write scope → mark
+        // dfAccessDenied so every live test soft-skips together instead of
+        // one write test blowing up mid-run.
+        const create = runDf([
+            "entities",
+            "create",
+            scratchName,
+            "--body",
+            '{"fields":[{"fieldName":"note","type":"STRING"}]}',
+        ]);
+        if (isAuthDenial(create)) {
+            dfAccessDenied = true;
+            return;
+        }
+        if (create.exitCode === 0) {
+            scratchEntityId = (extractJson(create.stdout) as Json).Data?.Id;
+        }
+
+        // Scratch folder + folder-scoped entity for S3. Failure here
+        // (Orchestrator not enabled or no folder-create permission) leaves S3
+        // in ctx.skip() — the rest of the suite is unaffected.
+        const createFolder = runOrc(["folders", "create", scratchFolderName]);
+        if (createFolder.exitCode !== 0) return;
+        scratchFolderKey = (extractJson(createFolder.stdout) as Json).Data?.Key;
+        if (!scratchFolderKey) return;
+
+        const createFolderEntity = runDf([
+            "entities",
+            "create",
+            folderScopedEntityName,
+            "--folder-key",
+            scratchFolderKey,
+            "--body",
+            '{"fields":[{"fieldName":"note","type":"STRING"}]}',
+        ]);
+        if (createFolderEntity.exitCode === 0) {
+            folderScopedEntityId = (
+                extractJson(createFolderEntity.stdout) as Json
+            ).Data?.Id;
+        }
+    }, SETUP_TIMEOUT);
+
+    afterAll(() => {
+        if (scratchEntityId) {
+            runDf([
+                "entities",
+                "delete",
+                scratchEntityId,
+                "--yes",
+                "--reason",
+                "e2e cleanup",
+            ]);
+        }
+        if (folderScopedEntityId && scratchFolderKey) {
+            runDf([
+                "entities",
+                "delete",
+                folderScopedEntityId,
+                "--folder-key",
+                scratchFolderKey,
+                "--yes",
+                "--reason",
+                "e2e cleanup",
+            ]);
+        }
+        if (scratchFolderKey) {
+            runOrc(["folders", "delete", scratchFolderKey, "--yes"]);
+        }
+    });
+
+    // ── S1 ── list, DF access needed ────────────────────────────────────────
+    it(
+        "S1: list tenant-level entities",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const out = cli(["entities", "list"]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("EntityList");
+            expect(Array.isArray(out.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S2 ── list --native-only ────────────────────────────────────────────
+    it(
+        "S2: list only native entities",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const out = cli(["entities", "list", "--native-only"]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("EntityList");
+            for (const e of out.Data as Json[]) {
+                const ext = Array.isArray(e.ExternalFields)
+                    ? e.ExternalFields.length
+                    : 0;
+                expect(ext).toBe(0);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S3 ── list --folder-key, uses scratch folder fixture ────────────────
+    it(
+        "S3: list entities from a specific folder",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchFolderKey || !folderScopedEntityId) {
+                return ctx.skip();
+            }
+            const out = cli([
+                "entities",
+                "list",
+                "--folder-key",
+                scratchFolderKey,
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("EntityList");
+            for (const e of out.Data as Json[]) {
+                expect(e.FolderId).toBe(scratchFolderKey);
+            }
+            const ids = (out.Data as Json[]).map((e) => e.Id);
+            expect(ids).toContain(folderScopedEntityId);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S4 ── list --include-folders ────────────────────────────────────────
+    it(
+        "S4: list tenant plus every visible folder in one call",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const out = cli(["entities", "list", "--include-folders"]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("EntityList");
+            expect(Array.isArray(out.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S5 ── folder-scope guard, pre-network ───────────────────────────────
+    it(
+        "S5: --folder-key and --include-folders are mutually exclusive",
+        () => {
+            const parsed = expectFailure(
+                runDf([
+                    "entities",
+                    "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,
+    );
+
+    // ── S6 ── get by id, uses runtime fixture ───────────────────────────────
+    it(
+        "S6: get an entity schema by id",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!anyEntity) return ctx.skip();
+            const out = cli(["entities", "get", anyEntity.Id]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("EntitySchema");
+            expect(out.Data.Id).toBe(anyEntity.Id);
+            expect(Array.isArray(out.Data.Fields)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S7 ── create, transient scratch cleaned up in the same test ─────────
+    it(
+        "S7: create an entity from an inline body",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchName}S7`;
+            const created = cli([
+                "entities",
+                "create",
+                name,
+                "--body",
+                '{"fields":[{"fieldName":"amount","type":"DECIMAL","decimalPrecision":2}]}',
+            ]);
+            try {
+                expect(created.Result).toBe("Success");
+                expect(created.Code).toBe("EntityCreated");
+                expect(typeof created.Data.Id).toBe("string");
+            } finally {
+                if (created.Data?.Id) {
+                    runDf([
+                        "entities",
+                        "delete",
+                        created.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S7 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S8 ── create rejects malformed, pre-network ─────────────────────────
+    it(
+        "S8: create rejects malformed payloads before the API call",
+        () => {
+            const rows: Array<{
+                label: string;
+                body: string;
+                message: string;
+            }> = [
+                {
+                    label: "non-object body",
+                    body: "[]",
+                    message: "Entity definition must be a JSON object",
+                },
+                {
+                    label: "missing fields array",
+                    body: '{"displayName":"X"}',
+                    message: "Entity definition must include a 'fields' array",
+                },
+                {
+                    label: "field without fieldName",
+                    body: '{"fields":[{"type":"STRING"}]}',
+                    message: "Each field must include a 'fieldName' string",
+                },
+                {
+                    label: "unknown field type",
+                    body: '{"fields":[{"fieldName":"amount","type":"NOT_A_TYPE"}]}',
+                    message: "Invalid field type in fields",
+                },
+            ];
+
+            for (const row of rows) {
+                const parsed = expectFailure(
+                    runDf(["entities", "create", "Widget", "--body", row.body]),
+                    row.label,
+                );
+                expect(parsed.Message, row.label).toBe(row.message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S9 ── update composition on a transient scratch ─────────────────────
+    it(
+        "S9: update adds, edits, and removes fields in one call",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchName}S9`;
+            const created = cli([
+                "entities",
+                "create",
+                name,
+                "--body",
+                '{"fields":[{"fieldName":"old_col","type":"STRING"}]}',
+            ]);
+            const id: string = created.Data.Id;
+            try {
+                const schema = cli(["entities", "get", id]);
+                const oldField = (schema.Data.Fields as Json[]).find(
+                    (f) => f.Name === "old_col",
+                );
+                if (!oldField) throw new Error("scratch missing 'old_col'");
+                const body = JSON.stringify({
+                    addFields: [{ fieldName: "status", type: "STRING" }],
+                    updateFields: [
+                        { id: oldField.Id, displayName: "Old Column" },
+                    ],
+                    removeFields: [{ fieldName: "old_col" }],
+                });
+                const updated = cli([
+                    "entities",
+                    "update",
+                    id,
+                    "--body",
+                    body,
+                    "--yes",
+                    "--reason",
+                    "S9 composition test",
+                ]);
+                expect(updated.Result).toBe("Success");
+                expect(updated.Code).toBe("EntityUpdated");
+                expect(updated.Data.Id).toBe(id);
+                expect(updated.Data.RemovedFields).toContain("old_col");
+                expect(updated.Data.Reason).toBe("S9 composition test");
+            } finally {
+                runDf([
+                    "entities",
+                    "delete",
+                    id,
+                    "--yes",
+                    "--reason",
+                    "S9 cleanup",
+                ]);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S10 ── update rejects malformed, pre-network ────────────────────────
+    it(
+        "S10: update rejects malformed payloads before the API call",
+        () => {
+            const rows: Array<{
+                label: string;
+                argv: string[];
+                message: string;
+            }> = [
+                {
+                    label: "addFields missing fieldName",
+                    argv: [
+                        "entities",
+                        "update",
+                        "pre-network",
+                        "--body",
+                        '{"addFields":[{"type":"STRING"}]}',
+                    ],
+                    message:
+                        "Each field in addFields must include a non-empty 'fieldName' string",
+                },
+                {
+                    label: "updateFields missing id",
+                    argv: [
+                        "entities",
+                        "update",
+                        "pre-network",
+                        "--body",
+                        '{"updateFields":[{"displayName":"X"}]}',
+                    ],
+                    message:
+                        "Each field in updateFields must include a non-empty 'id' string",
+                },
+                {
+                    label: "duplicate fieldName in addFields",
+                    argv: [
+                        "entities",
+                        "update",
+                        "pre-network",
+                        "--body",
+                        '{"addFields":[{"fieldName":"dup_col","type":"STRING"},{"fieldName":"dup_col","type":"STRING"}]}',
+                    ],
+                    message: "Duplicate fieldName 'dup_col' in addFields",
+                },
+                {
+                    label: "addFields ∩ removeFields conflict",
+                    argv: [
+                        "entities",
+                        "update",
+                        "pre-network",
+                        "--body",
+                        '{"addFields":[{"fieldName":"col","type":"STRING"}],"removeFields":[{"fieldName":"col"}]}',
+                        "--yes",
+                        "--reason",
+                        "x",
+                    ],
+                    message:
+                        "Field 'col' appears in both addFields and removeFields",
+                },
+            ];
+
+            for (const row of rows) {
+                const parsed = expectFailure(runDf(row.argv), row.label);
+                expect(parsed.Message, row.label).toBe(row.message);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S11 ── destructive-confirmation guard on update, pre-network ────────
+    it(
+        "S11: update refuses removeFields without --yes and --reason",
+        () => {
+            const body = '{"removeFields":[{"fieldName":"old_col"}]}';
+
+            const noFlags = expectFailure(
+                runDf(["entities", "update", "pre-network", "--body", body]),
+                "no flags",
+            );
+            expect(noFlags.Message).toContain("Confirmation required");
+
+            const yesNoReason = expectFailure(
+                runDf([
+                    "entities",
+                    "update",
+                    "pre-network",
+                    "--body",
+                    body,
+                    "--yes",
+                ]),
+                "--yes without --reason",
+            );
+            expect(yesNoReason.Message).toBe(
+                "Reason required for destructive operation",
+            );
+
+            const reasonNoYes = expectFailure(
+                runDf([
+                    "entities",
+                    "update",
+                    "pre-network",
+                    "--body",
+                    body,
+                    "--reason",
+                    "x",
+                ]),
+                "--reason without --yes",
+            );
+            expect(reasonNoYes.Message).toContain("Confirmation required");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S12 ── destructive-confirmation guard on delete, pre-network ────────
+    it(
+        "S12: delete requires confirmation and a reason",
+        () => {
+            const noFlags = expectFailure(
+                runDf(["entities", "delete", "pre-network"]),
+                "no flags",
+            );
+            expect(noFlags.Message).toContain("Confirmation required");
+
+            const yesNoReason = expectFailure(
+                runDf(["entities", "delete", "pre-network", "--yes"]),
+                "--yes without --reason",
+            );
+            expect(yesNoReason.Message).toBe(
+                "Reason required for destructive operation",
+            );
+
+            const reasonNoYes = expectFailure(
+                runDf(["entities", "delete", "pre-network", "--reason", "x"]),
+                "--reason without --yes",
+            );
+            expect(reasonNoYes.Message).toContain("Confirmation required");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S13 ── delete an entity, transient scratch ──────────────────────────
+    it(
+        "S13: delete an entity",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            const name = `${scratchName}S13`;
+            const created = cli([
+                "entities",
+                "create",
+                name,
+                "--body",
+                '{"fields":[{"fieldName":"note","type":"STRING"}]}',
+            ]);
+            const id: string = created.Data.Id;
+            const deleted = cli([
+                "entities",
+                "delete",
+                id,
+                "--yes",
+                "--reason",
+                "S13 test",
+            ]);
+            expect(deleted.Result).toBe("Success");
+            expect(deleted.Code).toBe("EntityDeleted");
+            expect(deleted.Data.Id).toBe(id);
+            expect(deleted.Data.Reason).toBe("S13 test");
+        },
+        EXEC_TIMEOUT,
+    );
+});