eslint-plugin-jest 28.11.2 → 28.13.0

package/README.md

@@ -363,6 +363,7 @@ Manually fixable by
 | [prefer-called-with](docs/rules/prefer-called-with.md)                               | Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`              |     |     |     |     |
 | [prefer-comparison-matcher](docs/rules/prefer-comparison-matcher.md)                 | Suggest using the built-in comparison matchers                            |     |     | 🔧  |     |
 | [prefer-each](docs/rules/prefer-each.md)                                             | Prefer using `.each` rather than manual loops                             |     |     |     |     |
+| [prefer-ending-with-an-expect](docs/rules/prefer-ending-with-an-expect.md)           | Prefer having the last statement in a test be an assertion                |     |     |     |     |
 | [prefer-equality-matcher](docs/rules/prefer-equality-matcher.md)                     | Suggest using the built-in equality matchers                              |     |     |     | 💡  |
 | [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)                   | Suggest using `expect.assertions()` OR `expect.hasAssertions()`           |     |     |     | 💡  |
 | [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)                       | Prefer `await expect(...).resolves` over `expect(await ...)` syntax       |     |     | 🔧  |     |

package/docs/rules/prefer-ending-with-an-expect.md

@@ -0,0 +1,168 @@
+# Prefer having the last statement in a test be an assertion (`prefer-ending-with-an-expect`)
+
+<!-- end auto-generated rule header -->
+
+Prefer ending tests with an `expect` assertion.
+
+## Rule details
+
+This rule triggers when a test body does not end with an `expect` call, which
+can indicate an unfinished test.
+
+Examples of **incorrect** code for this rule:
+
+```js
+it('lets me change the selected option', () => {
+  const container = render(MySelect, {
+    props: { options: [1, 2, 3], selected: 1 },
+  });
+
+  expect(container).toBeDefined();
+  expect(container.toHTML()).toContain('<option value="1" selected>');
+
+  container.setProp('selected', 2);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+it('lets me change the selected option', () => {
+  const container = render(MySelect, {
+    props: { options: [1, 2, 3], selected: 1 },
+  });
+
+  expect(container).toBeDefined();
+  expect(container.toHTML()).toContain('<option value="1" selected>');
+
+  container.setProp('selected', 2);
+
+  expect(container.toHTML()).not.toContain('<option value="1" selected>');
+  expect(container.toHTML()).toContain('<option value="2" selected>');
+});
+```
+
+## Options
+
+```json
+{
+  "jest/prefer-ending-with-an-expect": [
+    "error",
+    {
+      "assertFunctionNames": ["expect"],
+      "additionalTestBlockFunctions": []
+    }
+  ]
+}
+```
+
+### `assertFunctionNames`
+
+This array option specifies the names of functions that should be considered to
+be asserting functions. Function names can use wildcards i.e `request.*.expect`,
+`request.**.expect`, `request.*.expect*`
+
+Examples of **incorrect** code for the `{ "assertFunctionNames": ["expect"] }`
+option:
+
+```js
+/* eslint jest/prefer-ending-with-an-expect: ["error", { "assertFunctionNames": ["expect"] }] */
+
+import { expectSaga } from 'redux-saga-test-plan';
+import { addSaga } from '../src/sagas';
+
+test('returns sum', () => {
+  expectSaga(addSaga, 1, 1).returns(2).run();
+});
+```
+
+Examples of **correct** code for the
+`{ "assertFunctionNames": ["expect", "expectSaga"] }` option:
+
+```js
+/* eslint jest/prefer-ending-with-an-expect: ["error", { "assertFunctionNames": ["expect", "expectSaga"] }] */
+
+import { expectSaga } from 'redux-saga-test-plan';
+import { addSaga } from '../src/sagas';
+
+test('returns sum', () => {
+  expectSaga(addSaga, 1, 1).returns(2).run();
+});
+```
+
+Since the string is compiled into a regular expression, you'll need to escape
+special characters such as `$` with a double backslash:
+
+```js
+/* eslint jest/prefer-ending-with-an-expect: ["error", { "assertFunctionNames": ["expect\\$"] }] */
+
+it('is money-like', () => {
+  expect$(1.0);
+});
+```
+
+Examples of **correct** code for working with the HTTP assertions library
+[SuperTest](https://www.npmjs.com/package/supertest) with the
+`{ "assertFunctionNames": ["expect", "request.**.expect"] }` option:
+
+```js
+/* eslint jest/prefer-ending-with-an-expect: ["error", { "assertFunctionNames": ["expect", "request.**.expect"] }] */
+const request = require('supertest');
+const express = require('express');
+
+const app = express();
+
+describe('GET /user', function () {
+  it('responds with json', function (done) {
+    doSomething();
+
+    request(app).get('/user').expect('Content-Type', /json/).expect(200, done);
+  });
+});
+```
+
+### `additionalTestBlockFunctions`
+
+This array can be used to specify the names of functions that should also be
+treated as test blocks:
+
+```json
+{
+  "rules": {
+    "jest/prefer-ending-with-an-expect": [
+      "error",
+      { "additionalTestBlockFunctions": ["each.test"] }
+    ]
+  }
+}
+```
+
+The following is _correct_ when using the above configuration:
+
+```js
+each([
+  [2, 3],
+  [1, 3],
+]).test(
+  'the selection can change from %d to %d',
+  (firstSelection, secondSelection) => {
+    const container = render(MySelect, {
+      props: { options: [1, 2, 3], selected: firstSelection },
+    });
+
+    expect(container).toBeDefined();
+    expect(container.toHTML()).toContain(
+      `<option value="${firstSelection}" selected>`,
+    );
+
+    container.setProp('selected', secondSelection);
+
+    expect(container.toHTML()).not.toContain(
+      `<option value="${firstSelection}" selected>`,
+    );
+    expect(container.toHTML()).toContain(
+      `<option value="${secondSelection}" selected>`,
+    );
+  },
+);
+```

package/lib/rules/no-disabled-tests.js

@@ -13,30 +13,20 @@ var _default = exports.default = (0, _utils.createRule)({
     },
     messages: {
       missingFunction: 'Test is missing function argument',
-      pending: 'Call to pending()',
-      pendingSuite: 'Call to pending() within test suite',
-      pendingTest: 'Call to pending() within test',
-      disabledSuite: 'Disabled test suite',
-      disabledTest: 'Disabled test'
+      skippedTest: 'Tests should not be skipped'
     },
     schema: [],
     type: 'suggestion'
   },
   defaultOptions: [],
   create(context) {
-    let suiteDepth = 0;
-    let testDepth = 0;
     return {
       CallExpression(node) {
         const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
         if (!jestFnCall) {
           return;
         }
-        if (jestFnCall.type === 'describe') {
-          suiteDepth++;
-        }
         if (jestFnCall.type === 'test') {
-          testDepth++;
           if (node.arguments.length < 2 && jestFnCall.members.every(s => (0, _utils.getAccessorValue)(s) !== 'todo')) {
             context.report({
               messageId: 'missingFunction',
@@ -48,43 +38,19 @@ var _default = exports.default = (0, _utils.createRule)({
         // the only jest functions that are with "x" are "xdescribe", "xtest", and "xit"
         jestFnCall.name.startsWith('x') || jestFnCall.members.some(s => (0, _utils.getAccessorValue)(s) === 'skip')) {
           context.report({
-            messageId: jestFnCall.type === 'describe' ? 'disabledSuite' : 'disabledTest',
+            messageId: 'skippedTest',
             node
           });
         }
       },
-      'CallExpression:exit'(node) {
-        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
-        if (!jestFnCall) {
-          return;
-        }
-        if (jestFnCall.type === 'describe') {
-          suiteDepth--;
-        }
-        if (jestFnCall.type === 'test') {
-          testDepth--;
-        }
-      },
       'CallExpression[callee.name="pending"]'(node) {
         if ((0, _utils.resolveScope)((0, _utils.getScope)(context, node), 'pending')) {
           return;
         }
-        if (testDepth > 0) {
-          context.report({
-            messageId: 'pendingTest',
-            node
-          });
-        } else if (suiteDepth > 0) {
-          context.report({
-            messageId: 'pendingSuite',
-            node
-          });
-        } else {
-          context.report({
-            messageId: 'pending',
-            node
-          });
-        }
+        context.report({
+          messageId: 'skippedTest',
+          node
+        });
       }
     };
   }

package/lib/rules/prefer-ending-with-an-expect.js

@@ -0,0 +1,99 @@
+"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: 'Prefer having the last statement in a test be an assertion'
+    },
+    messages: {
+      mustEndWithExpect: 'Tests should end with an assertion'
+    },
+    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 = []
+  }]) {
+    function getLastStatement(fn) {
+      if (fn.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+        if (fn.body.body.length === 0) {
+          return null;
+        }
+        const lastStatement = fn.body.body[fn.body.body.length - 1];
+        if (lastStatement.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+          return lastStatement.expression;
+        }
+        return lastStatement;
+      }
+      return fn.body;
+    }
+    return {
+      CallExpression(node) {
+        const name = (0, _utils2.getNodeName)(node.callee) ?? '';
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) && !additionalTestBlockFunctions.includes(name)) {
+          return;
+        }
+        if (node.arguments.length < 2 || !(0, _utils2.isFunction)(node.arguments[1])) {
+          return;
+        }
+        const lastStatement = getLastStatement(node.arguments[1]);
+        if (lastStatement?.type === _utils.AST_NODE_TYPES.CallExpression && ((0, _utils2.isTypeOfJestFnCall)(lastStatement, context, ['expect']) || matchesAssertFunctionName((0, _utils2.getNodeName)(lastStatement.callee), assertFunctionNames))) {
+          return;
+        }
+        context.report({
+          messageId: 'mustEndWithExpect',
+          node: node.callee
+        });
+      }
+    };
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "28.11.2",
+  "version": "28.13.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",