eslint-plugin-jest 27.2.2 → 27.2.3

package/lib/rules/__tests__/no-test-return-statement.test.js

@@ -1,122 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _dedent = _interopRequireDefault(require("dedent"));
-var _noTestReturnStatement = _interopRequireDefault(require("../no-test-return-statement"));
-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-test-return-statement', _noTestReturnStatement.default, {
-  valid: ['it("noop", function () {});', 'test("noop", () => {});', 'test("one", () => expect(1).toBe(1));', 'test("empty")', (0, _dedent.default)`
-      test("one", () => {
-        expect(1).toBe(1);
-      });
-    `, (0, _dedent.default)`
-      it("one", function () {
-        expect(1).toBe(1);
-      });
-    `, (0, _dedent.default)`
-      it("one", myTest);
-      function myTest() {
-        expect(1).toBe(1);
-      }
-    `, (0, _dedent.default)`
-      it("one", () => expect(1).toBe(1));
-      function myHelper() {}
-    `],
-  invalid: [{
-    code: (0, _dedent.default)`
-        test("one", () => {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.skip("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each\`\`("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.each()("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.only.each\`\`("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it.only.each()("one", function () {
-          return expect(1).toBe(1);
-        });
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 2
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        it("one", myTest);
-        function myTest () {
-          return expect(1).toBe(1);
-        }
-      `,
-    errors: [{
-      messageId: 'noReturnValue',
-      column: 3,
-      line: 3
-    }]
-  }]
-});

package/lib/rules/__tests__/no-untyped-mock-factory.test.js

