eslint-plugin-jest 22.0.0 → 22.1.2

package/README.md

@@ -105,6 +105,7 @@ for more information about extending configuration files.
 | [no-test-callback][]         | Using a callback in asynchronous tests                            |                  | ![fixable-green][]  |
 | [no-test-prefixes][]         | Disallow using `f` & `x` prefixes to define focused/skipped tests | ![recommended][] | ![fixable-green][]  |
 | [no-test-return-statement][] | Disallow explicitly returning from tests                          |                  |                     |
+| [no-truthy-falsy][]          | Disallow using `toBeTruthy()` & `toBeFalsy()`                     |                  |                     |
 | [prefer-expect-assertions][] | Suggest using `expect.assertions()` OR `expect.hasAssertions()`   |                  |                     |
 | [prefer-spy-on][]            | Suggest using `jest.spyOn()`                                      |                  | ![fixable-green][]  |
 | [prefer-strict-equal][]      | Suggest using `toStrictEqual()`                                   |                  | ![fixable-green][]  |
@@ -137,6 +138,7 @@ for more information about extending configuration files.
 [no-test-callback]: docs/rules/no-test-callback.md
 [no-test-prefixes]: docs/rules/no-test-prefixes.md
 [no-test-return-statement]: docs/rules/no-test-return-statement.md
+[no-truthy-falsy]: docs/rules/no-truthy-falsy.md
 [prefer-expect-assertions]: docs/rules/prefer-expect-assertions.md
 [prefer-spy-on]: docs/rules/prefer-spy-on.md
 [prefer-strict-equal]: docs/rules/prefer-strict-equal.md

package/docs/rules/no-jasmine-globals.md

@@ -3,7 +3,7 @@
 `jest` uses `jasmine` as a test runner. A side effect of this is that both a
 `jasmine` object, and some jasmine-specific globals, are exposed to the test
 environment. Most functionality offered by Jasmine has been ported to Jest, and
-the Jasmine globals will stop working in the future. Developers should therefor
+the Jasmine globals will stop working in the future. Developers should therefore
 migrate to Jest's documented API instead of relying on the undocumented Jasmine
 API.
 

package/docs/rules/no-truthy-falsy.md

@@ -0,0 +1,32 @@
+# Disallow using `toBeTruthy()` & `toBeFalsy()` (no-truthy-falsy)
+
+Tests against boolean values should assert true or false. Asserting `toBeTruthy`
+or `toBeFalsy` matches non-boolean values as well and encourages weaker tests.
+
+For example, `expect(someBoolean).toBeFalsy()` passes when
+`someBoolean === null`, and when `someBoolean === false`.
+
+Similarly, `expect(someBoolean).toBeTruthy()` passes when `someBoolean === []`,
+and when `someBoolean === 'false'` (note that `'false'` is a string).
+
+## Rule details
+
+This rule triggers a warning if `toBeTruthy()` or `toBeFalsy()` are used.
+
+This rule is disabled by default.
+
+### Default configuration
+
+The following patterns are considered warnings:
+
+```js
+expect(someValue).toBeTruthy();
+expect(someValue).toBeFalsy();
+```
+
+The following patterns are not considered warnings:
+
+```js
+expect(someValue).toBe(true);
+expect(someValue).toBe(false);
+```

package/index.js

@@ -26,6 +26,7 @@ const preferStrictEqual = require('./rules/prefer-strict-equal');
 const requireTothrowMessage = require('./rules/require-tothrow-message');
 const noAliasMethods = require('./rules/no-alias-methods');
 const noTestCallback = require('./rules/no-test-callback');
+const noTruthyFalsy = require('./rules/no-truthy-falsy');
 
 const snapshotProcessor = require('./processors/snapshot-processor');
 
