@uipath/tasks-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/tests/complete.e2e.test.ts

@@ -91,26 +91,26 @@ describe("tasks complete e2e", () => {
         EXEC_TIMEOUT,
     );
 
+    // ── Tenant read (requires login) ─────────────────────────────────────────
+
     it(
-        "S2: missing --folder-id fails fast",
+        "S2: missing folder fails loud when not interactive",
         () => {
             const raw = localCliRaw(
                 tempDir,
                 "tasks complete 5 --type FormTask --output json",
             );
-            expect(raw.exitCode).toBe(3);
+            expect(raw.exitCode).not.toBe(0);
             const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
-            expect(res.Result).toBe("ValidationError");
-            expect(res.ErrorCode).toBe("invalid_argument");
-            expect(res.Message).toBe(
-                "error: required option '--folder-id <id>' not specified",
-            );
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("A folder is required");
+            expect(res.Instructions).toMatch(/--folder-id/);
+            expect(res.Instructions).toMatch(/--folder-path/);
+            expect(res.Instructions).toMatch(/--folder-key/);
         },
         EXEC_TIMEOUT,
     );
 
-    // ── Tenant read (requires login) ─────────────────────────────────────────
-
     it(
         "S3: invalid task type value is rejected",
         () => {

package/tests/data.e2e.test.ts

@@ -0,0 +1,187 @@
+import { RESULTS } from "@uipath/common";
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    localCliRawWithArgs,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+interface Envelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+}
+
+interface TaskRow {
+    Id?: number;
+    IsDeleted?: boolean;
+    Status?: string;
+    Type?: string;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+function listTasks(asAdmin: boolean): TaskRow[] {
+    const flag = asAdmin ? "--as-admin " : "";
+    const raw = localCliRaw(
+        tempDir,
+        `tasks list ${flag}--limit 200 --output json`,
+    );
+    if (raw.exitCode !== 0) return [];
+    return (parseOutput(raw.stdout, "json") as { Data?: TaskRow[] }).Data ?? [];
+}
+
+function discoverTask(): { taskId: string; folderId: string } | null {
+    const envFolder = process.env.TASKS_TOOL_E2E_FOLDER_ID;
+    const envTask =
+        process.env.TASKS_TOOL_E2E_TASK_ID_DATA ??
+        process.env.TASKS_TOOL_E2E_TASK_ID;
+    if (envFolder && envTask) {
+        return { taskId: envTask, folderId: envFolder };
+    }
+    for (const asAdmin of [false, true]) {
+        const task = listTasks(asAdmin).find(
+            (t) =>
+                !t.IsDeleted &&
+                t.Status !== "Completed" &&
+                t.Type === "ExternalTask" &&
+                typeof t.Id === "number" &&
+                typeof t.FolderId === "number",
+        );
+        if (task) {
+            return {
+                taskId: String(task.Id),
+                folderId: String(envFolder ?? task.FolderId),
+            };
+        }
+    }
+    // No actionable ExternalTask on this tenant; skip the live suite (guarded by describe.skipIf below).
+    return null;
+}
+
+const discovered = discoverTask();
+const taskId = discovered?.taskId ?? "";
+const folderId = discovered?.folderId ?? "";
+
+function getData(id: string): Envelope {
+    const raw = localCliRaw(
+        tempDir,
+        `tasks data get ${id} --folder-id ${folderId} --output json`,
+    );
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+function saveData(id: string, dataJson: string): Envelope {
+    const raw = localCliRawWithArgs(tempDir, [
+        "tasks",
+        "data",
+        "save",
+        id,
+        "--folder-id",
+        folderId,
+        "--data",
+        dataJson,
+        "--output",
+        "json",
+    ]);
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+describe.skipIf(!discovered)("tasks data e2e", () => {
+    it(
+        "S1: get task data",
+        () => {
+            const res = getData(taskId);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskData");
+            expect((res.Data as { Id?: number }).Id).toBe(Number(taskId));
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: get a non-existent task reports a failure",
+        () => {
+            const res = getData("999999999");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error getting data for task/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: invalid task id reports a validation error",
+        () => {
+            const res = getData("not-a-number");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid <task-id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: save task data",
+        () => {
+            const res = saveData(taskId, '{"amount":1200}');
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskDataSaved");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: invalid data JSON reports a validation error",
+        () => {
+            const res = saveData(taskId, "not-json");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid JSON in --data");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S6: save on a non-existent task reports a failure",
+        () => {
+            const res = saveData("999999999", '{"amount":1}');
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error saving data for task/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: non-object data is rejected before the API call",
+        () => {
+            const res = saveData(taskId, "[1,2,3]");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("--data must be a JSON object");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S8: data round-trips through save and get",
+        () => {
+            const marker = `sdk-cli-e2e-${Date.now()}`;
+            const save = saveData(taskId, `{"Marker":"${marker}"}`);
+            expect(save.Result).toBe(RESULTS.Success);
+
+            const res = getData(taskId);
+            expect(res.Result).toBe(RESULTS.Success);
+            const payload = (res.Data as { Data?: Record<string, unknown> })
+                .Data;
+            expect(payload?.Marker).toBe(marker);
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/get.e2e.test.ts

@@ -82,7 +82,7 @@ describe("tasks get e2e", () => {
     );
 
     it(
-        "S4: --task-type without --folder-id is rejected",
+        "S4: --task-type without a folder option is rejected",
         () => {
             const raw = localCliRaw(
                 tempDir,
@@ -92,9 +92,11 @@ describe("tasks get e2e", () => {
             const res = parseOutput(raw.stdout, "json") as GetEnvelope;
             expect(res.Result).toBe(RESULTS.Failure);
             expect(res.Message).toBe(
-                "--folder-id is required when --task-type is specified",
+                "A folder is required when --task-type is specified",
             );
             expect(res.Instructions).toMatch(/--folder-id/);
+            expect(res.Instructions).toMatch(/--folder-path/);
+            expect(res.Instructions).toMatch(/--folder-key/);
         },
         EXEC_TIMEOUT,
     );

package/tests/labels.e2e.test.ts

@@ -0,0 +1,184 @@
+import { RESULTS } from "@uipath/common";
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    localCliRawWithArgs,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+interface Envelope {
+    Result: string;
+    Code?: string;
+    Message?: string;
+    Instructions?: string;
+}
+
+interface TaskRow {
+    Id?: number;
+    IsDeleted?: boolean;
+    Status?: string;
+    Type?: string;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+function listTasks(asAdmin: boolean): TaskRow[] {
+    const flag = asAdmin ? "--as-admin " : "";
+    const raw = localCliRaw(
+        tempDir,
+        `tasks list ${flag}--limit 200 --output json`,
+    );
+    if (raw.exitCode !== 0) return [];
+    return (parseOutput(raw.stdout, "json") as { Data?: TaskRow[] }).Data ?? [];
+}
+
+function discoverTask(): { taskId: string; folderId: string } | null {
+    const envFolder = process.env.TASKS_TOOL_E2E_FOLDER_ID;
+    const envTask =
+        process.env.TASKS_TOOL_E2E_TASK_ID_LABELS ??
+        process.env.TASKS_TOOL_E2E_TASK_ID;
+    if (envFolder && envTask) {
+        return { taskId: envTask, folderId: envFolder };
+    }
+    for (const asAdmin of [false, true]) {
+        const task = listTasks(asAdmin).find(
+            (t) =>
+                !t.IsDeleted &&
+                t.Status !== "Completed" &&
+                t.Type === "ExternalTask" &&
+                typeof t.Id === "number" &&
+                typeof t.FolderId === "number",
+        );
+        if (task) {
+            return {
+                taskId: String(task.Id),
+                folderId: String(envFolder ?? task.FolderId),
+            };
+        }
+    }
+    // No actionable ExternalTask on this tenant; skip the live suite (guarded by describe.skipIf below).
+    return null;
+}
+
+const discovered = discoverTask();
+const taskId = discovered?.taskId ?? "";
+const folderId = discovered?.folderId ?? "";
+
+function setTags(id: string, tagsJson: string): Envelope {
+    const raw = localCliRawWithArgs(tempDir, [
+        "tasks",
+        "labels",
+        id,
+        "--folder-id",
+        folderId,
+        "--labels",
+        tagsJson,
+        "--output",
+        "json",
+    ]);
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+describe.skipIf(!discovered)("tasks labels e2e", () => {
+    it(
+        "S1: set labels on a task",
+        () => {
+            const res = setTags(taskId, '[{"name":"urgent"}]');
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskLabelsSaved");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: clear labels with an empty array",
+        () => {
+            const res = setTags(taskId, "[]");
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskLabelsSaved");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: invalid task id reports a validation error",
+        () => {
+            const res = setTags("not-a-number", "[]");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid <task-id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: set labels on a non-existent task reports a failure",
+        () => {
+            const res = setTags("999999999", '[{"name":"urgent"}]');
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error saving labels on task/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: invalid JSON in --labels is rejected before the API call",
+        () => {
+            const res = setTags(taskId, "not-json");
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid JSON in --labels");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S6: non-array --labels is rejected before the API call",
+        () => {
+            const res = setTags(taskId, '{"name":"urgent"}');
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("--labels must be a JSON array");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: set a label with a display name and value",
+        () => {
+            const res = setTags(
+                taskId,
+                '[{"name":"region","displayName":"Region","displayValue":"EMEA"}]',
+            );
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskLabelsSaved");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S8: labels round-trip through set and read-back",
+        () => {
+            const marker = `sdkclie2e${Date.now()}`;
+            const set = setTags(taskId, `[{"name":"${marker}"}]`);
+            expect(set.Result).toBe(RESULTS.Success);
+
+            const getRaw = localCliRaw(
+                tempDir,
+                `tasks get ${taskId} --output json`,
+            );
+            const task = parseOutput(getRaw.stdout, "json") as {
+                Data?: { Tags?: { Name?: string }[] };
+            };
+            expect((task.Data?.Tags ?? []).some((t) => t.Name === marker)).toBe(
+                true,
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/list.e2e.test.ts

@@ -7,6 +7,7 @@ import {
 import {
     EXEC_TIMEOUT,
     localCliRaw,
+    localCliRawWithArgs,
     parseOutput,
     readManifest,
 } from "../../../tests/e2e-shared/helpers";
@@ -39,6 +40,25 @@ function discoverFolderId(): string | undefined {
     return typeof folderId === "number" ? String(folderId) : undefined;
 }
 
+interface FolderRow {
+    Key?: string;
+    Name?: string;
+    Path?: string;
+}
+
+/**
+ * Discover a folder's path and key via `uip or folders list` — the exact
+ * source UV-15957 is about: its output has no numeric ID column, so path/key
+ * are what a caller actually holds.
+ */
+function discoverFolder(): { path?: string; key?: string } {
+    const raw = localCliRaw(tempDir, "or folders list --output json");
+    if (raw.exitCode !== 0) return {};
+    const res = parseOutput(raw.stdout, "json") as { Data?: FolderRow[] };
+    const first = res.Data?.[0];
+    return { path: first?.Path || first?.Name, key: first?.Key };
+}
+
 describe("tasks list e2e", () => {
     it(
         "S1: lists tasks across all folders",
@@ -121,4 +141,94 @@ describe("tasks list e2e", () => {
         },
         EXEC_TIMEOUT,
     );
+
+    it(
+        "S6: filters by folder path",
+        () => {
+            const { path } = discoverFolder();
+            if (!path) return;
+            // API-derived value — pass as its own argument, never through a
+            // shell-interpolated string.
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "list",
+                "--folder-path",
+                path,
+                "--output",
+                "json",
+            ]);
+            const res = parseOutput(raw.stdout, "json") as ListEnvelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: filters by folder key",
+        () => {
+            const { key } = discoverFolder();
+            if (!key) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks list --folder-key ${key} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as ListEnvelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S8: folder options are mutually exclusive",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks list --folder-id 1 --folder-path Shared --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as ListEnvelope;
+            expect(res.Message).toMatch(/cannot be used with/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S9: invalid --folder-key reports a validation error",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks list --folder-key not-a-guid --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as ListEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid --folder-key: not-a-guid");
+            expect(res.Instructions).toMatch(/UUID/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S10: unknown --folder-path reports folder not found",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                'tasks list --folder-path "NoSuchFolder-UV15957" --output json',
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as ListEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe(
+                "Folder not found: 'NoSuchFolder-UV15957'.",
+            );
+            expect(res.Instructions).toMatch(/uip or folders list/);
+        },
+        EXEC_TIMEOUT,
+    );
 });