Reduce prefer-arrow-callback integration tests

Author: lo1tuma

documentation/rules/prefer-arrow-callback.md

@@ -6,9 +6,11 @@
 
 <!-- end auto-generated rule header -->
 
-This rule is a variation of the core eslint `prefer-arrow-callback` rule that is mocha-aware and does not flag non-arrow callbacks within mocha functions.
+This rule is a Mocha-aware drop-in replacement for ESLint's core
+[`prefer-arrow-callback`](https://eslint.org/docs/latest/rules/prefer-arrow-callback) rule.
 
-You will want to disable the original `prefer-arrow-callback` rule and configure the mocha-friendly replacement under the rules section.
+Use it instead of the core rule when linting Mocha tests. It keeps the core rule's behavior, options,
+and fixes, but does not report the callback functions passed directly to Mocha suites, tests, and hooks.
 
 ```json
 {
@@ -19,136 +21,55 @@ You will want to disable the original `prefer-arrow-callback` rule and configure
 }
 ```
 
-## Rule Overview
-
-Arrow functions can be an attractive alternative to function expressions for callbacks or function arguments.
-
-For example, arrow functions are automatically bound to their surrounding scope/context. This provides an alternative to the pre-ES6 standard of explicitly binding function expressions to achieve similar behavior.
-
-Additionally, arrow functions are:
-
-- less verbose, and easier to reason about.
-
-- bound lexically regardless of where or when they are invoked.
-
 ## Rule Details
 
-This rule locates function expressions used as callbacks or function arguments. An error will be produced for any that could be replaced by an arrow function without changing the result.
+This rule behaves like ESLint's core `prefer-arrow-callback`, except that direct callbacks for Mocha
+functions are allowed.
 
-The following examples **will** be flagged:
+These patterns are considered correct:
 
 ```js
 /* eslint mocha/prefer-arrow-callback: "error" */
 
-foo(function (a) {
-    return a;
-}); // ERROR
-// prefer: foo(a => a)
+describe("suite", function () {
+    beforeEach(function () {
+        setup();
+    });
 
-foo(function () {
-    return this.a;
-}
-    .bind(this)); // ERROR
-// prefer: foo(() => this.a)
+    it("works", function () {
+        runAssertion();
+    });
+});
 ```
 
-Instances where an arrow function would not produce identical results will be ignored.
-
-The following examples **will not** be flagged:
+Non-Mocha callbacks are still checked, even when they appear inside Mocha callbacks:
 
 ```js
 /* eslint mocha/prefer-arrow-callback: "error" */
-/* eslint-env es6 */
-
-// arrow function callback
-foo((a) => a); // OK
-
-// generator as callback
-foo(function* () {
-    yield;
-}); // OK
-
-// function expression not used as callback or function argument
-var foo = function foo(a) {
-    return a;
-}; // OK
-
-// unbound function expression callback
-foo(function () {
-    return this.a;
-}); // OK
-
-// recursive named function callback
-foo(function bar(n) {
-    return n && n + bar(n - 1);
-}); // OK
-
-// mocha suite definition callback
-describe('test suite', function () {
-    return Promise.resolve();
-}); // OK
-
-// mocha hook callback
-beforeEach('before each test', function () {
-    return Promise.resolve();
-}); // OK
-
-// mocha test case callback
-it('should resolve', function () {
-    return Promise.resolve();
-}); // OK
-```
-
-## Options
-
-Access further control over this rule's behavior via an options object.
-
-Default: `{ allowNamedFunctions: false, allowUnboundThis: true }`
-
-### allowNamedFunctions
 
-By default `{ "allowNamedFunctions": false }`, this `boolean` option prohibits using named functions as callbacks or function arguments.
-
-Changing this value to `true` will reverse this option's behavior by allowing use of named functions without restriction.
-
-`{ "allowNamedFunctions": true }` **will not** flag the following example:
-
-```js
-/* eslint mocha/prefer-arrow-callback: [ "error", { "allowNamedFunctions": true } ] */
-
-foo(function bar() {});
+it("works", function () {
+    foo(function () {
+        bar();
+    }); // ERROR
+});
 ```
 
-### allowUnboundThis
-
-By default `{ "allowUnboundThis": true }`, this `boolean` option allows function expressions containing `this` to be used as callbacks, as long as the function in question has not been explicitly bound.
-
-When set to `false` this option prohibits the use of function expressions as callbacks or function arguments entirely, without exception.
-
-`{ "allowUnboundThis": false }` **will** flag the following examples:
+## Options
 
-```js
-/* eslint mocha/prefer-arrow-callback: [ "error", { "allowUnboundThis": false } ] */
-/* eslint-env es6 */
+This rule supports the same options as ESLint's core
+[`prefer-arrow-callback`](https://eslint.org/docs/latest/rules/prefer-arrow-callback#options) rule:
 
-foo(function () {
-    this.a;
-});
+- `allowNamedFunctions`
+- `allowUnboundThis`
 
-foo(function () {
-    (() => this);
-});
-
-someArray.map(function (itm) {
-    return this.doSomething(itm);
-}, someObject);
-```
+The only behavior change is the Mocha-specific exemption described above.
 
 ## When Not To Use It
 
-- In environments that have not yet adopted ES6 language features (ES3/5).
-- In ES6+ environments that allow the use of function expressions when describing callbacks or function arguments.
+- If you are not linting Mocha code.
+- If you want the core rule to report Mocha suite, test, and hook callbacks as well.
 
 ## Further Reading
 
-- [More on ES6 arrow functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
+- [ESLint core `prefer-arrow-callback`](https://eslint.org/docs/latest/rules/prefer-arrow-callback)
+- [Mocha and arrow functions](https://mochajs.org/#arrow-functions)

source/rules/prefer-arrow-callback.test.ts

@@ -26,22 +26,10 @@ const errors: [RuleTester.TestCaseError] = [{
 
 ruleTester.run('prefer-arrow-callback', preferArrowCallbackRule, {
     valid: [
+        // Smoke tests for the core ESLint rule integration.
         'foo(a => a);',
         'foo(function*() {});',
-        'foo(function() { this; });',
         { code: 'foo(function bar() {});', options: [{ allowNamedFunctions: true }] },
-        'foo(function() { (() => this); });',
-        'foo(function() { this; }.bind(obj));',
-        'foo(function() { this; }.call(this));',
-        'foo(a => { (function() {}); });',
-        'var foo = function foo() {};',
-        '(function foo() {})();',
-        'foo(function bar() { bar; });',
-        'foo(function bar() { arguments; });',
-        'foo(function bar() { arguments; }.bind(this));',
-        'foo(function bar() { new.target; });',
-        'foo(function bar() { new.target; }.bind(this));',
-        'foo(function bar() { this; }.bind(this, somethingElse));',
         {
             code: 'import.meta.url',
             languageOptions: {
@@ -78,135 +66,31 @@ ruleTester.run('prefer-arrow-callback', preferArrowCallbackRule, {
         'xspecify("name", function bar() {});'
     ],
     invalid: [
-        {
-            code: 'foo(function bar() {});',
-            output: 'foo(() => {});',
-            errors
-        },
+        // Smoke tests for the core ESLint rule integration.
         {
             code: 'foo(function() {});',
             output: 'foo(() => {});',
-            options: [{ allowNamedFunctions: true }],
-            errors
-        },
-        {
-            code: 'foo(function bar() {});',
-            output: 'foo(() => {});',
-            options: [{ allowNamedFunctions: false }],
-            errors
-        },
-        {
-            code: 'foo(function() {});',
-            output: 'foo(() => {});',
-            errors
-        },
-        {
-            code: 'foo(nativeCb || function() {});',
-            output: 'foo(nativeCb || (() => {}));',
-            errors
-        },
-        {
-            code: 'foo(bar ? function() {} : function() {});',
-            output: 'foo(bar ? () => {} : () => {});',
-            errors: [errors[0], errors[0]]
-        },
-        {
-            code: 'foo(function() { (function() { this; }); });',
-            output: 'foo(() => { (function() { this; }); });',
-            errors
-        },
-        {
-            code: 'foo(function() { this; }.bind(this));',
-            output: 'foo(() => { this; });',
             errors
         },
         {
             code: 'foo(bar || function() { this; }.bind(this));',
             output: 'foo(bar || (() => { this; }));',
             errors
         },
-        {
-            code: 'foo(function() { (() => this); }.bind(this));',
-            output: 'foo(() => { (() => this); });',
-            errors
-        },
-        {
-            code: 'foo(function bar(a) { a; });',
-            output: 'foo((a) => { a; });',
-            errors
-        },
-        {
-            code: 'foo(function(a) { a; });',
-            output: 'foo((a) => { a; });',
-            errors
-        },
-        {
-            code: 'foo(function(arguments) { arguments; });',
-            output: 'foo((arguments) => { arguments; });',
-            errors
-        },
         {
             code: 'foo(function() { this; });',
             // No fix applied
             output: null,
             options: [{ allowUnboundThis: false }],
             errors
         },
-        {
-            code: 'foo(function() { (() => this); });',
-            // No fix applied
-            output: null,
-            options: [{ allowUnboundThis: false }],
-            errors
-        },
-        {
-            code: 'qux(function(foo, bar, baz) { return foo * 2; })',
-            output: 'qux((foo, bar, baz) => { return foo * 2; })',
-            errors
-        },
-        {
-            code: 'qux(function(foo, bar, baz) { return foo * bar; }.bind(this))',
-            output: 'qux((foo, bar, baz) => { return foo * bar; })',
-            errors
-        },
-        {
-            code: 'foo(function() {}.bind(this, somethingElse))',
-            output: 'foo((() => {}).bind(this, somethingElse))',
-            errors
-        },
-        {
-            code: "qux(function(foo = 1, [bar = 2] = [], {qux: baz = 3} = {foo: 'bar'}) { return foo + bar; });",
-            output: "qux((foo = 1, [bar = 2] = [], {qux: baz = 3} = {foo: 'bar'}) => { return foo + bar; });",
-            errors
-        },
-        {
-            code: 'qux(function(baz, baz) { })',
-            // Duplicate parameter names are a SyntaxError in arrow functions
-            output: null,
-            errors
-        },
-        {
-            code: 'qux(function( /* no params */ ) { })',
-            output: 'qux(( /* no params */ ) => { })',
-            errors
-        },
-        {
-            code: 'qux(function( /* a */ foo /* b */ , /* c */ bar /* d */ , /* e */ baz /* f */ ) { return foo; })',
-            output: 'qux(( /* a */ foo /* b */ , /* c */ bar /* d */ , /* e */ baz /* f */ ) => { return foo; })',
-            errors
-        },
         {
             code: 'qux(async function (foo = 1, bar = 2, baz = 3) { return baz; })',
             output: 'qux(async (foo = 1, bar = 2, baz = 3) => { return baz; })',
             languageOptions: { ecmaVersion: 8 },
             errors
         },
-        {
-            code: 'qux(async function (foo = 1, bar = 2, baz = 3) { return this; }.bind(this))',
-            output: 'qux(async (foo = 1, bar = 2, baz = 3) => { return this; })',
-            languageOptions: { ecmaVersion: 8 },
-            errors
-        },
+        // Mocha-specific behavior.
         {
             code: 'it("name", function() { foo(function() {}); });',
             output: 'it("name", function() { foo(() => {}); });',