@pagopa/dx-cli 0.23.0 → 0.23.2

package/dist/adapters/azure/__tests__/cloud-account-service.test.js

@@ -1,378 +0,0 @@
-import { DefaultAzureCredential } from "@azure/identity";
-import { test as baseTest, beforeEach, describe, expect, vi } from "vitest";
-import { AzureCloudAccountService } from "../cloud-account-service.js";
-const { queryResources } = vi.hoisted(() => ({
-    queryResources: vi.fn().mockRejectedValue(new Error("Not implemented")),
-}));
-const { mockProviderGet, mockProviderRegister } = vi.hoisted(() => ({
-    mockProviderGet: vi
-        .fn()
-        .mockResolvedValue({ registrationState: "Registered" }),
-    mockProviderRegister: vi.fn().mockResolvedValue({}),
-}));
-const { mockRoleAssignmentsCreate, mockRoleAssignmentsListForScope } = vi.hoisted(() => ({
-    mockRoleAssignmentsCreate: vi.fn().mockResolvedValue({}),
-    mockRoleAssignmentsListForScope: vi.fn(),
-}));
-const { mockCreateFederatedIdentityCredential, mockCreateIdentity, mockCreateKeyVault, mockCreateResourceGroup, mockDeleteResourceGroup, mockGetSubscription, mockKeyVaultNameAvailability, mockSetSecret, } = vi.hoisted(() => ({
-    mockCreateFederatedIdentityCredential: vi.fn().mockResolvedValue({}),
-    mockCreateIdentity: vi
-        .fn()
-        .mockResolvedValue({ clientId: "client-1", principalId: "principal-1" }),
-    mockCreateKeyVault: vi.fn().mockResolvedValue({}),
-    mockCreateResourceGroup: vi.fn().mockResolvedValue({}),
-    mockDeleteResourceGroup: vi.fn().mockResolvedValue({}),
-    mockGetSubscription: vi.fn().mockResolvedValue({ tenantId: "tenant-1" }),
-    mockKeyVaultNameAvailability: vi.fn().mockResolvedValue({
-        nameAvailable: true,
-    }),
-    mockSetSecret: vi.fn().mockResolvedValue({}),
-}));
-vi.mock("@azure/arm-authorization", () => ({
-    AuthorizationManagementClient: class {
-        roleAssignments = {
-            create: mockRoleAssignmentsCreate,
-            listForScope: mockRoleAssignmentsListForScope,
-        };
-    },
-}));
-vi.mock("@azure/arm-keyvault", () => ({
-    KeyVaultManagementClient: class {
-        vaults = {
-            beginCreateOrUpdateAndWait: mockCreateKeyVault,
-            checkNameAvailability: mockKeyVaultNameAvailability,
-        };
-    },
-}));
-vi.mock("@azure/arm-msi", () => ({
-    ManagedServiceIdentityClient: class {
-        federatedIdentityCredentials = {
-            createOrUpdate: mockCreateFederatedIdentityCredential,
-        };
-        userAssignedIdentities = {
-            createOrUpdate: mockCreateIdentity,
-        };
-    },
-}));
-vi.mock("@azure/identity", () => ({
-    DefaultAzureCredential: vi.fn(),
-}));
-vi.mock("@azure/arm-resourcegraph", () => ({
-    ResourceGraphClient: class {
-        resources = queryResources;
-    },
-}));
-vi.mock("@azure/arm-resources", () => ({
-    ResourceManagementClient: class {
-        providers = {
-            get: mockProviderGet,
-            register: mockProviderRegister,
-        };
-        resourceGroups = {
-            beginDeleteAndWait: mockDeleteResourceGroup,
-            createOrUpdate: mockCreateResourceGroup,
-        };
-    },
-}));
-vi.mock("@azure/arm-resources-subscriptions", () => ({
-    SubscriptionClient: class {
-        subscriptions = {
-            get: mockGetSubscription,
-        };
-    },
-}));
-vi.mock("@azure/keyvault-secrets", () => ({
-    SecretClient: class {
-        setSecret = mockSetSecret;
-    },
-}));
-const test = baseTest.extend({
-    // the empty pattern is required by vitest!!!
-    // eslint-disable-next-line no-empty-pattern
-    cloudAccountService: async ({}, use) => {
-        const cloudAccountService = new AzureCloudAccountService(new DefaultAzureCredential());
-        await use(cloudAccountService);
-    },
-});
-beforeEach(() => {
-    queryResources.mockReset();
-    queryResources.mockResolvedValue({ data: [], totalRecords: 0 });
-    mockCreateFederatedIdentityCredential.mockClear();
-    mockCreateIdentity.mockClear();
-    mockCreateIdentity.mockResolvedValue({
-        clientId: "client-1",
-        principalId: "principal-1",
-    });
-    mockCreateKeyVault.mockClear();
-    mockCreateResourceGroup.mockClear();
-    mockDeleteResourceGroup.mockClear();
-    mockGetSubscription.mockClear();
-    mockGetSubscription.mockResolvedValue({ tenantId: "tenant-1" });
-    mockKeyVaultNameAvailability.mockClear();
-    mockKeyVaultNameAvailability.mockResolvedValue({ nameAvailable: true });
-    mockProviderGet.mockClear();
-    mockProviderGet.mockResolvedValue({ registrationState: "Registered" });
-    mockProviderRegister.mockClear();
-    mockRoleAssignmentsCreate.mockClear();
-    mockRoleAssignmentsListForScope.mockReset();
-    mockSetSecret.mockClear();
-});
-describe("getTerraformBackend", () => {
-    test("returns undefined when no matching storage account is found", async ({ cloudAccountService, }) => {
-        queryResources.mockResolvedValueOnce({
-            data: [],
-            totalRecords: 0,
-        });
-        const result = await cloudAccountService.getTerraformBackend("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toBeUndefined();
-    });
-    test("return the only matching storage account", async ({ cloudAccountService, }) => {
-        queryResources.mockResolvedValueOnce({
-            data: [
-                {
-                    location: "italynorth",
-                    name: "dxditntfstatest01",
-                    resourceGroup: "dx-d-itn-tfstate-rg-01",
-                    subscriptionId: "sub-1",
-                    type: "microsoft.storage/storageaccounts",
-                },
-            ],
-            totalRecords: 1,
-        });
-        const result = await cloudAccountService.getTerraformBackend("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toEqual(expect.objectContaining({
-            resourceGroupName: "dx-d-itn-tfstate-rg-01",
-            storageAccountName: "dxditntfstatest01",
-            type: "azurerm",
-        }));
-    });
-    test("returns the best matching storage account among multiple", async ({ cloudAccountService, }) => {
-        queryResources.mockResolvedValueOnce({
-            data: [
-                {
-                    location: "italynorth",
-                    name: "dxditntfstatest01",
-                    resourceGroup: "dx-d-itn-tfstate-rg-01",
-                    subscriptionId: "sub-1",
-                    type: "microsoft.storage/storageaccounts",
-                },
-                {
-                    location: "italynorth",
-                    name: "dxditntfstatest02",
-                    resourceGroup: "dx-d-itn-tfstate-rg-01",
-                    subscriptionId: "sub-1",
-                    type: "microsoft.storage/storageaccounts",
-                },
-                {
-                    location: "westeurope",
-                    name: "dxdweutfstatest01",
-                    resourceGroup: "dx-d-weu-tfstate-rg-01",
-                    subscriptionId: "sub-1",
-                    type: "microsoft.storage/storageaccounts",
-                },
-            ],
-            totalRecords: 3,
-        });
-        const result = await cloudAccountService.getTerraformBackend("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toEqual(expect.objectContaining({
-            resourceGroupName: "dx-d-itn-tfstate-rg-01",
-            storageAccountName: "dxditntfstatest02",
-            type: "azurerm",
-        }));
-    });
-});
-describe("isInitialized", () => {
-    test("returns true when both bootstrap identity and common Key Vault exist and all providers are registered", async ({ cloudAccountService, }) => {
-        // First call: identity query → found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        // Second call: key vault query → found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        // Provider checks → all registered (default mock)
-        const result = await cloudAccountService.isInitialized("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toBe(true);
-    });
-    test("returns false when bootstrap identity exists but common Key Vault does not", async ({ cloudAccountService, }) => {
-        // First call: identity query → found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        // Second call: key vault query → not found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 0 });
-        const result = await cloudAccountService.isInitialized("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toBe(false);
-    });
-    test("returns false when common Key Vault exists but bootstrap identity does not", async ({ cloudAccountService, }) => {
-        // First call: identity query → not found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 0 });
-        // Second call: key vault query → found
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        const result = await cloudAccountService.isInitialized("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toBe(false);
-    });
-    test("returns false when resources exist but a required provider is not registered", async ({ cloudAccountService, }) => {
-        // Both resources exist
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        queryResources.mockResolvedValueOnce({ data: [], totalRecords: 1 });
-        // One provider is not registered
-        mockProviderGet.mockResolvedValueOnce({
-            registrationState: "NotRegistered",
-        });
-        const result = await cloudAccountService.isInitialized("sub-1", {
-            name: "dev",
-            prefix: "dx",
-        });
-        expect(result).toBe(false);
-    });
-});
-describe("initialize", () => {
-    test("assigns bootstrap roles and creates bootstrap environment secrets", async ({ cloudAccountService, }) => {
-        const createOrUpdateEnvironmentSecret = vi
-            .fn()
-            .mockResolvedValue(undefined);
-        await cloudAccountService.initialize({
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "Test subscription",
-            id: "sub-1",
-        }, {
-            name: "dev",
-            prefix: "dx",
-        }, {
-            clientId: "app-client-id",
-            id: "app-id",
-            installationId: "installation-id",
-            key: "private-key\n",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, {
-            createBranch: vi.fn(),
-            createOrUpdateEnvironmentSecret,
-            createPullRequest: vi.fn(),
-            getFileContent: vi.fn(),
-            getRepository: vi.fn(),
-            updateFile: vi.fn(),
-        });
-        expect(mockRoleAssignmentsCreate).toHaveBeenCalledTimes(3);
-        expect(mockRoleAssignmentsCreate).toHaveBeenCalledWith("/subscriptions/sub-1", expect.any(String), expect.objectContaining({
-            principalId: "principal-1",
-            principalType: "ServicePrincipal",
-            roleDefinitionId: "/subscriptions/sub-1/providers/Microsoft.Authorization/roleDefinitions/f58310d9-a9f6-439a-9e8d-f62e7b41a168",
-        }));
-        expect(mockRoleAssignmentsCreate).toHaveBeenCalledWith("/subscriptions/sub-1", expect.any(String), expect.objectContaining({
-            principalId: "principal-1",
-            principalType: "ServicePrincipal",
-            roleDefinitionId: "/subscriptions/sub-1/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c",
-        }));
-        expect(mockRoleAssignmentsCreate).toHaveBeenCalledWith("/subscriptions/sub-1", expect.any(String), expect.objectContaining({
-            principalId: "principal-1",
-            principalType: "ServicePrincipal",
-            roleDefinitionId: "/subscriptions/sub-1/providers/Microsoft.Authorization/roleDefinitions/ba92f5b4-2d11-453d-a403-e96b0029c9fe",
-        }));
-        expect(mockCreateFederatedIdentityCredential).toHaveBeenCalledWith("dx-d-itn-common-rg-01", "dx-d-itn-bootstrap-id-01", "dx-bootstrapper-dev-cd", {
-            audiences: ["api://AzureADTokenExchange"],
-            issuer: "https://token.actions.githubusercontent.com",
-            subject: "repo:pagopa/dx:environment:bootstrapper-dev-cd",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledTimes(7);
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "ARM_CLIENT_ID",
-            secretValue: "client-1",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "ARM_TENANT_ID",
-            secretValue: "tenant-1",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "ARM_SUBSCRIPTION_ID",
-            secretValue: "sub-1",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "GH_APP_ID",
-            secretValue: "app-id",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "GH_APP_CLIENT_ID",
-            secretValue: "app-client-id",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "GH_APP_INSTALLATION_ID",
-            secretValue: "installation-id",
-        });
-        expect(createOrUpdateEnvironmentSecret).toHaveBeenCalledWith({
-            environmentName: "bootstrapper-dev-cd",
-            owner: "pagopa",
-            repo: "dx",
-            secretName: "GH_APP_KEY",
-            secretValue: "private-key",
-        });
-    });
-    test("uses a repository-specific federated credential name", async ({ cloudAccountService, }) => {
-        const createOrUpdateEnvironmentSecret = vi
-            .fn()
-            .mockResolvedValue(undefined);
-        await cloudAccountService.initialize({
-            csp: "azure",
-            defaultLocation: "italynorth",
-            displayName: "Test subscription",
-            id: "sub-1",
-        }, {
-            name: "dev",
-            prefix: "dx",
-        }, {
-            clientId: "app-client-id",
-            id: "app-id",
-            installationId: "installation-id",
-            key: "private-key\n",
-        }, {
-            owner: "pagopa",
-            repo: "dx-playground",
-        }, {
-            createBranch: vi.fn(),
-            createOrUpdateEnvironmentSecret,
-            createPullRequest: vi.fn(),
-            getFileContent: vi.fn(),
-            getRepository: vi.fn(),
-            updateFile: vi.fn(),
-        });
-        expect(mockCreateFederatedIdentityCredential).toHaveBeenCalledWith("dx-d-itn-common-rg-01", "dx-d-itn-bootstrap-id-01", "dx-playground-bootstrapper-dev-cd", {
-            audiences: ["api://AzureADTokenExchange"],
-            issuer: "https://token.actions.githubusercontent.com",
-            subject: "repo:pagopa/dx-playground:environment:bootstrapper-dev-cd",
-        });
-    });
-});

package/dist/adapters/codemods/__tests__/registry.test.d.ts

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

package/dist/adapters/codemods/__tests__/registry.test.js

@@ -1,56 +0,0 @@
-import { ok } from "neverthrow";
-import { describe, expect, it, vi } from "vitest";
-import { LocalCodemodRegistry } from "../registry.js";
-describe("LocalCodemodRegistry", () => {
-    const makeCodemod = (id, description = id) => ({
-        apply: vi.fn().mockResolvedValue(undefined),
-        description,
-        id,
-    });
-    it("returns empty list when no codemods are registered", async () => {
-        const registry = new LocalCodemodRegistry();
-        const result = await registry.getAll();
-        expect(result).toStrictEqual(ok([]));
-    });
-    it("adds codemods and lists them via getAll", async () => {
-        const registry = new LocalCodemodRegistry();
-        const a = makeCodemod("a", "A");
-        const b = makeCodemod("b", "B");
-        registry.add(a);
-        registry.add(b);
-        const result = await registry.getAll();
-        expect.assertions(3);
-        expect(result.isOk()).toBe(true);
-        const expected = result.unwrapOr([]);
-        expect(expected).toHaveLength(2);
-        expect(expected).toEqual(expect.arrayContaining([
-            expect.objectContaining({ id: "a" }),
-            expect.objectContaining({ id: "b" }),
-        ]));
-    });
-    it("retrieves a codemod by id and returns undefined when missing", async () => {
-        const registry = new LocalCodemodRegistry();
-        const a = makeCodemod("a", "A");
-        registry.add(a);
-        const found = await registry.getById("a");
-        expect(found.isOk()).toBe(true);
-        const expected = found.unwrapOr(undefined);
-        expect(expected).toBe(a);
-        const missing = await registry.getById("nope");
-        expect(missing.isOk()).toBe(true);
-        const missingValue = missing.unwrapOr(undefined);
-        expect(missingValue).toBeUndefined();
-    });
-    it("overwrites an existing codemod when adding with the same id", async () => {
-        const registry = new LocalCodemodRegistry();
-        const first = makeCodemod("a", "first");
-        const second = makeCodemod("a", "second");
-        registry.add(first);
-        registry.add(second);
-        const byId = await registry.getById("a");
-        expect(byId.isOk()).toBe(true);
-        const byIdValue = byId.unwrapOr(undefined);
-        expect(byIdValue).toBe(second);
-        expect(byIdValue).not.toBe(first);
-    });
-});

package/dist/adapters/codemods/__tests__/use-azure-appsvc.test.d.ts

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

package/dist/adapters/codemods/__tests__/use-azure-appsvc.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { migrateWorkflow } from "../use-azure-appsvc.js";
-describe("migrateWorkflow", () => {
-    const sha = "testsha";
-    const migrate = migrateWorkflow(sha);
-    it("adds disable_auto_staging_deploy under with for web_app_deploy", () => {
-        const input = `
-jobs:
-  deploy:
-    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
-    with:
-      web_app_name: my-app
-      use_staging_slot: true
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).toContain("disable_auto_staging_deploy: true");
-    });
-    it("adds disable_auto_staging_deploy under with for function_app_deploy", () => {
-        const input = `
-jobs:
-  deploy:
-    uses: pagopa/dx/.github/workflows/function_app_deploy.yaml@main
-    with:
-      function_app_name: my-func
-      use_staging_slot: true
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).toContain("disable_auto_staging_deploy: true");
-    });
-    it("renames function_app_name to web_app_name", () => {
-        const input = `
-jobs:
-  deploy:
-    uses: pagopa/dx/.github/workflows/function_app_deploy.yaml@main
-    with:
-      function_app_name: my-func
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).toContain("web_app_name: my-func");
-        expect(output).not.toContain("function_app_name:");
-    });
-    it("removes use_staging_slot", () => {
-        const input = `
-jobs:
-  deploy:
-    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
-    with:
-      web_app_name: my-app
-      use_staging_slot: true
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).not.toContain("use_staging_slot:");
-    });
-    it("updates uses to release-azure-appsvc.yaml@sha", () => {
-        const input = `
-jobs:
-  deploy:
-    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
-    with:
-      web_app_name: my-app
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).toContain(`uses: pagopa/dx/.github/workflows/release-azure-appsvc-v1.yaml@${sha}`);
-    });
-    it("does not change unrelated workflows", () => {
-        const input = `
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-`;
-        const output = migrate(input, "workflow.yaml");
-        expect(output).toBe(input);
-    });
-});

package/dist/adapters/codemods/__tests__/use-pnpm.test.d.ts

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

package/dist/adapters/codemods/__tests__/use-pnpm.test.js

@@ -1,148 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import YAML from "yaml";
-import { extractPackageExtensions, NPM, preparePackageJsonForPnpm, usePnpm, writePnpmWorkspaceFile, Yarn, } from "../use-pnpm.js";
-const { readFile, stdout, writeFile } = vi.hoisted(() => ({
-    readFile: vi.fn(async () => ""),
-    stdout: vi.fn(),
-    writeFile: vi.fn(),
-}));
-vi.mock("execa", () => ({
-    $: vi.fn((opts) => {
-        const hasOptions = typeof opts === "object" && Object.hasOwn(opts, "lines");
-        if (hasOptions) {
-            return () => stdout().then((output) => ({
-                stdout: output.split("\n"),
-            }));
-        }
-        return stdout().then((output) => ({
-            stdout: output,
-        }));
-    }),
-}));
-vi.mock("node:fs/promises", () => ({
-    default: {
-        appendFile: () => Promise.resolve(),
-        readFile,
-        rm: () => Promise.resolve(),
-        stat: () => Promise.resolve({
-            isFile: () => true,
-        }),
-        writeFile,
-    },
-}));
-vi.mock("../git.js", async () => ({
-    getLatestCommitShaOrRef: async () => "dummy-sha",
-}));
-describe("pm", () => {
-    test("yarn workspaces are parsed correctly", async () => {
-        const yarn = new Yarn();
-        stdout.mockResolvedValueOnce(`{"location":".","name":"io-messages"}\n{"location":"apps/citizen-func","name":"citizen-func"}`);
-        const workspaces = await yarn.listWorkspaces();
-        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
-    });
-    test("npm workspaces are parsed correctly", async () => {
-        const npm = new NPM();
-        stdout.mockResolvedValueOnce(`[{ "name": "io-messages", "location": "." },{ "name": "citizen-func", "location": "apps/citizen-func" }]`);
-        const workspaces = await npm.listWorkspaces();
-        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
-    });
-});
-describe("extractPackageExtensions", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("returns packageExtensions only if present", async () => {
-        const yarnrc = {
-            packageExtensions: {
-                "some-package@*": {
-                    peerDependencies: {
-                        react: "*",
-                    },
-                },
-            },
-        };
-        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
-        await expect(extractPackageExtensions()).resolves.toEqual(yarnrc.packageExtensions);
-        expect(readFile).toHaveBeenCalledOnce();
-    });
-    test("returns undefined if packageExtensions is not present", async () => {
-        const yarnrc = {
-            someOtherField: {},
-        };
-        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
-        await expect(extractPackageExtensions()).resolves.toBeUndefined();
-        expect(readFile).toHaveBeenCalledOnce();
-    });
-});
-describe("preparePackageJsonForPnpm", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("removes packageManager field and keeps workspaces", async () => {
-        const packageJson = {
-            name: "test-monorepo",
-            packageManager: "yarn@1.22.10",
-            version: "1.0.0",
-            workspaces: ["packages/*"],
-        };
-        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
-        const workspaces = await preparePackageJsonForPnpm();
-        expect(workspaces).toEqual(["packages/*"]);
-        expect(readFile).toHaveBeenCalledOnce();
-        expect(writeFile).toHaveBeenCalledWith("package.json", JSON.stringify({
-            name: packageJson.name,
-            version: packageJson.version,
-        }, null, 2));
-    });
-});
-describe("writePnpmWorkspaceFile", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("writes pnpm-workspace.yaml with given workspaces", async () => {
-        const workspaces = ["packages/*", "apps/*"];
-        const packageExtensions = {
-            "express@*": {
-                peerDependencies: {
-                    typescript: "*",
-                },
-            },
-        };
-        await writePnpmWorkspaceFile(workspaces, packageExtensions);
-        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packages: workspaces })), "utf-8");
-        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packageExtensions })), "utf-8");
-    });
-});
-describe("usePnpm", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    test("rejects if the project is already using pnpm", async () => {
-        await expect(usePnpm("pnpm", "10.20")).rejects.toThrow();
-    });
-    test.each([
-        { expected: false, version: "18.0.0" },
-        { expected: false, version: "20.10.0" },
-        { expected: false, version: "20.19.4" },
-        { expected: true, version: "22.0.0" },
-        { expected: true, version: "20.19.5" },
-    ])("rejects if Node.js version is less than required ($version)", async ({ expected, version }) => {
-        stdout.mockResolvedValue("[]");
-        readFile.mockResolvedValueOnce(JSON.stringify({ name: "test-monorepo", workspaces: [] }));
-        await expect(usePnpm("npm", version).then(() => true, () => false)).resolves.toBe(expected);
-    });
-    test("moves workspaces from package.json to pnpm-workspace.yaml", async () => {
-        const packageJson = {
-            name: "test-monorepo",
-            packageManager: "yarn@1.22.10",
-            version: "1.0.0",
-            workspaces: ["packages/*"],
-        };
-        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
-        stdout.mockResolvedValue(`[]`); // npm list workspaces
-        await usePnpm("npm", "22.0.0");
-        expect(writeFile).toHaveBeenNthCalledWith(2, "pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({
-            packages: packageJson.workspaces,
-        })), "utf-8");
-    });
-});

package/dist/adapters/commander/__tests__/env.test.d.ts

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