New: Allow mocking the cwd in rule tester

lib/rule-tester/rule-tester.js

@@ -120,7 +120,8 @@ const RuleTesterParameters = [
     "filename",
     "options",
     "errors",
-    "output"
+    "output",
+    "cwd"
 ];
 
 /*
@@ -337,7 +338,6 @@ class RuleTester {
          * @type {Object}
          */
         this.rules = {};
-        this.linter = new Linter();
     }
 
     /**
@@ -416,21 +416,30 @@ class RuleTester {
      * @param {Function} rule The rule to test.
      * @param {{
      *   valid: (ValidTestCase | string)[],
-     *   invalid: InvalidTestCase[]
+     *   invalid: InvalidTestCase[],
+     *   linterMapDevOnly?: Map<string | undefined, Linter>
      * }} test The collection of tests to run.
+     * test.linterMapDevOnly is for testing purpose
      * @returns {void}
      */
     run(ruleName, rule, test) {
 
         const testerConfig = this.testerConfig,
             requiredScenarios = ["valid", "invalid"],
             scenarioErrors = [],
-            linter = this.linter;
+            rules = this.rules;
 
         if (lodash.isNil(test) || typeof test !== "object") {
             throw new TypeError(`Test Scenarios for rule ${ruleName} : Could not find test scenario object`);
         }
 
+        /**
+         * Linter map, cwd -> Linter instance
+         * Injection of value in `test` is for test purpose.
+         * @type {Map<string | undefined, Linter>}
+         */
+        const { linterMapDevOnly: linterMap = new Map() } = test;
+
         requiredScenarios.forEach(scenarioType => {
             if (lodash.isNil(test[scenarioType])) {
                 scenarioErrors.push(`Could not find any ${scenarioType} test scenarios`);
@@ -443,20 +452,32 @@ class RuleTester {
             ].concat(scenarioErrors).join("\n"));
         }
 
+        /**
+         * get linter from linterMap according to cwd
+         * @param {string} [cwd] cwd
+         * @returns {Linter} Linter instance
+         * @private
+         */
+        function getLinter(cwd) {
+            if (!linterMap.has(cwd)) {
+                const linter = new Linter({ cwd });
 
-        linter.defineRule(ruleName, Object.assign({}, rule, {
+                linter.defineRule(ruleName, Object.assign({}, rule, {
 
-            // Create a wrapper rule that freezes the `context` properties.
-            create(context) {
-                freezeDeeply(context.options);
-                freezeDeeply(context.settings);
-                freezeDeeply(context.parserOptions);
+                    // Create a wrapper rule that freezes the `context` properties.
+                    create(context) {
+                        freezeDeeply(context.options);
+                        freezeDeeply(context.settings);
+                        freezeDeeply(context.parserOptions);
 
-                return (typeof rule === "function" ? rule : rule.create)(context);
+                        return (typeof rule === "function" ? rule : rule.create)(context);
+                    }
+                }));
+                linter.defineRules(rules);
+                linterMap.set(cwd, linter);
             }
-        }));
-
-        linter.defineRules(this.rules);
+            return linterMap.get(cwd);
+        }
 
         /**
          * Run the rule for the given item
@@ -467,6 +488,7 @@ class RuleTester {
         function runRuleForItem(item) {
             let config = lodash.cloneDeep(testerConfig),
                 code, filename, output, beforeAST, afterAST;
+            const linter = getLinter(item.cwd);
 
             if (typeof item === "string") {
                 code = item;

tests/lib/rule-tester/rule-tester.js

@@ -10,6 +10,7 @@
 const sinon = require("sinon"),
     EventEmitter = require("events"),
     { RuleTester } = require("../../../lib/rule-tester"),
+    { Linter } = require("../../../lib/linter"),
     assert = require("chai").assert,
     nodeAssert = require("assert"),
     { noop } = require("lodash");
@@ -751,8 +752,15 @@ describe("RuleTester", () => {
     });
 
     it("should pass-through the parser to the rule", () => {
-        const spy = sinon.spy(ruleTester.linter, "verify");
-
+        const linter = new Linter();
+        const spy = sinon.spy(linter, "verify");
+        const linterMap = new Map([
+            // eslint-disable-next-line no-undefined
+            [undefined, linter]
+        ]);
+
+        // ruleTester = new RuleTester({ linterMapDevOnly: linterMap });
+        ruleTester = new RuleTester();
         ruleTester.run("no-eval", require("../../fixtures/testers/rule-tester/no-eval"), {
             valid: [
                 {
@@ -765,7 +773,8 @@ describe("RuleTester", () => {
                     parser: require.resolve("esprima"),
                     errors: [{ line: 1 }]
                 }
-            ]
+            ],
+            linterMapDevOnly: linterMap
         });
         assert.strictEqual(spy.args[1][1].parser, require.resolve("esprima"));
     });
@@ -890,6 +899,20 @@ describe("RuleTester", () => {
         }, /Property "env" is the wrong type./u);
     });
 
+    it("should pass-through the cwd to the linter", () => {
+        ruleTester.run("some-random-rule", ctx => {
+
+            assert.strictEqual(ctx.getCwd(), "myCwd");
+            return {};
+        }, {
+            valid: [{
+                code: "var test = 'foo'",
+                cwd: "myCwd"
+            }],
+            invalid: []
+        });
+    });
+
     it("should pass-through the tester config to the rule", () => {
         ruleTester = new RuleTester({
             globals: { test: true }