eslint-plugin-jest 27.2.1 → 27.2.2

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

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

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

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

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