@pagopa/dx-cli 0.22.4 → 0.23.1

package/dist/adapters/plop/actions/__tests__/init-cloud-accounts.test.js

@@ -1,171 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { initCloudAccounts } from "../init-cloud-accounts.js";
-const createMockGitHubService = () => ({
-    createBranch: vi.fn(),
-    createOrUpdateEnvironmentSecret: vi.fn().mockResolvedValue(undefined),
-    createPullRequest: vi.fn(),
-    getFileContent: vi.fn(),
-    getRepository: vi.fn(),
-    updateFile: vi.fn(),
-});
-const createMockCloudAccountService = (overrides = {}) => ({
-    getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-    hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
-    initialize: vi.fn().mockResolvedValue(undefined),
-    isInitialized: vi.fn().mockResolvedValue(true),
-    provisionTerraformBackend: vi.fn().mockResolvedValue(undefined),
-    ...overrides,
-});
-const createMockCloudAccount = (overrides = {}) => ({
-    csp: "azure",
-    defaultLocation: "westeurope",
-    displayName: "Test-Account",
-    id: "test-subscription-id",
-    ...overrides,
-});
-const createMockPayload = (overrides = {}) => ({
-    env: {
-        cloudAccounts: [createMockCloudAccount()],
-        name: "dev",
-        prefix: "dx",
-    },
-    github: {
-        owner: "pagopa",
-        repo: "dx",
-    },
-    init: {
-        cloudAccountsToInitialize: [],
-        runnerAppCredentials: {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        },
-        terraformBackend: {
-            cloudAccount: createMockCloudAccount(),
-        },
-    },
-    tags: {},
-    workspace: {
-        domain: "test",
-    },
-    ...overrides,
-});
-describe("initCloudAccounts", () => {
-    it("should initialize all cloud accounts in cloudAccountsToInitialize", async () => {
-        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
-        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
-        const initializeMock = vi.fn().mockResolvedValue(undefined);
-        const mockService = createMockCloudAccountService({
-            initialize: initializeMock,
-        });
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "prod",
-                prefix: "io",
-            },
-            init: {
-                cloudAccountsToInitialize: [cloudAccount1, cloudAccount2],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).toHaveBeenCalledTimes(2);
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount1, expect.objectContaining({ name: "prod", prefix: "io" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount2, expect.objectContaining({ name: "prod", prefix: "io" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-    });
-    it("should not call initialize when cloudAccountsToInitialize is empty", async () => {
-        const initializeMock = vi.fn().mockResolvedValue(undefined);
-        const mockService = createMockCloudAccountService({
-            initialize: initializeMock,
-        });
-        const payload = createMockPayload({
-            init: {
-                cloudAccountsToInitialize: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).not.toHaveBeenCalled();
-    });
-    it("should not call initialize when payload.init is undefined", async () => {
-        const initializeMock = vi.fn().mockResolvedValue(undefined);
-        const mockService = createMockCloudAccountService({
-            initialize: initializeMock,
-        });
-        const payload = createMockPayload({
-            init: undefined,
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).not.toHaveBeenCalled();
-    });
-    it("should use prefix and environment name from payload.env", async () => {
-        const cloudAccount = createMockCloudAccount();
-        const initializeMock = vi.fn().mockResolvedValue(undefined);
-        const mockService = createMockCloudAccountService({
-            initialize: initializeMock,
-        });
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "uat",
-                prefix: "pagopa",
-            },
-            init: {
-                cloudAccountsToInitialize: [cloudAccount],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "uat", prefix: "pagopa" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-    });
-});

package/dist/adapters/plop/actions/__tests__/provision-terraform-backend.test.d.ts

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

package/dist/adapters/plop/actions/__tests__/provision-terraform-backend.test.js

@@ -1,134 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { provisionTerraformBackend } from "../provision-terraform-backend.js";
-const createMockCloudAccountService = (overrides = {}) => ({
-    getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-    hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
-    initialize: vi.fn().mockResolvedValue(undefined),
-    isInitialized: vi.fn().mockResolvedValue(true),
-    provisionTerraformBackend: vi.fn().mockResolvedValue(undefined),
-    ...overrides,
-});
-const createMockCloudAccount = (overrides = {}) => ({
-    csp: "azure",
-    defaultLocation: "westeurope",
-    displayName: "Test-Account",
-    id: "test-subscription-id",
-    ...overrides,
-});
-const createMockTerraformBackend = (overrides = {}) => ({
-    resourceGroupName: "dx-d-itn-tf-rg",
-    storageAccountName: "dxditntfst",
-    subscriptionId: "00000000-0000-0000-0000-000000000000",
-    type: "azurerm",
-    ...overrides,
-});
-const createMockPayload = (overrides = {}) => ({
-    env: {
-        cloudAccounts: [createMockCloudAccount()],
-        name: "dev",
-        prefix: "dx",
-    },
-    github: {
-        owner: "pagopa",
-        repo: "dx",
-    },
-    init: {
-        cloudAccountsToInitialize: [],
-        runnerAppCredentials: {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        },
-        terraformBackend: {
-            cloudAccount: createMockCloudAccount(),
-        },
-    },
-    tags: {},
-    workspace: {
-        domain: "test",
-    },
-    ...overrides,
-});
-describe("provisionTerraformBackend", () => {
-    it("should provision terraform backend and return it", async () => {
-        const mockBackend = createMockTerraformBackend();
-        const provisionMock = vi.fn().mockResolvedValue(mockBackend);
-        const mockService = createMockCloudAccountService({
-            provisionTerraformBackend: provisionMock,
-        });
-        const payload = createMockPayload();
-        const result = await provisionTerraformBackend(payload, mockService);
-        expect(result).toEqual(mockBackend);
-    });
-    it("should call provisionTerraformBackend with correct parameters", async () => {
-        const cloudAccount = createMockCloudAccount({ id: "my-subscription" });
-        const provisionMock = vi
-            .fn()
-            .mockResolvedValue(createMockTerraformBackend());
-        const mockService = createMockCloudAccountService({
-            provisionTerraformBackend: provisionMock,
-        });
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [cloudAccount],
-                name: "prod",
-                prefix: "io",
-            },
-            init: {
-                cloudAccountsToInitialize: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount,
-                },
-            },
-        });
-        await provisionTerraformBackend(payload, mockService);
-        expect(provisionMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "prod", prefix: "io" }), {});
-    });
-    it("should throw an error when payload.init is undefined", async () => {
-        const mockService = createMockCloudAccountService();
-        const payload = createMockPayload({
-            init: undefined,
-        });
-        await expect(provisionTerraformBackend(payload, mockService)).rejects.toThrow("This action requires initialization data in the payload");
-    });
-    it("should use the terraformBackend cloudAccount from init", async () => {
-        const envCloudAccount = createMockCloudAccount({ id: "env-account" });
-        const backendCloudAccount = createMockCloudAccount({
-            id: "backend-account",
-        });
-        const provisionMock = vi
-            .fn()
-            .mockResolvedValue(createMockTerraformBackend());
-        const mockService = createMockCloudAccountService({
-            provisionTerraformBackend: provisionMock,
-        });
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [envCloudAccount],
-                name: "uat",
-                prefix: "dx",
-            },
-            init: {
-                cloudAccountsToInitialize: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: backendCloudAccount,
-                },
-            },
-        });
-        await provisionTerraformBackend(payload, mockService);
-        expect(provisionMock).toHaveBeenCalledWith(backendCloudAccount, expect.objectContaining({ name: "uat", prefix: "dx" }), {});
-    });
-});

