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

package/lib/rules/consistent-test-it.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const buildFixer = (callee, nodeName, preferredTestKeyword) => fixer => [fixer.replaceText(callee.type === _utils.AST_NODE_TYPES.MemberExpression ? callee.object : callee, getPreferredNodeName(nodeName, preferredTestKeyword))];
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Enforce `test` and `it` usage conventions'
+    },
+    fixable: 'code',
+    messages: {
+      consistentMethod: "Prefer using '{{ testKeyword }}' instead of '{{ oppositeTestKeyword }}'",
+      consistentMethodWithinDescribe: "Prefer using '{{ testKeywordWithinDescribe }}' instead of '{{ oppositeTestKeyword }}' within describe"
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        fn: {
+          type: 'string',
+          enum: [_utils2.TestCaseName.it, _utils2.TestCaseName.test]
+        },
+        withinDescribe: {
+          type: 'string',
+          enum: [_utils2.TestCaseName.it, _utils2.TestCaseName.test]
+        }
+      },
+      additionalProperties: false
+    }],
+    type: 'suggestion'
+  },
+  defaultOptions: [{
+    fn: _utils2.TestCaseName.test,
+    withinDescribe: _utils2.TestCaseName.it
+  }],
+  create(context) {
+    const configObj = context.options[0] || {};
+    const testKeyword = configObj.fn || _utils2.TestCaseName.test;
+    const testKeywordWithinDescribe = configObj.withinDescribe || configObj.fn || _utils2.TestCaseName.it;
+    let describeNestingLevel = 0;
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.type === 'describe') {
+          describeNestingLevel++;
+          return;
+        }
+        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;
+        if (jestFnCall.type === 'test' && describeNestingLevel === 0 && !jestFnCall.name.endsWith(testKeyword)) {
+          const oppositeTestKeyword = getOppositeTestKeyword(testKeyword);
+          context.report({
+            messageId: 'consistentMethod',
+            node: node.callee,
+            data: {
+              testKeyword,
+              oppositeTestKeyword
+            },
+            fix: buildFixer(funcNode, jestFnCall.name, testKeyword)
+          });
+        }
+        if (jestFnCall.type === 'test' && describeNestingLevel > 0 && !jestFnCall.name.endsWith(testKeywordWithinDescribe)) {
+          const oppositeTestKeyword = getOppositeTestKeyword(testKeywordWithinDescribe);
+          context.report({
+            messageId: 'consistentMethodWithinDescribe',
+            node: node.callee,
+            data: {
+              testKeywordWithinDescribe,
+              oppositeTestKeyword
+            },
+            fix: buildFixer(funcNode, jestFnCall.name, testKeywordWithinDescribe)
+          });
+        }
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          describeNestingLevel--;
+        }
+      }
+    };
+  }
+});
+function getPreferredNodeName(nodeName, preferredTestKeyword) {
+  if (nodeName === _utils2.TestCaseName.fit) {
+    return 'test.only';
+  }
+  return nodeName.startsWith('f') || nodeName.startsWith('x') ? nodeName.charAt(0) + preferredTestKeyword : preferredTestKeyword;
+}
+function getOppositeTestKeyword(test) {
+  if (test === _utils2.TestCaseName.test) {
+    return _utils2.TestCaseName.it;
+  }
+  return _utils2.TestCaseName.test;
+}

package/lib/rules/expect-expect.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+/*
+ * This implementation is adapted from eslint-plugin-jasmine.
+ * MIT license, Remco Haszing.
+ */
+
+/**
+ * Checks if node names returned by getNodeName matches any of the given star patterns
+ * Pattern examples:
+ *   request.*.expect
+ *   request.**.expect
+ *   request.**.expect*
+ */
+function matchesAssertFunctionName(nodeName, patterns) {
+  return patterns.some(p => new RegExp(`^${p.split('.').map(x => {
+    if (x === '**') {
+      return '[a-z\\d\\.]*';
+    }
+    return x.replace(/\*/gu, '[a-z\\d]*');
+  }).join('\\.')}(\\.|$)`, 'ui').test(nodeName));
+}
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Enforce assertion to be made in a test body'
+    },
+    messages: {
+      noAssertions: 'Test has no assertions'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        assertFunctionNames: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        },
+        additionalTestBlockFunctions: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }],
+    type: 'suggestion'
+  },
+  defaultOptions: [{
+    assertFunctionNames: ['expect'],
+    additionalTestBlockFunctions: []
+  }],
+  create(context, [{
+    assertFunctionNames = ['expect'],
+    additionalTestBlockFunctions = []
+  }]) {
+    const unchecked = [];
+    function checkCallExpressionUsed(nodes) {
+      for (const node of nodes) {
+        const index = node.type === _utils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
+        if (node.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
+          const declaredVariables = context.sourceCode.getDeclaredVariables(node);
+          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
+          checkCallExpressionUsed(testCallExpressions);
+        }
+        if (index !== -1) {
+          unchecked.splice(index, 1);
+          break;
+        }
+      }
+    }
+    return {
+      CallExpression(node) {
+        const name = (0, _utils2.getNodeName)(node.callee) ?? '';
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || additionalTestBlockFunctions.includes(name)) {
+          if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'todo')) {
+            return;
+          }
+          unchecked.push(node);
+        } else if (matchesAssertFunctionName(name, assertFunctionNames)) {
+          // Return early in case of nested `it` statements.
+          checkCallExpressionUsed(context.sourceCode.getAncestors(node));
+        }
+      },
+      'Program:exit'() {
+        unchecked.forEach(node => context.report({
+          messageId: 'noAssertions',
+          node: node.callee
+        }));
+      }
+    };
+  }
+});

