eslint-plugin-jest 24.4.2 → 26.1.0

package/docs/rules/no-try-expect.md

@@ -1,63 +0,0 @@
-# Prevent catch assertions in tests (`no-try-expect`)
-
-## Deprecated
-
-This rule has been deprecated in favor of
-[`no-conditional-expect`](no-conditional-expect.md).
-
----
-
-This rule prevents the use of `expect` inside `catch` blocks.
-
-## Rule Details
-
-Expectations inside a `catch` block can be silently skipped. While Jest provides
-an `expect.assertions(number)` helper, it might be cumbersome to add this to
-every single test. Using `toThrow` concisely guarantees that an exception was
-thrown, and that its contents match expectations.
-
-The following patterns are warnings:
-
-```js
-it('foo', () => {
-  try {
-    foo(); // `foo` may be refactored to not throw exceptions, yet still appears to be tested here.
-  } catch (err) {
-    expect(err).toMatch(/foo error/);
-  }
-});
-
-it('bar', async () => {
-  try {
-    await foo();
-  } catch (err) {
-    expect(err).toMatch(/foo error/);
-  }
-});
-
-it('baz', async () => {
-  try {
-    await foo();
-  } catch (err) {
-    expect(err).toMatchObject({ code: 'MODULE_NOT_FOUND' });
-  }
-});
-```
-
-The following patterns are not warnings:
-
-```js
-it('foo', () => {
-  expect(() => foo()).toThrow(/foo error/);
-});
-
-it('bar', async () => {
-  await expect(fooPromise).rejects.toThrow(/foo error/);
-});
-
-it('baz', async () => {
-  await expect(() => foo()).rejects.toThrow(
-    expect.objectContaining({ code: 'MODULE_NOT_FOUND' }),
-  );
-});
-```

package/docs/rules/prefer-inline-snapshots.md

@@ -1,51 +0,0 @@
-# Suggest using inline snapshots (`prefer-inline-snapshots`)
-
-## Deprecated
-
-This rule has been deprecated in favor of
-[`no-restricted-matchers`](no-restricted-matchers.md) with the following config:
-
-```json
-{
-  "rules": {
-    "jest/no-restricted-matchers": [
-      "error",
-      {
-        "toThrowErrorMatchingSnapshot": "Use `toThrowErrorMatchingInlineSnapshot()` instead",
-        "toMatchSnapshot": "Use `toMatchInlineSnapshot()` instead"
-      }
-    ]
-  }
-}
-```
-
----
-
-In order to make snapshot tests more manageable and reviewable
-`toMatchInlineSnapshot()` and `toThrowErrorMatchingInlineSnapshot` should be
-used to write the snapshots' inline in the test file.
-
-## Rule details
-
-This rule triggers a warning if `toMatchSnapshot()` or
-`toThrowErrorMatchingSnapshot` is used to capture a snapshot.
-
-The following pattern is considered warning:
-
-```js
-expect(obj).toMatchSnapshot();
-```
-
-```js
-expect(error).toThrowErrorMatchingSnapshot();
-```
-
-The following pattern is not warning:
-
-```js
-expect(obj).toMatchInlineSnapshot();
-```
-
-```js
-expect(error).toThrowErrorMatchingInlineSnapshot();
-```

package/docs/rules/prefer-to-be-null.md

@@ -1,33 +0,0 @@
-# Suggest using `toBeNull()` (`prefer-to-be-null`)
-
-In order to have a better failure message, `toBeNull()` should be used upon
-asserting expectations on null value.
-
-## Rule details
-
-This rule triggers a warning if `toBe()`, `toEqual()` or `toStrictEqual()` is
-used to assert a null value.
-
-```js
-expect(null).toBe(null);
-```
-
-This rule is enabled by default.
-
-### Default configuration
-
-The following patterns are considered warnings:
-
-```js
-expect(null).toBe(null);
-
-expect(null).toEqual(null);
-
-expect(null).toStrictEqual(null);
-```
-
-The following pattern is not warning:
-
-```js
-expect(null).toBeNull();
-```

package/docs/rules/prefer-to-be-undefined.md

