Refactor prefer rules (#26)

xfumihiro · SimenB · commit bc74d338533e · 2017-12-04T16:11:53.000+01:00
diff --git a/rules/__tests__/prefer_to_be_undefined.test.js b/rules/__tests__/prefer_to_be_undefined.test.js
@@ -6,7 +6,10 @@ const rules = require('../../').rules;
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer_to_be_undefined', rules['prefer-to-be-undefined'], {
-  valid: ['expect(undefined).toBeUndefined();'],
+  valid: [
+    'expect(undefined).toBeUndefined();',
+    'expect(true).not.toBeUndefined();',
+  ],
 
   invalid: [
     {
diff --git a/rules/prefer_to_be_null.js b/rules/prefer_to_be_null.js
@@ -1,36 +1,23 @@
 'use strict';
+const argument = require('./util').argument;
+const expectToBeCase = require('./util').expectToBeCase;
+const expectToEqualCase = require('./util').expectToEqualCase;
+const method = require('./util').method;
 
 module.exports = context => {
   return {
     CallExpression(node) {
-      const calleeName = node.callee.name;
-
-      if (
-        calleeName === 'expect' &&
-        node.arguments.length == 1 &&
-        node.parent &&
-        node.parent.type === 'MemberExpression' &&
-        node.parent.parent
-      ) {
-        const parentProperty = node.parent.property;
-        const propertyName = parentProperty.name;
-        const argument = node.parent.parent.arguments[0];
-
-        if (
-          (propertyName === 'toBe' || propertyName === 'toEqual') &&
-          argument.value === null
-        ) {
-          context.report({
-            fix(fixer) {
-              return [
-                fixer.replaceText(parentProperty, 'toBeNull'),
-                fixer.remove(argument),
-              ];
-            },
-            message: 'Use toBeNull() instead',
-            node: parentProperty,
-          });
-        }
+      if (expectToBeCase(node, null) || expectToEqualCase(node, null)) {
+        context.report({
+          fix(fixer) {
+            return [
+              fixer.replaceText(method(node), 'toBeNull'),
+              fixer.remove(argument(node)),
+            ];
+          },
+          message: 'Use toBeNull() instead',
+          node: method(node),
+        });
       }
     },
   };
diff --git a/rules/prefer_to_be_undefined.js b/rules/prefer_to_be_undefined.js
@@ -1,36 +1,26 @@
 'use strict';
+const argument = require('./util').argument;
+const expectToBeCase = require('./util').expectToBeCase;
+const expectToEqualCase = require('./util').expectToEqualCase;
+const method = require('./util').method;
 
 module.exports = context => {
   return {
     CallExpression(node) {
-      const calleeName = node.callee.name;
-
       if (
-        calleeName === 'expect' &&
-        node.arguments.length == 1 &&
-        node.parent &&
-        node.parent.type === 'MemberExpression' &&
-        node.parent.parent
+        expectToBeCase(node, undefined) ||
+        expectToEqualCase(node, undefined)
       ) {
-        const parentProperty = node.parent.property;
-        const propertyName = parentProperty.name;
-        const argument = node.parent.parent.arguments[0];
-
-        if (
-          (propertyName === 'toBe' || propertyName === 'toEqual') &&
-          argument.value === undefined
-        ) {
-          context.report({
-            fix(fixer) {
-              return [
-                fixer.replaceText(parentProperty, 'toBeUndefined'),
-                fixer.remove(argument),
-              ];
-            },
-            message: 'Use toBeUndefined() instead',
-            node: parentProperty,
-          });
-        }
+        context.report({
+          fix(fixer) {
+            return [
+              fixer.replaceText(method(node), 'toBeUndefined'),
+              fixer.remove(argument(node)),
+            ];
+          },
+          message: 'Use toBeUndefined() instead',
+          node: method(node),
+        });
       }
     },
   };
diff --git a/rules/prefer_to_have_length.js b/rules/prefer_to_have_length.js
@@ -1,46 +1,42 @@
 'use strict';
+const expectCase = require('./util').expectCase;
+const expectNotCase = require('./util').expectNotCase;
+const expectResolveCase = require('./util').expectResolveCase;
+const expectRejectCase = require('./util').expectRejectCase;
+const method = require('./util').method;
 
 module.exports = context => {
   return {
     CallExpression(node) {
-      const calleeName = node.callee.name;
-
       if (
-        calleeName === 'expect' &&
-        node.arguments.length == 1 &&
-        node.parent &&
-        node.parent.type === 'MemberExpression' &&
-        node.parent.parent
+        !(
+          expectNotCase(node) ||
+          expectResolveCase(node) ||
+          expectRejectCase(node)
+        ) &&
+        expectCase(node) &&
+        (method(node).name === 'toBe' || method(node).name === 'toEqual') &&
+        node.arguments[0].property &&
+        node.arguments[0].property.name === 'length'
       ) {
-        const parentProperty = node.parent.property;
-        const propertyName = parentProperty.name;
-        const argumentObject = node.arguments[0].object;
-        const argumentProperty = node.arguments[0].property;
-
-        if (
-          (propertyName === 'toBe' || propertyName === 'toEqual') &&
-          argumentProperty &&
-          argumentProperty.name === 'length'
-        ) {
-          const propertyDot = context
-            .getSourceCode()
-            .getFirstTokenBetween(
-              argumentObject,
-              argumentProperty,
-              token => token.value === '.'
-            );
-          context.report({
-            fix(fixer) {
-              return [
-                fixer.remove(propertyDot),
-                fixer.remove(argumentProperty),
-                fixer.replaceText(parentProperty, 'toHaveLength'),
-              ];
-            },
-            message: 'Use toHaveLength() instead',
-            node: parentProperty,
-          });
-        }
+        const propertyDot = context
+          .getSourceCode()
+          .getFirstTokenBetween(
+            node.arguments[0].object,
+            node.arguments[0].property,
+            token => token.value === '.'
+          );
+        context.report({
+          fix(fixer) {
+            return [
+              fixer.remove(propertyDot),
+              fixer.remove(node.arguments[0].property),
+              fixer.replaceText(method(node), 'toHaveLength'),
+            ];
+          },
+          message: 'Use toHaveLength() instead',
+          node: method(node),
+        });
       }
     },
   };
diff --git a/rules/util.js b/rules/util.js
@@ -0,0 +1,82 @@
+'use strict';
+
+const expectCase = node =>
+  node.callee.name === 'expect' &&
+  node.arguments.length == 1 &&
+  node.parent &&
+  node.parent.type === 'MemberExpression' &&
+  node.parent.parent;
+
+const expectNotCase = node =>
+  expectCase(node) &&
+  node.parent.parent.type === 'MemberExpression' &&
+  methodName(node) === 'not';
+
+const expectResolveCase = node =>
+  expectCase(node) &&
+  node.parent.parent.type === 'MemberExpression' &&
+  methodName(node) === 'resolve';
+
+const expectRejectCase = node =>
+  expectCase(node) &&
+  node.parent.parent.type === 'MemberExpression' &&
+  methodName(node) === 'reject';
+
+const expectToBeCase = (node, arg) =>
+  !(expectNotCase(node) || expectResolveCase(node) || expectRejectCase(node)) &&
+  expectCase(node) &&
+  methodName(node) === 'toBe' &&
+  argument(node).value === arg;
+
+const expectNotToBeCase = (node, arg) =>
+  expectNotCase(node) &&
+  methodName2(node) === 'toBe' &&
+  argument2(node).value === arg;
+
+const expectToEqualCase = (node, arg) =>
+  !(expectNotCase(node) || expectResolveCase(node) || expectRejectCase(node)) &&
+  expectCase(node) &&
+  methodName(node) === 'toEqual' &&
+  argument(node).value === arg;
+
+const expectNotToEqualCase = (node, arg) =>
+  expectNotCase(node) &&
+  methodName2(node) === 'toEqual' &&
+  argument2(node).value === arg;
+
+const expectToBeUndefinedCase = node =>
+  !(expectNotCase(node) || expectResolveCase(node) || expectRejectCase(node)) &&
+  expectCase(node) &&
+  methodName(node) === 'toBeUndefined';
+
+const expectNotToBeUndefinedCase = node =>
+  expectNotCase(node) && methodName2(node) === 'toBeUndefined';
+
+const method = node => node.parent.property;
+
+const method2 = node => node.parent.parent.property;
+
+const methodName = node => method(node).name;
+
+const methodName2 = node => method2(node).name;
+
+const argument = node => node.parent.parent.arguments[0];
+
+const argument2 = node => node.parent.parent.parent.arguments[0];
+
+module.exports = {
+  method: method,
+  method2: method2,
+  argument: argument,
+  argument2: argument2,
+  expectCase: expectCase,
+  expectNotCase: expectNotCase,
+  expectResolveCase: expectResolveCase,
+  expectRejectCase: expectRejectCase,
+  expectToBeCase: expectToBeCase,
+  expectNotToBeCase: expectNotToBeCase,
+  expectToEqualCase: expectToEqualCase,
+  expectNotToEqualCase: expectNotToEqualCase,
+  expectToBeUndefinedCase: expectToBeUndefinedCase,
+  expectNotToBeUndefinedCase: expectNotToBeUndefinedCase,
+};
