config-initializer.js

/**
 * @fileoverview Tests for configInitializer.
 * @author Ilya Volodin
 */


//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

import chai from "chai";
import fs from "fs";
import path from "path";
import os from "os";
import sinon from "sinon";
import sh from "shelljs";
import * as npmUtils from "../../lib/init/npm-utils.js";
import * as log from "../../lib/shared/logging.js";
import proxyquireMod from "proxyquire";
import { Legacy, FlatCompat } from "@eslint/eslintrc";

const originalDir = process.cwd();
const { assert } = chai;
const proxyquire = proxyquireMod.noPreserveCache();

//------------------------------------------------------------------------------
// Tests
//------------------------------------------------------------------------------

let answers = {};
let pkgJSONContents = {};
let pkgJSONPath = "";

describe("configInitializer", () => {

    let fixtureDir;
    let npmCheckStub;
    let npmInstallStub;
    let npmFetchPeerDependenciesStub;
    let init;
    let localESLintVersion = null;

    // copy into clean area so as not to get "infected" by this project's .eslintrc files
    before(() => {
        fixtureDir = path.join(os.tmpdir(), "eslint/fixtures/config-initializer");
        sh.mkdir("-p", fixtureDir);
        sh.cp("-r", "./tests/fixtures/config-initializer/.", fixtureDir);
        fixtureDir = fs.realpathSync(fixtureDir);
    });

    beforeEach(async () => {
        td.replaceEsm("../../lib/init/npm-utils.js", {
            ...npmUtils,
            checkDevDeps: packages => packages.reduce((status, pkg) => {
                status[pkg] = false;
                return status;
            }, {}),
            fetchPeerDependencies: () => ({
                eslint: "^3.19.0",
                "eslint-plugin-jsx-a11y": "^5.0.1",
                "eslint-plugin-import": "^2.2.0",
                "eslint-plugin-react": "^7.0.1"
            })
        });

        td.replaceEsm("@eslint/eslintrc", {
            FlatCompat,
            Legacy: {
                ...Legacy,
                ModuleResolver: {
                    resolve: () => {
                        if (localESLintVersion) {
                            return `local-eslint-${localESLintVersion}`;
                        }
                        throw new Error("Cannot find module");
                    }
                }
            }
        })
        // td.replace(npmUtils, "checkDevDeps",
        //     packages => packages.reduce((status, pkg) => {
        //         status[pkg] = false;
        //         return status;
        //     }, {})
        // );
        // td.when(npmUtils.fetchPeerDependencies(td.matchers.anything())).thenReturn({
        //     eslint: "^3.19.0",
        //     "eslint-plugin-jsx-a11y": "^5.0.1",
        //     "eslint-plugin-import": "^2.2.0",
        //     "eslint-plugin-react": "^7.0.1"
        // });
        // td.replace(Legacy, "ModuleResolver", {
        //     resolve: function () {
        //         if (localESLintVersion) {
        //             return `local-eslint-${localESLintVersion}`;
        //         }
        //         throw new Error("Cannot find module");
        //     }
        // });
        td.replace("local-eslint-3.18.0", {linter: { version: "3.18.0" }, "@noCallThru": true });
        td.replace("local-eslint-3.19.0", {linter: { version: "3.19.0" }, "@noCallThru": true });
        td.replace("local-eslint-4.0.0", {linter: { version: "4.0.0" }, "@noCallThru": true });
        init = await import("../../lib/init/npm-utils.js");
        // td.when(Legacy.ModuleResolver.resolve("local-eslint-3.18.0")).thenReturn({ linter: { version: "3.18.0" }, "@noCallThru": true });
        // td.when(Legacy.ModuleResolver.resolve("local-eslint-3.19.0")).thenReturn({ linter: { version: "3.19.0" }, "@noCallThru": true });
        // td.when(Legacy.ModuleResolver.resolve("local-eslint-4.0.0")).thenReturn({ linter: { version: "4.0.0" }, "@noCallThru": true });
        // npmInstallStub = sinon.stub(npmUtils, "installSyncSaveDev");
        // npmCheckStub = sinon.stub(npmUtils, "checkDevDeps").callsFake(packages => packages.reduce((status, pkg) => {
        //     status[pkg] = false;
        //     return status;
        // }, {}));
        // npmFetchPeerDependenciesStub = sinon
        //     .stub(npmUtils, "fetchPeerDependencies")
        //     .returns({
        //         eslint: "^3.19.0",
        //         "eslint-plugin-jsx-a11y": "^5.0.1",
        //         "eslint-plugin-import": "^2.2.0",
        //         "eslint-plugin-react": "^7.0.1"
        //     });
        init = await import ("../../lib/init/config-initializer.js");
    });

    // afterEach(() => {
    //     npmInstallStub.restore();
    //     npmCheckStub.restore();
    //     npmFetchPeerDependenciesStub.restore();
    // });

    after(() => {
        sh.rm("-r", fixtureDir);
    });

    describe("processAnswers()", () => {

        describe("prompt", () => {

            beforeEach(() => {
                answers = {
                    purpose: "style",
                    source: "prompt",
                    extendDefault: true,
                    indent: 2,
                    quotes: "single",
                    linebreak: "unix",
                    semi: true,
                    moduleType: "esm",
                    es6Globals: true,
                    env: ["browser"],
                    format: "JSON"
                };
            });

            it("should create default config", () => {
                const config = init.processAnswers(answers);

                assert.deepStrictEqual(config.rules.indent, ["error", 2]);
                assert.deepStrictEqual(config.rules.quotes, ["error", "single"]);
                assert.deepStrictEqual(config.rules["linebreak-style"], ["error", "unix"]);
                assert.deepStrictEqual(config.rules.semi, ["error", "always"]);
                assert.strictEqual(config.env.es2021, true);
                assert.strictEqual(config.parserOptions.ecmaVersion, "latest");
                assert.strictEqual(config.parserOptions.sourceType, "module");
                assert.strictEqual(config.env.browser, true);
                assert.strictEqual(config.extends, "eslint:recommended");
            });

            it("should disable semi", () => {
                answers.semi = false;
                const config = init.processAnswers(answers);

                assert.deepStrictEqual(config.rules.semi, ["error", "never"]);
            });

            it("should enable react plugin", () => {
                answers.framework = "react";
                const config = init.processAnswers(answers);

                assert.strictEqual(config.parserOptions.ecmaFeatures.jsx, true);
                assert.strictEqual(config.parserOptions.ecmaVersion, "latest");
                assert.deepStrictEqual(config.plugins, ["react"]);
            });

            it("should enable vue plugin", () => {
                answers.framework = "vue";
                const config = init.processAnswers(answers);

                assert.strictEqual(config.parserOptions.ecmaVersion, "latest");
                assert.deepStrictEqual(config.plugins, ["vue"]);
                assert.deepStrictEqual(config.extends, ["eslint:recommended", "plugin:vue/essential"]);
            });

            it("should enable typescript parser and plugin", () => {
                answers.typescript = true;
                const config = init.processAnswers(answers);

                assert.strictEqual(config.parser, "@typescript-eslint/parser");
                assert.deepStrictEqual(config.plugins, ["@typescript-eslint"]);
                assert.deepStrictEqual(config.extends, ["eslint:recommended", "plugin:@typescript-eslint/recommended"]);
            });

            it("should enable typescript parser and plugin with vue", () => {
                answers.framework = "vue";
                answers.typescript = true;
                const config = init.processAnswers(answers);

                assert.deepStrictEqual(config.extends, ["eslint:recommended", "plugin:vue/essential", "plugin:@typescript-eslint/recommended"]);
                assert.strictEqual(config.parserOptions.parser, "@typescript-eslint/parser");
                assert.deepStrictEqual(config.plugins, ["vue", "@typescript-eslint"]);
            });

            it("should extend eslint:recommended", () => {
                const config = init.processAnswers(answers);

                assert.strictEqual(config.extends, "eslint:recommended");
            });

            it("should not use commonjs by default", () => {
                const config = init.processAnswers(answers);

                assert.isUndefined(config.env.commonjs);
            });

            it("should use commonjs when set", () => {
                answers.moduleType = "commonjs";
                const config = init.processAnswers(answers);

                assert.isTrue(config.env.commonjs);
            });
        });

        // TODO
        describe.skip("guide", () => {
            it("should support the google style guide", () => {
                const config = { extends: "google" };
                const modules = init.getModulesList(config);

                assert.deepStrictEqual(config, { extends: "google", installedESLint: true });
                assert.include(modules, "eslint-config-google@latest");
            });

            it("should support the airbnb style guide", () => {
                const config = { extends: "airbnb" };
                const modules = init.getModulesList(config);

                assert.deepStrictEqual(config, { extends: "airbnb", installedESLint: true });
                assert.include(modules, "eslint-config-airbnb@latest");
            });

            it("should support the airbnb base style guide", () => {
                const config = { extends: "airbnb-base" };
                const modules = init.getModulesList(config);

                assert.deepStrictEqual(config, { extends: "airbnb-base", installedESLint: true });
                assert.include(modules, "eslint-config-airbnb-base@latest");
            });

            it("should support the standard style guide", () => {
                const config = { extends: "standard" };
                const modules = init.getModulesList(config);

                assert.deepStrictEqual(config, { extends: "standard", installedESLint: true });
                assert.include(modules, "eslint-config-standard@latest");
            });

            it("should support the xo style guide", () => {
                const config = { extends: "xo" };
                const modules = init.getModulesList(config);

                assert.deepStrictEqual(config, { extends: "xo", installedESLint: true });
                assert.include(modules, "eslint-config-xo@latest");
            });

            it("should install required sharable config", () => {
                const config = { extends: "google" };

                init.installModules(init.getModulesList(config));
                assert(npmInstallStub.calledOnce);
                assert(npmInstallStub.firstCall.args[0].some(name => name.startsWith("eslint-config-google@")));
            });

            it("should install ESLint if not installed locally", () => {
                const config = { extends: "google" };

                init.installModules(init.getModulesList(config));
                assert(npmInstallStub.calledOnce);
                assert(npmInstallStub.firstCall.args[0].some(name => name.startsWith("eslint@")));
            });

            it("should install peerDependencies of the sharable config", () => {
                const config = { extends: "airbnb" };

                init.installModules(init.getModulesList(config));

                assert(npmFetchPeerDependenciesStub.calledOnce);
                assert(npmFetchPeerDependenciesStub.firstCall.args[0] === "eslint-config-airbnb@latest");
                assert(npmInstallStub.calledOnce);
                assert.deepStrictEqual(
                    npmInstallStub.firstCall.args[0],
                    [
                        "eslint-config-airbnb@latest",
                        "eslint@^3.19.0",
                        "eslint-plugin-jsx-a11y@^5.0.1",
                        "eslint-plugin-import@^2.2.0",
                        "eslint-plugin-react@^7.0.1"
                    ]
                );
            });

            describe("hasESLintVersionConflict (Note: peerDependencies always `eslint: \"^3.19.0\"` by stubs)", () => {
                describe("if local ESLint is not found,", () => {
                    before(() => {
                        localESLintVersion = null;
                    });

                    it("should return false.", () => {
                        const result = init.hasESLintVersionConflict({ styleguide: "airbnb" });

                        assert.strictEqual(result, false);
                    });
                });

                describe("if local ESLint is 3.19.0,", () => {
                    before(() => {
                        localESLintVersion = "3.19.0";
                    });

                    it("should return false.", () => {
                        const result = init.hasESLintVersionConflict({ styleguide: "airbnb" });

                        assert.strictEqual(result, false);
                    });
                });

                describe("if local ESLint is 4.0.0,", () => {
                    before(() => {
                        localESLintVersion = "4.0.0";
                    });

                    it("should return true.", () => {
                        const result = init.hasESLintVersionConflict({ styleguide: "airbnb" });

                        assert.strictEqual(result, true);
                    });
                });

                describe("if local ESLint is 3.18.0,", () => {
                    before(() => {
                        localESLintVersion = "3.18.0";
                    });

                    it("should return true.", () => {
                        const result = init.hasESLintVersionConflict({ styleguide: "airbnb" });

                        assert.strictEqual(result, true);
                    });
                });
            });

            it("should support the standard style guide with Vue.js", () => {
                const config = {
                    plugins: ["vue"],
                    extends: ["plugin:vue/essential", "standard"]
                };
                const modules = init.getModulesList(config);

                assert.include(modules, "eslint-plugin-vue@latest");
                assert.include(modules, "eslint-config-standard@latest");
            });

            it("should support custom parser", () => {
                const config = {
                    parser: "@typescript-eslint/parser"
                };
                const modules = init.getModulesList(config);

                assert.include(modules, "@typescript-eslint/parser@latest");
            });

            it("should support custom parser with Vue.js", () => {
                const config = {

                    // We should declare the parser at `parserOptions` when using with `eslint-plugin-vue`.
                    parserOptions: {
                        parser: "@typescript-eslint/parser"
                    }
                };
                const modules = init.getModulesList(config);

                assert.include(modules, "@typescript-eslint/parser@latest");
            });
        });

    });

    describe("writeFile()", () => {

        beforeEach(() => {
            answers = {
                purpose: "style",
                source: "prompt",
                extendDefault: true,
                indent: 2,
                quotes: "single",
                linebreak: "unix",
                semi: true,
                moduleType: "esm",
                es6Globals: true,
                env: ["browser"],
                format: "JSON"
            };

            pkgJSONContents = {
                name: "config-initializer",
                version: "1.0.0"
            };

            process.chdir(fixtureDir);

            pkgJSONPath = path.resolve(fixtureDir, "package.json");
        });

        afterEach(() => {
            process.chdir(originalDir);
        });

        it("should create .eslintrc.json", async () => {
            const config = init.processAnswers(answers);
            const filePath = path.resolve(fixtureDir, ".eslintrc.json");

            fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSONContents));

            await init.writeFile(config, answers.format);

            assert.isTrue(fs.existsSync(filePath));

            fs.unlinkSync(filePath);
            fs.unlinkSync(pkgJSONPath);
        });

        it("should create .eslintrc.js", async () => {
            answers.format = "JavaScript";

            const config = init.processAnswers(answers);
            const filePath = path.resolve(fixtureDir, ".eslintrc.js");

            fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSONContents));

            await init.writeFile(config, answers.format);

            assert.isTrue(fs.existsSync(filePath));

            fs.unlinkSync(filePath);
            fs.unlinkSync(pkgJSONPath);
        });

        it("should create .eslintrc.yml", async () => {
            answers.format = "YAML";

            const config = init.processAnswers(answers);
            const filePath = path.resolve(fixtureDir, ".eslintrc.yml");

            fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSONContents));

            await init.writeFile(config, answers.format);

            assert.isTrue(fs.existsSync(filePath));

            fs.unlinkSync(filePath);
            fs.unlinkSync(pkgJSONPath);
        });

        // For https://github.com/eslint/eslint/issues/14137
        it("should create .eslintrc.cjs", async () => {
            answers.format = "JavaScript";

            // create package.json with "type": "module"
            pkgJSONContents.type = "module";

            fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSONContents));

            const config = init.processAnswers(answers);
            const filePath = path.resolve(fixtureDir, ".eslintrc.cjs");

            await init.writeFile(config, answers.format);

            assert.isTrue(fs.existsSync(filePath));

            fs.unlinkSync(filePath);
            fs.unlinkSync(pkgJSONPath);
        });

        it("should create .eslintrc.json even with type: 'module'", async () => {
            answers.format = "JSON";

            // create package.json with "type": "module"
            pkgJSONContents.type = "module";

            fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSONContents));

            const config = init.processAnswers(answers);
            const filePath = path.resolve(fixtureDir, ".eslintrc.json");

            await init.writeFile(config, answers.format);

            assert.isTrue(fs.existsSync(filePath));

            fs.unlinkSync(filePath);
            fs.unlinkSync(pkgJSONPath);
        });
    });
});