@depup/eslint-plugin-jest 29.15.1-depup.0

package/lib/rules/no-jasmine-globals.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow Jasmine globals'
+    },
+    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'
+    },
+    fixable: 'code',
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const {
+          callee
+        } = node;
+        const calleeName = (0, _utils2.getNodeName)(callee);
+        if (!calleeName) {
+          return;
+        }
+        if (calleeName === 'spyOn' || calleeName === 'spyOnProperty' || calleeName === 'fail' || calleeName === 'pending') {
+          if ((0, _utils2.resolveScope)(context.sourceCode.getScope(node), calleeName)) {
+            // It's a local variable, not a jasmine global.
+            return;
+          }
+          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;
+        }
+        if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && calleeName.startsWith('jasmine.')) {
+          const functionName = calleeName.replace('jasmine.', '');
+          if (functionName === 'any' || functionName === 'anything' || functionName === 'arrayContaining' || functionName === 'objectContaining' || functionName === 'stringMatching') {
+            context.report({
+              fix: fixer => [fixer.replaceText(callee.object, 'expect')],
+              node,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: `expect.${functionName}`
+              }
+            });
+            return;
+          }
+          if (functionName === 'addMatchers') {
+            context.report({
+              node,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: 'expect.extend'
+              }
+            });
+            return;
+          }
+          if (functionName === 'createSpy') {
+            context.report({
+              node,
+              messageId: 'illegalMethod',
+              data: {
+                method: calleeName,
+                replacement: 'jest.fn'
+              }
+            });
+            return;
+          }
+          context.report({
+            node,
+            messageId: 'illegalJasmine'
+          });
+        }
+      },
+      MemberExpression(node) {
+        if ((0, _utils2.isSupportedAccessor)(node.object, 'jasmine')) {
+          const {
+            parent,
+            property
+          } = node;
+          if (parent && parent.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
+            if ((0, _utils2.isSupportedAccessor)(property, 'DEFAULT_TIMEOUT_INTERVAL')) {
+              const {
+                right
+              } = parent;
+              if (right.type === _utils.AST_NODE_TYPES.Literal) {
+                context.report({
+                  fix: fixer => [fixer.replaceText(parent, `jest.setTimeout(${right.value})`)],
+                  node,
+                  messageId: 'illegalJasmine'
+                });
+                return;
+              }
+            }
+            context.report({
+              node,
+              messageId: 'illegalJasmine'
+            });
+          }
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-large-snapshots.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = require("path");
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const reportOnViolation = (context, node, {
+  maxSize: lineLimit = 50,
+  allowedSnapshots = {}
+}) => {
+  const startLine = node.loc.start.line;
+  const endLine = node.loc.end.line;
+  const lineCount = endLine - startLine;
+  const allPathsAreAbsolute = Object.keys(allowedSnapshots).every(_path.isAbsolute);
+  if (!allPathsAreAbsolute) {
+    throw new Error('All paths for allowedSnapshots must be absolute. You can use JS config and `path.resolve`');
+  }
+  let isAllowed = false;
+  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && node.expression.left.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.expression.left.property)) {
+    const fileName = context.filename;
+    const allowedSnapshotsInFile = allowedSnapshots[fileName];
+    if (allowedSnapshotsInFile) {
+      const snapshotName = (0, _utils2.getAccessorValue)(node.expression.left.property);
+      isAllowed = allowedSnapshotsInFile.some(name => {
+        if (typeof name === 'string') {
+          return snapshotName === name;
+        }
+        return name.test(snapshotName);
+      });
+    }
+  }
+  if (!isAllowed && lineCount > lineLimit) {
+    context.report({
+      messageId: lineLimit === 0 ? 'noSnapshot' : 'tooLongSnapshots',
+      data: {
+        lineLimit,
+        lineCount
+      },
+      node
+    });
+  }
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow large snapshots'
+    },
+    messages: {
+      noSnapshot: 'Expected to not encounter a Jest snapshot but one was found that is {{ lineCount }} lines long',
+      tooLongSnapshots: 'Expected Jest snapshot to be smaller than {{ lineLimit }} lines but was {{ lineCount }} lines long'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        maxSize: {
+          type: 'number'
+        },
+        inlineMaxSize: {
+          type: 'number'
+        },
+        allowedSnapshots: {
+          type: 'object',
+          additionalProperties: {
+            type: 'array'
+          }
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{}],
+  create(context, [options]) {
+    if (context.filename.endsWith('.snap')) {
+      return {
+        ExpressionStatement(node) {
+          reportOnViolation(context, node, options);
+        }
+      };
+    }
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher)) && jestFnCall.args.length) {
+          reportOnViolation(context, jestFnCall.args[0], {
+            ...options,
+            maxSize: options.inlineMaxSize ?? options.maxSize
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-mocks-import.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = require("path");
+var _utils = require("./utils");
+const mocksDirName = '__mocks__';
+const isMockPath = path => path.split(_path.posix.sep).includes(mocksDirName);
+const isMockImportLiteral = expression => (0, _utils.isStringNode)(expression) && isMockPath((0, _utils.getStringValue)(expression));
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow manually importing from `__mocks__`'
+    },
+    messages: {
+      noManualImport: `Mocks should not be manually imported from a ${mocksDirName} directory. Instead use \`jest.mock\` and import from the original module path`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (isMockImportLiteral(node.source)) {
+          context.report({
+            node,
+            messageId: 'noManualImport'
+          });
+        }
+      },
+      'CallExpression[callee.name="require"]'(node) {
+        const [arg] = node.arguments;
+        if (arg && isMockImportLiteral(arg)) {
+          context.report({
+            node: arg,
+            messageId: 'noManualImport'
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-restricted-jest-methods.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const messages = {
+  restrictedJestMethod: 'Use of `{{ restriction }}` is disallowed',
+  restrictedJestMethodWithMessage: '{{ message }}'
+};
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow specific `jest.` methods'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: ['string', 'null']
+      }
+    }],
+    messages
+  },
+  defaultOptions: [{}],
+  create(context, [restrictedMethods]) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'jest' || jestFnCall.members.length === 0) {
+          return;
+        }
+        const method = (0, _utils.getAccessorValue)(jestFnCall.members[0]);
+        if (method in restrictedMethods) {
+          const message = restrictedMethods[method];
+          context.report({
+            messageId: message ? 'restrictedJestMethodWithMessage' : 'restrictedJestMethod',
+            data: {
+              message,
+              restriction: method
+            },
+            loc: {
+              start: jestFnCall.members[0].loc.start,
+              end: jestFnCall.members[jestFnCall.members.length - 1].loc.end
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-restricted-matchers.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const isChainRestricted = (chain, restriction) => {
+  if (_utils.ModifierName.hasOwnProperty(restriction) || restriction.endsWith('.not')) {
+    return chain.startsWith(restriction);
+  }
+  return chain === restriction;
+};
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow specific matchers & modifiers'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: ['string', 'null']
+      }
+    }],
+    messages: {
+      restrictedChain: 'Use of `{{ restriction }}` is disallowed',
+      restrictedChainWithMessage: '{{ message }}'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [restrictedChains]) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const chain = jestFnCall.members.map(nod => (0, _utils.getAccessorValue)(nod)).join('.');
+        for (const [restriction, message] of Object.entries(restrictedChains)) {
+          if (isChainRestricted(chain, restriction)) {
+            context.report({
+              messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
+              data: {
+                message,
+                restriction
+              },
+              loc: {
+                start: jestFnCall.members[0].loc.start,
+                end: jestFnCall.members[jestFnCall.members.length - 1].loc.end
+              }
+            });
+            break;
+          }
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-standalone-expect.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const getBlockType = (statement, context) => {
+  const func = statement.parent;
+
+  // functionDeclaration: function func() {}
+  if (func.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
+    return 'function';
+  }
+  if ((0, _utils2.isFunction)(func)) {
+    const expr = func.parent;
+
+    // arrow function or function expr
+    if (expr.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
+      return 'function';
+    }
+
+    // if it's not a variable, it will be callExpr, we only care about describe
+    if (expr.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTypeOfJestFnCall)(expr, context, ['describe'])) {
+      return 'describe';
+    }
+  }
+  return null;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow using `expect` outside of `it` or `test` blocks'
+    },
+    messages: {
+      unexpectedExpect: 'Expect must be inside of a test block'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        additionalTestBlockFunctions: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    additionalTestBlockFunctions: []
+  }],
+  create(context, [{
+    additionalTestBlockFunctions = []
+  }]) {
+    const callStack = [];
+    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'expect') {
+          if (jestFnCall.head.node.parent.type === _utils.AST_NODE_TYPES.MemberExpression && jestFnCall.members.length === 1 && !['assertions', 'hasAssertions'].includes((0, _utils2.getAccessorValue)(jestFnCall.members[0]))) {
+            return;
+          }
+          const parent = callStack[callStack.length - 1];
+          if (!parent || parent === _utils2.DescribeAlias.describe) {
+            context.report({
+              node,
+              messageId: 'unexpectedExpect'
+            });
+          }
+          return;
+        }
+        if (jestFnCall?.type === 'test' || isCustomTestBlockFunction(node)) {
+          callStack.push('test');
+        }
+        if (node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+          callStack.push('template');
+        }
+      },
+      'CallExpression:exit'(node) {
+        const top = callStack[callStack.length - 1];
+        if (top === 'test' && ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || isCustomTestBlockFunction(node)) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+          callStack.pop();
+        }
+      },
+      BlockStatement(statement) {
+        const blockType = getBlockType(statement, context);
+        if (blockType) {
+          callStack.push(blockType);
+        }
+      },
+      'BlockStatement:exit'(statement) {
+        if (callStack[callStack.length - 1] === getBlockType(statement, context)) {
+          callStack.pop();
+        }
+      },
+      ArrowFunctionExpression(node) {
+        if (node.parent.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          callStack.push('arrow');
+        }
+      },
+      'ArrowFunctionExpression:exit'() {
+        if (callStack[callStack.length - 1] === 'arrow') {
+          callStack.pop();
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-test-prefixes.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Require using `.only` and `.skip` over `f` and `x`'
+    },
+    messages: {
+      usePreferredName: 'Use "{{ preferredNodeName }}" instead'
+    },
+    fixable: 'code',
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'describe' && jestFnCall?.type !== 'test') {
+          return;
+        }
+        if (jestFnCall.name[0] !== 'f' && jestFnCall.name[0] !== 'x') {
+          return;
+        }
+        const preferredNodeName = [jestFnCall.name.slice(1), jestFnCall.name[0] === 'f' ? 'only' : 'skip', ...jestFnCall.members.map(s => (0, _utils2.getAccessorValue)(s))].join('.');
+        const funcNode = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+        context.report({
+          messageId: 'usePreferredName',
+          node: node.callee,
+          data: {
+            preferredNodeName
+          },
+          fix(fixer) {
+            return [fixer.replaceText(funcNode, preferredNodeName)];
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-test-return-statement.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const getBody = args => {
+  const [, secondArg] = args;
+  if (secondArg && (0, _utils2.isFunction)(secondArg) && secondArg.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+    return secondArg.body.body;
+  }
+  return [];
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow explicitly returning from tests'
+    },
+    messages: {
+      noReturnValue: 'Jest tests should not return a value'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+          return;
+        }
+        const body = getBody(node.arguments);
+        const returnStmt = body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
+        if (!returnStmt) {
+          return;
+        }
+        context.report({
+          messageId: 'noReturnValue',
+          node: returnStmt
+        });
+      },
+      FunctionDeclaration(node) {
+        const declaredVariables = context.sourceCode.getDeclaredVariables(node);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
+        if (testCallExpressions.length === 0) {
+          return;
+        }
+        const returnStmt = node.body.body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
+        if (!returnStmt) {
+          return;
+        }
+        context.report({
+          messageId: 'noReturnValue',
+          node: returnStmt
+        });
+      }
+    };
+  }
+});