@pagopa/dx-cli 0.23.0 → 0.23.1

package/dist/domain/__tests__/environment.test.js

@@ -1,332 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { environmentSchema, getInitializationStatus, getTerraformBackend, hasUserPermissionToInitialize, } from "../environment.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-account-id",
-    ...overrides,
-});
-const createMockEnvironment = (overrides = {}) => ({
-    cloudAccounts: [createMockCloudAccount()],
-    name: "dev",
-    prefix: "dx",
-    ...overrides,
-});
-const createMockTerraformBackend = (overrides = {}) => ({
-    resourceGroupName: "dx-d-itn-tf-rg",
-    storageAccountName: "dxditntfst",
-    subscriptionId: "00000000-0000-0000-0000-000000000000",
-    type: "azurerm",
-    ...overrides,
-});
-describe("getInitializationStatus", () => {
-    it("should return initialized true when all cloud accounts are initialized and backend exists", async () => {
-        const mockBackend = createMockTerraformBackend();
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
-            isInitialized: vi.fn().mockResolvedValue(true),
-        });
-        const environment = createMockEnvironment();
-        const result = await getInitializationStatus(mockService, environment);
-        expect(result).toEqual({ initialized: true });
-    });
-    it("should return CLOUD_ACCOUNT_NOT_INITIALIZED issue when cloud account is not initialized", async () => {
-        const cloudAccount = createMockCloudAccount({ id: "uninitialized-id" });
-        const mockBackend = createMockTerraformBackend();
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
-            isInitialized: vi.fn().mockResolvedValue(false),
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [cloudAccount],
-        });
-        const result = await getInitializationStatus(mockService, environment);
-        expect(result).toEqual({
-            initialized: false,
-            issues: [
-                {
-                    cloudAccount,
-                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-                },
-            ],
-        });
-    });
-    it("should return MISSING_REMOTE_BACKEND issue when terraform backend is not found", async () => {
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-            isInitialized: vi.fn().mockResolvedValue(true),
-        });
-        const environment = createMockEnvironment();
-        const result = await getInitializationStatus(mockService, environment);
-        expect(result).toEqual({
-            initialized: false,
-            issues: [
-                {
-                    type: "MISSING_REMOTE_BACKEND",
-                },
-            ],
-        });
-    });
-    it("should return multiple issues when both cloud account is not initialized and backend is missing", async () => {
-        const cloudAccount = createMockCloudAccount();
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-            isInitialized: vi.fn().mockResolvedValue(false),
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [cloudAccount],
-        });
-        const result = await getInitializationStatus(mockService, environment);
-        expect(result).toEqual({
-            initialized: false,
-            issues: [
-                {
-                    cloudAccount,
-                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-                },
-                {
-                    type: "MISSING_REMOTE_BACKEND",
-                },
-            ],
-        });
-    });
-    it("should check initialization for each cloud account with correct parameters", async () => {
-        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
-        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
-        const mockBackend = createMockTerraformBackend();
-        const isInitializedMock = vi.fn().mockResolvedValue(true);
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
-            isInitialized: isInitializedMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [cloudAccount1, cloudAccount2],
-            name: "prod",
-            prefix: "io",
-        });
-        await getInitializationStatus(mockService, environment);
-        expect(isInitializedMock).toHaveBeenCalledTimes(2);
-        expect(isInitializedMock).toHaveBeenCalledWith("account-1", expect.objectContaining({
-            name: "prod",
-            prefix: "io",
-        }));
-        expect(isInitializedMock).toHaveBeenCalledWith("account-2", expect.objectContaining({
-            name: "prod",
-            prefix: "io",
-        }));
-    });
-    it("should return issues for multiple uninitialized cloud accounts", async () => {
-        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
-        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
-        const mockBackend = createMockTerraformBackend();
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
-            isInitialized: vi.fn().mockResolvedValue(false),
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [cloudAccount1, cloudAccount2],
-        });
-        const result = await getInitializationStatus(mockService, environment);
-        expect(result).toEqual({
-            initialized: false,
-            issues: [
-                {
-                    cloudAccount: cloudAccount1,
-                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-                },
-                {
-                    cloudAccount: cloudAccount2,
-                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
-                },
-            ],
-        });
-    });
-});
-describe("getTerraformBackend", () => {
-    it("should return the terraform backend when it exists", async () => {
-        const mockBackend = createMockTerraformBackend();
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
-        });
-        const environment = createMockEnvironment();
-        const result = await getTerraformBackend(mockService, environment);
-        expect(result).toEqual(mockBackend);
-    });
-    it("should return undefined when no terraform backend exists", async () => {
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
-        });
-        const environment = createMockEnvironment();
-        const result = await getTerraformBackend(mockService, environment);
-        expect(result).toBeUndefined();
-    });
-    it("should call getTerraformBackend with correct parameters", async () => {
-        const getTerraformBackendMock = vi.fn().mockResolvedValue(undefined);
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: getTerraformBackendMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [createMockCloudAccount({ id: "my-account" })],
-            name: "uat",
-            prefix: "io",
-        });
-        await getTerraformBackend(mockService, environment);
-        expect(getTerraformBackendMock).toHaveBeenCalledWith("my-account", expect.objectContaining({
-            name: "uat",
-            prefix: "io",
-        }));
-    });
-    it("should return the first backend found when multiple cloud accounts exist", async () => {
-        const mockBackend = createMockTerraformBackend({
-            storageAccountName: "firstaccountst",
-        });
-        const getTerraformBackendMock = vi.fn().mockResolvedValue(mockBackend);
-        const mockService = createMockCloudAccountService({
-            getTerraformBackend: getTerraformBackendMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [
-                createMockCloudAccount({ id: "account-1" }),
-                createMockCloudAccount({ id: "account-2" }),
-            ],
-        });
-        const result = await getTerraformBackend(mockService, environment);
-        expect(result).toEqual(mockBackend);
-        // Should only call for the first account due to early return
-        expect(getTerraformBackendMock).toHaveBeenCalledTimes(1);
-    });
-    it("should return undefined when environment has no cloud accounts", async () => {
-        const mockService = createMockCloudAccountService();
-        const environment = createMockEnvironment({
-            cloudAccounts: [],
-        });
-        const result = await getTerraformBackend(mockService, environment);
-        expect(result).toBeUndefined();
-    });
-});
-describe("hasUserPermissionToInitialize", () => {
-    it("should return true when all cloud accounts have permission", async () => {
-        const mockService = createMockCloudAccountService({
-            hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [
-                createMockCloudAccount({ id: "account-1" }),
-                createMockCloudAccount({ id: "account-2" }),
-            ],
-        });
-        const result = await hasUserPermissionToInitialize(mockService, environment);
-        expect(result).toBe(true);
-    });
-    it("should return false when any cloud account lacks permission", async () => {
-        const hasUserPermissionMock = vi
-            .fn()
-            .mockResolvedValueOnce(true)
-            .mockResolvedValueOnce(false);
-        const mockService = createMockCloudAccountService({
-            hasUserPermissionToInitialize: hasUserPermissionMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [
-                createMockCloudAccount({ id: "account-1" }),
-                createMockCloudAccount({ id: "account-2" }),
-            ],
-        });
-        const result = await hasUserPermissionToInitialize(mockService, environment);
-        expect(result).toBe(false);
-        expect(hasUserPermissionMock).toHaveBeenCalledTimes(2);
-    });
-    it("should short-circuit and return false on first unauthorized account", async () => {
-        const hasUserPermissionMock = vi.fn().mockResolvedValue(false);
-        const mockService = createMockCloudAccountService({
-            hasUserPermissionToInitialize: hasUserPermissionMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [
-                createMockCloudAccount({ id: "account-1" }),
-                createMockCloudAccount({ id: "account-2" }),
-                createMockCloudAccount({ id: "account-3" }),
-            ],
-        });
-        const result = await hasUserPermissionToInitialize(mockService, environment);
-        expect(result).toBe(false);
-        // Should only check the first account before short-circuiting
-        expect(hasUserPermissionMock).toHaveBeenCalledTimes(1);
-        expect(hasUserPermissionMock).toHaveBeenCalledWith("account-1");
-    });
-    it("should call service with correct cloud account IDs", async () => {
-        const hasUserPermissionMock = vi.fn().mockResolvedValue(true);
-        const mockService = createMockCloudAccountService({
-            hasUserPermissionToInitialize: hasUserPermissionMock,
-        });
-        const environment = createMockEnvironment({
-            cloudAccounts: [
-                createMockCloudAccount({ id: "account-a" }),
-                createMockCloudAccount({ id: "account-b" }),
-            ],
-        });
-        await hasUserPermissionToInitialize(mockService, environment);
-        expect(hasUserPermissionMock).toHaveBeenCalledTimes(2);
-        expect(hasUserPermissionMock).toHaveBeenNthCalledWith(1, "account-a");
-        expect(hasUserPermissionMock).toHaveBeenNthCalledWith(2, "account-b");
-    });
-});
-describe("environmentSchema — prefix transforms", () => {
-    const baseEnv = {
-        cloudAccounts: [
-            {
-                csp: "azure",
-                defaultLocation: "westeurope",
-                displayName: "Test Account",
-                id: "test-account-id",
-            },
-        ],
-        name: "dev",
-        prefix: "dx",
-    };
-    it("lowercases an uppercase prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "ABC" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("abc");
-    });
-    it("lowercases a mixed-case prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "AbCd" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("abcd");
-    });
-    it("trims leading and trailing whitespace from prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " dx " });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-    it("trims and lowercases prefix together", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " DX " });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-    it("still rejects a prefix shorter than 2 characters after trim", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " a " });
-        expect(result.success).toBe(false);
-    });
-    it("still rejects a prefix longer than 4 characters after trim", () => {
-        const result = environmentSchema.safeParse({
-            ...baseEnv,
-            prefix: "abcde",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("accepts a valid lowercase prefix unchanged", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "dx" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-});

package/dist/domain/__tests__/info.test.d.ts

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

package/dist/domain/__tests__/info.test.js

@@ -1,77 +0,0 @@
-import { errAsync, okAsync } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { getInfo } from "../info.js";
-import { makeMockDependencies, makeMockPackageJson, makeMockRepositoryRoot, } from "./data.js";
-describe("getInfo", () => {
-    describe("packageManager", () => {
-        it("should return default packageManager (npm) when packageManager is not detected", async () => {
-            const mockPackageJson = makeMockPackageJson({
-                packageManager: undefined,
-            });
-            const mockDependencies = makeMockDependencies();
-            const repositoryRoot = makeMockRepositoryRoot();
-            mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
-            mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
-            mockDependencies.repositoryReader.fileExists.mockReturnValue(okAsync(false));
-            mockDependencies.repositoryReader.readFile.mockReturnValue(okAsync("22.0.0"));
-            const result = await getInfo(mockDependencies)();
-            expect(result.packageManager).toStrictEqual("npm");
-            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(1, "a/repo/root/pnpm-lock.yaml");
-            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(2, "a/repo/root/yarn.lock");
-            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(3, "a/repo/root/package-lock.json");
-        });
-        it("should return yarn when yarn.lock is present", async () => {
-            const mockPackageJson = makeMockPackageJson({
-                packageManager: undefined,
-            });
-            const mockDependencies = makeMockDependencies();
-            mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
-            mockDependencies.repositoryReader.fileExists
-                .mockReturnValueOnce(okAsync(false))
-                .mockReturnValueOnce(okAsync(true)); // yarn lock file exists
-            mockDependencies.repositoryReader.readFile.mockReturnValue(okAsync("22.0.0"));
-            const repositoryRoot = makeMockRepositoryRoot();
-            mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
-            const result = await getInfo(mockDependencies)();
-            expect(result.packageManager).toStrictEqual("yarn");
-            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(1, "a/repo/root/pnpm-lock.yaml");
-            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(2, "a/repo/root/yarn.lock");
-            expect(mockDependencies.repositoryReader.fileExists).not.toHaveBeenCalledWith("a/repo/root/package-lock.json");
-        });
-    });
-    it("should return all info", async () => {
-        const mockPackageJson = makeMockPackageJson({
-            devDependencies: new Map([["turbo", "^2.5.0"]]),
-        });
-        const repositoryRoot = makeMockRepositoryRoot();
-        const mockDependencies = makeMockDependencies();
-        mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
-        mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
-        mockDependencies.repositoryReader.readFile
-            .mockReturnValueOnce(okAsync("\n22.0.0\n"))
-            .mockReturnValueOnce(okAsync("1.0.0\n"));
-        const result = await getInfo(mockDependencies)();
-        expect(result).toStrictEqual({
-            node: "22.0.0",
-            packageManager: "pnpm",
-            terraform: "1.0.0",
-            turbo: "^2.5.0",
-        });
-        expect(mockDependencies.repositoryReader.readFile).toHaveBeenCalledWith("a/repo/root/.node-version");
-        expect(mockDependencies.repositoryReader.readFile).toHaveBeenCalledWith("a/repo/root/.terraform-version");
-    });
-    it("should only required information", async () => {
-        const repositoryRoot = makeMockRepositoryRoot();
-        const mockDependencies = makeMockDependencies();
-        mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
-        mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(makeMockPackageJson()));
-        mockDependencies.repositoryReader.readFile.mockReturnValue(errAsync(new Error("File not found")));
-        const result = await getInfo(mockDependencies)();
-        expect(result).toStrictEqual({
-            node: undefined,
-            packageManager: "pnpm",
-            terraform: undefined,
-            turbo: undefined,
-        });
-    });
-});

package/dist/domain/__tests__/package-json.test.d.ts

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

package/dist/domain/__tests__/package-json.test.js

@@ -1,39 +0,0 @@
-import { errAsync, ok, okAsync } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { checkMonorepoScripts } from "../package-json.js";
-import { makeMockDependencies, makeMockRepositoryRoot } from "./data.js";
-describe("checkMonorepoScripts", () => {
-    const repositoryRoot = makeMockRepositoryRoot();
-    it("should return error result when getScripts fails", async () => {
-        const deps = makeMockDependencies();
-        const errorMessage = "Oh No!";
-        deps.packageJsonReader.getScripts.mockReturnValueOnce(errAsync(new Error(errorMessage)));
-        const result = await checkMonorepoScripts(deps, repositoryRoot);
-        expect(result.isErr()).toBe(true);
-    });
-    it("should return ok result with successful validation when all required scripts are present", async () => {
-        const deps = makeMockDependencies();
-        const scripts = new Map()
-            .set("build", "eslint .")
-            .set("code-review", "eslint .");
-        deps.packageJsonReader.getScripts.mockReturnValueOnce(okAsync(scripts));
-        deps.packageJsonReader.getRootRequiredScripts.mockReturnValueOnce(new Map().set("code-review", "eslint ."));
-        const result = await checkMonorepoScripts(deps, repositoryRoot);
-        expect(result).toStrictEqual(ok({
-            checkName: "Monorepo Scripts",
-            isValid: true,
-            successMessage: "Monorepo scripts are correctly set up",
-        }));
-    });
-    it("should return ok result with failed validation when required scripts are missing", async () => {
-        const deps = makeMockDependencies();
-        deps.packageJsonReader.getScripts.mockReturnValueOnce(okAsync(new Map()));
-        deps.packageJsonReader.getRootRequiredScripts.mockReturnValueOnce(new Map().set("code-review", "eslint ."));
-        const result = await checkMonorepoScripts(deps, repositoryRoot);
-        expect(result).toStrictEqual(ok({
-            checkName: "Monorepo Scripts",
-            errorMessage: "Missing required scripts: code-review",
-            isValid: false,
-        }));
-    });
-});

package/dist/domain/__tests__/repository.test.d.ts

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

package/dist/domain/__tests__/repository.test.js

@@ -1,111 +0,0 @@
-import { errAsync, ok, okAsync } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { checkNxConfig, checkPreCommitConfig } from "../repository.js";
-import { makeMockConfig, makeMockDependencies, makeMockRepositoryRoot, } from "./data.js";
-describe("checkPreCommitConfig", () => {
-    it("should return ok result with successful validation when .pre-commit-config.yaml exists", async () => {
-        const deps = makeMockDependencies();
-        const repositoryRoot = makeMockRepositoryRoot();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        const result = await checkPreCommitConfig(deps, repositoryRoot);
-        expect(result).toStrictEqual(ok({
-            checkName: "Pre-commit Configuration",
-            isValid: true,
-            successMessage: "Pre-commit configuration is present in the repository root",
-        }));
-        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/.pre-commit-config.yaml");
-    });
-    it("should return ok result with failed validation when .pre-commit-config.yaml does not exist", async () => {
-        const deps = makeMockDependencies();
-        const repositoryRoot = makeMockRepositoryRoot();
-        const errorMessage = ".pre-commit-config.yaml not found in repository root. Make sure to have pre-commit configured for the repository.";
-        deps.repositoryReader.fileExists.mockReturnValueOnce(errAsync(new Error(errorMessage)));
-        const result = await checkPreCommitConfig(deps, repositoryRoot);
-        expect(result).toStrictEqual(ok({
-            checkName: "Pre-commit Configuration",
-            errorMessage,
-            isValid: false,
-        }));
-    });
-});
-describe("checkNxConfig", () => {
-    const config = makeMockConfig();
-    const repositoryRoot = makeMockRepositoryRoot();
-    it("should return ok result with successful validation when nx.json exists and nx dependency is present", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", "^22.6.1")));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            isValid: true,
-            successMessage: "Nx configuration is present in the monorepo root and Nx dependency is installed",
-        }));
-        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/nx.json");
-    });
-    it("should return ok result with failed validation when nx.json exists but Nx dependency is missing", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            errorMessage: "Nx dependency not found in devDependencies. Please add 'nx' to your devDependencies.",
-            isValid: false,
-        }));
-    });
-    it("should return ok result with failed validation when nx.json does not exist", async () => {
-        const deps = makeMockDependencies();
-        const errorMessage = "nx.json not found in repository root. Make sure to have Nx configured for the monorepo.";
-        deps.repositoryReader.fileExists.mockReturnValueOnce(errAsync(new Error(errorMessage)));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            errorMessage,
-            isValid: false,
-        }));
-    });
-    it("should return ok result with failed validation when fileExists returns ok(false)", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(false));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            errorMessage: "nx.json not found in repository root. Make sure to have Nx configured for the monorepo.",
-            isValid: false,
-        }));
-    });
-    it("should return the error message when nx is not listed in devDependencies", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            errorMessage: "Nx dependency not found in devDependencies. Please add 'nx' to your devDependencies.",
-            isValid: false,
-        }));
-    });
-    it("should return the error message when nx version is less than minimum", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", "1.0.0")));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            errorMessage: `Nx version (1.0.0) is too low. Minimum required version is ${config.minVersions.nx}.`,
-            isValid: false,
-        }));
-    });
-    it("should return the success message when nx version is ok", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", config.minVersions.nx)));
-        const result = await checkNxConfig(deps, repositoryRoot, config);
-        expect(result).toStrictEqual(ok({
-            checkName: "Nx Configuration",
-            isValid: true,
-            successMessage: "Nx configuration is present in the monorepo root and Nx dependency is installed",
-        }));
-    });
-});

