eslint-plugin-jest 27.2.0 → 27.2.2

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

@@ -0,0 +1,1437 @@
+"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
+    }]
+  }]
+});