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

package/docs/rules/valid-expect.md

@@ -0,0 +1,155 @@
+# jest/valid-expect
+
+📝 Enforce valid `expect()` usage.
+
+💼 This rule is enabled in the ✅ `recommended`
+[config](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations).
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+> [!NOTE] Test function will be fixed if it is async and does not have await in
+> the async assertion.
+
+Ensure `expect()` is called with a single argument and there is an actual
+expectation made.
+
+## Rule details
+
+This rule triggers a warning if `expect()` is called with more than one argument
+or without arguments. It would also issue a warning if there is nothing called
+on `expect()`, e.g.:
+
+```js
+expect();
+expect('something');
+```
+
+or when a matcher function was not called, e.g.:
+
+```js
+expect(true).toBeDefined;
+```
+
+or when an async assertion was not `await`ed or returned, e.g.:
+
+```js
+expect(Promise.resolve('Hi!')).resolves.toBe('Hi!');
+```
+
+This rule is enabled by default.
+
+## Options
+
+```json5
+{
+  type: 'object',
+  properties: {
+    alwaysAwait: {
+      type: 'boolean',
+      default: false,
+    },
+    asyncMatchers: {
+      type: 'array',
+      items: { type: 'string' },
+      default: ['toResolve', 'toReject'],
+    },
+    minArgs: {
+      type: 'number',
+      minimum: 0,
+    },
+    maxArgs: {
+      type: 'number',
+      minimum: 1,
+    },
+  },
+  additionalProperties: false,
+}
+```
+
+### `alwaysAwait`
+
+Enforces to use `await` inside block statements. Using `return` will trigger a
+warning. Returning one line statements with arrow functions is _always allowed_.
+
+Examples of **incorrect** code for the `{ "alwaysAwait": true }` option:
+
+```js
+// alwaysAwait: true
+test('test1', async () => {
+  await expect(Promise.resolve(2)).resolves.toBeDefined();
+  return expect(Promise.resolve(1)).resolves.toBe(1); // `return` statement will trigger a warning
+});
+```
+
+Examples of **correct** code for the `{ "alwaysAwait": true }` option:
+
+```js
+// alwaysAwait: true
+test('test1', async () => {
+  await expect(Promise.resolve(2)).resolves.toBeDefined();
+  await expect(Promise.resolve(1)).resolves.toBe(1);
+});
+
+test('test2', () => expect(Promise.resolve(2)).resolves.toBe(2));
+```
+
+### `asyncMatchers`
+
+Allows specifying which matchers return promises, and so should be considered
+async when checking if an `expect` should be returned or awaited.
+
+By default, this has a list of all the async matchers provided by
+`jest-extended` (namely, `toResolve` and `toReject`).
+
+### `minArgs` & `maxArgs`
+
+Enforces the minimum and maximum number of arguments that `expect` can take, and
+is required to take.
+
+Both of these properties have a default value of `1`, which is the number of
+arguments supported by vanilla `expect`.
+
+This is useful when you're using libraries that increase the number of arguments
+supported by `expect`, such as
+[`jest-expect-message`](https://www.npmjs.com/package/jest-expect-message).
+
+The following patterns are considered warnings:
+
+```js
+test('all the things', async () => {
+  expect();
+  expect().toEqual('something');
+  expect('something', 'else');
+  expect('something');
+  await expect('something');
+  expect(true).toBeDefined;
+  expect(Promise.resolve('hello')).resolves;
+  expect(Promise.resolve('hello')).resolves.toEqual('hello');
+  Promise.resolve(expect(Promise.resolve('hello')).resolves.toEqual('hello'));
+  Promise.all([
+    expect(Promise.resolve('hello')).resolves.toEqual('hello'),
+    expect(Promise.resolve('hi')).resolves.toEqual('hi'),
+  ]);
+});
+```
+
+The following patterns are not warnings:
+
+```js
+test('all the things', async () => {
+  expect('something').toEqual('something');
+  expect([1, 2, 3]).toEqual([1, 2, 3]);
+  expect(true).toBeDefined();
+  await expect(Promise.resolve('hello')).resolves.toEqual('hello');
+  await Promise.resolve(
+    expect(Promise.resolve('hello')).resolves.toEqual('hello'),
+  );
+  await Promise.all([
+    expect(Promise.resolve('hello')).resolves.toEqual('hello'),
+    expect(Promise.resolve('hi')).resolves.toEqual('hi'),
+  ]);
+});
+```

package/docs/rules/valid-mock-module-path.md

@@ -0,0 +1,72 @@
+# jest/valid-mock-module-path
+
+📝 Disallow mocking of non-existing module paths.
+
+<!-- end auto-generated rule header -->
+
+This rule raises an error when using `jest.mock` and `jest.doMock` and the first
+argument for mocked object (module/local file) do not exist.
+
+## Rule details
+
+This rule checks existence of the supplied path for `jest.mock` or `jest.doMock`
+in the first argument.
+
+The following patterns are considered errors:
+
+```js
+// Module(s) that cannot be found
+jest.mock('@org/some-module-not-in-package-json');
+jest.mock('some-module-not-in-package-json');
+
+// Local module (directory) that cannot be found
+jest.mock('../../this/module/does/not/exist');
+
+// Local file that cannot be found
+jest.mock('../../this/path/does/not/exist.js');
+```
+
+The following patterns are **not** considered errors:
+
+```js
+// Module(s) that can be found
+jest.mock('@org/some-module-in-package-json');
+jest.mock('some-module-in-package-json');
+
+// Local module that cannot be found
+jest.mock('../../this/module/really/does/exist');
+
+// Local file that cannot be found
+jest.mock('../../this/path/really/does/exist.js');
+```
+
+## Options
+
+```json
+{
+  "jest/valid-mock-module-path": [
+    "error",
+    {
+      "moduleFileExtensions": [".js", ".ts", ".jsx", ".tsx", ".json"]
+    }
+  ]
+}
+```
+
+### `moduleFileExtensions`
+
+This array option controls which file extensions the plugin checks for
+existence. The default extensions are:
+
+- `".js"`
+- `".ts"`
+- `".jsx"`
+- `".tsx"`
+- `".json"`
+
+For any custom extension, a preceding dot **must** be present before the file
+extension for desired effect.
+
+## When Not To Use It
+
+Don't use this rule on non-jest test files.

package/docs/rules/valid-title.md

@@ -0,0 +1,319 @@
+# jest/valid-title
+
+📝 Enforce valid titles.
+
+💼 This rule is enabled in the ✅ `recommended`
+[config](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations).
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+Checks that the title of Jest blocks are valid by ensuring that titles are:
+
+- not empty,
+- is a string,
+- not prefixed with their block name,
+- have no leading or trailing spaces
+- using valid printf specifiers when applicable
+
+## Rule details
+
+**emptyTitle**
+
+An empty title is not informative, and serves little purpose.
+
+Examples of **incorrect** code for this rule:
+
+```js
+describe('', () => {});
+describe('foo', () => {
+  it('', () => {});
+});
+it('', () => {});
+test('', () => {});
+xdescribe('', () => {});
+xit('', () => {});
+xtest('', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+describe('foo', () => {});
+describe('foo', () => {
+  it('bar', () => {});
+});
+test('foo', () => {});
+it('foo', () => {});
+xdescribe('foo', () => {});
+xit('foo', () => {});
+xtest('foo', () => {});
+```
+
+**invalidEachSpecifier**
+
+Titles for
+[array-based `.each`s](https://jestjs.io/docs/api#1-testeachtablename-fn-timeout_)
+can use
+[`printf` formatting](https://nodejs.org/api/util.html#util_util_format_format_args),
+but there are specific specifiers that are allowed.
+
+Examples of **incorrect** code for this rule:
+
+```js
+test.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%I, %I)', (a, b, expected) => {
+  expect(a + b).toBe(expected);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+test.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  expect(a + b).toBe(expected);
+});
+```
+
+**titleMustBeString**
+
+Titles for `describe`, `test`, and `it` blocks should always be a string; you
+can disable this with the `ignoreTypeOfDescribeName` and `ignoreTypeOfTestName`
+options.
+
+Examples of **incorrect** code for this rule:
+
+```js
+it(123, () => {});
+describe(String(/.+/), () => {});
+describe(myFunction, () => {});
+xdescribe(myFunction, () => {});
+describe(6, function () {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+it('is a string', () => {});
+test('is a string', () => {});
+xtest('is a string', () => {});
+describe('is a string', () => {});
+describe.skip('is a string', () => {});
+fdescribe('is a string', () => {});
+```
+
+Examples of **correct** code when `ignoreTypeOfDescribeName` is `true`:
+
+```js
+it('is a string', () => {});
+test('is a string', () => {});
+xtest('is a string', () => {});
+describe('is a string', () => {});
+describe.skip('is a string', () => {});
+fdescribe('is a string', () => {});
+
+describe(String(/.+/), () => {});
+describe(myFunction, () => {});
+xdescribe(myFunction, () => {});
+describe(6, function () {});
+```
+
+Examples of **correct** code when `ignoreTypeOfTestName` is `true`:
+
+```js
+const myTestName = 'is a string';
+
+it(String(/.+/), () => {});
+it(myFunction, () => {});
+it(myTestName, () => {});
+xit(myFunction, () => {});
+it(6, function () {});
+```
+
+**duplicatePrefix**
+
+A `describe` / `test` block should not start with `duplicatePrefix`
+
+Examples of **incorrect** code for this rule
+
+```js
+test('test foo', () => {});
+it('it foo', () => {});
+
+describe('foo', () => {
+  test('test bar', () => {});
+});
+
+describe('describe foo', () => {
+  test('bar', () => {});
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+test('foo', () => {});
+it('foo', () => {});
+
+describe('foo', () => {
+  test('bar', () => {});
+});
+```
+
+**accidentalSpace**
+
+A `describe` / `test` block should not contain accidentalSpace, but can be
+turned off via the `ignoreSpaces` option:
+
+Examples of **incorrect** code for this rule
+
+```js
+test(' foo', () => {});
+it(' foo', () => {});
+
+describe('foo', () => {
+  test(' bar', () => {});
+});
+
+describe(' foo', () => {
+  test('bar', () => {});
+});
+
+describe('foo  ', () => {
+  test('bar', () => {});
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+test('foo', () => {});
+it('foo', () => {});
+
+describe('foo', () => {
+  test('bar', () => {});
+});
+```
+
+## Options
+
+```ts
+interface Options {
+  ignoreSpaces?: boolean;
+  ignoreTypeOfDescribeName?: boolean;
+  ignoreTypeOfTestName?: boolean;
+  disallowedWords?: string[];
+  mustNotMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
+  mustMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
+}
+```
+
+#### `ignoreSpaces`
+
+Default: `false`
+
+When enabled, the leading and trailing spaces won't be checked.
+
+#### `ignoreTypeOfDescribeName` & `ignoreTypeOfTestName`
+
+Default: `false`
+
+When enabled, the type of the first argument to `describe`/`test` blocks won't
+be checked.
+
+#### `disallowedWords`
+
+Default: `[]`
+
+A string array of words that are not allowed to be used in test titles. Matching
+is not case-sensitive, and looks for complete words:
+
+Examples of **incorrect** code when using `disallowedWords`:
+
+```js
+// with disallowedWords: ['correct', 'all', 'every', 'properly']
+describe('the correct way to do things', () => {});
+it('has ALL the things', () => {});
+xdescribe('every single one of them', () => {});
+test(`that the value is set properly`, () => {});
+```
+
+Examples of **correct** code when using `disallowedWords`:
+
+```js
+// with disallowedWords: ['correct', 'all', 'every', 'properly']
+it('correctly sets the value', () => {});
+test('that everything is as it should be', () => {});
+describe('the proper way to handle things', () => {});
+```
+
+#### `mustMatch` & `mustNotMatch`
+
+Defaults: `{}`
+
+Allows enforcing that titles must match or must not match a given Regular
+Expression, with an optional message. An object can be provided to apply
+different Regular Expressions (with optional messages) to specific Jest test
+function groups (`describe`, `test`, and `it`).
+
+Examples of **incorrect** code when using `mustMatch`:
+
+```js
+// with mustMatch: '^that'
+describe('the correct way to do things', () => {});
+fit('this there!', () => {});
+
+// with mustMatch: { test: '^that' }
+describe('the tests that will be run', () => {});
+test('the stuff works', () => {});
+xtest('errors that are thrown have messages', () => {});
+```
+
+Examples of **correct** code when using `mustMatch`:
+
+```js
+// with mustMatch: '^that'
+describe('that thing that needs to be done', () => {});
+fit('that this there!', () => {});
+
+// with mustMatch: { test: '^that' }
+describe('the tests that will be run', () => {});
+test('that the stuff works', () => {});
+xtest('that errors that thrown have messages', () => {});
+```
+
+Optionally you can provide a custom message to show for a particular matcher by
+using a tuple at any level where you can provide a matcher:
+
+```js
+const prefixes = ['when', 'with', 'without', 'if', 'unless', 'for'];
+const prefixesList = prefixes.join('  - \n');
+
+module.exports = {
+  rules: {
+    'jest/valid-title': [
+      'error',
+      {
+        mustNotMatch: ['\\.$', 'Titles should not end with a full-stop'],
+        mustMatch: {
+          describe: [
+            new RegExp(`^(?:[A-Z]|\\b(${prefixes.join('|')})\\b`, 'u').source,
+            `Describe titles should either start with a capital letter or one of the following prefixes: ${prefixesList}`,
+          ],
+          test: [/[^A-Z]/u.source],
+          it: /[^A-Z]/u.source,
+        },
+      },
+    ],
+  },
+};
+```

package/index.d.ts

@@ -0,0 +1,28 @@
+import type { Linter, Rule } from 'eslint';
+
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  environments: {
+    globals: {
+      globals: {
+        [key: string]: boolean;
+      };
+    };
+  };
+  configs: {
+    all: Linter.LegacyConfig;
+    recommended: Linter.LegacyConfig;
+    style: Linter.LegacyConfig;
+    'flat/all': Linter.FlatConfig;
+    'flat/recommended': Linter.FlatConfig;
+    'flat/style': Linter.FlatConfig;
+  };
+  rules: {
+    [key: string]: Rule.RuleModule;
+  };
+};
+
+export = plugin;

package/lib/globals.json

@@ -0,0 +1,15 @@
+{
+  "afterAll": false,
+  "afterEach": false,
+  "beforeAll": false,
+  "beforeEach": false,
+  "describe": false,
+  "expect": false,
+  "fit": false,
+  "it": false,
+  "jest": false,
+  "test": false,
+  "xdescribe": false,
+  "xit": false,
+  "xtest": false
+}

package/lib/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _fs = require("fs");
+var _path = require("path");
+var _package = require("../package.json");
+var _globals = _interopRequireDefault(require("./globals.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// copied from https://github.com/babel/babel/blob/d8da63c929f2d28c401571e2a43166678c555bc4/packages/babel-helpers/src/helpers.js#L602-L606
+/* istanbul ignore next */
+const interopRequireDefault = obj => obj && obj.__esModule ? obj : {
+  default: obj
+};
+const importDefault = moduleName =>
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+interopRequireDefault(require(moduleName)).default;
+const rulesDir = (0, _path.join)(__dirname, 'rules');
+const excludedFiles = ['__tests__', 'detectJestVersion', 'utils'];
+const rules = Object.fromEntries((0, _fs.readdirSync)(rulesDir).map(rule => (0, _path.parse)(rule).name).filter(rule => !excludedFiles.includes(rule)).map(rule => [rule, importDefault((0, _path.join)(rulesDir, rule))]));
+const recommendedRules = {
+  'jest/expect-expect': 'warn',
+  'jest/no-alias-methods': 'error',
+  'jest/no-commented-out-tests': 'warn',
+  'jest/no-conditional-expect': 'error',
+  'jest/no-deprecated-functions': 'error',
+  'jest/no-disabled-tests': 'warn',
+  'jest/no-done-callback': 'error',
+  'jest/no-export': 'error',
+  'jest/no-focused-tests': 'error',
+  'jest/no-identical-title': 'error',
+  'jest/no-interpolation-in-snapshots': 'error',
+  'jest/no-jasmine-globals': 'error',
+  'jest/no-mocks-import': 'error',
+  'jest/no-standalone-expect': 'error',
+  'jest/no-test-prefixes': 'error',
+  'jest/valid-describe-callback': 'error',
+  'jest/valid-expect': 'error',
+  'jest/valid-expect-in-promise': 'error',
+  'jest/valid-title': 'error'
+};
+const styleRules = {
+  'jest/prefer-to-be': 'error',
+  'jest/prefer-to-contain': 'error',
+  'jest/prefer-to-have-length': 'error'
+};
+const allRules = Object.fromEntries(Object.entries(rules).filter(([, rule]) => !rule.meta.deprecated).map(([name]) => [`jest/${name}`, 'error']));
+const plugin = {
+  meta: {
+    name: _package.name,
+    version: _package.version
+  },
+  // ugly cast for now to keep TypeScript happy since
+  // we don't have types for flat config yet
+  configs: {},
+  environments: {
+    globals: {
+      globals: _globals.default
+    }
+  },
+  rules
+};
+const createRCConfig = rules => ({
+  plugins: ['jest'],
+  env: {
+    'jest/globals': true
+  },
+  rules
+});
+const createFlatConfig = rules => ({
+  plugins: {
+    jest: plugin
+  },
+  languageOptions: {
+    globals: _globals.default
+  },
+  rules
+});
+plugin.configs = {
+  all: createRCConfig(allRules),
+  recommended: createRCConfig(recommendedRules),
+  style: createRCConfig(styleRules),
+  'flat/all': createFlatConfig(allRules),
+  'flat/recommended': createFlatConfig(recommendedRules),
+  'flat/style': createFlatConfig(styleRules)
+};
+module.exports = plugin;