@@ -112,5 +113,6 @@ module.exports = {
     'require-tothrow-message': requireTothrowMessage,
     'no-alias-methods': noAliasMethods,
     'no-test-callback': noTestCallback,
+    'no-truthy-falsy': noTruthyFalsy,
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "22.0.0",
+  "version": "22.1.2",
   "description": "Eslint rules for Jest",
   "repository": "jest-community/eslint-plugin-jest",
   "license": "MIT",

package/rules/__tests__/no-alias-methods.test.js

@@ -153,5 +153,41 @@ ruleTester.run('no-alias-methods', rule, {
       ],
       output: 'expect(a).toThrow()',
     },
+    {
+      code: 'expect(a).resolves.toThrowError()',
+      errors: [
+        {
+          message:
+            'Replace toThrowError() with its canonical name of toThrow()',
+          column: 20,
+          line: 1,
+        },
+      ],
+      output: 'expect(a).resolves.toThrow()',
+    },
+    {
+      code: 'expect(a).rejects.toThrowError()',
+      errors: [
+        {
+          message:
+            'Replace toThrowError() with its canonical name of toThrow()',
+          column: 19,
+          line: 1,
+        },
+      ],
+      output: 'expect(a).rejects.toThrow()',
+    },
+    {
+      code: 'expect(a).not.toThrowError()',
+      errors: [
+        {
+          message:
+            'Replace toThrowError() with its canonical name of toThrow()',
+          column: 15,
+          line: 1,
+        },
+      ],
+      output: 'expect(a).not.toThrow()',
+    },
   ],
 });

package/rules/__tests__/no-jasmine-globals.test.js