package/dist/domain/__tests__/workspace.test.d.ts

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

package/dist/domain/__tests__/workspace.test.js

@@ -1,57 +0,0 @@
-import { err, ok } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { checkWorkspaces, workspaceSchema } from "../workspace.js";
-import { makeMockDependencies } from "./data.js";
-describe("checkWorkspaces", () => {
-    const monorepoDir = "/path/to/monorepo";
-    const validWorkspaces = [
-        workspaceSchema.parse({
-            name: "workspace1",
-            path: "/path/to/workspace1",
-        }),
-        workspaceSchema.parse({
-            name: "workspace2",
-            path: "/path/to/workspace2",
-        }),
-    ];
-    it("should return the list of workspaces", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok(validWorkspaces));
-        const result = await checkWorkspaces(deps, monorepoDir);
-        expect(result).toStrictEqual(ok({
-            checkName: "Workspaces",
-            isValid: true,
-            successMessage: "Found 2 workspaces",
-        }));
-    });
-    it("should return error when getWorkspaces fails", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(err(new Error("Failed to get workspaces")));
-        const result = await checkWorkspaces(deps, monorepoDir);
-        expect(result).toStrictEqual(ok({
-            checkName: "Workspaces",
-            errorMessage: "Something is wrong with the workspaces configuration. If you need help, please contact the DevEx team.",
-            isValid: false,
-        }));
-    });
-    it("should return success when workspaces are found", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok([validWorkspaces[0]]));
-        const result = await checkWorkspaces(deps, monorepoDir);
-        expect(result).toStrictEqual(ok({
-            checkName: "Workspaces",
-            isValid: true,
-            successMessage: "Found 1 workspace",
-        }));
-    });
-    it("should return error when no workspace configuration is found", async () => {
-        const deps = makeMockDependencies();
-        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok([]));
-        const result = await checkWorkspaces(deps, monorepoDir);
-        expect(result).toStrictEqual(ok({
-            checkName: "Workspaces",
-            errorMessage: "No workspace configuration found. Make sure to configure workspaces in pnpm-workspace.yaml.",
-            isValid: false,
-        }));
-    });
-});

package/dist/use-cases/__tests__/apply-codemod.test.d.ts

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