@@ -1,33 +0,0 @@
-# Suggest using `toBeUndefined()` (`prefer-to-be-undefined`)
-
-In order to have a better failure message, `toBeUndefined()` should be used upon
-asserting expectations on undefined value.
-
-## Rule details
-
-This rule triggers a warning if `toBe()`, `toEqual()` or `toStrictEqual()` is
-used to assert an undefined value.
-
-```js
-expect(undefined).toBe(undefined);
-```
-
-This rule is enabled by default.
-
-### Default configuration
-
-The following patterns are considered warnings:
-
-```js
-expect(undefined).toBe(undefined);
-
-expect(undefined).toEqual(undefined);
-
-expect(undefined).toStrictEqual(undefined);
-```
-
-The following pattern is not warning:
-
-```js
-expect(undefined).toBeUndefined();
-```

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

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _utils = require("./utils");
-
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      category: 'Best Practices',
-      description: 'Disallow expect.resolves',
-      recommended: false
-    },
-    deprecated: true,
-    replacedBy: ['no-restricted-matchers'],
-    messages: {
-      expectResolves: 'Use `expect(await promise)` instead.'
-    },
-    schema: [],
-    type: 'suggestion'
-  },
-  defaultOptions: [],
-  create: context => ({
-    MemberExpression(node) {
-      if ((0, _utils.isExpectCall)(node.object) && (0, _utils.isSupportedAccessor)(node.property, _utils.ModifierName.resolves)) {
-        context.report({
-          node: node.property,
-          messageId: 'expectResolves'
-        });
-      }
-    }
-
-  })
-});
-
-exports.default = _default;

package/lib/rules/no-truthy-falsy.js

@@ -1,58 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _utils = require("./utils");
-
-// todo: refactor into "ban-matchers"
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      category: 'Best Practices',
-      description: 'Disallow using `toBeTruthy()` & `toBeFalsy()`',
-      recommended: false
-    },
-    deprecated: true,
-    replacedBy: ['no-restricted-matchers'],
-    messages: {
-      avoidMatcher: 'Avoid {{ matcherName }}'
-    },
-    type: 'suggestion',
-    schema: []
-  },
-  defaultOptions: [],
-
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
-          return;
-        }
-
-        const {
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (!matcher || !['toBeTruthy', 'toBeFalsy'].includes(matcher.name)) {
-          return;
-        }
-
-        context.report({
-          messageId: 'avoidMatcher',
-          node: matcher.node.property,
-          data: {
-            matcherName: matcher.name
-          }
-        });
-      }
-
-    };
-  }
-
-});
-
-exports.default = _default;

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

@@ -1,89 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _utils = require("./utils");
-
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      description: 'Prefer using toThrow for exception tests',
-      category: 'Best Practices',
-      recommended: 'error'
-    },
-    deprecated: true,
-    replacedBy: ['no-conditional-expect'],
-    messages: {
-      noTryExpect: ['Tests should use Jest‘s exception helpers.', 'Use "expect(() => yourFunction()).toThrow()" for synchronous tests,', 'or "await expect(yourFunction()).rejects.toThrow()" for async tests'].join(' ')
-    },
-    type: 'problem',
-    schema: []
-  },
-  defaultOptions: [],
-
-  create(context) {
-    let isTest = false;
-    let catchDepth = 0;
-
-    function isThrowExpectCall(node) {
-      return catchDepth > 0 && (0, _utils.isExpectCall)(node);
-    }
-
-    return {
-      CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
-          isTest = true;
-        } else if (isTest && isThrowExpectCall(node)) {
-          context.report({
-            messageId: 'noTryExpect',
-            node
-          });
-        }
-      },
-
-      FunctionDeclaration(node) {
-        const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
-
-        if (testCallExpressions.length > 0) {
-          isTest = true;
-        }
-      },
-
-      CatchClause() {
-        if (isTest) {
-          ++catchDepth;
-        }
-      },
-
-      'CatchClause:exit'() {
-        if (isTest) {
-          --catchDepth;
-        }
-      },
-
-      'CallExpression:exit'(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
-          isTest = false;
-        }
-      },
-
-      'FunctionDeclaration:exit'(node) {
-        const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
-
-        if (testCallExpressions.length > 0) {
-          isTest = false;
-        }
-      }
-
-    };
-  }
-
-});
-
-exports.default = _default;