package/dist/adapters/plop/generators/environment/__tests__/actions.test.d.ts

@@ -1,2 +0,0 @@
-import { Payload } from "../prompts.js";
-export declare const getPayload: (includeInit?: boolean) => Payload;

package/dist/adapters/plop/generators/environment/__tests__/actions.test.js

@@ -1,92 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { z } from "zod";
-import getActions from "../actions.js";
-const terraformBackendActionSchema = z.object({
-    data: z.object({
-        terraformBackendKey: z.string(),
-    }),
-    type: z.literal("addMany"),
-});
-export const getPayload = (includeInit = false) => {
-    const cloudAccount = {
-        csp: "azure",
-        defaultLocation: "westeurope",
-        displayName: "Test-Account",
-        id: "test-subscription-id",
-    };
-    const payload = {
-        env: {
-            cloudAccounts: [cloudAccount],
-            name: "dev",
-            prefix: "dx",
-        },
-        github: {
-            owner: "pagopa",
-            repo: "dx",
-        },
-        tags: {},
-        workspace: {
-            domain: "mytest",
-        },
-    };
-    if (includeInit) {
-        payload.init = {
-            cloudAccountsToInitialize: [cloudAccount],
-            runnerAppCredentials: {
-                clientId: "test-app-client-id",
-                id: "test-app-id",
-                installationId: "test-installation-id",
-                key: "test-private-key",
-            },
-            terraformBackend: {
-                cloudAccount,
-            },
-        };
-    }
-    return payload;
-};
-describe("actions", () => {
-    test.each([
-        {
-            payload: getPayload(true),
-        },
-        {
-            payload: getPayload(false),
-        },
-    ])("correct order of actions", ({ payload }) => {
-        const actionsOrder = [
-            "getTerraformBackend",
-            "addMany",
-            "addMany",
-            "addMany",
-        ];
-        if (payload.init) {
-            actionsOrder.unshift("initCloudAccounts", "provisionTerraformBackend");
-            actionsOrder.push("addMany", "addMany");
-        }
-        const actions = getActions("/templates/path")(payload);
-        const actionTypes = actions
-            .filter((action) => typeof action === "object" && Object.hasOwn(action, "type"))
-            .map((action) => action.type);
-        expect(actionTypes).toEqual(actionsOrder);
-    });
-    test.each([
-        {
-            expectedKeys: [
-                "dx/mytest/bootstrapper.tfstate",
-                "dx/mytest/core.tfstate",
-            ],
-            payload: getPayload(true),
-        },
-        {
-            expectedKeys: ["dx/mytest/bootstrapper.tfstate"],
-            payload: getPayload(false),
-        },
-    ])("uses prefix/domain/scope state keys in shared backend actions", ({ expectedKeys, payload }) => {
-        const actions = getActions("/templates/path")(payload);
-        const terraformBackendKeys = actions
-            .filter((action) => terraformBackendActionSchema.safeParse(action).success)
-            .map((action) => action.data.terraformBackendKey);
-        expect(terraformBackendKeys).toEqual(expectedKeys);
-    });
-});

