eslint-plugin-jest 22.15.0 → 22.17.0

package/lib/rules/valid-expect-in-promise.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
 
@@ -15,33 +17,34 @@ function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d =
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-const isThenOrCatch = node => {
-  return node.property && (node.property.name === 'then' || node.property.name === 'catch');
-};
+const isThenOrCatchCall = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property) && ['then', 'catch'].includes((0, _utils.getAccessorValue)(node.callee.property));
 
 const isExpectCallPresentInFunction = body => {
-  if (body.type === 'BlockStatement') {
+  if (body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
     return body.body.find(line => {
-      if (line.type === 'ExpressionStatement') return isExpectCall(line.expression);
-      if (line.type === 'ReturnStatement') return isExpectCall(line.argument);
+      if (line.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement) {
+        return isFullExpectCall(line.expression);
+      }
+
+      if (line.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement && line.argument) {
+        return isFullExpectCall(line.argument);
+      }
     });
   }
 
-  return isExpectCall(body);
+  return isFullExpectCall(body);
 };
 
-const isExpectCall = expression => {
-  return expression && expression.type === 'CallExpression' && expression.callee.type === 'MemberExpression' && expression.callee.object.type === 'CallExpression' && expression.callee.object.callee.name === 'expect';
-};
+const isFullExpectCall = expression => expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isExpectMember)(expression.callee);
 
 const reportReturnRequired = (context, node) => {
   context.report({
     loc: {
       end: {
-        column: node.parent.parent.loc.end.column,
-        line: node.parent.parent.loc.end.line
+        column: node.loc.end.column,
+        line: node.loc.end.line
       },
-      start: node.parent.parent.loc.start
+      start: node.loc.start
     },
     messageId: 'returnPromise',
     node
@@ -51,99 +54,101 @@ const reportReturnRequired = (context, node) => {
 const isPromiseReturnedLater = (node, testFunctionBody) => {
   let promiseName;
 
-  if (node.parent.parent.type === 'ExpressionStatement') {
-    promiseName = node.parent.parent.expression.callee.object.name;
-  } else if (node.parent.parent.type === 'VariableDeclarator') {
-    promiseName = node.parent.parent.id.name;
+  if (node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement && node.expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.expression.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.expression.callee.object)) {
+    promiseName = (0, _utils.getAccessorValue)(node.expression.callee.object);
+  } else if (node.type === _experimentalUtils.AST_NODE_TYPES.VariableDeclarator && node.id.type === _experimentalUtils.AST_NODE_TYPES.Identifier) {
+    promiseName = node.id.name;
   }
 
   const lastLineInTestFunc = testFunctionBody[testFunctionBody.length - 1];
-  return lastLineInTestFunc.type === 'ReturnStatement' && lastLineInTestFunc.argument.name === promiseName;
+  return lastLineInTestFunc.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement && lastLineInTestFunc.argument && ('name' in lastLineInTestFunc.argument && lastLineInTestFunc.argument.name === promiseName || !promiseName);
 };
 
-const isTestFunc = node => {
-  return node.type === 'CallExpression' && (node.callee.name === 'it' || node.callee.name === 'test');
-};
+const isTestFunc = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isSupportedAccessor)(node.callee) && [_utils.TestCaseName.it, _utils.TestCaseName.test].includes((0, _utils.getAccessorValue)(node.callee));
 
-const getFunctionBody = func => {
-  if (func.body.type === 'BlockStatement') return func.body.body;
-  return func.body; //arrow-short-hand-fn
-};
-
-const getTestFunction = node => {
-  let parent = node.parent;
-
-  while (parent) {
-    if ((0, _util.isFunction)(parent) && isTestFunc(parent.parent)) {
-      return parent;
+const findTestFunction = node => {
+  while (node) {
+    if ((0, _utils.isFunction)(node) && node.parent && isTestFunc(node.parent)) {
+      return node;
     }
 
-    parent = parent.parent;
+    node = node.parent;
   }
-};
 
-const isParentThenOrPromiseReturned = (node, testFunctionBody) => {
-  return testFunctionBody.type === 'CallExpression' || testFunctionBody.type === 'NewExpression' || node.parent.parent.type === 'ReturnStatement' || isPromiseReturnedLater(node, testFunctionBody) || isThenOrCatch(node.parent.parent);
+  return null;
 };
 
+const isParentThenOrPromiseReturned = (node, testFunctionBody) => node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement || isPromiseReturnedLater(node, testFunctionBody); // prettier-ignore
+// WEB-40105
+
+
 const verifyExpectWithReturn = (promiseCallbacks, node, context, testFunctionBody) => {
   promiseCallbacks.some(promiseCallback => {
-    if (promiseCallback && (0, _util.isFunction)(promiseCallback)) {
-      if (isExpectCallPresentInFunction(promiseCallback.body) && !isParentThenOrPromiseReturned(node, testFunctionBody)) {
-        reportReturnRequired(context, node);
+    if (promiseCallback && (0, _utils.isFunction)(promiseCallback) && promiseCallback.body) {
+      if (isExpectCallPresentInFunction(promiseCallback.body) && node.parent && node.parent.parent && !isParentThenOrPromiseReturned(node.parent.parent, testFunctionBody)) {
+        reportReturnRequired(context, node.parent.parent);
         return true;
       }
     }
   });
 };
 
-const isAwaitExpression = node => {
-  return node.parent.parent && node.parent.parent.type === 'AwaitExpression';
-};
-
-const isHavingAsyncCallBackParam = testFunction => {
-  try {
-    return testFunction.params[0].type === 'Identifier';
-  } catch (e) {
-    return false;
-  }
-};
+const isHavingAsyncCallBackParam = testFunction => testFunction.params[0] && testFunction.params[0].type === _experimentalUtils.AST_NODE_TYPES.Identifier;
 
-var _default = {
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Enforce having return statement when testing with promises',
+      recommended: 'error'
     },
     messages: {
       returnPromise: 'Promise should be returned to test its fulfillment or rejection'
     },
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
-      MemberExpression(node) {
-        if (node.type === 'MemberExpression' && isThenOrCatch(node) && node.parent.type === 'CallExpression' && !isAwaitExpression(node)) {
-          const testFunction = getTestFunction(node);
+      CallExpression(node) {
+        if (!isThenOrCatchCall(node) || node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression) {
+          return;
+        }
 
-          if (testFunction && !isHavingAsyncCallBackParam(testFunction)) {
-            const testFunctionBody = getFunctionBody(testFunction);
+        const testFunction = findTestFunction(node);
 
-            const _node$parent$argument = _slicedToArray(node.parent.arguments, 2),
-                  fulfillmentCallback = _node$parent$argument[0],
-                  rejectionCallback = _node$parent$argument[1]; // then block can have two args, fulfillment & rejection
-            // then block can have one args, fulfillment
-            // catch block can have one args, rejection
-            // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+        if (testFunction && !isHavingAsyncCallBackParam(testFunction)) {
+          const body = testFunction.body;
+          /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
 
+          if (!body) {
+            throw new Error(`Unexpected null when attempting to fix ${context.getFilename()} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
+          }
 
-            verifyExpectWithReturn([fulfillmentCallback, rejectionCallback], node, context, testFunctionBody);
+          if (body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+            return;
           }
+
+          const testFunctionBody = body.body;
+
+          const _node$arguments = _slicedToArray(node.arguments, 2),
+                fulfillmentCallback = _node$arguments[0],
+                rejectionCallback = _node$arguments[1]; // then block can have two args, fulfillment & rejection
+          // then block can have one args, fulfillment
+          // catch block can have one args, rejection
+          // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+
+          verifyExpectWithReturn([fulfillmentCallback, rejectionCallback], node.callee, context, testFunctionBody);
         }
       }
 
     };
   }
 
-};
+});
+
 exports.default = _default;

package/lib/rules/valid-expect.js

@@ -5,33 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
 
 /*
  * This implementation is ported from from eslint-plugin-jasmine.
  * MIT license, Tom Vincent.
  */
-const expectProperties = ['not', 'resolves', 'rejects'];
-const promiseArgumentTypes = ['CallExpression', 'ArrayExpression'];
-/**
- * expect statement can have chained matchers.
- * We are looking for the closest CallExpression
- * to find `expect().x.y.z.t()` usage.
- *
- * @Returns CallExpressionNode
- */
-
-const getClosestParentCallExpressionNode = node => {
-  if (!node || !node.parent || !node.parent.parent) {
-    return null;
-  }
 
-  if (node.parent.type === 'CallExpression') {
-    return node.parent;
-  }
-
-  return getClosestParentCallExpressionNode(node.parent);
-};
 /**
  * Async assertions might be called in Promise
  * methods like `Promise.x(expect1)` or `Promise.x([expect1, expect2])`.
@@ -39,24 +21,24 @@ const getClosestParentCallExpressionNode = node => {
  *
  * @Returns CallExpressionNode
  */
-
-
 const getPromiseCallExpressionNode = node => {
-  if (node && node.type === 'ArrayExpression' && node.parent && node.parent.type === 'CallExpression') {
+  if (node && node.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
     node = node.parent;
   }
 
-  if (node.type === 'CallExpression' && node.callee && node.callee.type === 'MemberExpression' && node.callee.object.name === 'Promise' && node.parent) {
+  if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.object) && (0, _utils.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
     return node;
   }
 
   return null;
 };
 
+const findPromiseCallExpressionNode = node => node.parent && node.parent.parent && [_experimentalUtils.AST_NODE_TYPES.CallExpression, _experimentalUtils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+
 const getParentIfThenified = node => {
   const grandParentNode = node.parent && node.parent.parent;
 
-  if (grandParentNode && grandParentNode.type === 'CallExpression' && grandParentNode.callee && grandParentNode.callee.type === 'MemberExpression' && ['then', 'catch'].includes(grandParentNode.callee.property.name) && grandParentNode.parent) {
+  if (grandParentNode && grandParentNode.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && grandParentNode.callee && (0, _utils.isExpectMember)(grandParentNode.callee) && ['then', 'catch'].includes((0, _utils.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.parent) {
     // Just in case `then`s are chained look one above.
     return getParentIfThenified(grandParentNode);
   }
@@ -64,25 +46,20 @@ const getParentIfThenified = node => {
   return node;
 };
 
-const checkIfValidReturn = (parentCallExpressionNode, allowReturn) => {
-  const validParentNodeTypes = ['ArrowFunctionExpression', 'AwaitExpression'];
-
-  if (allowReturn) {
-    validParentNodeTypes.push('ReturnStatement');
-  }
-
-  return validParentNodeTypes.includes(parentCallExpressionNode.type);
-};
+const isAcceptableReturnNode = (node, allowReturn) => allowReturn && node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement || [_experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression, _experimentalUtils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
 
 const promiseArrayExceptionKey = ({
   start,
   end
 }) => `${start.line}:${start.column}-${end.line}:${end.column}`;
 
-var _default = {
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Enforce valid `expect()` usage',
+      recommended: 'error'
     },
     messages: {
       multipleArgs: 'More than one argument was passed to expect().',
@@ -94,6 +71,7 @@ var _default = {
       asyncMustBeAwaited: 'Async assertions must be awaited{{ orReturned }}.',
       promisesWithAsyncAssertionsMustBeAwaited: 'Promises which return async assertions must be awaited{{ orReturned }}.'
     },
+    type: 'suggestion',
     schema: [{
       type: 'object',
       properties: {
@@ -105,169 +83,157 @@ var _default = {
       additionalProperties: false
     }]
   },
+  defaultOptions: [{
+    alwaysAwait: false
+  }],
 
-  create(context) {
+  create(context, [{
+    alwaysAwait
+  }]) {
     // Context state
-    const arrayExceptions = {};
+    const arrayExceptions = new Set();
 
-    const pushPromiseArrayException = loc => {
-      const key = promiseArrayExceptionKey(loc);
-      arrayExceptions[key] = true;
-    };
+    const pushPromiseArrayException = loc => arrayExceptions.add(promiseArrayExceptionKey(loc));
     /**
      * Promise method that accepts an array of promises,
-     * ( eg. Promise.all), will throw warnings for the each
+     * (eg. Promise.all), will throw warnings for the each
      * unawaited or non-returned promise. To avoid throwing
      * multiple warnings, we check if there is a warning in
      * the given location.
      */
 
 
-    const promiseArrayExceptionExists = loc => {
-      const key = promiseArrayExceptionKey(loc);
-      return !!arrayExceptions[key];
-    };
+    const promiseArrayExceptionExists = loc => arrayExceptions.has(promiseArrayExceptionKey(loc));
 
     return {
       CallExpression(node) {
-        // checking "expect()" arguments
-        if ((0, _util.expectCase)(node)) {
-          if (node.arguments.length > 1) {
-            const secondArgumentLocStart = node.arguments[1].loc.start;
-            const lastArgumentLocEnd = node.arguments[node.arguments.length - 1].loc.end;
-            context.report({
-              loc: {
-                end: {
-                  column: lastArgumentLocEnd.column - 1,
-                  line: lastArgumentLocEnd.line
-                },
-                start: secondArgumentLocStart
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
+
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              expect = _parseExpectCall.expect,
+              modifier = _parseExpectCall.modifier,
+              matcher = _parseExpectCall.matcher;
+
+        if (expect.arguments.length > 1) {
+          const secondArgumentLocStart = expect.arguments[1].loc.start;
+          const lastArgumentLocEnd = expect.arguments[node.arguments.length - 1].loc.end;
+          context.report({
+            loc: {
+              end: {
+                column: lastArgumentLocEnd.column - 1,
+                line: lastArgumentLocEnd.line
               },
-              messageId: 'multipleArgs',
-              node
-            });
-          } else if (node.arguments.length === 0) {
-            const expectLength = node.callee.name.length;
+              start: secondArgumentLocStart
+            },
+            messageId: 'multipleArgs',
+            node
+          });
+        } else if (expect.arguments.length === 0) {
+          const expectLength = (0, _utils.getAccessorValue)(expect.callee).length;
+          context.report({
+            loc: {
+              end: {
+                column: node.loc.start.column + expectLength + 1,
+                line: node.loc.start.line
+              },
+              start: {
+                column: node.loc.start.column + expectLength,
+                line: node.loc.start.line
+              }
+            },
+            messageId: 'noArgs',
+            node
+          });
+        } // something was called on `expect()`
+
+
+        if (!matcher) {
+          if (modifier) {
             context.report({
-              loc: {
-                end: {
-                  column: node.loc.start.column + expectLength + 1,
-                  line: node.loc.start.line
-                },
-                start: {
-                  column: node.loc.start.column + expectLength,
-                  line: node.loc.start.line
-                }
+              data: {
+                propertyName: modifier.name
               },
-              messageId: 'noArgs',
-              node
+              // todo: rename to 'modifierName'
+              messageId: 'propertyWithoutMatcher',
+              // todo: rename to 'modifierWithoutMatcher'
+              node: modifier.node.property
             });
-          } // something was called on `expect()`
-
-
-          if (node.parent && node.parent.type === 'MemberExpression' && node.parent.parent) {
-            let parentNode = node.parent;
-            let parentProperty = parentNode.property;
-            let propertyName = parentProperty.name;
-            let grandParent = parentNode.parent; // a property is accessed, get the next node
-
-            if (grandParent.type === 'MemberExpression') {
-              // a modifier is used, just get the next one
-              if (expectProperties.indexOf(propertyName) > -1) {
-                grandParent = grandParent.parent;
-              } else {
-                // only a few properties are allowed
-                context.report({
-                  // For some reason `endColumn` isn't set in tests if `loc` is
-                  // not added
-                  loc: parentProperty.loc,
-                  messageId: 'invalidProperty',
-                  data: {
-                    propertyName
-                  },
-                  node: parentProperty
-                });
-              } // this next one should be the matcher
-
-
-              parentNode = parentNode.parent;
-              parentProperty = parentNode.property;
-              propertyName = parentProperty.name;
-            } // matcher was not called
-
-
-            if (grandParent.type === 'ExpressionStatement') {
-              context.report({
-                // For some reason `endColumn` isn't set in tests if `loc` is not
-                // added
-                loc: parentProperty.loc,
-                data: {
-                  propertyName
-                },
-                messageId: expectProperties.indexOf(propertyName) > -1 ? 'propertyWithoutMatcher' : 'matcherOnPropertyNotCalled',
-                node: parentProperty
-              });
-            }
           }
+
+          return;
         }
 
-        if ((0, _util.expectResolvesCase)(node) || (0, _util.expectRejectsCase)(node) || (0, _util.expectNotResolvesCase)(node) || (0, _util.expectNotRejectsCase)(node)) {
-          let parentNode = getClosestParentCallExpressionNode(node);
-
-          if (parentNode) {
-            /**
-             * If parent node is an array expression, we'll report the warning,
-             * for the array object, not for each individual assertion.
-             */
-            const isParentArrayExpression = parentNode.parent.type === 'ArrayExpression';
-            const options = context.options;
-            const allowReturn = !options[0] || !options[0].alwaysAwait;
-            const orReturned = allowReturn ? ' or returned' : '';
-            let messageId = 'asyncMustBeAwaited';
-            /**
-             * An async assertion can be chained with `then` or `catch` statements.
-             * In that case our target CallExpression node is the one with
-             * the last `then` or `catch` statement.
-             */
-
-            parentNode = getParentIfThenified(parentNode); // Promise.x([expect()]) || Promise.x(expect())
-
-            if (promiseArgumentTypes.includes(parentNode.parent.type)) {
-              const promiseNode = getPromiseCallExpressionNode(parentNode.parent);
-
-              if (promiseNode) {
-                parentNode = promiseNode;
-                messageId = 'promisesWithAsyncAssertionsMustBeAwaited';
-              }
-            }
-
-            if ( // If node is not awaited or returned
-            !checkIfValidReturn(parentNode.parent, allowReturn) && // if we didn't warn user already
-            !promiseArrayExceptionExists(parentNode.loc)) {
-              context.report({
-                loc: parentNode.loc,
-                data: {
-                  orReturned
-                },
-                messageId,
-                node
-              });
-
-              if (isParentArrayExpression) {
-                pushPromiseArrayException(parentNode.loc);
-              }
-            }
+        if (matcher.node.parent && (0, _utils.isExpectMember)(matcher.node.parent)) {
+          context.report({
+            messageId: 'invalidProperty',
+            // todo: rename to 'invalidModifier'
+            data: {
+              propertyName: matcher.name
+            },
+            // todo: rename to 'matcherName' (or modifierName?)
+            node: matcher.node.property
+          });
+          return;
+        }
+
+        if (!matcher.arguments) {
+          context.report({
+            data: {
+              propertyName: matcher.name
+            },
+            // todo: rename to 'matcherName'
+            messageId: 'matcherOnPropertyNotCalled',
+            // todo: rename to 'matcherNotCalled'
+            node: matcher.node.property
+          });
+        }
+
+        const parentNode = matcher.node.parent;
+
+        if (!modifier || !parentNode || !parentNode.parent || modifier.name === _utils.ModifierName.not) {
+          return;
+        }
+        /**
+         * If parent node is an array expression, we'll report the warning,
+         * for the array object, not for each individual assertion.
+         */
+
+
+        const isParentArrayExpression = parentNode.parent.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression;
+        const orReturned = alwaysAwait ? '' : ' or returned';
+        /**
+         * An async assertion can be chained with `then` or `catch` statements.
+         * In that case our target CallExpression node is the one with
+         * the last `then` or `catch` statement.
+         */
+
+        const targetNode = getParentIfThenified(parentNode);
+        const finalNode = findPromiseCallExpressionNode(targetNode) || targetNode;
+
+        if (finalNode.parent && // If node is not awaited or returned
+        !isAcceptableReturnNode(finalNode.parent, !alwaysAwait) && // if we didn't warn user already
+        !promiseArrayExceptionExists(finalNode.loc)) {
+          context.report({
+            loc: finalNode.loc,
+            data: {
+              orReturned
+            },
+            messageId: finalNode === targetNode ? 'asyncMustBeAwaited' : 'promisesWithAsyncAssertionsMustBeAwaited',
+            node
+          });
+
+          if (isParentArrayExpression) {
+            pushPromiseArrayException(finalNode.loc);
           }
         }
       },
 
       // nothing called on "expect()"
       'CallExpression:exit'(node) {
-        if (node.callee.name === 'expect' && node.parent.type === 'ExpressionStatement') {
+        if ((0, _utils.isExpectCall)(node) && node.parent.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement) {
           context.report({
-            // For some reason `endColumn` isn't set in tests if `loc` is not
-            // added
-            loc: node.loc,
             messageId: 'noAssertions',
             node
           });
@@ -277,5 +243,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "22.15.0",
+  "version": "22.17.0",
   "description": "Eslint rules for Jest",
   "repository": "jest-community/eslint-plugin-jest",
   "license": "MIT",
@@ -51,7 +51,8 @@
     "@types/node": "^12.6.6",
     "@typescript-eslint/eslint-plugin": "^1.13.0",
     "@typescript-eslint/parser": "^1.13.0",
-    "babel-jest": "^24.8.0",
+    "babel-jest": "^24.9.0",
+    "babel-plugin-replace-ts-export-assignment": "^0.0.2",
     "eslint": "^5.1.0",
     "eslint-config-prettier": "^5.1.0",
     "eslint-plugin-eslint-plugin": "^2.0.0",
@@ -59,12 +60,12 @@
     "eslint-plugin-node": "^8.0.0",
     "eslint-plugin-prettier": "^3.0.0",
     "husky": "^1.0.1",
-    "jest": "^24.0.0",
+    "jest": "^24.9.0",
     "jest-runner-eslint": "^0.7.1",
     "lint-staged": "^8.0.4",
     "prettier": "^1.10.2",
     "prettylint": "^1.0.0",
-    "rimraf": "^2.6.3",
+    "rimraf": "^3.0.0",
     "typescript": "^3.5.3"
   },
   "prettier": {
@@ -103,7 +104,7 @@
         "displayName": "lint",
         "runner": "jest-runner-eslint",
         "testMatch": [
-          "<rootDir>/**/*.js"
+          "<rootDir>/**/*.{js,ts}"
         ],
         "testPathIgnorePatterns": [
           "<rootDir>/lib/.*"