feat(rules): add no-truthy-falsy rule

Fixes #204

Author: noahbenham

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

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);
+```

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,
  },
 };

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,
+ },
+ ],
+ },
+ ],
+});

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,
+ });
+ }
+ }
+ },
+ };
+ },
+};