package/lib/rules/max-expects.js

@@ -0,0 +1,70 @@
+"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: 'Enforces a maximum number assertion calls in a test body'
+    },
+    messages: {
+      exceededMaxAssertion: 'Too many assertion calls ({{ count }}) - maximum allowed is {{ max }}'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        max: {
+          type: 'integer',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    max: 5
+  }],
+  create(context, [{
+    max
+  }]) {
+    let count = 0;
+    const maybeResetCount = node => {
+      const isTestFn = node.parent.type !== _utils.AST_NODE_TYPES.CallExpression || (0, _utils2.isTypeOfJestFnCall)(node.parent, context, ['test']);
+      if (isTestFn) {
+        count = 0;
+      }
+    };
+    return {
+      FunctionExpression: maybeResetCount,
+      'FunctionExpression:exit': maybeResetCount,
+      ArrowFunctionExpression: maybeResetCount,
+      'ArrowFunctionExpression:exit': maybeResetCount,
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'test') {
+          count = 0;
+        }
+        if (jestFnCall?.type !== 'expect' || jestFnCall.head.node.parent.type === _utils.AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        count += 1;
+        if (count > max) {
+          context.report({
+            node,
+            messageId: 'exceededMaxAssertion',
+            data: {
+              count,
+              max
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/max-nested-describe.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Enforces a maximum depth to nested describe calls'
+    },
+    messages: {
+      exceededMaxDepth: 'Too many nested describe calls ({{ depth }}) - maximum allowed is {{ max }}'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        max: {
+          type: 'integer',
+          minimum: 0
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    max: 5
+  }],
+  create(context, [{
+    max
+  }]) {
+    const describes = [];
+    return {
+      CallExpression(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          describes.unshift(node);
+          if (describes.length > max) {
+            context.report({
+              node,
+              messageId: 'exceededMaxDepth',
+              data: {
+                depth: describes.length,
+                max
+              }
+            });
+          }
+        }
+      },
+      'CallExpression:exit'(node) {
+        if (describes[0] === node) {
+          describes.shift();
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-alias-methods.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow alias methods'
+    },
+    messages: {
+      replaceAlias: `Replace {{ alias }}() with its canonical name of {{ canonical }}()`
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    // map of jest matcher aliases & their canonical names
+    const methodNames = {
+      toBeCalled: 'toHaveBeenCalled',
+      toBeCalledTimes: 'toHaveBeenCalledTimes',
+      toBeCalledWith: 'toHaveBeenCalledWith',
+      lastCalledWith: 'toHaveBeenLastCalledWith',
+      nthCalledWith: 'toHaveBeenNthCalledWith',
+      toReturn: 'toHaveReturned',
+      toReturnTimes: 'toHaveReturnedTimes',
+      toReturnWith: 'toHaveReturnedWith',
+      lastReturnedWith: 'toHaveLastReturnedWith',
+      nthReturnedWith: 'toHaveNthReturnedWith',
+      toThrowError: 'toThrow'
+    };
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        const alias = (0, _utils.getAccessorValue)(matcher);
+        if (alias in methodNames) {
+          const canonical = methodNames[alias];
+          context.report({
+            messageId: 'replaceAlias',
+            data: {
+              alias,
+              canonical
+            },
+            node: matcher,
+            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher, canonical)]
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-commented-out-tests.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+function hasTests(node) {
+  return /^\s*[xf]?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\(/mu.test(node.value);
+}
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow commented out tests'
+    },
+    messages: {
+      commentedTests: 'Do not comment out tests'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    const {
+      sourceCode
+    } = context;
+    function checkNode(node) {
+      if (!hasTests(node)) {
+        return;
+      }
+      context.report({
+        messageId: 'commentedTests',
+        node
+      });
+    }
+    return {
+      Program() {
+        const comments = sourceCode.getAllComments();
+        comments.forEach(checkNode);
+      }
+    };
+  }
+});

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

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isCatchCall = node => node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'catch');
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow calling `expect` conditionally'
+    },
+    messages: {
+      conditionalExpect: 'Avoid calling `expect` conditionally`'
+    },
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let conditionalDepth = 0;
+    let inTestCase = false;
+    let inPromiseCatch = false;
+    const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
+    const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
+    return {
+      FunctionDeclaration(node) {
+        const declaredVariables = context.sourceCode.getDeclaredVariables(node);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
+        if (testCallExpressions.length > 0) {
+          inTestCase = true;
+        }
+      },
+      CallExpression(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils2.parseJestFnCall)(node, context) ?? {};
+        if (jestFnCallType === 'test') {
+          inTestCase = true;
+        }
+        if (isCatchCall(node)) {
+          inPromiseCatch = true;
+        }
+        if (inTestCase && jestFnCallType === 'expect' && conditionalDepth > 0) {
+          context.report({
+            messageId: 'conditionalExpect',
+            node
+          });
+        }
+        if (inPromiseCatch && jestFnCallType === 'expect') {
+          context.report({
+            messageId: 'conditionalExpect',
+            node
+          });
+        }
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+          inTestCase = false;
+        }
+        if (isCatchCall(node)) {
+          inPromiseCatch = false;
+        }
+      },
+      CatchClause: increaseConditionalDepth,
+      'CatchClause:exit': decreaseConditionalDepth,
+      IfStatement: increaseConditionalDepth,
+      'IfStatement:exit': decreaseConditionalDepth,
+      SwitchStatement: increaseConditionalDepth,
+      'SwitchStatement:exit': decreaseConditionalDepth,
+      ConditionalExpression: increaseConditionalDepth,
+      'ConditionalExpression:exit': decreaseConditionalDepth,
+      LogicalExpression: increaseConditionalDepth,
+      'LogicalExpression:exit': decreaseConditionalDepth
+    };
+  }
+});

