eslint-plugin-jest 27.2.2 → 27.3.0

package/lib/rules/__tests__/prefer-expect-assertions.test.js

@@ -1,1437 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _dedent = _interopRequireDefault(require("dedent"));
-var _preferExpectAssertions = _interopRequireDefault(require("../prefer-expect-assertions"));
-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('prefer-expect-assertions', _preferExpectAssertions.default, {
-  valid: ['test("nonsense", [])', 'test("it1", () => {expect.assertions(0);})', 'test("it1", function() {expect.assertions(0);})', 'test("it1", function() {expect.hasAssertions();})', 'it("it1", function() {expect.assertions(0);})', (0, _dedent.default)`
-      it("it1", function() {
-        expect.assertions(1);
-        expect(someValue).toBe(true)
-      });
-    `, 'test("it1")', 'itHappensToStartWithIt("foo", function() {})', 'testSomething("bar", function() {})', 'it(async () => {expect.assertions(0);})', (0, _dedent.default)`
-      it("returns numbers that are greater than four", function() {
-        expect.assertions(2);
-
-        for(let thing in things) {
-          expect(number).toBeGreaterThan(4);
-        }
-      });
-    `, (0, _dedent.default)`
-      it("returns numbers that are greater than four", function() {
-        expect.hasAssertions();
-
-        for (let i = 0; i < things.length; i++) {
-          expect(number).toBeGreaterThan(4);
-        }
-      });
-    `, {
-    code: (0, _dedent.default)`
-        it("it1", async () => {
-          expect.assertions(1);
-          expect(someValue).toBe(true)
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", function() {
-          expect(someValue).toBe(true)
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: 'it("it1", () => {})',
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", async () => {
-          expect.assertions(2);
-
-          for(let thing in things) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", () => {
-          for(let thing in things) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        import { expect as pleaseExpect } from '@jest/globals';
-
-        it("returns numbers that are greater than four", function() {
-          pleaseExpect.assertions(2);
-  
-          for(let thing in things) {
-            pleaseExpect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    parserOptions: {
-      sourceType: 'module'
-    }
-  }],
-  invalid: [{
-    code: 'it("it1", () => foo())',
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: null
-    }]
-  }, {
-    code: "it('resolves', () => expect(staged()).toBe(true));",
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: null
-    }]
-  }, {
-    code: "it('resolves', async () => expect(await staged()).toBe(true));",
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: null
-    }]
-  }, {
-    code: 'it("it1", () => {})',
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestAddingHasAssertions',
-        output: 'it("it1", () => {expect.hasAssertions();})'
-      }, {
-        messageId: 'suggestAddingAssertions',
-        output: 'it("it1", () => {expect.assertions();})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", () => { foo()})',
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestAddingHasAssertions',
-        output: 'it("it1", () => {expect.hasAssertions(); foo()})'
-      }, {
-        messageId: 'suggestAddingAssertions',
-        output: 'it("it1", () => {expect.assertions(); foo()})'
-      }]
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", function() {
-          someFunctionToDo();
-          someFunctionToDo2();
-        });
-      `,
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestAddingHasAssertions',
-        output: (0, _dedent.default)`
-                it("it1", function() {expect.hasAssertions();
-                  someFunctionToDo();
-                  someFunctionToDo2();
-                });
-              `
-      }, {
-        messageId: 'suggestAddingAssertions',
-        output: (0, _dedent.default)`
-                it("it1", function() {expect.assertions();
-                  someFunctionToDo();
-                  someFunctionToDo2();
-                });
-              `
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {var a = 2;})',
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestAddingHasAssertions',
-        output: 'it("it1", function() {expect.hasAssertions();var a = 2;})'
-      }, {
-        messageId: 'suggestAddingAssertions',
-        output: 'it("it1", function() {expect.assertions();var a = 2;})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {expect.assertions();})',
-    errors: [{
-      messageId: 'assertionsRequiresOneArgument',
-      column: 30,
-      line: 1,
-      suggestions: []
-    }]
-  }, {
-    code: 'it("it1", function() {expect.assertions(1,2);})',
-    errors: [{
-      messageId: 'assertionsRequiresOneArgument',
-      column: 43,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: 'it("it1", function() {expect.assertions(1,);})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {expect.assertions(1,2,);})',
-    errors: [{
-      messageId: 'assertionsRequiresOneArgument',
-      column: 43,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: 'it("it1", function() {expect.assertions(1,);})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {expect.assertions("1");})',
-    errors: [{
-      messageId: 'assertionsRequiresNumberArgument',
-      column: 41,
-      line: 1,
-      suggestions: []
-    }]
-  }, {
-    code: 'it("it1", function() {expect.hasAssertions("1");})',
-    errors: [{
-      messageId: 'hasAssertionsTakesNoArguments',
-      column: 30,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: 'it("it1", function() {expect.hasAssertions();})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {expect.hasAssertions("1",);})',
-    errors: [{
-      messageId: 'hasAssertionsTakesNoArguments',
-      column: 30,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: 'it("it1", function() {expect.hasAssertions();})'
-      }]
-    }]
-  }, {
-    code: 'it("it1", function() {expect.hasAssertions("1", "2");})',
-    errors: [{
-      messageId: 'hasAssertionsTakesNoArguments',
-      column: 30,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: 'it("it1", function() {expect.hasAssertions();})'
-      }]
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", function() {
-          expect.hasAssertions(() => {
-            someFunctionToDo();
-            someFunctionToDo2();
-          });
-        });
-      `,
-    errors: [{
-      messageId: 'hasAssertionsTakesNoArguments',
-      column: 10,
-      line: 2,
-      suggestions: [{
-        messageId: 'suggestRemovingExtraArguments',
-        output: (0, _dedent.default)`
-                it("it1", function() {
-                  expect.hasAssertions();
-                });
-              `
-      }]
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", async function() {
-          expect(someValue).toBe(true);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", async () => {
-          for(let thing in things) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", async () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", async () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("returns numbers that are greater than five", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(5);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-expect-assertions (loops)', _preferExpectAssertions.default, {
-  valid: [{
-    code: (0, _dedent.default)`
-        const expectNumbersToBeGreaterThan = (numbers, value) => {
-          for (let number of numbers) {
-            expect(number).toBeGreaterThan(value);
-          }
-        };
-
-        it('returns numbers that are greater than two', function () {
-          expectNumbersToBeGreaterThan(getNumbers(), 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than five", function () {
-          expect.assertions(2);
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(5);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns things that are less than ten", function () {
-          expect.hasAssertions();
-
-          for (const thing in things) {
-            expect(thing).toBeLessThan(10);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }]
-  }],
-  invalid: [{
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than six', () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(6);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('returns numbers that are greater than two', function () {
-          const expectNumbersToBeGreaterThan = (numbers, value) => {
-            for (let number of numbers) {
-              expect(number).toBeGreaterThan(value);
-            }
-          };
-
-          expectNumbersToBeGreaterThan(getNumbers(), 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("only returns numbers that are greater than seven", function () {
-          const numbers = getNumbers();
-
-          for (let i = 0; i < numbers.length; i++) {
-            expect(numbers[i]).toBeGreaterThan(7);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('has the number two', () => {
-          expect(number).toBe(2);
-        });
-
-        it('only returns numbers that are less than twenty', () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeLessThan(20);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 5
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("is wrong");
-
-        it("is a test", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 3
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-
-        it("returns numbers that are greater than four", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("returns numbers that are greater than five", () => {
-          expect(number).toBeGreaterThan(5);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 5
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each([1, 2, 3])("returns numbers that are greater than four", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("is a number that is greater than four", () => {
-          expect.hasAssertions();
-
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", () => {
-          expect.hasAssertions();
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-
-        it("it1", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", async () => {
-          for (const number of await getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("returns numbers that are greater than five", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(5);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }, {
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 7
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", async () => {
-          expect.hasAssertions();
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("it1", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.skip.each\`\`("it1", async () => {
-          expect.hasAssertions();
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("it1", () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", async () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-
-        it("it1", () => {
-          expect.hasAssertions();
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-expect-assertions (callbacks)', _preferExpectAssertions.default, {
-  valid: [{
-    code: (0, _dedent.default)`
-        const expectNumbersToBeGreaterThan = (numbers, value) => {
-          numbers.forEach(number => {
-            expect(number).toBeGreaterThan(value);
-          });
-        };
-
-        it('returns numbers that are greater than two', function () {
-          expectNumbersToBeGreaterThan(getNumbers(), 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('returns numbers that are greater than two', function () {
-          expect.assertions(2);
-
-          const expectNumbersToBeGreaterThan = (numbers, value) => {
-            for (let number of numbers) {
-              expect(number).toBeGreaterThan(value);
-            }
-          };
-
-          expectNumbersToBeGreaterThan(getNumbers(), 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than five", function () {
-          expect.assertions(2);
-
-          getNumbers().forEach(number => {
-            expect(number).toBeGreaterThan(5);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns things that are less than ten", function () {
-          expect.hasAssertions();
-
-          things.forEach(thing => {
-            expect(thing).toBeLessThan(10);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('sends the data as a string', () => {
-          expect.hasAssertions();
-
-          const stream = openStream();
-
-          stream.on('data', data => {
-            expect(data).toBe(expect.any(String));
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          expect.assertions(1);
-
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each([1, 2, 3])("returns ok", id => {
-          expect.assertions(3);
-
-          client.get(\`/users/$\{id}\`, response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('is a test', () => {
-          expect(expected).toBe(actual);
-        });
-
-        describe('my test', () => {
-          it('is another test', () => {
-            expect(expected).toBe(actual);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }]
-  }],
-  invalid: [{
-    code: (0, _dedent.default)`
-        it('sends the data as a string', () => {
-          const stream = openStream();
-
-          stream.on('data', data => {
-            expect(data).toBe(expect.any(String));
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          client.get('/user', response => {
-            expect.assertions(1);
-
-            expect(response.status).toBe(200);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          const expectOkResponse = response => {
-            expect.assertions(1);
-
-            expect(response.status).toBe(200);
-          }; 
-
-          client.get('/user', expectOkResponse);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('returns numbers that are greater than two', function () {
-          const expectNumberToBeGreaterThan = (number, value) => {
-            expect(number).toBeGreaterThan(value);
-          };
-
-          expectNumberToBeGreaterThan(1, 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('returns numbers that are greater than two', function () {
-          const expectNumbersToBeGreaterThan = (numbers, value) => {
-            for (let number of numbers) {
-              expect(number).toBeGreaterThan(value);
-            }
-          };
-
-          expectNumbersToBeGreaterThan(getNumbers(), 2);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than six', () => {
-          getNumbers().forEach(number => {
-            expect(number).toBeGreaterThan(6);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("is wrong");
-
-        it('responds ok', function () {
-          const expectOkResponse = response => {
-            expect.assertions(1);
-
-            expect(response.status).toBe(200);
-          };
-
-          client.get('/user', expectOkResponse);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 3
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-
-        it('responds ok', function () {
-          const expectOkResponse = response => {
-            expect(response.status).toBe(200);
-          };
-
-          client.get('/user', expectOkResponse);
-        });
-
-        it("returns numbers that are greater than five", () => {
-          expect(number).toBeGreaterThan(5);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 5
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-
-        it("returns numbers that are greater than four", () => {
-          getNumbers().map(number => {
-            expect(number).toBeGreaterThan(0);
-          });
-        });
-
-        it("returns numbers that are greater than five", () => {
-          expect(number).toBeGreaterThan(5);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 5
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each([1, 2, 3])("returns ok", id => {
-          client.get(\`/users/$\{id}\`, response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it("is a number that is greater than four", () => {
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it("is a number that is greater than four", () => {
-          expect.hasAssertions();
-
-          expect(number).toBeGreaterThan(4);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("it1", () => {
-          expect.hasAssertions();
-
-          getNumbers().forEach(number => {
-            expect(number).toBeGreaterThan(0);
-          });
-        });
-
-        it("it1", () => {
-          getNumbers().forEach(number => {
-            expect(number).toBeGreaterThan(0);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('responds ok', function () {
-          expect.hasAssertions();
-
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it('responds not found', function () {
-          client.get('/user', response => {
-            expect(response.status).toBe(404);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.skip.each\`\`("it1", async () => {
-          expect.hasAssertions();
-
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-
-        it("responds ok", () => {
-          client.get('/user', response => {
-            expect(response.status).toBe(200);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInCallback: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("returns numbers that are greater than four", function(expect) {
-          expect.assertions(2);
-
-          for(let thing in things) {
-            expect(number).toBeGreaterThan(4);
-          }
-        });
-      `,
-    parserOptions: {
-      sourceType: 'module'
-    },
-    errors: [{
-      endColumn: 3,
-      column: 1,
-      messageId: 'haveExpectAssertions'
-    }]
-  }]
-});
-ruleTester.run('prefer-expect-assertions (mixed)', _preferExpectAssertions.default, {
-  valid: [{
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than zero', async () => {
-          expect.hasAssertions();
-
-          for (const number of await getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true,
-      onlyFunctionsWithExpectInLoop: true
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than zero', async () => {
-          expect.assertions(2);
-
-          for (const number of await getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true,
-      onlyFunctionsWithExpectInLoop: true
-    }]
-  }],
-  invalid: [{
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than zero', () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-
-        it("is zero", () => {
-          expect.hasAssertions();
-
-          expect(0).toBe(0);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than zero', () => {
-          expect.hasAssertions();
-
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-
-        it('only returns numbers that are less than 100', () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeLessThan(0);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 9
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("to be true", async function() {
-          expect(someValue).toBe(true);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true,
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it('only returns numbers that are greater than zero', async () => {
-          for (const number of getNumbers()) {
-            expect(number).toBeGreaterThan(0);
-          }
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true,
-      onlyFunctionsWithExpectInLoop: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('.each support', _preferExpectAssertions.default, {
-  valid: ['test.each()("is fine", () => { expect.assertions(0); })', 'test.each``("is fine", () => { expect.assertions(0); })', 'test.each()("is fine", () => { expect.hasAssertions(); })', 'test.each``("is fine", () => { expect.hasAssertions(); })', 'it.each()("is fine", () => { expect.assertions(0); })', 'it.each``("is fine", () => { expect.assertions(0); })', 'it.each()("is fine", () => { expect.hasAssertions(); })', 'it.each``("is fine", () => { expect.hasAssertions(); })', {
-    code: 'test.each()("is fine", () => {})',
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: 'test.each``("is fine", () => {})',
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: 'it.each()("is fine", () => {})',
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, {
-    code: 'it.each``("is fine", () => {})',
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }]
-  }, (0, _dedent.default)`
-      describe.each(['hello'])('%s', () => {
-        it('is fine', () => {
-          expect.assertions(0);
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each\`\`('%s', () => {
-        it('is fine', () => {
-          expect.assertions(0);
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each(['hello'])('%s', () => {
-        it('is fine', () => {
-          expect.hasAssertions();
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each\`\`('%s', () => {
-        it('is fine', () => {
-          expect.hasAssertions();
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each(['hello'])('%s', () => {
-        it.each()('is fine', () => {
-          expect.assertions(0);
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each\`\`('%s', () => {
-        it.each()('is fine', () => {
-          expect.assertions(0);
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each(['hello'])('%s', () => {
-        it.each()('is fine', () => {
-          expect.hasAssertions();
-        });
-      });
-    `, (0, _dedent.default)`
-      describe.each\`\`('%s', () => {
-        it.each()('is fine', () => {
-          expect.hasAssertions();
-        });
-      });
-    `],
-  invalid: [{
-    code: (0, _dedent.default)`
-        test.each()("is not fine", () => {
-          expect(someValue).toBe(true);
-        });
-      `,
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        describe.each()('something', () => {
-          it("is not fine", () => {
-            expect(someValue).toBe(true);
-          });
-        });
-      `,
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        describe.each()('something', () => {
-          test.each()("is not fine", () => {
-            expect(someValue).toBe(true);
-          });
-        });
-      `,
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        test.each()("is not fine", async () => {
-          expect(someValue).toBe(true);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each()("is not fine", async () => {
-          expect(someValue).toBe(true);
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 1,
-      line: 1
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        describe.each()('something', () => {
-          test.each()("is not fine", async () => {
-            expect(someValue).toBe(true);
-          });
-        });
-      `,
-    options: [{
-      onlyFunctionsWithAsyncKeyword: true
-    }],
-    errors: [{
-      messageId: 'haveExpectAssertions',
-      column: 3,
-      line: 2
-    }]
-  }]
-});