eslint-plugin-jest 27.2.2 → 27.2.3

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

@@ -1,244 +0,0 @@
-"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

@@ -1,230 +0,0 @@
-"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

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