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

package/src/commands/directory.spec.ts

@@ -0,0 +1,544 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../utils/sdk-client", () => ({
+    createDataFabricClient: vi.fn(),
+    connectOrFail: 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 { connectOrFail } from "../utils/sdk-client";
+import { registerDirectoryCommand } from "./directory";
+
+function buildProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerDirectoryCommand(program);
+    return program;
+}
+
+function mockSdk(overrides: Record<string, unknown> = {}) {
+    const sdk = {
+        entities: {
+            directory: {
+                list: vi.fn().mockResolvedValue({
+                    totalCount: 0,
+                    results: [],
+                }),
+                assignRoles: vi.fn().mockResolvedValue([]),
+                revokeRoles: vi.fn().mockResolvedValue(undefined),
+                ...overrides,
+            },
+        },
+    };
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
+    return sdk;
+}
+
+describe("directory list", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should register the directory command with list, assign-roles, and revoke-roles subcommands", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "directory");
+        expect(cmd).toBeDefined();
+        const subNames = cmd?.commands.map((c) => c.name()) ?? [];
+        expect(subNames).toContain("list");
+        expect(subNames).toContain("assign-roles");
+        expect(subNames).toContain("revoke-roles");
+    });
+
+    it("should list one page of principals with default paging", async () => {
+        const sdk = mockSdk();
+        const response = {
+            totalCount: 1,
+            results: [
+                {
+                    externalId: "p-1",
+                    name: "automation-users",
+                    type: "Group",
+                    roles: [{ id: "r-1", name: "DataWriter" }],
+                    isUIEnabled: true,
+                },
+            ],
+        };
+        vi.mocked(sdk.entities.directory.list).mockResolvedValue(
+            response as never,
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "directory", "list"]);
+
+        expect(sdk.entities.directory.list).toHaveBeenCalledWith({
+            skip: 0,
+            top: 50,
+        });
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "DirectoryList",
+                Data: response,
+            }),
+        );
+    });
+
+    it("should forward --limit and --offset", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "list",
+            "--limit",
+            "10",
+            "--offset",
+            "20",
+        ]);
+
+        expect(sdk.entities.directory.list).toHaveBeenCalledWith({
+            skip: 20,
+            top: 10,
+        });
+    });
+
+    it("should reject a non-positive --limit", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "list",
+            "--limit",
+            "0",
+        ]);
+
+        expect(sdk.entities.directory.list).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --limit value '0'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject a negative --offset", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "list",
+            "--offset",
+            "-5",
+        ]);
+
+        expect(sdk.entities.directory.list).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --offset value '-5'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject a --limit with trailing non-numeric characters", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "list",
+            "--limit",
+            "10abc",
+        ]);
+
+        expect(sdk.entities.directory.list).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --limit value '10abc'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject a fractional --offset", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "list",
+            "--offset",
+            "1.5",
+        ]);
+
+        expect(sdk.entities.directory.list).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --offset value '1.5'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should fail with exit 1 when the SDK call errors", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.directory.list).mockRejectedValue(
+            new Error("boom"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "directory", "list"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing directory principals",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should bail when SDK connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "directory", "list"]);
+
+        expect(sdk.entities.directory.list).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+    });
+});
+
+describe("directory assign-roles", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should assign roles to multiple principals with preserved defaults", async () => {
+        const sdk = mockSdk();
+        const results = [
+            { principalId: "p-1", roleIds: ["r-1"] },
+            { principalId: "p-2", roleIds: ["r-1"] },
+        ];
+        vi.mocked(sdk.entities.directory.assignRoles).mockResolvedValue(
+            results as never,
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "p-2",
+            "--type",
+            "Group",
+            "--role-ids",
+            "r-1",
+        ]);
+
+        expect(sdk.entities.directory.assignRoles).toHaveBeenCalledWith(
+            ["p-1", "p-2"],
+            "Group",
+            ["r-1"],
+            {},
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "DirectoryRolesAssigned",
+                Data: results,
+            }),
+        );
+    });
+
+    it("should normalize a case-insensitive --type and split comma-separated --role-ids", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "--type",
+            "user",
+            "--role-ids",
+            " r-1 , r-2 ",
+        ]);
+
+        expect(sdk.entities.directory.assignRoles).toHaveBeenCalledWith(
+            ["p-1"],
+            "User",
+            ["r-1", "r-2"],
+            {},
+        );
+    });
+
+    it("should pass preserveExisting false with --replace and uiEnabled false with --no-ui-access", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "--type",
+            "Application",
+            "--role-ids",
+            "r-1",
+            "--replace",
+            "--no-ui-access",
+        ]);
+
+        expect(sdk.entities.directory.assignRoles).toHaveBeenCalledWith(
+            ["p-1"],
+            "Application",
+            ["r-1"],
+            { preserveExisting: false, uiEnabled: false },
+        );
+    });
+
+    it("should reject an unknown --type without calling the SDK", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "--type",
+            "Robot",
+            "--role-ids",
+            "r-1",
+        ]);
+
+        expect(sdk.entities.directory.assignRoles).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --type value 'Robot'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject --role-ids with no usable IDs", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "--type",
+            "User",
+            "--role-ids",
+            " , ",
+        ]);
+
+        expect(sdk.entities.directory.assignRoles).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "No role IDs provided",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should fail with exit 1 when the SDK call errors", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.directory.assignRoles).mockRejectedValue(
+            new Error("boom"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "assign-roles",
+            "p-1",
+            "--type",
+            "User",
+            "--role-ids",
+            "r-1",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error assigning roles",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("directory revoke-roles", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should require confirmation (no --yes): exit 1, SDK not called", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "revoke-roles",
+            "p-1",
+            "--reason",
+            "offboarding",
+        ]);
+
+        expect(sdk.entities.directory.revokeRoles).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --reason", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "revoke-roles",
+            "p-1",
+            "--yes",
+        ]);
+
+        expect(sdk.entities.directory.revokeRoles).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should revoke roles from multiple principals with --yes and --reason", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "revoke-roles",
+            "p-1",
+            "p-2",
+            "--yes",
+            "--reason",
+            "offboarding",
+        ]);
+
+        expect(sdk.entities.directory.revokeRoles).toHaveBeenCalledWith([
+            "p-1",
+            "p-2",
+        ]);
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "DirectoryRolesRevoked",
+                Data: {
+                    PrincipalIds: ["p-1", "p-2"],
+                    Reason: "offboarding",
+                },
+            }),
+        );
+    });
+
+    it("should fail with exit 1 when the SDK call errors", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.directory.revokeRoles).mockRejectedValue(
+            new Error("boom"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "revoke-roles",
+            "p-1",
+            "--yes",
+            "--reason",
+            "offboarding",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error revoking roles",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should bail when SDK connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "directory",
+            "revoke-roles",
+            "p-1",
+            "--yes",
+            "--reason",
+            "offboarding",
+        ]);
+
+        expect(sdk.entities.directory.revokeRoles).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+    });
+});