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

package/tests/records-management.e2e.test.ts

@@ -0,0 +1,646 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    extractJson,
+    localCliPath,
+    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/records-management.md.
+//
+// Same runtime pattern as the other data-fabric e2es: `beforeAll` probes DF
+// access, creates a scratch entity (fields: note/amount/status), seeds 3
+// records; `afterAll` deletes the entity. Every mutating scenario creates
+// its own transient records and cleans them up inline. S13 (MULTILINE_MAX)
+// needs the tenant's MultilineMax feature flag, which the shared install
+// doesn't guarantee — stays as it.skip.
+
+// biome-ignore lint/suspicious/noExplicitAny: dynamic CLI JSON
+type Json = any;
+
+const AUTH_MARKERS = [
+    "forbidden",
+    "403",
+    "401",
+    "unauthorized",
+    "not logged in",
+    "auth_token",
+    "authentication",
+    "insufficient_scope",
+];
+
+const SCRATCH_DIR = join(tempDir, `df-records-e2e-${process.pid}`);
+
+function runDf(argv: string[]): { stdout: string; exitCode: number } {
+    const res = localCliRawWithArgs(tempDir, [
+        "df",
+        ...argv,
+        "--output",
+        "json",
+    ]);
+    return { stdout: res.stdout, exitCode: res.exitCode };
+}
+
+// Same shape as runDf but pipes `stdin` to the CLI so tests can exercise
+// `--body -` / `--file -`. execFileSync forwards `input` to stdin.
+function runDfWithStdin(
+    argv: string[],
+    stdin: string,
+): { stdout: string; exitCode: number } {
+    try {
+        const stdout = execFileSync(
+            process.execPath,
+            [localCliPath(tempDir), "df", ...argv, "--output", "json"],
+            {
+                cwd: tempDir,
+                encoding: "utf-8",
+                input: stdin,
+                timeout: EXEC_TIMEOUT,
+                maxBuffer: 10 * 1024 * 1024,
+                stdio: ["pipe", "pipe", "pipe"],
+            },
+        ).trim();
+        return { stdout, exitCode: 0 };
+    } catch (err: unknown) {
+        const e = err as {
+            stdout?: { toString(): string };
+            status?: number;
+        };
+        return {
+            stdout: e.stdout?.toString().trim() ?? "",
+            exitCode: e.status ?? 1,
+        };
+    }
+}
+
+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 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 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;
+}
+
+let dfAccessDenied = false;
+let scratchEntityId: string | undefined;
+let seedRecordIds: string[] = [];
+// Unique-per-run suffix matches the repo pattern used by orchestrator-tool
+// e2es to avoid collisions with orphans a prior failed run left behind.
+const RUN_ID = `${process.pid}_${Date.now()}`;
+const scratchEntityName = `E2eDfRecords${RUN_ID}`;
+
+describe("df records — records management", () => {
+    beforeAll(() => {
+        const probe = runDf(["entities", "list"]);
+        if (probe.exitCode !== 0) {
+            dfAccessDenied = isAuthDenial(probe);
+            if (!dfAccessDenied) {
+                console.warn(
+                    `[df records e2e] Probe failed for a non-auth reason; live scenarios will run and assert.\n${probe.stdout}`,
+                );
+            }
+            return;
+        }
+
+        mkdirSync(SCRATCH_DIR, { recursive: true });
+
+        // Scratch entity — doubles as the write-scope probe. Fields cover the
+        // three shapes records tests need: text (note), decimal (amount),
+        // categorical (status).
+        const createEntity = runDf([
+            "entities",
+            "create",
+            scratchEntityName,
+            "--body",
+            '{"fields":[{"fieldName":"note","type":"STRING"},{"fieldName":"amount","type":"DECIMAL","decimalPrecision":2},{"fieldName":"status","type":"STRING"}]}',
+        ]);
+        if (isAuthDenial(createEntity)) {
+            dfAccessDenied = true;
+            return;
+        }
+        if (createEntity.exitCode !== 0) return;
+        scratchEntityId = (extractJson(createEntity.stdout) as Json).Data?.Id;
+        if (!scratchEntityId) return;
+
+        // Seed 3 records — enough for list / get / query to have something
+        // real to assert against, without depending on per-test ordering.
+        const seed = runDf([
+            "records",
+            "insert",
+            scratchEntityId,
+            "--body",
+            '[{"note":"Alpha","amount":100,"status":"Open"},{"note":"Beta","amount":200,"status":"Open"},{"note":"Gamma","amount":300,"status":"Closed"}]',
+        ]);
+        if (seed.exitCode === 0) {
+            const data = (extractJson(seed.stdout) as Json).Data;
+            const records: Json[] = data?.SuccessRecords ?? [];
+            seedRecordIds = records
+                .map((r: Json) => r.Id)
+                .filter((id: unknown): id is string => typeof id === "string");
+        }
+    }, SETUP_TIMEOUT);
+
+    afterAll(() => {
+        if (scratchEntityId) {
+            runDf([
+                "entities",
+                "delete",
+                scratchEntityId,
+                "--yes",
+                "--reason",
+                "e2e cleanup",
+            ]);
+        }
+        if (existsSync(SCRATCH_DIR)) {
+            rmSync(SCRATCH_DIR, { recursive: true, force: true });
+        }
+    });
+
+    // ── S1 ── list returns a paginated page ─────────────────────────────────
+    it(
+        "S1: list records returns a paginated page",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const out = cli([
+                "records",
+                "list",
+                scratchEntityId,
+                "--limit",
+                "50",
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("RecordList");
+            // records list wraps the page: { Items: [...], TotalCount,
+            // HasNextPage, CurrentPage, TotalPages, SupportsPageJump }.
+            expect(Array.isArray(out.Data.Items)).toBe(true);
+            expect(out.Data.Items.length).toBeGreaterThanOrEqual(
+                seedRecordIds.length,
+            );
+            expect(typeof out.Data.TotalCount).toBe("number");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S2 ── get by id ─────────────────────────────────────────────────────
+    it(
+        "S2: get a single record by id",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId || seedRecordIds.length === 0) {
+                return ctx.skip();
+            }
+            const id = seedRecordIds[0];
+            const out = cli(["records", "get", scratchEntityId, id]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("RecordDetails");
+            expect(out.Data.Id).toBe(id);
+
+            // Unknown record surfaces a clear failure.
+            const unknown = runDf([
+                "records",
+                "get",
+                scratchEntityId,
+                "00000000-0000-0000-0000-000000000099",
+            ]);
+            expect(unknown.exitCode).toBe(1);
+            const parsed = extractJson(unknown.stdout) as Json;
+            expect(parsed.Result).toBe("Failure");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S3 ── insert one, cleanup inline ────────────────────────────────────
+    it(
+        "S3: insert one record",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const inserted = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--body",
+                '{"note":"S3","amount":1500,"status":"New"}',
+            ]);
+            try {
+                expect(inserted.Result).toBe("Success");
+                expect(inserted.Code).toBe("RecordInserted");
+                expect(typeof inserted.Data.Id).toBe("string");
+            } finally {
+                if (inserted.Data?.Id) {
+                    runDf([
+                        "records",
+                        "delete",
+                        scratchEntityId,
+                        inserted.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S3 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S4 ── insert many (array payload → RecordsBatchInserted) ────────────
+    it(
+        "S4: insert many records in one call",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const payloadPath = join(SCRATCH_DIR, "s4.json");
+            writeFileSync(
+                payloadPath,
+                JSON.stringify([
+                    { note: "S4a", amount: 1, status: "Open" },
+                    { note: "S4b", amount: 2, status: "Open" },
+                ]),
+            );
+            const out = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--file",
+                payloadPath,
+            ]);
+            const ids: string[] = (out.Data?.SuccessRecords as Json[])
+                .map((r: Json) => r.Id)
+                .filter((id: unknown): id is string => typeof id === "string");
+            try {
+                expect(out.Result).toBe("Success");
+                expect(out.Code).toBe("RecordsBatchInserted");
+                expect(out.Data.SuccessCount).toBeGreaterThanOrEqual(2);
+            } finally {
+                if (ids.length > 0) {
+                    runDf([
+                        "records",
+                        "delete",
+                        scratchEntityId,
+                        ...ids,
+                        "--yes",
+                        "--reason",
+                        "S4 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S5 ── update (single → RecordUpdated) ───────────────────────────────
+    it(
+        "S5: update a record (must include Id)",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const inserted = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--body",
+                '{"note":"S5","amount":10,"status":"Draft"}',
+            ]);
+            const id: string = inserted.Data.Id;
+            try {
+                const updated = cli([
+                    "records",
+                    "update",
+                    scratchEntityId,
+                    "--body",
+                    JSON.stringify({ Id: id, status: "Paid" }),
+                ]);
+                expect(updated.Result).toBe("Success");
+                expect(updated.Code).toBe("RecordUpdated");
+                // Fetch and confirm the change actually persisted. Formatter
+                // transforms record field keys to PascalCase (status → Status).
+                const fresh = cli(["records", "get", scratchEntityId, id]);
+                expect(fresh.Data.Status).toBe("Paid");
+            } finally {
+                runDf([
+                    "records",
+                    "delete",
+                    scratchEntityId,
+                    id,
+                    "--yes",
+                    "--reason",
+                    "S5 cleanup",
+                ]);
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S6 ── inline body reaches SDK call ──────────────────────────────────
+    it(
+        "S6: inline body parses a json payload",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const inserted = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--body",
+                '{"note":"S6","amount":42}',
+            ]);
+            try {
+                expect(inserted.Result).toBe("Success");
+                expect(inserted.Code).toBe("RecordInserted");
+            } finally {
+                if (inserted.Data?.Id) {
+                    runDf([
+                        "records",
+                        "delete",
+                        scratchEntityId,
+                        inserted.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S6 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S7 ── --file source parses a json payload ───────────────────────────
+    it(
+        "S7: file source reads a json payload",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const payloadPath = join(SCRATCH_DIR, "s7.json");
+            writeFileSync(
+                payloadPath,
+                JSON.stringify({ note: "S7", amount: 7, status: "Open" }),
+            );
+            const inserted = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--file",
+                payloadPath,
+            ]);
+            try {
+                expect(inserted.Result).toBe("Success");
+                expect(inserted.Code).toBe("RecordInserted");
+            } finally {
+                if (inserted.Data?.Id) {
+                    runDf([
+                        "records",
+                        "delete",
+                        scratchEntityId,
+                        inserted.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S7 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S8 ── stdin with `--body -` (Windows-safe path) ─────────────────────
+    it(
+        "S8: body reads from stdin when value is `-`",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            // Include `&` in the payload — this is the char that cmd.exe
+            // splits on. Reading via stdin bypasses the shell.
+            const res = runDfWithStdin(
+                ["records", "insert", scratchEntityId, "--body", "-"],
+                '{"note":"S8&Suffix","amount":8}',
+            );
+            expect(res.exitCode).toBe(0);
+            const inserted = extractJson(res.stdout) as Json;
+            try {
+                expect(inserted.Result).toBe("Success");
+                expect(inserted.Code).toBe("RecordInserted");
+                // Formatter transforms record field keys to PascalCase.
+                expect(inserted.Data.Note).toBe("S8&Suffix");
+            } finally {
+                if (inserted.Data?.Id) {
+                    runDf([
+                        "records",
+                        "delete",
+                        scratchEntityId,
+                        inserted.Data.Id,
+                        "--yes",
+                        "--reason",
+                        "S8 cleanup",
+                    ]);
+                }
+            }
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S9 ── pre-network input edge cases ──────────────────────────────────
+    it(
+        "S9: input edge cases fail clearly",
+        () => {
+            // A: empty stdin with --body - → parse fails before any SDK call.
+            const empty = runDfWithStdin(
+                ["records", "insert", "pre-network", "--body", "-"],
+                "",
+            );
+            const emptyParsed = expectFailure(empty, "empty stdin");
+            expect(emptyParsed.Message).toBe("Error parsing input data");
+            // readStdin returns null on TTY / empty pipe → "Expected JSON on
+            // stdin…"; if it returns "" (readable stream ended) → parseJson
+            // throws "Invalid JSON input:". Either is acceptable — both prove
+            // the CLI didn't proceed past parsing.
+            expect(emptyParsed.Instructions).toMatch(
+                /(Expected JSON on stdin|Invalid JSON input)/,
+            );
+
+            // B: malformed inline body.
+            const bad = runDf([
+                "records",
+                "insert",
+                "pre-network",
+                "--body",
+                "{bad",
+            ]);
+            const badParsed = expectFailure(bad, "bad JSON body");
+            expect(badParsed.Message).toBe("Error parsing input data");
+            expect(badParsed.Instructions).toContain("Invalid JSON input");
+
+            // C: neither --body nor --file → the missing-input message.
+            const missing = runDf(["records", "insert", "pre-network"]);
+            const missingParsed = expectFailure(missing, "no --body/--file");
+            expect(missingParsed.Message).toBe("Error parsing input data");
+            expect(missingParsed.Instructions).toContain(
+                "--file <path> or --body <json>",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S10 ── query with filterGroup ───────────────────────────────────────
+    it(
+        "S10: query records with a filter/aggregate body",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const body = JSON.stringify({
+                filterGroup: {
+                    queryFilters: [
+                        {
+                            fieldName: "status",
+                            operator: "=",
+                            value: "Open",
+                        },
+                    ],
+                },
+                selectedFields: ["note", "amount", "status"],
+            });
+            const out = cli([
+                "records",
+                "query",
+                scratchEntityId,
+                "--body",
+                body,
+                "--limit",
+                "50",
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("RecordQuery");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S11 ── CSV import ───────────────────────────────────────────────────
+    it(
+        "S11: import records from a CSV file",
+        (ctx) => {
+            if (dfAccessDenied) return ctx.skip();
+            if (!scratchEntityId) return ctx.skip();
+            const csvPath = join(SCRATCH_DIR, "s11.csv");
+            writeFileSync(
+                csvPath,
+                "note,amount,status\nS11a,11,Open\nS11b,12,Closed\n",
+            );
+            const out = cli([
+                "records",
+                "import",
+                scratchEntityId,
+                "--file",
+                csvPath,
+            ]);
+            expect(out.Result).toBe("Success");
+            expect(out.Code).toBe("RecordsImported");
+            expect(out.Data.TotalRecords).toBeGreaterThanOrEqual(2);
+            // Import writes rows directly; there's no per-row Id in the
+            // response, so cleanup happens via afterAll (entity delete
+            // cascades to all its records).
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S12 ── delete confirmation guard + happy path ───────────────────────
+    it(
+        "S12: delete records requires explicit confirmation",
+        (ctx) => {
+            // Confirmation guard is pre-network — always runs.
+            const noFlags = expectFailure(
+                runDf(["records", "delete", "pre-network", "pre-network"]),
+                "no flags",
+            );
+            expect(noFlags.Message).toContain("Confirmation required");
+
+            const yesNoReason = expectFailure(
+                runDf([
+                    "records",
+                    "delete",
+                    "pre-network",
+                    "pre-network",
+                    "--yes",
+                ]),
+                "--yes without --reason",
+            );
+            expect(yesNoReason.Message).toBe(
+                "Reason required for destructive operation",
+            );
+
+            // Happy path: needs live access + a record to delete.
+            if (dfAccessDenied) return;
+            if (!scratchEntityId) return;
+            const inserted = cli([
+                "records",
+                "insert",
+                scratchEntityId,
+                "--body",
+                '{"note":"S12","amount":0}',
+            ]);
+            const id: string = inserted.Data.Id;
+            const deleted = cli([
+                "records",
+                "delete",
+                scratchEntityId,
+                id,
+                "--yes",
+                "--reason",
+                "S12 cleanup",
+            ]);
+            expect(deleted.Result).toBe("Success");
+            expect(deleted.Code).toBe("RecordsDeleted");
+            expect(deleted.Data.Reason).toBe("S12 cleanup");
+            expect(deleted.Data.SuccessCount).toBeGreaterThanOrEqual(1);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── S13 ── MULTILINE_MAX behavior needs a MultilineMax-enabled tenant ──
+    // Verified live on alpha 2026-07-13 (see scenario file) but requires the
+    // MultilineMax feature flag that the shared install can't guarantee.
+    it.skip("S13: MULTILINE_MAX fields: size marker on list/query, full content on get", () => {});
+});