@@ -1,149 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _dedent = _interopRequireDefault(require("dedent"));
-var _noUntypedMockFactory = _interopRequireDefault(require("../no-untyped-mock-factory"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const ruleTester = new _utils.TSESLint.RuleTester({
-  parser: require.resolve('@typescript-eslint/parser')
-});
-ruleTester.run('no-untyped-mock-factory', _noUntypedMockFactory.default, {
-  valid: ["jest.mock('random-number');", (0, _dedent.default)`
-      jest.mock<typeof import('../moduleName')>('../moduleName', () => {
-        return jest.fn(() => 42);
-      });
-    `, (0, _dedent.default)`
-      jest.mock<typeof import('./module')>('./module', () => ({
-        ...jest.requireActual('./module'),
-        foo: jest.fn()
-      }));
-    `, (0, _dedent.default)`
-      jest.mock<typeof import('foo')>('bar', () => ({
-        ...jest.requireActual('bar'),
-        foo: jest.fn()
-      }));
-    `, (0, _dedent.default)`
-      jest.doMock('./module', (): typeof import('./module') => ({
-        ...jest.requireActual('./module'),
-        foo: jest.fn()
-      }));
-    `, (0, _dedent.default)`
-      jest.mock('../moduleName', function (): typeof import('../moduleName') {
-        return jest.fn(() => 42);
-      });
-    `, (0, _dedent.default)`
-      jest.mock<() => number>('random-num', () => {
-        return jest.fn(() => 42);
-      });
-    `, (0, _dedent.default)`
-      jest['doMock']<() => number>('random-num', () => {
-        return jest.fn(() => 42);
-      });
-    `, (0, _dedent.default)`
-      jest.mock<any>('random-num', () => {
-        return jest.fn(() => 42);
-      });
-    `, (0, _dedent.default)`
-      jest.mock(
-        '../moduleName',
-        () => {
-          return jest.fn(() => 42)
-        },
-        {virtual: true},
-      );
-    `, (0, _dedent.default)`
-      jest.mock('../moduleName', function (): (() => number) {
-        return jest.fn(() => 42);
-      });
-    `,
-  // Should not match
-  (0, _dedent.default)`
-      mockito<() => number>('foo', () => {
-        return jest.fn(() => 42);
-      });
-    `],
-  invalid: [{
-    code: (0, _dedent.default)`
-        jest.mock('../moduleName', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    output: (0, _dedent.default)`
-        jest.mock<typeof import('../moduleName')>('../moduleName', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        jest.mock("./module", () => ({
-          ...jest.requireActual('./module'),
-          foo: jest.fn()
-        }));
-      `,
-    output: (0, _dedent.default)`
-        jest.mock<typeof import("./module")>("./module", () => ({
-          ...jest.requireActual('./module'),
-          foo: jest.fn()
-        }));
-      `,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        jest.mock('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    output: (0, _dedent.default)`
-        jest.mock<typeof import('random-num')>('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        jest.doMock('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    output: (0, _dedent.default)`
-        jest.doMock<typeof import('random-num')>('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        jest['mock']('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    output: (0, _dedent.default)`
-        jest['mock']<typeof import('random-num')>('random-num', () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }, {
-    code: (0, _dedent.default)`
-        const moduleToMock = 'random-num';
-        jest.mock(moduleToMock, () => {
-          return jest.fn(() => 42);
-        });
-      `,
-    output: null,
-    errors: [{
-      messageId: 'addTypeParameterToModuleMock'
-    }]
-  }]
-});

package/lib/rules/__tests__/prefer-called-with.test.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _preferCalledWith = _interopRequireDefault(require("../prefer-called-with"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const ruleTester = new _utils.TSESLint.RuleTester();
-ruleTester.run('prefer-called-with', _preferCalledWith.default, {
-  valid: ['expect(fn).toBeCalledWith();', 'expect(fn).toHaveBeenCalledWith();', 'expect(fn).toBeCalledWith(expect.anything());', 'expect(fn).toHaveBeenCalledWith(expect.anything());', 'expect(fn).not.toBeCalled();', 'expect(fn).rejects.not.toBeCalled();', 'expect(fn).not.toHaveBeenCalled();', 'expect(fn).not.toBeCalledWith();', 'expect(fn).not.toHaveBeenCalledWith();', 'expect(fn).resolves.not.toHaveBeenCalledWith();', 'expect(fn).toBeCalledTimes(0);', 'expect(fn).toHaveBeenCalledTimes(0);', 'expect(fn);'],
-  invalid: [{
-    code: 'expect(fn).toBeCalled();',
-    errors: [{
-      messageId: 'preferCalledWith',
-      data: {
-        matcherName: 'toBeCalled'
-      },
-      column: 12,
-      line: 1
-    }]
-  }, {
-    code: 'expect(fn).resolves.toBeCalled();',
-    errors: [{
-      messageId: 'preferCalledWith',
-      data: {
-        matcherName: 'toBeCalled'
-      },
-      column: 21,
-      line: 1
-    }]
-  }, {
-    code: 'expect(fn).toHaveBeenCalled();',
-    errors: [{
-      messageId: 'preferCalledWith',
-      data: {
-        matcherName: 'toHaveBeenCalled'
-      },
-      column: 12,
-      line: 1
-    }]
-  }]
-});

package/lib/rules/__tests__/prefer-comparison-matcher.test.js

@@ -1,200 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _preferComparisonMatcher = _interopRequireDefault(require("../prefer-comparison-matcher"));
-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
-  }
-});
-const generateInvalidCases = (operator, equalityMatcher, preferredMatcher, preferredMatcherWhenNegated) => {
-  return [{
-    code: `expect(value ${operator} 1).${equalityMatcher}(true);`,
-    output: `expect(value).${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 18 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1,).${equalityMatcher}(true,);`,
-    output: `expect(value,).${preferredMatcher}(1,);`,
-    parserOptions: {
-      ecmaVersion: 2017
-    },
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 19 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)['${equalityMatcher}'](true);`,
-    output: `expect(value).${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 18 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).resolves.${equalityMatcher}(true);`,
-    output: `expect(value).resolves.${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 27 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).${equalityMatcher}(false);`,
-    output: `expect(value).${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 18 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)['${equalityMatcher}'](false);`,
-    output: `expect(value).${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 18 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).resolves.${equalityMatcher}(false);`,
-    output: `expect(value).resolves.${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 27 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).not.${equalityMatcher}(true);`,
-    output: `expect(value).${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 22 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)['not'].${equalityMatcher}(true);`,
-    output: `expect(value).${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 25 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).resolves.not.${equalityMatcher}(true);`,
-    output: `expect(value).resolves.${preferredMatcherWhenNegated}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher: preferredMatcherWhenNegated
-      },
-      column: 31 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).not.${equalityMatcher}(false);`,
-    output: `expect(value).${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 22 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1).resolves.not.${equalityMatcher}(false);`,
-    output: `expect(value).resolves.${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 31 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)["resolves"].not.${equalityMatcher}(false);`,
-    output: `expect(value).resolves.${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 34 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)["resolves"]["not"].${equalityMatcher}(false);`,
-    output: `expect(value).resolves.${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 37 + operator.length,
-      line: 1
-    }]
-  }, {
-    code: `expect(value ${operator} 1)["resolves"]["not"]['${equalityMatcher}'](false);`,
-    output: `expect(value).resolves.${preferredMatcher}(1);`,
-    errors: [{
-      messageId: 'useToBeComparison',
-      data: {
-        preferredMatcher
-      },
-      column: 37 + operator.length,
-      line: 1
-    }]
-  }];
-};
-const generateValidStringLiteralCases = (operator, matcher) => {
-  return [['x', "'y'"], ['x', '`y`'], ['x', '`y${z}`']].reduce((cases, [a, b]) => [...cases, ...[`expect(${a} ${operator} ${b}).${matcher}(true)`, `expect(${a} ${operator} ${b}).${matcher}(false)`, `expect(${a} ${operator} ${b}).not.${matcher}(true)`, `expect(${a} ${operator} ${b}).not.${matcher}(false)`, `expect(${b} ${operator} ${a}).${matcher}(true)`, `expect(${b} ${operator} ${a}).${matcher}(false)`, `expect(${b} ${operator} ${a}).not.${matcher}(true)`, `expect(${b} ${operator} ${a}).not.${matcher}(false)`, `expect(${a} ${operator} ${b}).${matcher}(true)`, `expect(${a} ${operator} ${b}).${matcher}(false)`, `expect(${a} ${operator} ${b}).not.${matcher}(true)`, `expect(${a} ${operator} ${b}).not.${matcher}(false)`, `expect(${b} ${operator} ${a}).${matcher}(true)`, `expect(${b} ${operator} ${a}).${matcher}(false)`, `expect(${b} ${operator} ${a}).not.${matcher}(true)`, `expect(${b} ${operator} ${a}).not.${matcher}(false)`, `expect(${b} ${operator} ${b}).not.${matcher}(false)`, `expect(${b} ${operator} ${b}).resolves.not.${matcher}(false)`, `expect(${b} ${operator} ${b}).resolves.${matcher}(false)`]]);
-};
-const testComparisonOperator = (operator, preferredMatcher, preferredMatcherWhenNegated) => {
-  ruleTester.run(`prefer-to-be-comparison: ${operator}`, _preferComparisonMatcher.default, {
-    valid: ['expect()', 'expect({}).toStrictEqual({})', `expect(value).${preferredMatcher}(1);`, `expect(value).${preferredMatcherWhenNegated}(1);`, `expect(value).not.${preferredMatcher}(1);`, `expect(value).not.${preferredMatcherWhenNegated}(1);`, ...['toBe', 'toEqual', 'toStrictEqual'].reduce((cases, equalityMatcher) => [...cases, ...generateValidStringLiteralCases(operator, equalityMatcher)], [])],
-    invalid: ['toBe', 'toEqual', 'toStrictEqual'].reduce((cases, equalityMatcher) => [...cases, ...generateInvalidCases(operator, equalityMatcher, preferredMatcher, preferredMatcherWhenNegated)], [])
-  });
-};
-testComparisonOperator('>', 'toBeGreaterThan', 'toBeLessThanOrEqual');
-testComparisonOperator('<', 'toBeLessThan', 'toBeGreaterThanOrEqual');
-testComparisonOperator('>=', 'toBeGreaterThanOrEqual', 'toBeLessThan');
-testComparisonOperator('<=', 'toBeLessThanOrEqual', 'toBeGreaterThan');
-ruleTester.run(`prefer-to-be-comparison`, _preferComparisonMatcher.default, {
-  valid: ['expect.hasAssertions', 'expect.hasAssertions()', 'expect.assertions(1)', 'expect(true).toBe(...true)', 'expect()', 'expect({}).toStrictEqual({})', 'expect(a === b).toBe(true)', 'expect(a !== 2).toStrictEqual(true)', 'expect(a === b).not.toEqual(true)', 'expect(a !== "string").toStrictEqual(true)', 'expect(5 != a).toBe(true)', 'expect(a == "string").toBe(true)', 'expect(a == "string").not.toBe(true)'],
-  invalid: []
-});