package/lib/rules/prefer-inline-snapshots.js

@@ -1,69 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
-
-var _utils = require("./utils");
-
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      category: 'Best Practices',
-      description: 'Suggest using inline snapshots',
-      recommended: false
-    },
-    deprecated: true,
-    replacedBy: ['no-restricted-matchers'],
-    messages: {
-      toMatch: 'Use toMatchInlineSnapshot() instead',
-      toMatchError: 'Use toThrowErrorMatchingInlineSnapshot() instead'
-    },
-    fixable: 'code',
-    schema: [],
-    type: 'suggestion'
-  },
-  defaultOptions: [],
-
-  create(context) {
-    return {
-      CallExpression(node) {
-        const {
-          callee
-        } = node;
-
-        if (callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || callee.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
-          return;
-        }
-
-        if (callee.property.name === 'toMatchSnapshot') {
-          context.report({
-            fix(fixer) {
-              return [fixer.replaceText(callee.property, 'toMatchInlineSnapshot')];
-            },
-
-            messageId: 'toMatch',
-            node: callee.property
-          });
-        } else if (callee.property.name === 'toThrowErrorMatchingSnapshot') {
-          context.report({
-            fix(fixer) {
-              return [fixer.replaceText(callee.property, 'toThrowErrorMatchingInlineSnapshot')];
-            },
-
-            messageId: 'toMatchError',
-            node: callee.property
-          });
-        }
-      }
-
-    };
-  }
-
-});
-
-exports.default = _default;

package/lib/rules/prefer-to-be-null.js

@@ -1,67 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
-
-var _utils = require("./utils");
-
-const isNullLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && node.value === null;
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a `null` literal as the sole argument.
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedEqualityMatcherCall<MaybeTypeCast<NullLiteral>>}
- */
-
-
-const isNullEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isNullLiteral((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
-
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      category: 'Best Practices',
-      description: 'Suggest using `toBeNull()`',
-      recommended: false
-    },
-    messages: {
-      useToBeNull: 'Use toBeNull() instead'
-    },
-    fixable: 'code',
-    type: 'suggestion',
-    schema: []
-  },
-  defaultOptions: [],
-
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
-          return;
-        }
-
-        const {
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (matcher && isNullEqualityMatcher(matcher)) {
-          context.report({
-            fix: fixer => [fixer.replaceText(matcher.node.property, 'toBeNull'), fixer.remove(matcher.arguments[0])],
-            messageId: 'useToBeNull',
-            node: matcher.node.property
-          });
-        }
-      }
-
-    };
-  }
-
-});
-
-exports.default = _default;

package/lib/rules/prefer-to-be-undefined.js

@@ -1,67 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
-
-var _utils = require("./utils");
-
-const isUndefinedIdentifier = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && node.name === 'undefined';
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a `undefined` identifier as the sole argument.
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedEqualityMatcherCall<MaybeTypeCast<UndefinedIdentifier>>}
- */
-
-
-const isUndefinedEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isUndefinedIdentifier((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
-
-var _default = (0, _utils.createRule)({
-  name: __filename,
-  meta: {
-    docs: {
-      category: 'Best Practices',
-      description: 'Suggest using `toBeUndefined()`',
-      recommended: false
-    },
-    messages: {
-      useToBeUndefined: 'Use toBeUndefined() instead'
-    },
-    fixable: 'code',
-    type: 'suggestion',
-    schema: []
-  },
-  defaultOptions: [],
-
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
-          return;
-        }
-
-        const {
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (matcher && isUndefinedEqualityMatcher(matcher)) {
-          context.report({
-            fix: fixer => [fixer.replaceText(matcher.node.property, 'toBeUndefined'), fixer.remove(matcher.arguments[0])],
-            messageId: 'useToBeUndefined',
-            node: matcher.node.property
-          });
-        }
-      }
-
-    };
-  }
-
-});
-
-exports.default = _default;