@@ -15,6 +15,9 @@ ruleTester.run('no-jasmine-globals', rule, {
     'test("foo", function () {})',
     'foo()',
     `require('foo')('bar')`,
+    'function callback(fail) { fail() }',
+    'var spyOn = require("actions"); spyOn("foo")',
+    'function callback(pending) { pending() }',
   ],
   invalid: [
     {

package/rules/__tests__/no-truthy-falsy.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const { RuleTester } = require('eslint');
+const rule = require('../no-truthy-falsy');
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-truthy-falsy', rule, {
+  valid: [
+    'expect(true).toBe(true);',
+    'expect(false).toBe(false);',
+    'expect("anything").toBe(true);',
+    'expect("anything").toEqual(false);',
+    'expect("anything").not.toBe(true);',
+    'expect("anything").not.toEqual(true);',
+    'expect(Promise.resolve({})).resolves.toBe(true);',
+    'expect(Promise.reject({})).rejects.toBe(true);',
+  ],
+
+  invalid: [
+    {
+      code: 'expect(true).toBeTruthy();',
+      errors: [
+        {
+          message: 'Avoid toBeTruthy',
+          column: 14,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(false).not.toBeTruthy();',
+      errors: [
+        {
+          message: 'Avoid toBeTruthy',
+          column: 19,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(Promise.resolve({})).resolves.toBeTruthy()',
+      errors: [
+        {
+          message: 'Avoid toBeTruthy',
+          column: 38,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(Promise.resolve({})).rejects.toBeTruthy()',
+      errors: [
+        {
+          message: 'Avoid toBeTruthy',
+          column: 37,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(false).toBeFalsy();',
+      errors: [
+        {
+          message: 'Avoid toBeFalsy',
+          column: 15,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(true).not.toBeFalsy();',
+      errors: [
+        {
+          message: 'Avoid toBeFalsy',
+          column: 18,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(Promise.resolve({})).resolves.toBeFalsy()',
+      errors: [
+        {
+          message: 'Avoid toBeFalsy',
+          column: 38,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'expect(Promise.resolve({})).rejects.toBeFalsy()',
+      errors: [
+        {
+          message: 'Avoid toBeFalsy',
+          column: 37,
+          line: 1,
+        },
+      ],
+    },
+  ],
+});

package/rules/__tests__/prefer-to-be-null.test.js

@@ -18,6 +18,7 @@ ruleTester.run('prefer-to-be-null', rule, {
     'expect("a string").toMatchSnapshot(null);',
     'expect("a string").not.toMatchSnapshot();',
     "expect(something).toEqual('a string');",
+    'expect(null).toBe',
   ],
 
   invalid: [

package/rules/__tests__/prefer-to-be-undefined.test.js

@@ -15,6 +15,7 @@ ruleTester.run('prefer-to-be-undefined', rule, {
     'expect(something).toEqual(somethingElse)',
     'expect(something).not.toBe(somethingElse)',
     'expect(something).not.toEqual(somethingElse)',
+    'expect(undefined).toBe',
   ],
 
   invalid: [

package/rules/no-alias-methods.js

@@ -32,9 +32,19 @@ module.exports = {
           return;
         }
 
-        // Check if the method used matches any of ours.
-        const propertyName = method(node) && method(node).name;
-        const methodItem = methodNames.find(item => item[1] === propertyName);
+        let targetNode = method(node);
+        if (
+          targetNode.name === 'resolves' ||
+          targetNode.name === 'rejects' ||
+          targetNode.name === 'not'
+        ) {
+          targetNode = method(node.parent);
+        }
+
+        // Check if the method used matches any of ours
+        const methodItem = methodNames.find(
+          item => item[1] === targetNode.name
+        );
 
         if (methodItem) {
           context.report({
@@ -43,9 +53,9 @@ module.exports = {
               replace: methodItem[1],
               canonical: methodItem[0],
             },
-            node: method(node),
+            node: targetNode,
             fix(fixer) {
-              return [fixer.replaceText(method(node), methodItem[0])];
+              return [fixer.replaceText(targetNode, methodItem[0])];
             },
           });
         }

package/rules/no-disabled-tests.js

@@ -1,33 +1,6 @@
 'use strict';
 
-const { getDocsUrl, getNodeName } = require('./util');
-
-function collectReferences(scope) {
-  const locals = new Set();
-  const unresolved = new Set();
-
-  let currentScope = scope;
-
-  while (currentScope !== null) {
-    for (const ref of currentScope.variables) {
-      const isReferenceDefined = ref.defs.some(def => {
-        return def.type !== 'ImplicitGlobalVariable';
-      });
-
-      if (isReferenceDefined) {
-        locals.add(ref.name);
-      }
-    }
-
-    for (const ref of currentScope.through) {
-      unresolved.add(ref.identifier.name);
-    }
-
-    currentScope = currentScope.upper;
-  }
-
-  return { locals, unresolved };
-}
+const { getDocsUrl, getNodeName, scopeHasLocalReference } = require('./util');
 
 module.exports = {
   meta: {
@@ -67,15 +40,7 @@ module.exports = {
         }
       },
       'CallExpression[callee.name="pending"]'(node) {
-        const references = collectReferences(context.getScope());
-
-        if (
-          // `pending` was found as a local variable or function declaration.
-          references.locals.has('pending') ||
-          // `pending` was not found as an unresolved reference,
-          // meaning it is likely not an implicit global reference.
-          !references.unresolved.has('pending')
-        ) {
+        if (scopeHasLocalReference(context.getScope(), 'pending')) {
           return;
         }
 

package/rules/no-jasmine-globals.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getDocsUrl, getNodeName } = require('./util');
+const { getDocsUrl, getNodeName, scopeHasLocalReference } = require('./util');
 
 module.exports = {
   meta: {
@@ -8,6 +8,17 @@ module.exports = {
       url: getDocsUrl(__filename),
     },
     fixable: 'code',
+    messages: {
+      illegalGlobal:
+        'Illegal usage of global `{{ global }}`, prefer `{{ replacement }}`',
+      illegalMethod:
+        'Illegal usage of `{{ method }}`, prefer `{{ replacement }}`',
+      illegalFail:
+        'Illegal usage of `fail`, prefer throwing an error, or the `done.fail` callback',
+      illegalPending:
+        'Illegal usage of `pending`, prefer explicitly skipping a test using `test.skip`',
+      illegalJasmine: 'Illegal usage of jasmine global',
+    },
   },
   create(context) {
     return {
@@ -17,30 +28,39 @@ module.exports = {
         if (!calleeName) {
           return;
         }
+        if (
+          calleeName === 'spyOn' ||
+          calleeName === 'spyOnProperty' ||
+          calleeName === 'fail' ||
+          calleeName === 'pending'
+        ) {
+          if (scopeHasLocalReference(context.getScope(), calleeName)) {
+            // It's a local variable, not a jasmine global.
+            return;
+          }
 
-        if (calleeName === 'spyOn' || calleeName === 'spyOnProperty') {
-          context.report({
-            node,
-            message: `Illegal usage of global \`${calleeName}\`, prefer \`jest.spyOn\``,
-          });
-          return;
-        }
-
-        if (calleeName === 'fail') {
-          context.report({
-            node,
-            message:
-              'Illegal usage of `fail`, prefer throwing an error, or the `done.fail` callback',
-          });
-          return;
-        }
-
-        if (calleeName === 'pending') {
-          context.report({
-            node,
-            message:
-              'Illegal usage of `pending`, prefer explicitly skipping a test using `test.skip`',
-          });
+          switch (calleeName) {
+            case 'spyOn':
+            case 'spyOnProperty':
+              context.report({
+                node,
+                messageId: 'illegalGlobal',
+                data: { global: calleeName, replacement: 'jest.spyOn' },
+              });
+              break;
+            case 'fail':
+              context.report({
+                node,
+                messageId: 'illegalFail',
+              });
+              break;
+            case 'pending':
+              context.report({
+                node,
+                messageId: 'illegalPending',
+              });
+              break;
+          }
           return;
         }
 
@@ -59,7 +79,11 @@ module.exports = {
                 return [fixer.replaceText(node.callee.object, 'expect')];
               },
               node,
-              message: `Illegal usage of \`${calleeName}\`, prefer \`expect.${functionName}\``,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: `expect.${functionName}`,
+              },
             });
             return;
           }
@@ -67,7 +91,11 @@ module.exports = {
           if (functionName === 'addMatchers') {
             context.report({
               node,
-              message: `Illegal usage of \`${calleeName}\`, prefer \`expect.extend\``,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: `expect.extend`,
+              },
             });
             return;
           }
@@ -75,14 +103,18 @@ module.exports = {
           if (functionName === 'createSpy') {
             context.report({
               node,
-              message: `Illegal usage of \`${calleeName}\`, prefer \`jest.fn\``,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: 'jest.fn',
+              },
             });
             return;
           }
 
           context.report({
             node,
-            message: 'Illegal usage of jasmine global',
+            messageId: 'illegalJasmine',
           });
         }
       },

package/rules/no-truthy-falsy.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {
+  getDocsUrl,
+  expectCase,
+  expectNotCase,
+  expectResolveCase,
+  expectRejectCase,
+  method,
+} = require('./util');
+
+module.exports = {
+  meta: {
+    docs: {
+      url: getDocsUrl(__filename),
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (
+          expectCase(node) ||
+          expectNotCase(node) ||
+          expectResolveCase(node) ||
+          expectRejectCase(node)
+        ) {
+          const targetNode =
+            node.parent.parent.type === 'MemberExpression' ? node.parent : node;
+
+          const methodNode = method(targetNode);
+          const { name: methodName } = methodNode;
+
+          if (methodName === 'toBeTruthy' || methodName === 'toBeFalsy') {
+            context.report({
+              data: { methodName },
+              message: 'Avoid {{methodName}}',
+              node: methodNode,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/util.js

@@ -73,9 +73,11 @@ const methodName = node => method(node).name;
 
 const methodName2 = node => method2(node).name;
 
-const argument = node => node.parent.parent.arguments[0];
+const argument = node =>
+  node.parent.parent.arguments && node.parent.parent.arguments[0];
 
-const argument2 = node => node.parent.parent.parent.arguments[0];
+const argument2 = node =>
+  node.parent.parent.parent.arguments && node.parent.parent.parent.arguments[0];
 
 const describeAliases = Object.assign(Object.create(null), {
   describe: true,
@@ -142,6 +144,44 @@ const getDocsUrl = filename => {
   return `${REPO_URL}/blob/v${version}/docs/rules/${ruleName}.md`;
 };
 
+const collectReferences = scope => {
+  const locals = new Set();
+  const unresolved = new Set();
+
+  let currentScope = scope;
+
+  while (currentScope !== null) {
+    for (const ref of currentScope.variables) {
+      const isReferenceDefined = ref.defs.some(def => {
+        return def.type !== 'ImplicitGlobalVariable';
+      });
+
+      if (isReferenceDefined) {
+        locals.add(ref.name);
+      }
+    }
+
+    for (const ref of currentScope.through) {
+      unresolved.add(ref.identifier.name);
+    }
+
+    currentScope = currentScope.upper;
+  }
+
+  return { locals, unresolved };
+};
+
+const scopeHasLocalReference = (scope, referenceName) => {
+  const references = collectReferences(scope);
+  return (
+    // referenceName was found as a local variable or function declaration.
+    references.locals.has(referenceName) ||
+    // referenceName was not found as an unresolved reference,
+    // meaning it is likely not an implicit global reference.
+    !references.unresolved.has(referenceName)
+  );
+};
+
 module.exports = {
   method,
   method2,
@@ -160,4 +200,5 @@ module.exports = {
   isFunction,
   isTestCase,
   getDocsUrl,
+  scopeHasLocalReference,
 };