eslint-plugin-jest 27.2.0 → 27.2.2

package/lib/rules/__tests__/no-restricted-matchers.test.js

@@ -0,0 +1,244 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _noRestrictedMatchers = _interopRequireDefault(require("../no-restricted-matchers"));
+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('no-restricted-matchers', _noRestrictedMatchers.default, {
+  valid: ['expect(a).toHaveBeenCalled()', 'expect(a).not.toHaveBeenCalled()', 'expect(a).toHaveBeenCalledTimes()', 'expect(a).toHaveBeenCalledWith()', 'expect(a).toHaveBeenLastCalledWith()', 'expect(a).toHaveBeenNthCalledWith()', 'expect(a).toHaveReturned()', 'expect(a).toHaveReturnedTimes()', 'expect(a).toHaveReturnedWith()', 'expect(a).toHaveLastReturnedWith()', 'expect(a).toHaveNthReturnedWith()', 'expect(a).toThrow()', 'expect(a).rejects;', 'expect(a);', {
+    code: 'expect(a).resolves',
+    options: [{
+      not: null
+    }]
+  }, {
+    code: 'expect(a).toBe(b)',
+    options: [{
+      'not.toBe': null
+    }]
+  }, {
+    code: 'expect(a).toBeUndefined(b)',
+    options: [{
+      toBe: null
+    }]
+  }, {
+    code: 'expect(a)["toBe"](b)',
+    options: [{
+      'not.toBe': null
+    }]
+  }, {
+    code: 'expect(a).resolves.not.toBe(b)',
+    options: [{
+      not: null
+    }]
+  }, {
+    code: 'expect(a).resolves.not.toBe(b)',
+    options: [{
+      'not.toBe': null
+    }]
+  }, {
+    code: "expect(uploadFileMock).resolves.toHaveBeenCalledWith('file.name')",
+    options: [{
+      'not.toHaveBeenCalledWith': 'Use not.toHaveBeenCalled instead'
+    }]
+  }, {
+    code: "expect(uploadFileMock).resolves.not.toHaveBeenCalledWith('file.name')",
+    options: [{
+      'not.toHaveBeenCalledWith': 'Use not.toHaveBeenCalled instead'
+    }]
+  }],
+  invalid: [{
+    code: 'expect(a).toBe(b)',
+    options: [{
+      toBe: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'toBe'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a)["toBe"](b)',
+    options: [{
+      toBe: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'toBe'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).not[x]()',
+    options: [{
+      not: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'not'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).not.toBe(b)',
+    options: [{
+      not: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'not'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).resolves.toBe(b)',
+    options: [{
+      resolves: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'resolves'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).resolves.not.toBe(b)',
+    options: [{
+      resolves: null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'resolves'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).resolves.not.toBe(b)',
+    options: [{
+      'resolves.not': null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'resolves.not'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).not.toBe(b)',
+    options: [{
+      'not.toBe': null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'not.toBe'
+      },
+      endColumn: 19,
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).resolves.not.toBe(b)',
+    options: [{
+      'resolves.not.toBe': null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'resolves.not.toBe'
+      },
+      endColumn: 28,
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a).toBe(b)',
+    options: [{
+      toBe: 'Prefer `toStrictEqual` instead'
+    }],
+    errors: [{
+      messageId: 'restrictedChainWithMessage',
+      data: {
+        message: 'Prefer `toStrictEqual` instead',
+        restriction: 'toBe'
+      },
+      column: 11,
+      line: 1
+    }]
+  }, {
+    code: `
+        test('some test', async () => {
+          await expect(Promise.resolve(1)).resolves.toBe(1);
+         });
+      `,
+    options: [{
+      resolves: 'Use `expect(await promise)` instead.'
+    }],
+    errors: [{
+      messageId: 'restrictedChainWithMessage',
+      data: {
+        message: 'Use `expect(await promise)` instead.',
+        restriction: 'resolves'
+      },
+      endColumn: 57,
+      column: 44
+    }]
+  }, {
+    code: 'expect(Promise.resolve({})).rejects.toBeFalsy()',
+    options: [{
+      'rejects.toBeFalsy': null
+    }],
+    errors: [{
+      messageId: 'restrictedChain',
+      data: {
+        message: null,
+        restriction: 'rejects.toBeFalsy'
+      },
+      endColumn: 46,
+      column: 29
+    }]
+  }, {
+    code: "expect(uploadFileMock).not.toHaveBeenCalledWith('file.name')",
+    options: [{
+      'not.toHaveBeenCalledWith': 'Use not.toHaveBeenCalled instead'
+    }],
+    errors: [{
+      messageId: 'restrictedChainWithMessage',
+      data: {
+        message: 'Use not.toHaveBeenCalled instead',
+        restriction: 'not.toHaveBeenCalledWith'
+      },
+      endColumn: 48,
+      column: 24
+    }]
+  }]
+});

package/lib/rules/__tests__/no-standalone-expect.test.js

@@ -0,0 +1,230 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noStandaloneExpect = _interopRequireDefault(require("../no-standalone-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: 2015
+  }
+});
+ruleTester.run('no-standalone-expect', _noStandaloneExpect.default, {
+  valid: ['expect.any(String)', 'expect.extend({})', 'describe("a test", () => { it("an it", () => {expect(1).toBe(1); }); });', 'describe("a test", () => { it("an it", () => { const func = () => { expect(1).toBe(1); }; }); });', 'describe("a test", () => { const func = () => { expect(1).toBe(1); }; });', 'describe("a test", () => { function func() { expect(1).toBe(1); }; });', 'describe("a test", () => { const func = function(){ expect(1).toBe(1); }; });', 'it("an it", () => expect(1).toBe(1))', 'const func = function(){ expect(1).toBe(1); };', 'const func = () => expect(1).toBe(1);', '{}', 'it.each([1, true])("trues", value => { expect(value).toBe(true); });', 'it.each([1, true])("trues", value => { expect(value).toBe(true); }); it("an it", () => { expect(1).toBe(1) });', (0, _dedent.default)`
+      it.each\`
+        num   | value
+        \${1} | \${true}
+      \`('trues', ({ value }) => {
+        expect(value).toBe(true);
+      });
+    `, 'it.only("an only", value => { expect(value).toBe(true); });', 'it.concurrent("an concurrent", value => { expect(value).toBe(true); });', 'describe.each([1, true])("trues", value => { it("an it", () => expect(value).toBe(true) ); });', {
+    code: (0, _dedent.default)`
+        describe('scenario', () => {
+          const t = Math.random() ? it.only : it;
+          t('testing', () => expect(true));
+        });
+      `,
+    options: [{
+      additionalTestBlockFunctions: ['t']
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        each([
+          [1, 1, 2],
+          [1, 2, 3],
+          [2, 1, 3],
+        ]).test('returns the result of adding %d to %d', (a, b, expected) => {
+          expect(a + b).toBe(expected);
+        });
+      `,
+    options: [{
+      additionalTestBlockFunctions: ['each.test']
+    }]
+  }],
+  invalid: [{
+    code: "(() => {})('testing', () => expect(true).toBe(false))",
+    errors: [{
+      endColumn: 53,
+      column: 29,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'expect.hasAssertions()',
+    errors: [{
+      endColumn: 23,
+      column: 1,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'expect().hasAssertions()',
+    errors: [{
+      endColumn: 25,
+      column: 1,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        describe('scenario', () => {
+          const t = Math.random() ? it.only : it;
+          t('testing', () => expect(true).toBe(false));
+        });
+      `,
+    errors: [{
+      endColumn: 46,
+      column: 22,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        describe('scenario', () => {
+          const t = Math.random() ? it.only : it;
+          t('testing', () => expect(true).toBe(false));
+        });
+      `,
+    options: [{
+      additionalTestBlockFunctions: undefined
+    }],
+    errors: [{
+      endColumn: 46,
+      column: 22,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        each([
+          [1, 1, 2],
+          [1, 2, 3],
+          [2, 1, 3],
+        ]).test('returns the result of adding %d to %d', (a, b, expected) => {
+          expect(a + b).toBe(expected);
+        });
+      `,
+    errors: [{
+      endColumn: 31,
+      column: 3,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        each([
+          [1, 1, 2],
+          [1, 2, 3],
+          [2, 1, 3],
+        ]).test('returns the result of adding %d to %d', (a, b, expected) => {
+          expect(a + b).toBe(expected);
+        });
+      `,
+    options: [{
+      additionalTestBlockFunctions: ['each']
+    }],
+    errors: [{
+      endColumn: 31,
+      column: 3,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        each([
+          [1, 1, 2],
+          [1, 2, 3],
+          [2, 1, 3],
+        ]).test('returns the result of adding %d to %d', (a, b, expected) => {
+          expect(a + b).toBe(expected);
+        });
+      `,
+    options: [{
+      additionalTestBlockFunctions: ['test']
+    }],
+    errors: [{
+      endColumn: 31,
+      column: 3,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'describe("a test", () => { expect(1).toBe(1); });',
+    errors: [{
+      endColumn: 45,
+      column: 28,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'describe("a test", () => expect(1).toBe(1));',
+    errors: [{
+      endColumn: 43,
+      column: 26,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'describe("a test", () => { const func = () => { expect(1).toBe(1); }; expect(1).toBe(1); });',
+    errors: [{
+      endColumn: 88,
+      column: 71,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'describe("a test", () => {  it(() => { expect(1).toBe(1); }); expect(1).toBe(1); });',
+    errors: [{
+      endColumn: 80,
+      column: 63,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'expect(1).toBe(1);',
+    errors: [{
+      endColumn: 18,
+      column: 1,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: '{expect(1).toBe(1)}',
+    errors: [{
+      endColumn: 19,
+      column: 2,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'it.each([1, true])("trues", value => { expect(value).toBe(true); }); expect(1).toBe(1);',
+    errors: [{
+      endColumn: 87,
+      column: 70,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: 'describe.each([1, true])("trues", value => { expect(value).toBe(true); });',
+    errors: [{
+      endColumn: 70,
+      column: 46,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect as pleaseExpect } from '@jest/globals';
+
+        describe("a test", () => { pleaseExpect(1).toBe(1); });
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      endColumn: 51,
+      column: 28,
+      messageId: 'unexpectedExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect as pleaseExpect } from '@jest/globals';
+
+        beforeEach(() => pleaseExpect.hasAssertions());
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      endColumn: 46,
+      column: 18,
+      messageId: 'unexpectedExpect'
+    }]
+  }]
+});

package/lib/rules/__tests__/no-test-prefixes.test.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noTestPrefixes = _interopRequireDefault(require("../no-test-prefixes"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester();
+ruleTester.run('no-test-prefixes', _noTestPrefixes.default, {
+  valid: ['describe("foo", function () {})', 'it("foo", function () {})', 'it.concurrent("foo", function () {})', 'test("foo", function () {})', 'test.concurrent("foo", function () {})', 'describe.only("foo", function () {})', 'it.only("foo", function () {})', 'it.each()("foo", function () {})', {
+    code: 'it.each``("foo", function () {})',
+    parserOptions: {
+      ecmaVersion: 6
+    }
+  }, 'test.only("foo", function () {})', 'test.each()("foo", function () {})', {
+    code: 'test.each``("foo", function () {})',
+    parserOptions: {
+      ecmaVersion: 6
+    }
+  }, 'describe.skip("foo", function () {})', 'it.skip("foo", function () {})', 'test.skip("foo", function () {})', 'foo()', '[1,2,3].forEach()'],
+  invalid: [{
+    code: 'fdescribe("foo", function () {})',
+    output: 'describe.only("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'describe.only'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xdescribe.each([])("foo", function () {})',
+    output: 'describe.skip.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'describe.skip.each'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'fit("foo", function () {})',
+    output: 'it.only("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.only'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xdescribe("foo", function () {})',
+    output: 'describe.skip("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'describe.skip'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit("foo", function () {})',
+    output: 'it.skip("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.skip'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest("foo", function () {})',
+    output: 'test.skip("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'test.skip'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit.each``("foo", function () {})',
+    output: 'it.skip.each``("foo", function () {})',
+    parserOptions: {
+      ecmaVersion: 6
+    },
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.skip.each'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest.each``("foo", function () {})',
+    output: 'test.skip.each``("foo", function () {})',
+    parserOptions: {
+      ecmaVersion: 6
+    },
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'test.skip.each'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit.each([])("foo", function () {})',
+    output: 'it.skip.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.skip.each'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest.each([])("foo", function () {})',
+    output: 'test.skip.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'test.skip.each'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { xit } from '@jest/globals';
+
+        xit("foo", function () {})
+      `,
+    output: (0, _dedent.default)`
+        import { xit } from '@jest/globals';
+
+        it.skip("foo", function () {})
+      `,
+    parserOptions: {
+      sourceType: 'module',
+      ecmaVersion: 2015
+    },
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.skip'
+      },
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { xit as skipThis } from '@jest/globals';
+
+        skipThis("foo", function () {})
+      `,
+    output: (0, _dedent.default)`
+        import { xit as skipThis } from '@jest/globals';
+
+        it.skip("foo", function () {})
+      `,
+    parserOptions: {
+      sourceType: 'module',
+      ecmaVersion: 2015
+    },
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.skip'
+      },
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { fit as onlyThis } from '@jest/globals';
+
+        onlyThis("foo", function () {})
+      `,
+    output: (0, _dedent.default)`
+        import { fit as onlyThis } from '@jest/globals';
+
+        it.only("foo", function () {})
+      `,
+    parserOptions: {
+      sourceType: 'module',
+      ecmaVersion: 2015
+    },
+    errors: [{
+      messageId: 'usePreferredName',
+      data: {
+        preferredNodeName: 'it.only'
+      },
+      column: 1,
+      line: 3
+    }]
+  }]
+});