package/lib/rules/no-conditional-in-test.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow conditional logic in tests'
+    },
+    messages: {
+      conditionalInTest: 'Avoid having conditionals in tests'
+    },
+    type: 'problem',
+    schema: [{
+      type: 'object',
+      properties: {
+        allowOptionalChaining: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    allowOptionalChaining: true
+  }],
+  create(context, [{
+    allowOptionalChaining
+  }]) {
+    let inTestCase = false;
+    const maybeReportConditional = node => {
+      if (inTestCase) {
+        context.report({
+          messageId: 'conditionalInTest',
+          node
+        });
+      }
+    };
+    return {
+      CallExpression(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
+          inTestCase = true;
+        }
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
+          inTestCase = false;
+        }
+      },
+      IfStatement: maybeReportConditional,
+      SwitchStatement: maybeReportConditional,
+      ConditionalExpression: maybeReportConditional,
+      LogicalExpression: maybeReportConditional,
+      ...(!allowOptionalChaining && {
+        ChainExpression: maybeReportConditional
+      })
+    };
+  }
+});

package/lib/rules/no-confusing-set-timeout.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+function isJestSetTimeout(jestFnCall) {
+  return jestFnCall.type === 'jest' && jestFnCall.members.length === 1 && (0, _utils.isIdentifier)(jestFnCall.members[0], 'setTimeout');
+}
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow confusing usages of jest.setTimeout'
+    },
+    messages: {
+      globalSetTimeout: '`jest.setTimeout` should be call in `global` scope',
+      multipleSetTimeouts: 'Do not call `jest.setTimeout` multiple times, as only the last call will have an effect',
+      orderSetTimeout: '`jest.setTimeout` should be placed before any other jest methods'
+    },
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let seenJestTimeout = false;
+    let shouldEmitOrderSetTimeout = false;
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (!isJestSetTimeout(jestFnCall)) {
+          shouldEmitOrderSetTimeout = true;
+          return;
+        }
+        if (!['global', 'module'].includes(context.sourceCode.getScope(node).type)) {
+          context.report({
+            messageId: 'globalSetTimeout',
+            node
+          });
+        }
+        if (shouldEmitOrderSetTimeout) {
+          context.report({
+            messageId: 'orderSetTimeout',
+            node
+          });
+        }
+        if (seenJestTimeout) {
+          context.report({
+            messageId: 'multipleSetTimeouts',
+            node
+          });
+        }
+        seenJestTimeout = true;
+      }
+    };
+  }
+});