@uipath/tasks-tool 0.9.0

package/src/commands/tasks.spec.ts

@@ -0,0 +1,692 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { registerTasksCommand } from "./tasks";
+
+vi.mock("../utils/sdk-client", () => ({
+    createTasksClient: vi.fn(),
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: {
+            success: vi.fn(),
+            error: vi.fn(),
+        },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import { createTasksClient } from "../utils/sdk-client";
+
+function buildProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerTasksCommand(program);
+    return program;
+}
+
+function mockSdk(overrides: Record<string, unknown> = {}) {
+    const sdk = {
+        tasks: {
+            getAll: vi.fn().mockResolvedValue([]),
+            getById: vi.fn().mockResolvedValue({}),
+            assign: vi.fn().mockResolvedValue({ success: true, data: [] }),
+            reassign: vi.fn().mockResolvedValue({ success: true, data: [] }),
+            unassign: vi.fn().mockResolvedValue({ success: true, data: [] }),
+            complete: vi.fn().mockResolvedValue({ success: true }),
+            ...overrides,
+        },
+    };
+    vi.mocked(createTasksClient).mockResolvedValue(sdk as never);
+    return sdk;
+}
+
+describe("tasks command registration", () => {
+    it("should register all commands on program", () => {
+        const program = buildProgram();
+        const subcommands = program.commands.map((c) => c.name());
+        expect(subcommands).toContain("list");
+        expect(subcommands).toContain("get");
+        expect(subcommands).toContain("assign");
+        expect(subcommands).toContain("reassign");
+        expect(subcommands).toContain("unassign");
+        expect(subcommands).toContain("complete");
+    });
+});
+
+describe("tasks list", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should list tasks successfully", async () => {
+        const taskData = [
+            { id: 1, title: "Task 1", status: "Pending" },
+            { id: 2, title: "Task 2", status: "Unassigned" },
+        ];
+        mockSdk({ getAll: vi.fn().mockResolvedValue(taskData) });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list"]);
+
+        expect(createTasksClient).toHaveBeenCalledWith(undefined);
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskList",
+                Data: taskData,
+            }),
+        );
+    });
+
+    it("should pass folder-id option", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list", "--folder-id", "42"]);
+
+        expect(sdk.tasks.getAll).toHaveBeenCalledWith(
+            expect.objectContaining({ folderId: 42, pageSize: 100 }),
+        );
+    });
+
+    it("should pass as-admin option", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list", "--as-admin"]);
+
+        expect(sdk.tasks.getAll).toHaveBeenCalledWith(
+            expect.objectContaining({ asTaskAdmin: true, pageSize: 100 }),
+        );
+    });
+
+    it("should pass tenant option", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list", "-t", "MyTenant"]);
+
+        expect(createTasksClient).toHaveBeenCalledWith("MyTenant");
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle API error", async () => {
+        mockSdk({
+            getAll: vi.fn().mockRejectedValue(new Error("API error")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing tasks",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should paginate through multiple pages", async () => {
+        const page1 = {
+            items: [{ id: 1, title: "Task 1" }],
+            hasNextPage: true,
+            nextCursor: { value: "cursor-2" },
+        };
+        const page2 = {
+            items: [{ id: 2, title: "Task 2" }],
+            hasNextPage: false,
+        };
+        const getAllMock = vi
+            .fn()
+            .mockResolvedValueOnce(page1)
+            .mockResolvedValueOnce(page2);
+        mockSdk({ getAll: getAllMock });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list"]);
+
+        expect(getAllMock).toHaveBeenCalledTimes(2);
+        expect(getAllMock).toHaveBeenLastCalledWith(
+            expect.objectContaining({ cursor: { value: "cursor-2" } }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskList",
+                Data: [
+                    { id: 1, title: "Task 1" },
+                    { id: 2, title: "Task 2" },
+                ],
+            }),
+        );
+    });
+
+    it("should respect --limit option", async () => {
+        const page1 = {
+            items: [
+                { id: 1, title: "Task 1" },
+                { id: 2, title: "Task 2" },
+                { id: 3, title: "Task 3" },
+            ],
+            hasNextPage: true,
+            nextCursor: { value: "cursor-2" },
+        };
+        mockSdk({ getAll: vi.fn().mockResolvedValue(page1) });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "list", "--limit", "2"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: [
+                    { id: 1, title: "Task 1" },
+                    { id: 2, title: "Task 2" },
+                ],
+            }),
+        );
+    });
+});
+
+describe("tasks get", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should get task by ID", async () => {
+        const task = { id: 123, title: "My Task", status: "Pending" };
+        mockSdk({ getById: vi.fn().mockResolvedValue(task) });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "get", "123"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskDetails",
+                Data: task,
+            }),
+        );
+    });
+
+    it("should pass task-type and folder-id options", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "get",
+            "123",
+            "--task-type",
+            "FormTask",
+            "--folder-id",
+            "42",
+        ]);
+
+        expect(sdk.tasks.getById).toHaveBeenCalledWith(
+            123,
+            expect.objectContaining({ taskType: "FormTask" }),
+            42,
+        );
+    });
+
+    it("should handle get error", async () => {
+        mockSdk({
+            getById: vi.fn().mockRejectedValue(new Error("Not found")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "get", "999"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error getting task '999'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "get", "123"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("tasks assign", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should assign task by user email", async () => {
+        const result = { success: true, data: [{ taskId: 123 }] };
+        const sdk = mockSdk({
+            assign: vi.fn().mockResolvedValue(result),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "assign",
+            "123",
+            "--user",
+            "alice@company.com",
+        ]);
+
+        expect(sdk.tasks.assign).toHaveBeenCalledWith(
+            expect.objectContaining({
+                taskId: 123,
+                userNameOrEmail: "alice@company.com",
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskAssigned",
+            }),
+        );
+    });
+
+    it("should assign task by user ID", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "assign",
+            "123",
+            "--user-id",
+            "456",
+        ]);
+
+        expect(sdk.tasks.assign).toHaveBeenCalledWith(
+            expect.objectContaining({
+                taskId: 123,
+                userId: 456,
+            }),
+        );
+    });
+
+    it("should error when no assignee provided", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "assign", "123"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Missing assignee",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle assign API error", async () => {
+        mockSdk({
+            assign: vi.fn().mockRejectedValue(new Error("Permission denied")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "assign",
+            "123",
+            "--user",
+            "alice@company.com",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error assigning task '123'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "assign",
+            "123",
+            "--user",
+            "alice@company.com",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("tasks reassign", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should reassign task by user email", async () => {
+        const result = { success: true, data: [{ taskId: 123 }] };
+        const sdk = mockSdk({
+            reassign: vi.fn().mockResolvedValue(result),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "reassign",
+            "123",
+            "--user",
+            "bob@company.com",
+        ]);
+
+        expect(sdk.tasks.reassign).toHaveBeenCalledWith(
+            expect.objectContaining({
+                taskId: 123,
+                userNameOrEmail: "bob@company.com",
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskReassigned",
+            }),
+        );
+    });
+
+    it("should error when no assignee provided", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "reassign", "123"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Missing assignee",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle reassign API error", async () => {
+        mockSdk({
+            reassign: vi.fn().mockRejectedValue(new Error("Permission denied")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "reassign",
+            "123",
+            "--user",
+            "bob@company.com",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error reassigning task '123'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("tasks unassign", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should unassign task", async () => {
+        const result = { success: true, data: [{ taskId: 123 }] };
+        const sdk = mockSdk({
+            unassign: vi.fn().mockResolvedValue(result),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "unassign", "123"]);
+
+        expect(sdk.tasks.unassign).toHaveBeenCalledWith(123);
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskUnassigned",
+            }),
+        );
+    });
+
+    it("should handle unassign API error", async () => {
+        mockSdk({
+            unassign: vi.fn().mockRejectedValue(new Error("Task not found")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "unassign", "999"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error unassigning task '999'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "unassign", "123"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("tasks complete", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should complete task with type and folder-id", async () => {
+        const result = { success: true };
+        const sdk = mockSdk({
+            complete: vi.fn().mockResolvedValue(result),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "complete",
+            "123",
+            "--type",
+            "ExternalTask",
+            "--folder-id",
+            "42",
+        ]);
+
+        expect(sdk.tasks.complete).toHaveBeenCalledWith(
+            expect.objectContaining({
+                taskId: 123,
+                type: "ExternalTask",
+            }),
+            42,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskCompleted",
+            }),
+        );
+    });
+
+    it("should complete FormTask with action and data", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "complete",
+            "123",
+            "--type",
+            "FormTask",
+            "--folder-id",
+            "42",
+            "--action",
+            "Approve",
+            "--data",
+            '{"comments":"Looks good"}',
+        ]);
+
+        expect(sdk.tasks.complete).toHaveBeenCalledWith(
+            expect.objectContaining({
+                taskId: 123,
+                type: "FormTask",
+                action: "Approve",
+                data: { comments: "Looks good" },
+            }),
+            42,
+        );
+    });
+
+    it("should error on invalid JSON in --data", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "complete",
+            "123",
+            "--type",
+            "ExternalTask",
+            "--folder-id",
+            "42",
+            "--data",
+            "not-json",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid JSON in --data",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle complete API error", async () => {
+        mockSdk({
+            complete: vi.fn().mockRejectedValue(new Error("Server error")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "complete",
+            "123",
+            "--type",
+            "ExternalTask",
+            "--folder-id",
+            "42",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error completing task '123'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "complete",
+            "123",
+            "--type",
+            "ExternalTask",
+            "--folder-id",
+            "42",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});