Fix: Check for arrow functions in utils.getAssertContextNameForTest (#…

…214) * Fix: Check for arrow functions in utils.getAssertContextNameForTest Fixes #213 * Add tests to other affected rules
qunitjs · Nov 3, 2021 · ad5f79f · ad5f79f
1 parent 34968fe
commit ad5f79f
Show file tree

Hide file tree

Showing 18 changed files with 280 additions and 120 deletions.
diff --git a/lib/utils.js b/lib/utils.js
@@ -218,7 +218,7 @@ exports.isSkip = function (calleeNode) {
 
 exports.getAssertContextNameForTest = function (argumentsNodes) {
     const functionExpr = argumentsNodes.find(function (argNode) {
-        return argNode.type === "FunctionExpression";
+        return argNode.type === "FunctionExpression" || argNode.type === "ArrowFunctionExpression";
     });
 
     return this.getAssertContextName(functionExpr);

diff --git a/tests/lib/rules/assert-args.js b/tests/lib/rules/assert-args.js
@@ -19,6 +19,10 @@ function wrap(assertionCode, testName = "Name") {
     return `QUnit.test('${testName}', function (assert) { ${assertionCode} });`;
 }
 
+function wrapArrow(assertionCode, testName = "Name") {
+    return `QUnit.test('${testName}', (assert) => { ${assertionCode} });`;
+}
+
 //------------------------------------------------------------------------------
 // Tests
 //------------------------------------------------------------------------------
@@ -377,6 +381,17 @@ ruleTester.run("assert-args", rule, {
                 }
             }]
         },
+        {
+            code: wrapArrow("assert.strictEqual();"),
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "unexpectedArgCountNoMessage",
+                data: {
+                    callee: "assert.strictEqual",
+                    argCount: 0
+                }
+            }]
+        },
         {
             code: wrap("assert.strictEqual(a);"),
             errors: [{

diff --git a/tests/lib/rules/literal-compare-order.js b/tests/lib/rules/literal-compare-order.js
@@ -19,6 +19,10 @@ function wrap(assertionCode, testName = "Name") {
     return `QUnit.test('${testName}', function (assert) { ${assertionCode} });`;
 }
 
+function wrapArrow(assertionCode, testName = "Name") {
+    return `QUnit.test('${testName}', (assert) => { ${assertionCode} });`;
+}
+
 //------------------------------------------------------------------------------
 // Tests
 //------------------------------------------------------------------------------
@@ -115,6 +119,18 @@ ruleTester.run("literal-compare-order", rule, {
                 }
             }]
         },
+        {
+            code: wrapArrow("assert.equal('Literal', variable);"),
+            output: wrapArrow("assert.equal(variable, 'Literal');"),
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "actualFirst",
+                data: {
+                    expected: "'Literal'",
+                    actual: "variable"
+                }
+            }]
+        },
         {
             code: wrap("assert.equal('Literal', variable, 'message');"),
             output: wrap("assert.equal(variable, 'Literal', 'message');"),

diff --git a/tests/lib/rules/no-assert-equal-boolean.js b/tests/lib/rules/no-assert-equal-boolean.js
@@ -62,6 +62,12 @@ ruleTester.run("no-assert-equal-boolean", rule, {
             output: "QUnit.test('Name', function (assert) { assert.true(a); });",
             errors: [{ messageId: "useAssertTrueOrFalse" }]
         },
+        {
+            code: "QUnit.test('Name', (assert) => { assert.equal(a, true); });",
+            output: "QUnit.test('Name', (assert) => { assert.true(a); });",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ messageId: "useAssertTrueOrFalse" }]
+        },
         {
             code: "QUnit.test('Name', function (assert) { assert.equal(a, false); });",
             output: "QUnit.test('Name', function (assert) { assert.false(a); });",

diff --git a/tests/lib/rules/no-assert-equal.js b/tests/lib/rules/no-assert-equal.js
@@ -64,6 +64,28 @@ ruleTester.run("no-assert-equal", rule, {
                 ]
             }]
         },
+        {
+            code: "QUnit.test('Name', (assert) => { assert.equal(a, b); });",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "unexpectedAssertEqual",
+                data: { assertVar: "assert" },
+                suggestions: [
+                    {
+                        messageId: "switchToDeepEqual",
+                        output: "QUnit.test('Name', (assert) => { assert.deepEqual(a, b); });"
+                    },
+                    {
+                        messageId: "switchToPropEqual",
+                        output: "QUnit.test('Name', (assert) => { assert.propEqual(a, b); });"
+                    },
+                    {
+                        messageId: "switchToStrictEqual",
+                        output: "QUnit.test('Name', (assert) => { assert.strictEqual(a, b); });"
+                    }
+                ]
+            }]
+        },
         {
             code: "QUnit.test('Name', function (foo) { foo.equal(a, b); });",
             errors: [{

diff --git a/tests/lib/rules/no-assert-logical-expression.js b/tests/lib/rules/no-assert-logical-expression.js
@@ -19,6 +19,10 @@ function wrap(code) {
     return `QUnit.test('test', function (assert) { ${code} });`;
 }
 
+function wrapArrow(code) {
+    return `QUnit.test('test', (assert) => { ${code} });`;
+}
+
 //------------------------------------------------------------------------------
 // Tests
 //------------------------------------------------------------------------------
@@ -68,6 +72,19 @@ ruleTester.run("no-assert-logical-expression", rule, {
                 column: 50
             }]
         },
+        {
+            code: wrapArrow("assert.ok(foo && bar);"),
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "noLogicalOperator",
+                data: {
+                    operator: "&&"
+                },
+                type: "LogicalExpression",
+                line: 1,
+                column: 44
+            }]
+        },
         {
             code: wrap("assert.ok(foo || bar);"),
             errors: [{

diff --git a/tests/lib/rules/no-assert-ok.js b/tests/lib/rules/no-assert-ok.js
@@ -47,6 +47,17 @@ ruleTester.run("no-assert-ok", rule, {
                 }
             }]
         },
+        {
+            code: "QUnit.test('Name', (assert) => { assert.ok(a); });",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "unexpectedLocalOkNotOk",
+                data: {
+                    assertVar: "assert",
+                    assertion: "ok"
+                }
+            }]
+        },
         {
             code: "QUnit.test('Name', function (foo) { foo.ok(a); });",
             errors: [{

diff --git a/tests/lib/rules/no-async-in-loops.js b/tests/lib/rules/no-async-in-loops.js
@@ -498,6 +498,18 @@ ruleTester.run("no-async-in-loops", rule, {
                 type: "CallExpression"
             }]
         },
+        {
+            code: "test('name', (assert) => { while (false) assert.async(); });",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "unexpectedAsyncInLoop",
+                data: {
+                    call: "assert.async()",
+                    loopTypeText: "while loop"
+                },
+                type: "CallExpression"
+            }]
+        },
         {
             code: "test('name', function (assert) { while (false) { assert.async(); } });",
             errors: [{