@pagopa/dx-cli 0.22.4 → 0.23.1

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 {};

package/dist/adapters/commander/__tests__/env.test.js

@@ -1,45 +0,0 @@
-import fc from "fast-check";
-/**
- * Tests for the CLI environment schema.
- * Validates that `cliEnvSchema` correctly parses `process.env`.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-import { cliEnvSchema } from "../env.js";
-// The accepted stringbool values mirror those recognised by z.stringbool().
-const CI_TRUTHY = ["true", "1", "yes", "y", "on"];
-const CI_FALSEY = ["false", "0", "no", "n", "off"];
-const CI_ACCEPTED = [...CI_TRUTHY, ...CI_FALSEY];
-describe("cliEnvSchema", () => {
-    afterEach(() => {
-        vi.unstubAllEnvs();
-    });
-    describe("CI field", () => {
-        it("should be true for truthy string-bool values", () => {
-            fc.assert(fc.property(fc.constantFrom(...CI_TRUTHY), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(true);
-                expect(result.success && result.data.CI).toBe(true);
-            }));
-        });
-        it("should be false for falsey string-bool values or when unset", () => {
-            fc.assert(fc.property(fc.constantFrom(...CI_FALSEY, undefined), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(true);
-                expect(result.success && result.data.CI).toBe(false);
-            }));
-        });
-        it("should not parse unrecognised values", () => {
-            fc.assert(fc.property(
-            // Every string not in the accepted list
-            fc.string().filter((s) => !CI_ACCEPTED.includes(s.toLowerCase())), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(false);
-                expect(result.error).toBeInstanceOf(z.ZodError);
-            }));
-        });
-    });
-});

package/dist/adapters/commander/__tests__/error-reporting.test.d.ts

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

package/dist/adapters/commander/__tests__/error-reporting.test.js

@@ -1,63 +0,0 @@
-import { ExecaError } from "execa";
-import { describe, expect, it } from "vitest";
-import { formatErrorDetailed, toErrorMessage } from "../error-reporting.js";
-describe("toErrorMessage", () => {
-    it("returns the string as-is when given a string", () => {
-        expect(toErrorMessage("oops")).toBe("oops");
-    });
-    it("returns 'Unknown error' for null/undefined", () => {
-        expect(toErrorMessage(null)).toBe("Unknown error");
-        expect(toErrorMessage(undefined)).toBe("Unknown error");
-    });
-    it("returns Error.message when given a plain Error", () => {
-        expect(toErrorMessage(new Error("boom"))).toBe("boom");
-    });
-    it("prefers ExecaError.shortMessage over message", () => {
-        const execaError = Object.assign(Object.create(ExecaError.prototype), {
-            message: "long noisy message with stderr",
-            shortMessage: "Command failed: terraform init",
-        });
-        expect(toErrorMessage(execaError)).toBe("Command failed: terraform init");
-    });
-    it("flattens AggregateError into a bulleted message", () => {
-        const aggregate = new AggregateError([new Error("first"), new Error("second")], "parent");
-        expect(toErrorMessage(aggregate)).toBe("parent\n  - first\n  - second");
-    });
-    it("extracts `message` property from plain objects when present", () => {
-        expect(toErrorMessage({ message: "from object" })).toBe("from object");
-    });
-    it("falls back to JSON.stringify for objects without message", () => {
-        expect(toErrorMessage({ code: 42 })).toBe('{"code":42}');
-    });
-});
-describe("formatErrorDetailed", () => {
-    it("renders name, message and stack for a single error", () => {
-        const err = new Error("top");
-        const formatted = formatErrorDetailed(err);
-        expect(formatted).toContain("Error: top");
-        expect(formatted).toContain("at ");
-    });
-    it("walks the cause chain", () => {
-        const root = new Error("root failure");
-        const middle = new Error("middle", { cause: root });
-        const top = new Error("top", { cause: middle });
-        const formatted = formatErrorDetailed(top);
-        expect(formatted).toContain("Error: top");
-        expect(formatted).toContain("Caused by: Error: middle");
-        expect(formatted).toContain("Caused by: Error: root failure");
-    });
-    it("terminates when encountering a cycle in the cause chain", () => {
-        const a = new Error("a");
-        const b = new Error("b", { cause: a });
-        a.cause = b;
-        const formatted = formatErrorDetailed(a);
-        expect(formatted).toContain("Error: a");
-        expect(formatted).toContain("Caused by: Error: b");
-    });
-    it("handles non-Error causes gracefully", () => {
-        const err = new Error("wrapped", { cause: "raw string cause" });
-        const formatted = formatErrorDetailed(err);
-        expect(formatted).toContain("Error: wrapped");
-        expect(formatted).toContain("Caused by: raw string cause");
-    });
-});

package/dist/adapters/commander/__tests__/exit-with-error.test.d.ts

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

package/dist/adapters/commander/__tests__/exit-with-error.test.js

@@ -1,92 +0,0 @@
-import { Command } from "commander";
-import { describe, expect, it } from "vitest";
-import { exitWithError, isVerbose } from "../index.js";
-/**
- * Builds a parent command that exposes the global `--verbose` flag so that
- * `optsWithGlobals()` behaves the same way it does on the real CLI.
- */
-const makeProgramWith = (child, argv) => {
-    const program = new Command()
-        .name("dx")
-        .option("-v, --verbose", "verbose output", false)
-        .exitOverride()
-        .configureOutput({
-        writeErr: () => {
-            /* silence stderr in tests */
-        },
-        writeOut: () => {
-            /* silence stdout in tests */
-        },
-    });
-    child.exitOverride().configureOutput({
-        writeErr: () => {
-            /* silence */
-        },
-        writeOut: () => {
-            /* silence */
-        },
-    });
-    program.addCommand(child);
-    program.parse(argv, { from: "user" });
-    return program;
-};
-/**
- * `exitWithError` always throws (Commander's `exitOverride()` converts the
- * process.exit call into a CommanderError throw). This helper captures that
- * throw so tests can assert on the thrown payload without putting `expect`
- * inside a `catch` block (which vitest/no-conditional-expect disallows).
- */
-const captureThrown = (fn) => {
-    try {
-        fn();
-    }
-    catch (error) {
-        return error;
-    }
-    throw new Error("expected the callback to throw");
-};
-describe("isVerbose", () => {
-    it("is false when --verbose is not provided", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        expect(isVerbose(cmd)).toBe(false);
-    });
-    it("is true when -v is provided at the root", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["-v", "run"]);
-        expect(isVerbose(cmd)).toBe(true);
-    });
-    it("is true when --verbose is provided at the root", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["--verbose", "run"]);
-        expect(isVerbose(cmd)).toBe(true);
-    });
-});
-describe("exitWithError", () => {
-    it("reports only the message in normal mode", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        const err = new Error("outer", { cause: new Error("inner secret") });
-        expect(() => exitWithError(cmd)(err)).toThrow(/outer/);
-        const thrown = captureThrown(() => exitWithError(cmd)(err));
-        const message = String(thrown?.message ?? thrown);
-        expect(message).not.toContain("Caused by");
-        expect(message).not.toContain("inner secret");
-    });
-    it("includes the cause chain and stack trace in verbose mode", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["--verbose", "run"]);
-        const root = new Error("root cause");
-        const err = new Error("surface", { cause: root });
-        const thrown = captureThrown(() => exitWithError(cmd)(err));
-        const message = String(thrown?.message ?? thrown);
-        expect(message).toContain("Error: surface");
-        expect(message).toContain("Caused by: Error: root cause");
-        expect(message).toContain("at ");
-    });
-    it("works with non-Error values", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        expect(() => exitWithError(cmd)("plain string failure")).toThrow(/plain string failure/);
-    });
-});

package/dist/adapters/commander/__tests__/global-options.test.d.ts

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

package/dist/adapters/commander/__tests__/global-options.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mock } from "vitest-mock-extended";
-import { makeCli } from "../index.js";
-const makeProgram = (argv) => {
-    const program = makeCli(mock(), mock(), mock(), "0.0.0");
-    program.exitOverride().configureOutput({
-        writeErr: () => {
-            /* silence stderr in tests */
-        },
-        writeOut: () => {
-            /* silence stdout in tests */
-        },
-    });
-    program.parseOptions(argv);
-    return program;
-};
-describe("--output option", () => {
-    it("defaults to 'text' when not provided", () => {
-        const program = makeProgram([]);
-        expect(program.opts().output).toBe("text");
-    });
-    it("accepts 'text' explicitly", () => {
-        const program = makeProgram(["--output", "text"]);
-        expect(program.opts().output).toBe("text");
-    });
-    it("accepts 'json'", () => {
-        const program = makeProgram(["--output", "json"]);
-        expect(program.opts().output).toBe("json");
-    });
-    it("rejects invalid values", () => {
-        expect(() => makeProgram(["--output", "xml"])).toThrow();
-    });
-});

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

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

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.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/presenters/__tests__/index.test.d.ts

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