276 lines
13 KiB
JavaScript
Executable file
276 lines
13 KiB
JavaScript
Executable file
/**
|
|
* @fileoverview Tests for prefer-arrow-functions rule.
|
|
* @author Triston Jones
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const singleReturnOnly = (code, extraRuleOptions) => ({
|
|
code,
|
|
options: [Object.assign({singleReturnOnly: true}, extraRuleOptions)],
|
|
parserOptions: {sourceType: 'module'}
|
|
});
|
|
|
|
var rule = require('../../../lib/rules/prefer-arrow-functions'),
|
|
RuleTester = require('eslint').RuleTester;
|
|
|
|
var tester = new RuleTester({parserOptions: {ecmaVersion: 6}});
|
|
tester.run('lib/rules/prefer-arrow-functions', rule, {
|
|
parserOptions: {ecmaVersion: 6},
|
|
valid: [
|
|
'var foo = (bar) => bar;',
|
|
'var foo = bar => bar;',
|
|
'var foo = bar => { return bar; }',
|
|
'var foo = () => 1;',
|
|
'var foo = (bar, fuzz) => bar + fuzz',
|
|
'["Hello", "World"].reduce((p, a) => p + " " + a);',
|
|
'var foo = (...args) => args',
|
|
'class obj {constructor(foo){this.foo = foo;}}; obj.prototype.func = function() {};',
|
|
'class obj {constructor(foo){this.foo = foo;}}; obj.prototype = {func: function() {}};',
|
|
'var foo = function() { return this.bar; };',
|
|
'function * testGenerator() { return yield 1; }',
|
|
'const foo = { get bar() { return "test"; } }',
|
|
'const foo = { set bar(xyz) {} }',
|
|
'class foo { get bar() { return "test"; } }',
|
|
'class foo { set bar(xyz) { } }',
|
|
'class foo { bar() { return "test" } }',
|
|
...[
|
|
'var foo = (bar) => {return bar();}',
|
|
'function foo(bar) {bar()}',
|
|
'var x = function foo(bar) {bar()}',
|
|
'var x = function(bar) {bar()}',
|
|
'function foo(bar) {/* yo */ bar()}',
|
|
'function foo() {}',
|
|
'function foo(bar) {bar(); return bar()}',
|
|
'class MyClass { foo(bar) {bar(); return bar()} }',
|
|
'var MyClass = { foo(bar) {bar(); return bar()} }',
|
|
'export default function xyz() { return 3; }',
|
|
'class MyClass { render(a, b) { return 3; } }'
|
|
].map(singleReturnOnly),
|
|
...[
|
|
'const foo = async bar => bar;',
|
|
'const foo = async bar => await Promise.resolve(2);',
|
|
'const foo = async (a, b) => { return await Promise.resolve(2); }',
|
|
'class MyClass { async foo(bar) { return bar; } }',
|
|
].map(code => ({ code, parserOptions: { ecmaVersion: 2017 } })),
|
|
|
|
// Valid tests for "allowStandaloneDeclarations" option
|
|
{code: 'function foo() { return "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'function * fooGen() { return yield "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'async function foo() { return await "bar"; }', options: [{ allowStandaloneDeclarations: true }], parserOptions: { ecmaVersion: 2017 }},
|
|
{code: 'function foo() { return () => "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'module.exports = function() { return "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'module.exports.foo = function() { return "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'exports.foo = function() { return "bar"; }', options: [{ allowStandaloneDeclarations: true }]},
|
|
{
|
|
code: 'export function foo() { return "bar"; }',
|
|
options: [{ allowStandaloneDeclarations: true }],
|
|
parserOptions: { sourceType: 'module'},
|
|
},
|
|
{
|
|
code: 'export default function() { return "bar"; }',
|
|
options: [{ allowStandaloneDeclarations: true }],
|
|
parserOptions: { sourceType: 'module'},
|
|
},
|
|
{
|
|
code: 'export default function foo() { return "bar"; }',
|
|
options: [{ allowStandaloneDeclarations: true }],
|
|
parserOptions: { sourceType: 'module'},
|
|
},
|
|
{
|
|
// Make sure "allowStandaloneDeclarations" works with typescript
|
|
code: 'function foo(a: string): string { return `bar ${a}`;}',
|
|
options: [{ allowStandaloneDeclarations: true }],
|
|
parser: require.resolve('@typescript-eslint/parser')
|
|
},
|
|
|
|
{
|
|
code: 'class MyClass { constructor() { this.x = 0; } add = (y) => { this.x += y; }; }',
|
|
options: [{ classPropertiesAllowed: true }],
|
|
parser: require.resolve('babel-eslint')
|
|
}
|
|
],
|
|
invalid: [
|
|
{code: 'function foo() { return "Hello!"; }', errors: ['Use const or class constructors instead of named functions']},
|
|
{code: 'function foo() { return arguments; }', errors: ['Use const or class constructors instead of named functions']},
|
|
{code: 'var foo = function() { return "World"; }', errors: ['Prefer using arrow functions over plain functions']},
|
|
{code: '["Hello", "World"].reduce(function(a, b) { return a + " " + b; })', errors: ['Prefer using arrow functions over plain functions']},
|
|
{code: 'class obj {constructor(foo){this.foo = foo;}}; obj.prototype.func = function() {};', errors: ['Prefer using arrow functions over plain functions'], options: [{disallowPrototype:true}]},
|
|
|
|
// Invalid tests for "allowStandaloneDeclarations" option
|
|
{code: 'var foo = function() { return "bar"; }', errors: ['Prefer using arrow functions over plain functions'], options: [{ allowStandaloneDeclarations: true }]},
|
|
{code: 'class FooClass { foo() { return "bar" }}', errors: ['Prefer using arrow functions over plain functions'], options: [{ allowStandaloneDeclarations: true, classPropertiesAllowed: true }]},
|
|
{code: 'exports = function() { return "bar"; }', options: [{ allowStandaloneDeclarations: true }], errors: ['Prefer using arrow functions over plain functions']},
|
|
{
|
|
// We are using multiple lines to check that it only errors on the inner function
|
|
code: `function top() {
|
|
return function inner() { return "bar"; };
|
|
}`,
|
|
errors: [{ message: 'Prefer using arrow functions over plain functions', line: 2 }],
|
|
options: [{ allowStandaloneDeclarations: true }]
|
|
},
|
|
{
|
|
// Make sure "allowStandaloneDeclarations" works with typescript
|
|
code: `function foo(a: string): () => string {
|
|
return function() { return \`bar \${a}\`; };
|
|
}`,
|
|
errors: [{ message: 'Prefer using arrow functions over plain functions', line: 2}],
|
|
options: [{ allowStandaloneDeclarations: true }],
|
|
parser: require.resolve('@typescript-eslint/parser')
|
|
},
|
|
|
|
...[
|
|
// Make sure it works with ES6 classes & functions declared in object literals (Babel only)
|
|
[
|
|
'class MyClass { render(a, b) { return 3; } }',
|
|
'class MyClass { render = (a, b) => 3; }',
|
|
{ classPropertiesAllowed: true },
|
|
{ parser: require.resolve('babel-eslint') },
|
|
],
|
|
[
|
|
'class MyClass { async render(a, b) { return 3; } }',
|
|
'class MyClass { render = async (a, b) => 3; }',
|
|
{ classPropertiesAllowed: true },
|
|
{ parser: require.resolve('babel-eslint') },
|
|
],
|
|
[
|
|
'class MyClass {async render(a, b) { return 3; } }',
|
|
'class MyClass {render = async (a, b) => 3; }',
|
|
{ classPropertiesAllowed: true },
|
|
{ parser: require.resolve('babel-eslint') },
|
|
],
|
|
['var MyClass = { render(a, b) { return 3; }, b: false }', 'var MyClass = { render: (a, b) => 3, b: false }'],
|
|
['const foo = { barProp() { return "bar"; } };', 'const foo = { barProp: () => "bar" };'],
|
|
// Make sure named function declarations work
|
|
['function foo() { return 3; }', 'const foo = () => 3;'],
|
|
['function foo(a) { return 3 }', 'const foo = (a) => 3;'],
|
|
['function foo(a) { return 3; }', 'const foo = (a) => 3;'],
|
|
|
|
// Eslint treats export default as a special form of function declaration
|
|
['export default function() { return 3; }', 'export default () => 3;'],
|
|
|
|
// Sanity check - make sure complex logic works
|
|
['function foo(a) { return a && (3 + a()) ? true : 99; }', 'const foo = (a) => a && (3 + a()) ? true : 99;'],
|
|
|
|
// Make sure function expressions work
|
|
['var foo = function() { return "World"; }', 'var foo = () => "World"'],
|
|
['var foo = function() { return "World"; };', 'var foo = () => "World";'],
|
|
['var foo = function x() { return "World"; };', 'var foo = () => "World";'],
|
|
|
|
// Make sure we wrap object literal returns in parens
|
|
['var foo = function() { return {a: false} }', 'var foo = () => ({a: false})'],
|
|
['var foo = function() { return {a: false}; }', 'var foo = () => ({a: false})'],
|
|
['function foo(a) { return {a: false}; }', 'const foo = (a) => ({a: false});'],
|
|
['function foo(a) { return {a: false} }', 'const foo = (a) => ({a: false});'],
|
|
|
|
// Make sure we treat inner functions properly
|
|
['var foo = function () { return function(a) { a() } }', 'var foo = () => function(a) { a() }'],
|
|
['var foo = function () { return () => false }', 'var foo = () => () => false'],
|
|
|
|
// Make sure we don't obliterate comments/whitespace and only remove newlines when appropriate
|
|
['var foo = function() {\n return "World";\n}', 'var foo = () => "World"'],
|
|
['var foo = function() {\n return "World"\n}', 'var foo = () => "World"'],
|
|
['function foo(a) {\n return 3;\n}', 'const foo = (a) => 3;'],
|
|
['function foo(a) {\n return 3\n}', 'const foo = (a) => 3;'],
|
|
[
|
|
'/*1*/var/*2*/ /*3*/foo/*4*/ /*5*/=/*6*/ /*7*/function/*8*/ /*9*/x/*10*/(/*11*/a/*12*/, /*13*/b/*14*/)/*15*/ /*16*/{/*17*/ /*18*/return/*19*/ /*20*/false/*21*/;/*22*/ /*23*/}/*24*/;/*25*/',
|
|
'/*1*/var/*2*/ /*3*/foo/*4*/ /*5*/=/*6*/ /*7*//*8*/ /*9*//*10*/(/*11*/a/*12*/, /*13*/b/*14*/)/*15*/ /*16*/=> /*17*/ /*18*//*19*/ /*20*/false/*21*//*22*/ /*23*//*24*/;/*25*/',
|
|
],
|
|
[
|
|
'/*1*/function/*2*/ /*3*/foo/*4*/(/*5*/a/*6*/)/*7*/ /*8*/\{/*9*/ /*10*/return/*11*/ /*12*/false/*13*/;/*14*/ /*15*/}/*16*/',
|
|
'/*1*/const/*2*/ /*3*/foo/*4*/ = (/*5*/a/*6*/)/*7*/ /*8*/=> /*9*/ /*10*//*11*/ /*12*/false/*13*//*14*/ /*15*/;/*16*/'
|
|
],
|
|
|
|
// Make sure we don't mess up inner generator functions
|
|
[
|
|
'function foo() { return function * gen() { return yield 1; }; }',
|
|
'const foo = () => function * gen() { return yield 1; };'
|
|
],
|
|
|
|
// Make sure we don't mess with the semicolon in for statements
|
|
[
|
|
'function withLoop() { return () => { for (i = 0; i < 5; i++) {}}}',
|
|
'const withLoop = () => () => { for (i = 0; i < 5; i++) {}};'
|
|
],
|
|
[
|
|
'var withLoop = function() { return () => { for (i = 0; i < 5; i++) {}}}',
|
|
'var withLoop = () => () => { for (i = 0; i < 5; i++) {}}'
|
|
],
|
|
[
|
|
'function withLoop() { return () => { for (i = 0; i < 5; i++) {}} /* foo */; }',
|
|
'const withLoop = () => () => { for (i = 0; i < 5; i++) {}} /* foo */;'
|
|
],
|
|
|
|
// Support async / await syntax
|
|
...[
|
|
['async function foo() { return "bar" }', 'const foo = async () => "bar";'],
|
|
['var foo = async function() { return "bar" };', 'var foo = async () => "bar";'],
|
|
[
|
|
'async function foo() { return await Promise.resolve("bar"); }',
|
|
'const foo = async () => await Promise.resolve("bar");'
|
|
],
|
|
[
|
|
'var foo = async function() { return await Promise.resolve("bar") };',
|
|
'var foo = async () => await Promise.resolve("bar");'
|
|
],
|
|
].map(asyncTest => [...asyncTest, null, { parserOptions: { ecmaVersion: 2017 } }]),
|
|
|
|
// Support fixes with typescript typings
|
|
...[
|
|
[
|
|
'const foo = { bar(x: string) { return "bar"; } }',
|
|
'const foo = { bar: (x: string) => "bar" }'
|
|
],
|
|
[
|
|
'const foo = { bar(x: string): string { return "bar"; } }',
|
|
'const foo = { bar: (x: string): string => "bar" }'
|
|
],
|
|
[
|
|
'function foo(x: string): string { return x; }',
|
|
'const foo = (x: string): string => x;'
|
|
],
|
|
[
|
|
'async function foo(x: number): Promise<number> { return x; }',
|
|
'const foo = async (x: number): Promise<number> => x;'
|
|
],
|
|
[
|
|
'const nested = { foo: { bar(name: string) { return name; } } }',
|
|
'const nested = { foo: { bar: (name: string) => name } }',
|
|
],
|
|
[
|
|
'const foo = function x(n: number): number { return n + 1; };',
|
|
'const foo = (n: number): number => n + 1;',
|
|
],
|
|
[
|
|
'export function test(str: string): string { return str; }',
|
|
'export const test = (str: string): string => str;',
|
|
],
|
|
[
|
|
'function str(n: number) { return n as string; }',
|
|
'const str = (n: number) => n as string;',
|
|
]
|
|
].map(test => [...test, null, { parser: require.resolve('@typescript-eslint/parser') }])
|
|
].map(inputOutput => Object.assign(
|
|
{
|
|
errors: ['Prefer using arrow functions over plain functions which only return a value'],
|
|
output: inputOutput[1],
|
|
...(inputOutput[3] || {}),
|
|
},
|
|
{
|
|
...singleReturnOnly(inputOutput[0], inputOutput[2]),
|
|
parserOptions: {
|
|
...singleReturnOnly(inputOutput[0], inputOutput[2]).parserOptions,
|
|
...((inputOutput[3] || {}).parserOptions || {})
|
|
},
|
|
}
|
|
)),
|
|
|
|
{
|
|
code: 'class MyClass { constructor() { this.x = 0; } add(y) { this.x += y; } }',
|
|
errors: ['Prefer using arrow functions over plain functions'],
|
|
options: [{ classPropertiesAllowed: true }],
|
|
parser: require.resolve('babel-eslint')
|
|
}
|
|
]
|
|
});
|