package/dist/adapters/plop/generators/environment/__tests__/prompts.test.d.ts

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

package/dist/adapters/plop/generators/environment/__tests__/prompts.test.js

@@ -1,182 +0,0 @@
-// Tests for workspaceSchema transforms (lowercase and trim on domain).
-import inquirer from "inquirer";
-import { describe, expect, it, vi } from "vitest";
-import prompts, { formatInitializationDetails, workspaceSchema, } from "../prompts.js";
-describe("workspaceSchema — domain transforms", () => {
-    it("lowercases an uppercase domain", () => {
-        const result = workspaceSchema.safeParse({ domain: "API" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.domain).toBe("api");
-    });
-    it("lowercases a mixed-case domain", () => {
-        const result = workspaceSchema.safeParse({ domain: "MyDomain" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.domain).toBe("mydomain");
-    });
-    it("trims leading and trailing whitespace from domain", () => {
-        const result = workspaceSchema.safeParse({ domain: " aPi " });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.domain).toBe("api");
-    });
-    it("requires domain to be provided", () => {
-        const result = workspaceSchema.safeParse({});
-        expect(result.success).toBe(false);
-    });
-    it("rejects domains that would create nested paths", () => {
-        const result = workspaceSchema.safeParse({ domain: "core/platform" });
-        expect(result.success).toBe(false);
-    });
-});
-describe("formatInitializationDetails", () => {
-    const account = (overrides = {}) => ({
-        csp: "azure",
-        defaultLocation: "italynorth",
-        displayName: "DEV-FooBar",
-        id: "sub-123",
-        ...overrides,
-    });
-    const notInitializedStatus = (issues) => ({
-        initialized: false,
-        issues,
-    });
-    it("lists each uninitialized cloud account by displayName", () => {
-        const status = notInitializedStatus([
-            {
-                cloudAccount: account({ displayName: "DEV-A" }),
-                type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-            },
-            {
-                cloudAccount: account({ displayName: "DEV-B" }),
-                type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-            },
-        ]);
-        const output = formatInitializationDetails(status);
-        expect(output).toContain('Azure subscription "DEV-A"');
-        expect(output).toContain('Azure subscription "DEV-B"');
-        expect(output).toContain("managed identity");
-        expect(output).toContain("OIDC");
-        expect(output).toContain("ARM_CLIENT_ID");
-        expect(output).toContain("ARM_SUBSCRIPTION_ID");
-        expect(output).not.toContain("ARM_TENANT_ID");
-        expect(output).toContain("Key Vault");
-    });
-    it("includes the Terraform backend section when MISSING_REMOTE_BACKEND issue is present", () => {
-        const status = notInitializedStatus([
-            { cloudAccount: account(), type: "CLOUD_ACCOUNT_NOT_INITIALIZED" },
-            { type: "MISSING_REMOTE_BACKEND" },
-        ]);
-        const output = formatInitializationDetails(status);
-        expect(output).toContain("Terraform remote backend");
-        expect(output).toContain("Storage Account");
-    });
-    it("omits the Terraform backend section when no MISSING_REMOTE_BACKEND issue is present", () => {
-        const status = notInitializedStatus([
-            { cloudAccount: account(), type: "CLOUD_ACCOUNT_NOT_INITIALIZED" },
-        ]);
-        const output = formatInitializationDetails(status);
-        expect(output).not.toContain("Terraform remote backend");
-    });
-    it("omits the cloud account section when no CLOUD_ACCOUNT_NOT_INITIALIZED issues are present", () => {
-        const status = notInitializedStatus([{ type: "MISSING_REMOTE_BACKEND" }]);
-        const output = formatInitializationDetails(status);
-        expect(output).not.toContain("Azure subscription");
-        expect(output).toContain("Terraform remote backend");
-    });
-    it("returns an empty string when there are no relevant issues", () => {
-        const status = notInitializedStatus([]);
-        expect(formatInitializationDetails(status)).toBe("");
-    });
-});
-describe("prompts", () => {
-    it("prompts for the GitHub runner app client ID when initialization is required", async () => {
-        const cloudAccount = {
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "DEV-FooBar",
-            id: "sub-123",
-        };
-        const cloudAccountRepository = {
-            list: vi.fn().mockResolvedValue([cloudAccount]),
-        };
-        const cloudAccountService = {
-            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-            hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
-            initialize: vi.fn().mockResolvedValue(undefined),
-            isInitialized: vi.fn().mockResolvedValue(false),
-            provisionTerraformBackend: vi.fn().mockResolvedValue(undefined),
-        };
-        const promptSpy = vi.spyOn(inquirer, "prompt");
-        const consoleLogSpy = vi
-            .spyOn(console, "log")
-            .mockImplementation(() => undefined);
-        promptSpy
-            .mockResolvedValueOnce({
-            env: {
-                cloudAccounts: [cloudAccount],
-                name: "dev",
-                prefix: "dx",
-            },
-            tags: {
-                BusinessUnit: "Platform",
-                CostCenter: "TS000",
-                ManagementTeam: "Engineering",
-            },
-            workspace: {
-                domain: "payments",
-            },
-        })
-            .mockResolvedValueOnce({
-            [cloudAccount.id]: "italynorth",
-        })
-            .mockResolvedValueOnce({
-            init: true,
-        })
-            .mockResolvedValueOnce({
-            runnerAppCredentials: {
-                clientId: "app-client-id",
-                id: "app-id",
-                installationId: "installation-id",
-                key: "private-key",
-            },
-        });
-        try {
-            const result = await prompts({
-                cloudAccountRepository,
-                cloudAccountService,
-                github: {
-                    owner: "pagopa",
-                    repo: "dx",
-                },
-            })(inquirer);
-            const runnerCredentialQuestions = promptSpy.mock.calls[3]?.[0];
-            expect(runnerCredentialQuestions).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    message: "GitHub Runner App ID",
-                    name: "runnerAppCredentials.id",
-                }),
-                expect.objectContaining({
-                    message: "GitHub Runner App Client ID",
-                    name: "runnerAppCredentials.clientId",
-                }),
-                expect.objectContaining({
-                    message: "GitHub Runner App Installation ID",
-                    name: "runnerAppCredentials.installationId",
-                }),
-                expect.objectContaining({
-                    message: "GitHub Runner App Private Key",
-                    name: "runnerAppCredentials.key",
-                }),
-            ]));
-            expect(result.init?.runnerAppCredentials).toEqual({
-                clientId: "app-client-id",
-                id: "app-id",
-                installationId: "installation-id",
-                key: "private-key",
-            });
-        }
-        finally {
-            promptSpy.mockRestore();
-            consoleLogSpy.mockRestore();
-        }
-    });
-});

package/dist/adapters/plop/helpers/__tests__/resource-prefix.test.d.ts

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