eslint-plugin-jest 27.2.2 → 27.3.0

package/lib/rules/__tests__/valid-expect.test.js

@@ -1,894 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _dedent = _interopRequireDefault(require("dedent"));
-var _validExpect = _interopRequireDefault(require("../valid-expect"));
-var _testUtils = require("./test-utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const ruleTester = new _utils.TSESLint.RuleTester({
-  parser: _testUtils.espreeParser,
-  parserOptions: {
-    ecmaVersion: 2017
-  }
-});
-ruleTester.run('valid-expect', _validExpect.default, {
-  valid: ['expect.hasAssertions', 'expect.hasAssertions()', 'expect("something").toEqual("else");', 'expect(true).toBeDefined();', 'expect([1, 2, 3]).toEqual([1, 2, 3]);', 'expect(undefined).not.toBeDefined();', 'test("valid-expect", () => { return expect(Promise.resolve(2)).resolves.toBeDefined(); });', 'test("valid-expect", () => { return expect(Promise.reject(2)).rejects.toBeDefined(); });', 'test("valid-expect", () => { return expect(Promise.resolve(2)).resolves.not.toBeDefined(); });', 'test("valid-expect", () => { return expect(Promise.resolve(2)).rejects.not.toBeDefined(); });', 'test("valid-expect", function () { return expect(Promise.resolve(2)).resolves.not.toBeDefined(); });', 'test("valid-expect", function () { return expect(Promise.resolve(2)).rejects.not.toBeDefined(); });', 'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined()); });', 'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).rejects.not.toBeDefined()); });', {
-    code: 'test("valid-expect", () => expect(Promise.resolve(2)).resolves.toBeDefined());',
-    options: [{
-      alwaysAwait: true
-    }]
-  }, 'test("valid-expect", () => expect(Promise.resolve(2)).resolves.toBeDefined());', 'test("valid-expect", () => expect(Promise.reject(2)).rejects.toBeDefined());', 'test("valid-expect", () => expect(Promise.reject(2)).resolves.not.toBeDefined());', 'test("valid-expect", () => expect(Promise.reject(2)).rejects.not.toBeDefined());', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined(); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).rejects.not.toBeDefined(); });', 'test("valid-expect", async function () { await expect(Promise.reject(2)).resolves.not.toBeDefined(); });', 'test("valid-expect", async function () { await expect(Promise.reject(2)).rejects.not.toBeDefined(); });', 'test("valid-expect", async () => { await Promise.resolve(expect(Promise.reject(2)).rejects.not.toBeDefined()); });', 'test("valid-expect", async () => { await Promise.reject(expect(Promise.reject(2)).rejects.not.toBeDefined()); });', 'test("valid-expect", async () => { await Promise.all([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });', 'test("valid-expect", async () => { await Promise.race([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });', 'test("valid-expect", async () => { await Promise.allSettled([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });', 'test("valid-expect", async () => { await Promise.any([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });', 'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")); });', 'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).then(() => console.log("another valid case")); });', 'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log("valid-case")); });', 'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).catch(() => console.log("another valid case")); });', 'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).then(() => console.log("another valid case")); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log("valid-case")); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).catch(() => console.log("another valid case")); });', 'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });', (0, _dedent.default)`
-      test("valid-expect", () => {
-        return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => {
-          return expect(Promise.resolve(2)).resolves.toBe(1);
-        });
-      });
-    `, (0, _dedent.default)`
-      test("valid-expect", () => {
-        return expect(functionReturningAPromise()).resolves.toEqual(1).then(async () => {
-          await expect(Promise.resolve(2)).resolves.toBe(1);
-        });
-      });
-    `, (0, _dedent.default)`
-      test("valid-expect", () => {
-        return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => expect(Promise.resolve(2)).resolves.toBe(1));
-      });
-    `, (0, _dedent.default)`
-      expect.extend({
-        toResolve(obj) {
-          return this.isNot
-            ? expect(obj).toBe(true)
-            : expect(obj).resolves.not.toThrow();
-        }
-      });
-    `, (0, _dedent.default)`
-      expect.extend({
-        toResolve(obj) {
-          return this.isNot
-            ? expect(obj).resolves.not.toThrow()
-            : expect(obj).toBe(true);
-        }
-      });
-    `, (0, _dedent.default)`
-      expect.extend({
-        toResolve(obj) {
-          return this.isNot
-            ? expect(obj).toBe(true)
-            : anotherCondition
-            ? expect(obj).resolves.not.toThrow()
-            : expect(obj).toBe(false)
-        }
-      });
-    `, {
-    code: 'expect(1).toBe(2);',
-    options: [{
-      maxArgs: 2
-    }]
-  }, {
-    code: 'expect(1, "1 !== 2").toBe(2);',
-    options: [{
-      maxArgs: 2
-    }]
-  }, {
-    code: 'expect(1, "1 !== 2").toBe(2);',
-    options: [{
-      maxArgs: 2,
-      minArgs: 2
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(2).not.toBe(2); });',
-    options: [{
-      asyncMatchers: ['toRejectWith']
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.reject(2)).toRejectWith(2); });',
-    options: [{
-      asyncMatchers: ['toResolveWith']
-    }]
-  }, {
-    code: 'test("valid-expect", async () => { await expect(Promise.resolve(2)).toResolve(); });',
-    options: [{
-      asyncMatchers: ['toResolveWith']
-    }]
-  }, {
-    code: 'test("valid-expect", async () => { expect(Promise.resolve(2)).toResolve(); });',
-    options: [{
-      asyncMatchers: ['toResolveWith']
-    }]
-  }],
-  invalid: [{
-    code: 'expect().toBe(2);',
-    options: [{
-      minArgs: undefined,
-      maxArgs: undefined
-    }],
-    errors: [{
-      messageId: 'notEnoughArgs',
-      data: {
-        s: '',
-        amount: 1
-      }
-    }]
-  }, {
-    code: 'expect().toBe(true);',
-    errors: [{
-      endColumn: 8,
-      column: 7,
-      messageId: 'notEnoughArgs',
-      data: {
-        s: '',
-        amount: 1
-      }
-    }]
-  }, {
-    code: 'expect().toEqual("something");',
-    errors: [{
-      endColumn: 8,
-      column: 7,
-      messageId: 'notEnoughArgs',
-      data: {
-        s: '',
-        amount: 1
-      }
-    }]
-  }, {
-    code: 'expect("something", "else").toEqual("something");',
-    errors: [{
-      endColumn: 26,
-      column: 21,
-      messageId: 'tooManyArgs',
-      data: {
-        s: '',
-        amount: 1
-      }
-    }]
-  }, {
-    code: 'expect("something", "else", "entirely").toEqual("something");',
-    options: [{
-      maxArgs: 2
-    }],
-    errors: [{
-      endColumn: 38,
-      column: 29,
-      messageId: 'tooManyArgs',
-      data: {
-        s: 's',
-        amount: 2
-      }
-    }]
-  }, {
-    code: 'expect("something", "else", "entirely").toEqual("something");',
-    options: [{
-      maxArgs: 2,
-      minArgs: 2
-    }],
-    errors: [{
-      endColumn: 38,
-      column: 29,
-      messageId: 'tooManyArgs',
-      data: {
-        s: 's',
-        amount: 2
-      }
-    }]
-  }, {
-    code: 'expect("something", "else", "entirely").toEqual("something");',
-    options: [{
-      maxArgs: 2,
-      minArgs: 1
-    }],
-    errors: [{
-      endColumn: 38,
-      column: 29,
-      messageId: 'tooManyArgs',
-      data: {
-        s: 's',
-        amount: 2
-      }
-    }]
-  }, {
-    code: 'expect("something").toEqual("something");',
-    options: [{
-      minArgs: 2
-    }],
-    errors: [{
-      endColumn: 8,
-      column: 7,
-      messageId: 'notEnoughArgs',
-      data: {
-        s: 's',
-        amount: 2
-      }
-    }]
-  }, {
-    code: 'expect("something", "else").toEqual("something");',
-    options: [{
-      maxArgs: 1,
-      minArgs: 3
-    }],
-    errors: [{
-      endColumn: 8,
-      column: 7,
-      messageId: 'notEnoughArgs',
-      data: {
-        s: 's',
-        amount: 3
-      }
-    }, {
-      endColumn: 26,
-      column: 21,
-      messageId: 'tooManyArgs',
-      data: {
-        s: '',
-        amount: 1
-      }
-    }]
-  }, {
-    code: 'expect("something");',
-    errors: [{
-      endColumn: 20,
-      column: 1,
-      messageId: 'matcherNotFound'
-    }]
-  }, {
-    code: 'expect();',
-    errors: [{
-      endColumn: 9,
-      column: 1,
-      messageId: 'matcherNotFound'
-    }]
-  }, {
-    code: 'expect(true).toBeDefined;',
-    errors: [{
-      endColumn: 25,
-      column: 14,
-      messageId: 'matcherNotCalled'
-    }]
-  }, {
-    code: 'expect(true).not.toBeDefined;',
-    errors: [{
-      endColumn: 29,
-      column: 18,
-      messageId: 'matcherNotCalled'
-    }]
-  }, {
-    code: 'expect(true).nope.toBeDefined;',
-    errors: [{
-      endColumn: 30,
-      column: 19,
-      messageId: 'matcherNotCalled'
-    }]
-  }, {
-    code: 'expect(true).nope.toBeDefined();',
-    errors: [{
-      endColumn: 32,
-      column: 1,
-      messageId: 'modifierUnknown'
-    }]
-  }, {
-    code: 'expect(true).not.resolves.toBeDefined();',
-    errors: [{
-      endColumn: 40,
-      column: 1,
-      messageId: 'modifierUnknown'
-    }]
-  }, {
-    code: 'expect(true).not.not.toBeDefined();',
-    errors: [{
-      endColumn: 35,
-      column: 1,
-      messageId: 'modifierUnknown'
-    }]
-  }, {
-    code: 'expect(true).resolves.not.exactly.toBeDefined();',
-    errors: [{
-      endColumn: 48,
-      column: 1,
-      messageId: 'modifierUnknown'
-    }]
-  }, {
-    code: 'expect(true).resolves;',
-    errors: [{
-      endColumn: 22,
-      column: 14,
-      messageId: 'matcherNotFound'
-    }]
-  }, {
-    code: 'expect(true).rejects;',
-    errors: [{
-      endColumn: 21,
-      column: 14,
-      messageId: 'matcherNotFound'
-    }]
-  }, {
-    code: 'expect(true).not;',
-    errors: [{
-      endColumn: 17,
-      column: 14,
-      messageId: 'matcherNotFound'
-    }]
-  },
-  /**
-   * .resolves & .rejects checks
-   */
-  // Inline usages
-  {
-    code: 'expect(Promise.resolve(2)).resolves.toBeDefined();',
-    errors: [{
-      column: 1,
-      endColumn: 50,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: 'expect(Promise.resolve(2)).rejects.toBeDefined();',
-    errors: [{
-      column: 1,
-      endColumn: 49,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // alwaysAwait option changes error message
-  {
-    code: 'expect(Promise.resolve(2)).resolves.toBeDefined();',
-    options: [{
-      alwaysAwait: true
-    }],
-    errors: [{
-      column: 1,
-      endColumn: 50,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        expect.extend({
-          toResolve(obj) {
-            this.isNot
-              ? expect(obj).toBe(true)
-              : expect(obj).resolves.not.toThrow();
-          }
-        });
-      `,
-    errors: [{
-      column: 9,
-      endColumn: 43,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        expect.extend({
-          toResolve(obj) {
-            this.isNot
-              ? expect(obj).resolves.not.toThrow()
-              : expect(obj).toBe(true);
-          }
-        });
-      `,
-    errors: [{
-      column: 9,
-      endColumn: 43,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        expect.extend({
-          toResolve(obj) {
-            this.isNot
-              ? expect(obj).toBe(true)
-              : anotherCondition
-              ? expect(obj).resolves.not.toThrow()
-              : expect(obj).toBe(false)
-          }
-        });
-      `,
-    errors: [{
-      column: 9,
-      endColumn: 43,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  },
-  // expect().resolves
-  {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).resolves.toBeDefined(); });',
-    errors: [{
-      column: 30,
-      endColumn: 79,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).toResolve(); });',
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30,
-      line: 1
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).toResolve(); });',
-    options: [{
-      asyncMatchers: undefined
-    }],
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30,
-      line: 1
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).toReject(); });',
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30,
-      line: 1
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).not.toReject(); });',
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30,
-      line: 1
-    }]
-  },
-  // expect().resolves.not
-  {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
-    errors: [{
-      column: 30,
-      endColumn: 83,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // expect().rejects
-  {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).rejects.toBeDefined(); });',
-    errors: [{
-      column: 30,
-      endColumn: 78,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // expect().rejects.not
-  {
-    code: 'test("valid-expect", () => { expect(Promise.resolve(2)).rejects.not.toBeDefined(); });',
-    errors: [{
-      column: 30,
-      endColumn: 82,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // usages in async function
-  {
-    code: 'test("valid-expect", async () => { expect(Promise.resolve(2)).resolves.toBeDefined(); });',
-    errors: [{
-      column: 36,
-      endColumn: 85,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: 'test("valid-expect", async () => { expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
-    errors: [{
-      column: 36,
-      endColumn: 89,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.reject(2)).toRejectWith(2); });',
-    options: [{
-      asyncMatchers: ['toRejectWith']
-    }],
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30
-    }]
-  }, {
-    code: 'test("valid-expect", () => { expect(Promise.reject(2)).rejects.toBe(2); });',
-    options: [{
-      asyncMatchers: ['toRejectWith']
-    }],
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 30
-    }]
-  },
-  // alwaysAwait:false, one not awaited
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          expect(Promise.resolve(2)).resolves.not.toBeDefined();
-          expect(Promise.resolve(1)).rejects.toBeDefined();
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 56,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }, {
-      line: 3,
-      column: 3,
-      endColumn: 51,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // alwaysAwait: true, one returned
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          await expect(Promise.resolve(2)).resolves.not.toBeDefined();
-          expect(Promise.resolve(1)).rejects.toBeDefined();
-        });
-      `,
-    errors: [{
-      line: 3,
-      column: 3,
-      endColumn: 51,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  /**
-   * Multiple async assertions
-   */
-  // both not awaited
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          expect(Promise.resolve(2)).resolves.not.toBeDefined();
-          return expect(Promise.resolve(1)).rejects.toBeDefined();
-        });
-      `,
-    options: [{
-      alwaysAwait: true
-    }],
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 56,
-      messageId: 'asyncMustBeAwaited'
-    }, {
-      line: 3,
-      column: 10,
-      endColumn: 58,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  },
-  // alwaysAwait:true, one not awaited, one returned
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          expect(Promise.resolve(2)).resolves.not.toBeDefined();
-          return expect(Promise.resolve(1)).rejects.toBeDefined();
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 56,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // one not awaited
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          await expect(Promise.resolve(2)).resolves.not.toBeDefined();
-          return expect(Promise.resolve(1)).rejects.toBeDefined();
-        });
-      `,
-    options: [{
-      alwaysAwait: true
-    }],
-    errors: [{
-      line: 3,
-      column: 10,
-      endColumn: 58,
-      messageId: 'asyncMustBeAwaited'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          await expect(Promise.resolve(2)).toResolve();
-          return expect(Promise.resolve(1)).toReject();
-        });
-      `,
-    options: [{
-      alwaysAwait: true
-    }],
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      column: 10,
-      line: 3
-    }]
-  },
-  /**
-   * Promise.x(expect()) usages
-   */
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 73,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.reject(expect(Promise.resolve(2)).resolves.not.toBeDefined());
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 72,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.x(expect(Promise.resolve(2)).resolves.not.toBeDefined());
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 67,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // alwaysAwait option changes error message
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
-        });
-      `,
-    options: [{
-      alwaysAwait: true
-    }],
-    errors: [{
-      line: 2,
-      column: 3,
-      endColumn: 73,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited'
-    }]
-  },
-  // Promise method accepts arrays and returns 1 error
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.all([
-            expect(Promise.resolve(2)).resolves.not.toBeDefined(),
-            expect(Promise.resolve(3)).resolves.not.toBeDefined(),
-          ]);
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endLine: 5,
-      endColumn: 5,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  // Promise.any([expect1, expect2]) returns one error
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          Promise.x([
-            expect(Promise.resolve(2)).resolves.not.toBeDefined(),
-            expect(Promise.resolve(3)).resolves.not.toBeDefined(),
-          ]);
-        });
-      `,
-    errors: [{
-      line: 2,
-      column: 3,
-      endLine: 5,
-      endColumn: 5,
-      messageId: 'promisesWithAsyncAssertionsMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  },
-  //
-  {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          const assertions = [
-            expect(Promise.resolve(2)).resolves.not.toBeDefined(),
-            expect(Promise.resolve(3)).resolves.not.toBeDefined(),
-          ]
-        });
-      `,
-    errors: [{
-      line: 3,
-      column: 5,
-      endLine: 3,
-      endColumn: 58,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }, {
-      line: 4,
-      column: 5,
-      endLine: 4,
-      endColumn: 58,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          const assertions = [
-            expect(Promise.resolve(2)).toResolve(),
-            expect(Promise.resolve(3)).toReject(),
-          ]
-        });
-      `,
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 5,
-      line: 3
-    }, {
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 5,
-      line: 4
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          const assertions = [
-            expect(Promise.resolve(2)).not.toResolve(),
-            expect(Promise.resolve(3)).resolves.toReject(),
-          ]
-        });
-      `,
-    errors: [{
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 5,
-      line: 3
-    }, {
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      },
-      column: 5,
-      line: 4
-    }]
-  }, {
-    code: 'expect(Promise.resolve(2)).resolves.toBe;',
-    errors: [{
-      column: 37,
-      endColumn: 41,
-      messageId: 'matcherNotCalled'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => {
-            expect(Promise.resolve(2)).resolves.toBe(1);
-          });
-        });
-      `,
-    errors: [{
-      line: 3,
-      column: 5,
-      endLine: 3,
-      endColumn: 48,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", () => {
-          return expect(functionReturningAPromise()).resolves.toEqual(1).then(async () => {
-            await expect(Promise.resolve(2)).resolves.toBe(1);
-            expect(Promise.resolve(4)).resolves.toBe(4);
-          });
-        });
-      `,
-    errors: [{
-      line: 4,
-      column: 5,
-      endLine: 4,
-      endColumn: 48,
-      messageId: 'asyncMustBeAwaited',
-      data: {
-        orReturned: ' or returned'
-      }
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test("valid-expect", async () => {
-          await expect(Promise.resolve(1));
-        });
-      `,
-    errors: [{
-      endColumn: 35,
-      column: 9,
-      messageId: 'matcherNotFound'
-    }]
-  }]
-});