@pagopa/dx-cli 0.23.0 → 0.23.1

package/dist/adapters/commander/commands/__tests__/add.test.js

@@ -1,167 +0,0 @@
-/**
- * Tests for authorizeCloudAccounts in the init command.
- */
-import { errAsync, okAsync } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { mock } from "vitest-mock-extended";
-import { AuthorizationError, AuthorizationResult, } from "../../../../domain/authorization.js";
-import { authorizeCloudAccounts } from "../add.js";
-const makeEnvPayload = (overrides = {}) => ({
-    env: {
-        cloudAccounts: [
-            {
-                csp: "azure",
-                defaultLocation: "italynorth",
-                displayName: "DEV-FooBar",
-                id: "sub-123",
-            },
-        ],
-        name: "dev",
-        prefix: "dx",
-    },
-    github: { owner: "pagopa", repo: "test-repo" },
-    tags: { BusinessUnit: "BU", CostCenter: "TS000", ManagementTeam: "MT" },
-    workspace: { domain: "" },
-    ...overrides,
-});
-describe("authorizeCloudAccounts", () => {
-    it("returns empty array when init is undefined (env already initialized)", async () => {
-        const authService = mock();
-        const envPayload = makeEnvPayload({ init: undefined });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toEqual([]);
-        expect(authService.requestAuthorization).not.toHaveBeenCalled();
-    });
-    it("returns empty array when cloudAccountsToInitialize is empty", async () => {
-        const authService = mock();
-        const envPayload = makeEnvPayload({
-            init: { cloudAccountsToInitialize: [] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toEqual([]);
-    });
-    it("requests authorization for each initialized account", async () => {
-        const authService = mock();
-        const expectedPr = new AuthorizationResult("https://github.com/pagopa/eng-azure-authorization/pull/42");
-        authService.requestAuthorization.mockReturnValue(okAsync(expectedPr));
-        const account = {
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "DEV-FooBar",
-            id: "sub-123",
-        };
-        const envPayload = makeEnvPayload({
-            env: {
-                cloudAccounts: [account],
-                name: "dev",
-                prefix: "dx",
-            },
-            init: { cloudAccountsToInitialize: [account] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toEqual([expectedPr]);
-        expect(authService.requestAuthorization).toHaveBeenCalledWith(expect.objectContaining({
-            bootstrapIdentityId: "dx-d-itn-bootstrap-id-01",
-            envShort: "d",
-            prefix: "dx",
-            subscriptionName: "DEV-FooBar",
-        }));
-    });
-    it("computes correct identity for westeurope location", async () => {
-        const authService = mock();
-        authService.requestAuthorization.mockReturnValue(okAsync(new AuthorizationResult("https://example.com/pr/1")));
-        const account = {
-            csp: "azure",
-            defaultLocation: "westeurope",
-            displayName: "PROD-Bar",
-            id: "sub-456",
-        };
-        const envPayload = makeEnvPayload({
-            env: {
-                cloudAccounts: [account],
-                name: "prod",
-                prefix: "io",
-            },
-            init: { cloudAccountsToInitialize: [account] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        expect(authService.requestAuthorization).toHaveBeenCalledWith(expect.objectContaining({
-            bootstrapIdentityId: "io-p-weu-bootstrap-id-01",
-            envShort: "p",
-            prefix: "io",
-            subscriptionName: "PROD-Bar",
-        }));
-    });
-    it("skips accounts with unsupported locations", async () => {
-        const authService = mock();
-        const account = {
-            csp: "azure",
-            defaultLocation: "eastus",
-            displayName: "DEV-Unsupported",
-            id: "sub-789",
-        };
-        const envPayload = makeEnvPayload({
-            init: { cloudAccountsToInitialize: [account] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toEqual([]);
-        expect(authService.requestAuthorization).not.toHaveBeenCalled();
-    });
-    it("continues when authorization fails for one account", async () => {
-        const authService = mock();
-        const account1 = {
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "DEV-First",
-            id: "sub-1",
-        };
-        const account2 = {
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "DEV-Second",
-            id: "sub-2",
-        };
-        const expectedPr = new AuthorizationResult("https://example.com/pr/2");
-        authService.requestAuthorization
-            .mockReturnValueOnce(errAsync(new AuthorizationError("Branch already exists")))
-            .mockReturnValueOnce(okAsync(expectedPr));
-        const envPayload = makeEnvPayload({
-            env: {
-                cloudAccounts: [account1, account2],
-                name: "dev",
-                prefix: "dx",
-            },
-            init: { cloudAccountsToInitialize: [account1, account2] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        const prs = result._unsafeUnwrap();
-        expect(prs).toHaveLength(1);
-        expect(prs[0]).toEqual(expectedPr);
-    });
-    it("returns a no-op authorization result when nothing changed", async () => {
-        const authService = mock();
-        const account = {
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "DEV-Existing",
-            id: "sub-exists",
-        };
-        // No-op result: Ok with no URL (identity + groups already configured)
-        authService.requestAuthorization.mockReturnValue(okAsync(new AuthorizationResult()));
-        const envPayload = makeEnvPayload({
-            init: { cloudAccountsToInitialize: [account] },
-        });
-        const result = await authorizeCloudAccounts(authService)(envPayload);
-        expect(result.isOk()).toBe(true);
-        // The no-op result is still collected but has no URL
-        const prs = result._unsafeUnwrap();
-        expect(prs).toHaveLength(1);
-        expect(prs[0].url).toBeUndefined();
-    });
-});

package/dist/adapters/commander/commands/__tests__/init-command.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for the init Commander command workflow.
- */
-export {};

package/dist/adapters/commander/commands/__tests__/init-command.test.js

@@ -1,44 +0,0 @@
-/**
- * Tests for the init Commander command workflow.
- */
-import { Command } from "commander";
-import { okAsync } from "neverthrow";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { mock } from "vitest-mock-extended";
-const { tfMock } = vi.hoisted(() => ({
-    tfMock: vi.fn(),
-}));
-vi.mock("ora", () => ({
-    oraPromise: (promise) => promise,
-}));
-vi.mock("../../../execa/terraform.js", () => ({
-    tf$: tfMock,
-}));
-import { makeInitCommand } from "../init.js";
-const makeRoot = (command) => new Command()
-    .exitOverride()
-    .addCommand(command)
-    .configureOutput({
-    writeErr: () => {
-        /* silence stderr in tests */
-    },
-    writeOut: () => {
-        /* silence stdout in tests */
-    },
-});
-describe("makeInitCommand", () => {
-    afterEach(() => {
-        tfMock.mockReset();
-    });
-    it("checks local preconditions before requiring GitHub auth", async () => {
-        tfMock.mockRejectedValueOnce(new Error("Terraform not installed"));
-        const requireGitHubAuthSpy = vi.fn(() => okAsync({
-            authorizationService: mock(),
-            gitHubService: mock(),
-        }));
-        const requireGitHubAuth = requireGitHubAuthSpy;
-        const root = makeRoot(makeInitCommand(requireGitHubAuth));
-        await expect(root.parseAsync(["init"], { from: "user" })).rejects.toBeTruthy();
-        expect(requireGitHubAuthSpy).not.toHaveBeenCalled();
-    });
-});

package/dist/adapters/commander/commands/__tests__/init.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for confirmGitHubRepoCreation in the init command.
- */
-export {};

package/dist/adapters/commander/commands/__tests__/init.test.js

@@ -1,48 +0,0 @@
-/**
- * Tests for confirmGitHubRepoCreation in the init command.
- */
-import inquirer from "inquirer";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { confirmGitHubRepoCreation } from "../init.js";
-vi.mock("inquirer");
-const makePayload = (overrides = {}) => ({
-    repoDescription: "A test repo",
-    repoName: "test-repo",
-    repoOwner: "pagopa",
-    ...overrides,
-});
-describe("confirmGitHubRepoCreation", () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("returns true when the user confirms", async () => {
-        vi.mocked(inquirer.prompt).mockResolvedValue({ confirm: true });
-        const result = await confirmGitHubRepoCreation(makePayload());
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toBe(true);
-    });
-    it("returns false when the user declines", async () => {
-        vi.mocked(inquirer.prompt).mockResolvedValue({ confirm: false });
-        const result = await confirmGitHubRepoCreation(makePayload());
-        expect(result.isOk()).toBe(true);
-        expect(result._unsafeUnwrap()).toBe(false);
-    });
-    it("prompts with the correct repository name and owner", async () => {
-        vi.mocked(inquirer.prompt).mockResolvedValue({ confirm: true });
-        const payload = makePayload({ repoName: "my-repo", repoOwner: "my-org" });
-        await confirmGitHubRepoCreation(payload);
-        expect(inquirer.prompt).toHaveBeenCalledWith(expect.objectContaining({
-            message: expect.stringContaining("my-org/my-repo"),
-            type: "confirm",
-        }));
-    });
-    it("returns an error result when the prompt rejects", async () => {
-        const cause = new Error("non-interactive TTY");
-        vi.mocked(inquirer.prompt).mockRejectedValue(cause);
-        const result = await confirmGitHubRepoCreation(makePayload());
-        expect(result.isErr()).toBe(true);
-        const err = result._unsafeUnwrapErr();
-        expect(err).toBeInstanceOf(Error);
-        expect(err.cause).toBe(cause);
-    });
-});

package/dist/adapters/commander/commands/__tests__/preconditions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/commands/__tests__/preconditions.test.js

@@ -1,32 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-const mocks = vi.hoisted(() => ({
-    oraPromise: vi.fn((promise) => promise),
-    tf$: vi.fn(async (...args) => {
-        void args;
-        return { stdout: '{"user":{"name":"test@example.com"}}' };
-    }),
-}));
-vi.mock("ora", () => ({ oraPromise: mocks.oraPromise }));
-vi.mock("../../../execa/terraform.js", () => ({ tf$: mocks.tf$ }));
-import { checkAddEnvironmentPreconditions, checkInitPreconditions, } from "../init.js";
-const calledCommands = () => mocks.tf$.mock.calls.map(([strings, ...values]) => strings.reduce((command, part, index) => command + part + String(values[index] ?? ""), ""));
-describe("init preconditions", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("checkInitPreconditions does not require Azure login", async () => {
-        const result = await checkInitPreconditions();
-        expect(result.isOk()).toBe(true);
-        expect(calledCommands()).toEqual(["terraform -version", "corepack -v"]);
-    });
-    it("checkAddEnvironmentPreconditions requires Azure login", async () => {
-        const result = await checkAddEnvironmentPreconditions();
-        expect(result.isOk()).toBe(true);
-        expect(calledCommands()).toEqual([
-            "terraform -version",
-            "az account show",
-            "az group list",
-            "corepack -v",
-        ]);
-    });
-});

package/dist/adapters/commander/commands/__tests__/savemoney.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Unit tests for the pure helper functions in the savemoney command.
- *
- * The full command action (Azure API calls, spinner) is not exercised here
- * because it requires live credentials. These tests cover the stateless
- * parsing helpers that can be validated without any I/O.
- */
-export {};

package/dist/adapters/commander/commands/__tests__/savemoney.test.js

@@ -1,60 +0,0 @@
-/**
- * Unit tests for the pure helper functions in the savemoney command.
- *
- * The full command action (Azure API calls, spinner) is not exercised here
- * because it requires live credentials. These tests cover the stateless
- * parsing helpers that can be validated without any I/O.
- */
-import { InvalidArgumentError } from "commander";
-import { describe, expect, it } from "vitest";
-import { makeSavemoneyCommand, parseSourceOption, parseTagsOption, } from "../savemoney.js";
-describe("parseSourceOption", () => {
-    it("accepts 'advisor'", () => {
-        expect(parseSourceOption("advisor")).toBe("advisor");
-    });
-    it("accepts 'custom'", () => {
-        expect(parseSourceOption("custom")).toBe("custom");
-    });
-    it("accepts 'all'", () => {
-        expect(parseSourceOption("all")).toBe("all");
-    });
-    it("throws InvalidArgumentError for an unknown value", () => {
-        expect(() => parseSourceOption("aws")).toThrow(InvalidArgumentError);
-    });
-    it("throws InvalidArgumentError for an empty string", () => {
-        expect(() => parseSourceOption("")).toThrow(InvalidArgumentError);
-    });
-});
-describe("parseTagsOption", () => {
-    it("returns an empty Map when tagsOption is undefined", () => {
-        expect(parseTagsOption(undefined)).toEqual(new Map());
-    });
-    it("returns an empty Map when tagsOption is an empty array", () => {
-        expect(parseTagsOption([])).toEqual(new Map());
-    });
-    it("parses a single key=value pair", () => {
-        expect(parseTagsOption(["env=dev"])).toEqual(new Map([["env", "dev"]]));
-    });
-    it("parses multiple key=value pairs", () => {
-        expect(parseTagsOption(["env=dev", "team=platform"])).toEqual(new Map([
-            ["env", "dev"],
-            ["team", "platform"],
-        ]));
-    });
-    it("handles values that contain '='", () => {
-        expect(parseTagsOption(["url=https://example.com/path=1"])).toEqual(new Map([["url", "https://example.com/path=1"]]));
-    });
-    it("ignores entries without a '=' separator", () => {
-        expect(parseTagsOption(["noequalssign"])).toEqual(new Map());
-    });
-    it("trims whitespace from keys and values", () => {
-        expect(parseTagsOption([" env = dev "])).toEqual(new Map([["env", "dev"]]));
-    });
-});
-describe("makeSavemoneyCommand", () => {
-    it("documents that --tags does not filter subscription-level Advisor findings", () => {
-        const command = makeSavemoneyCommand();
-        const tagsOption = command.options.find((option) => option.flags.includes("--tags"));
-        expect(tagsOption?.description).toContain("Advisor subscription-level findings remain global.");
-    });
-});

package/dist/adapters/commander/commands/__tests__/spec.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests for the `spec` Commander command.
- *
- * Verifies that `makeSpecCommand` calls the `getSpec` callback and writes the
- * resulting CliSpec as pretty-printed JSON to stdout.
- */
-export {};

package/dist/adapters/commander/commands/__tests__/spec.test.js

@@ -1,85 +0,0 @@
-/**
- * Tests for the `spec` Commander command.
- *
- * Verifies that `makeSpecCommand` calls the `getSpec` callback and writes the
- * resulting CliSpec as pretty-printed JSON to stdout.
- */
-import { Command } from "commander";
-import { afterEach, beforeEach, describe, expect, it, vi, } from "vitest";
-import { makeSpecCommand } from "../spec.js";
-const makeMinimalSpec = () => ({
-    commands: [],
-    description: "The CLI for DX-Platform",
-    globalOptions: [],
-    name: "dx",
-    specVersion: "1",
-    version: "0.0.0",
-});
-describe("makeSpecCommand", () => {
-    let stdoutSpy;
-    beforeEach(() => {
-        stdoutSpy = vi
-            .spyOn(process.stdout, "write")
-            .mockImplementation(() => true);
-    });
-    afterEach(() => {
-        stdoutSpy.mockRestore();
-    });
-    it("is registered as the 'spec' subcommand", () => {
-        const cmd = makeSpecCommand(() => makeMinimalSpec());
-        expect(cmd.name()).toBe("spec");
-    });
-    it("calls getSpec and writes JSON to stdout when invoked", async () => {
-        const spec = makeMinimalSpec();
-        const getSpec = vi.fn().mockReturnValue(spec);
-        const cmd = makeSpecCommand(getSpec);
-        // Parse with an isolated parent so Commander doesn't exit
-        const root = new Command().exitOverride().addCommand(cmd);
-        root.configureOutput({
-            writeErr: () => {
-                /* silence */
-            },
-            writeOut: () => {
-                /* silence */
-            },
-        });
-        await root.parseAsync(["spec"], { from: "user" });
-        expect(getSpec).toHaveBeenCalledOnce();
-        const written = stdoutSpy.mock.calls.map((c) => c[0]).join("");
-        expect(JSON.parse(written)).toEqual(spec);
-    });
-    it("outputs valid pretty-printed JSON (indented)", async () => {
-        const spec = makeMinimalSpec();
-        const cmd = makeSpecCommand(() => spec);
-        const root = new Command().exitOverride().addCommand(cmd);
-        root.configureOutput({
-            writeErr: () => {
-                /* silence */
-            },
-            writeOut: () => {
-                /* silence */
-            },
-        });
-        await root.parseAsync(["spec"], { from: "user" });
-        const written = stdoutSpy.mock.calls.map((c) => c[0]).join("");
-        // Pretty-printed JSON has newlines
-        expect(written).toContain("\n");
-        expect(written).toContain("  ");
-    });
-    it("includes specVersion '1' in the output", async () => {
-        const cmd = makeSpecCommand(() => makeMinimalSpec());
-        const root = new Command().exitOverride().addCommand(cmd);
-        root.configureOutput({
-            writeErr: () => {
-                /* silence */
-            },
-            writeOut: () => {
-                /* silence */
-            },
-        });
-        await root.parseAsync(["spec"], { from: "user" });
-        const written = stdoutSpy.mock.calls.map((c) => c[0]).join("");
-        const parsed = JSON.parse(written);
-        expect(parsed.specVersion).toBe("1");
-    });
-});

package/dist/adapters/commander/presenters/__tests__/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/presenters/__tests__/index.test.js

@@ -1,23 +0,0 @@
-/**
- * Tests for isNonInteractive and createCommandPresenter factory.
- */
-import { describe, expect, it } from "vitest";
-import { createCommandPresenter, isNonInteractive } from "../index.js";
-import { JsonCommandPresenter } from "../json-command-presenter.js";
-import { TextCommandPresenter } from "../text-command-presenter.js";
-describe("isNonInteractive", () => {
-    it("returns true when CI is true", () => {
-        expect(isNonInteractive({ CI: true })).toBe(true);
-    });
-    it("returns false when CI is false", () => {
-        expect(isNonInteractive({ CI: false })).toBe(false);
-    });
-});
-describe("createCommandPresenter", () => {
-    it("returns a TextCommandPresenter when output is 'text'", () => {
-        expect(createCommandPresenter("text")).toBeInstanceOf(TextCommandPresenter);
-    });
-    it("returns a JsonCommandPresenter when output is 'json'", () => {
-        expect(createCommandPresenter("json")).toBeInstanceOf(JsonCommandPresenter);
-    });
-});

package/dist/adapters/commander/presenters/__tests__/json.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/presenters/__tests__/json.test.js

@@ -1,108 +0,0 @@
-/**
- * Tests for JsonCommandPresenter.
- *
- * JsonCommandPresenter uses a split-stream convention:
- *   - stdout for the final result/error envelope
- *   - stderr for step lifecycle (progress) events
- *
- * Tests verify the wire format, correct stream usage, and that values
- * flow through correctly.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { JsonCommandPresenter } from "../json-command-presenter.js";
-const captureStdout = () => {
-    const written = [];
-    vi.spyOn(process.stdout, "write").mockImplementation((data) => {
-        written.push(String(data));
-        return true;
-    });
-    return { written };
-};
-const captureStderr = () => {
-    const written = [];
-    vi.spyOn(process.stderr, "write").mockImplementation((data) => {
-        written.push(String(data));
-        return true;
-    });
-    return { written };
-};
-describe("JsonCommandPresenter", () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe("trackStep", () => {
-        it("executes the task and returns its resolved value", async () => {
-            captureStderr();
-            const logger = new JsonCommandPresenter();
-            const result = await logger.trackStep("check terraform", () => Promise.resolve(42));
-            expect(result).toBe(42);
-        });
-        it("emits start then success events to stderr", async () => {
-            const stderr = captureStderr();
-            const logger = new JsonCommandPresenter();
-            await logger.trackStep("check terraform", () => Promise.resolve("done"));
-            expect(stderr.written).toHaveLength(2);
-            expect(JSON.parse(stderr.written[0])).toMatchObject({
-                name: "check terraform",
-                status: "start",
-                type: "step",
-            });
-            expect(JSON.parse(stderr.written[1])).toMatchObject({
-                name: "check terraform",
-                status: "success",
-                type: "step",
-            });
-        });
-        it("emits error event to stderr and rethrows on task failure", async () => {
-            const stderr = captureStderr();
-            const logger = new JsonCommandPresenter();
-            const error = new Error("terraform not found");
-            await expect(logger.trackStep("check terraform", () => Promise.reject(error))).rejects.toThrow("terraform not found");
-            expect(JSON.parse(stderr.written[1])).toMatchObject({
-                error: "terraform not found",
-                name: "check terraform",
-                status: "error",
-                type: "step",
-            });
-        });
-        it("can run multiple sequential steps", async () => {
-            captureStderr();
-            const logger = new JsonCommandPresenter();
-            const order = [];
-            await logger.trackStep("step A", async () => {
-                order.push("A");
-            });
-            await logger.trackStep("step B", async () => {
-                order.push("B");
-            });
-            expect(order).toEqual(["A", "B"]);
-        });
-    });
-    describe("reportResult", () => {
-        it("emits an ok:true JSON envelope to stdout", () => {
-            const stdout = captureStdout();
-            const logger = new JsonCommandPresenter();
-            logger.reportResult({ repository: { name: "my-repo" } });
-            expect(JSON.parse(stdout.written[0])).toEqual({
-                data: { repository: { name: "my-repo" } },
-                ok: true,
-            });
-        });
-    });
-    describe("reportError", () => {
-        it("emits an ok:false JSON envelope to stdout", () => {
-            const stdout = captureStdout();
-            const logger = new JsonCommandPresenter();
-            logger.reportError(new Error("something failed"));
-            expect(JSON.parse(stdout.written[0])).toMatchObject({
-                error: "something failed",
-                ok: false,
-            });
-        });
-        it("handles non-Error values without throwing", () => {
-            captureStdout();
-            const logger = new JsonCommandPresenter();
-            expect(() => logger.reportError("plain string error")).not.toThrow();
-        });
-    });
-});

package/dist/adapters/commander/presenters/__tests__/text.test.d.ts

@@ -1 +0,0 @@
-export {};