eslint-plugin-jest 27.2.2 → 27.3.0

package/lib/rules/__tests__/prefer-spy-on.test.js

@@ -1,100 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _preferSpyOn = _interopRequireDefault(require("../prefer-spy-on"));
-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('prefer-spy-on', _preferSpyOn.default, {
-  valid: ['Date.now = () => 10', 'window.fetch = jest.fn', 'Date.now = fn()', 'obj.mock = jest.something()', 'const mock = jest.fn()', 'mock = jest.fn()', 'const mockObj = { mock: jest.fn() }', 'mockObj = { mock: jest.fn() }', 'window[`${name}`] = jest[`fn${expression}`]()'],
-  invalid: [{
-    code: 'obj.a = jest.fn(); const test = 10;',
-    output: "jest.spyOn(obj, 'a').mockImplementation(); const test = 10;",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: "Date['now'] = jest['fn']()",
-    output: "jest.spyOn(Date, 'now').mockImplementation()",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: 'window[`${name}`] = jest[`fn`]()',
-    output: 'jest.spyOn(window, `${name}`).mockImplementation()',
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: "obj['prop' + 1] = jest['fn']()",
-    output: "jest.spyOn(obj, 'prop' + 1).mockImplementation()",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: 'obj.one.two = jest.fn(); const test = 10;',
-    output: "jest.spyOn(obj.one, 'two').mockImplementation(); const test = 10;",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: 'obj.a = jest.fn(() => 10,)',
-    output: "jest.spyOn(obj, 'a').mockImplementation(() => 10)",
-    parserOptions: {
-      ecmaVersion: 2017
-    },
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: "obj.a.b = jest.fn(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();",
-    output: "jest.spyOn(obj.a, 'b').mockImplementation(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    code: 'window.fetch = jest.fn(() => ({})).one.two().three().four',
-    output: "jest.spyOn(window, 'fetch').mockImplementation(() => ({})).one.two().three().four",
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    // https://github.com/jest-community/eslint-plugin-jest/issues/1304
-    code: 'foo[bar] = jest.fn().mockReturnValue(undefined)',
-    output: 'jest.spyOn(foo, bar).mockImplementation().mockReturnValue(undefined)',
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }, {
-    // https://github.com/jest-community/eslint-plugin-jest/issues/1307
-    code: `
-        foo.bar = jest.fn().mockImplementation(baz => baz)
-        foo.bar = jest.fn(a => b).mockImplementation(baz => baz)
-      `,
-    output: `
-        jest.spyOn(foo, 'bar').mockImplementation(baz => baz)
-        jest.spyOn(foo, 'bar').mockImplementation(baz => baz)
-      `,
-    errors: [{
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }, {
-      messageId: 'useJestSpyOn',
-      type: _utils.AST_NODE_TYPES.AssignmentExpression
-    }]
-  }]
-});

package/lib/rules/__tests__/prefer-strict-equal.test.js

@@ -1,46 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _preferStrictEqual = _interopRequireDefault(require("../prefer-strict-equal"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const ruleTester = new _utils.TSESLint.RuleTester();
-ruleTester.run('prefer-strict-equal', _preferStrictEqual.default, {
-  valid: ['expect(something).toStrictEqual(somethingElse);', "a().toEqual('b')", 'expect(a);'],
-  invalid: [{
-    code: 'expect(something).toEqual(somethingElse);',
-    errors: [{
-      messageId: 'useToStrictEqual',
-      column: 19,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestReplaceWithStrictEqual',
-        output: 'expect(something).toStrictEqual(somethingElse);'
-      }]
-    }]
-  }, {
-    code: 'expect(something).toEqual(somethingElse,);',
-    parserOptions: {
-      ecmaVersion: 2017
-    },
-    errors: [{
-      messageId: 'useToStrictEqual',
-      column: 19,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestReplaceWithStrictEqual',
-        output: 'expect(something).toStrictEqual(somethingElse,);'
-      }]
-    }]
-  }, {
-    code: 'expect(something)["toEqual"](somethingElse);',
-    errors: [{
-      messageId: 'useToStrictEqual',
-      column: 19,
-      line: 1,
-      suggestions: [{
-        messageId: 'suggestReplaceWithStrictEqual',
-        output: "expect(something)['toStrictEqual'](somethingElse);"
-      }]
-    }]
-  }]
-});

package/lib/rules/__tests__/prefer-to-be.test.js

@@ -1,438 +0,0 @@
-"use strict";
-
-var _utils = require("@typescript-eslint/utils");
-var _preferToBe = _interopRequireDefault(require("../prefer-to-be"));
-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('prefer-to-be', _preferToBe.default, {
-  valid: ['expect(null).toBeNull();', 'expect(null).not.toBeNull();', 'expect(null).toBe(1);', 'expect(null).toBe(-1);', 'expect(null).toBe(...1);', 'expect(obj).toStrictEqual([ x, 1 ]);', 'expect(obj).toStrictEqual({ x: 1 });', 'expect(obj).not.toStrictEqual({ x: 1 });', 'expect(value).toMatchSnapshot();', "expect(catchError()).toStrictEqual({ message: 'oh noes!' })", 'expect("something");', 'expect(token).toStrictEqual(/[abc]+/g);', "expect(token).toStrictEqual(new RegExp('[abc]+', 'g'));", 'expect(value).toEqual(dedent`my string`);'],
-  invalid: [{
-    code: 'expect(value).toEqual("my string");',
-    output: 'expect(value).toBe("my string");',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toStrictEqual("my string");',
-    output: 'expect(value).toBe("my string");',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toStrictEqual(1);',
-    output: 'expect(value).toBe(1);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toStrictEqual(1,);',
-    output: 'expect(value).toBe(1,);',
-    parserOptions: {
-      ecmaVersion: 2017
-    },
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toStrictEqual(-1);',
-    output: 'expect(value).toBe(-1);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toEqual(`my string`);',
-    output: 'expect(value).toBe(`my string`);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value)["toEqual"](`my string`);',
-    output: "expect(value)['toBe'](`my string`);",
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(value).toStrictEqual(`my ${string}`);',
-    output: 'expect(value).toBe(`my ${string}`);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 15,
-      line: 1
-    }]
-  }, {
-    code: 'expect(loadMessage()).resolves.toStrictEqual("hello world");',
-    output: 'expect(loadMessage()).resolves.toBe("hello world");',
-    errors: [{
-      messageId: 'useToBe',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect(loadMessage()).resolves["toStrictEqual"]("hello world");',
-    output: 'expect(loadMessage()).resolves[\'toBe\']("hello world");',
-    errors: [{
-      messageId: 'useToBe',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect(loadMessage())["resolves"].toStrictEqual("hello world");',
-    output: 'expect(loadMessage())["resolves"].toBe("hello world");',
-    errors: [{
-      messageId: 'useToBe',
-      column: 35,
-      line: 1
-    }]
-  }, {
-    code: 'expect(loadMessage()).resolves.toStrictEqual(false);',
-    output: 'expect(loadMessage()).resolves.toBe(false);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 32,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-to-be: null', _preferToBe.default, {
-  valid: ['expect(null).toBeNull();', 'expect(null).not.toBeNull();', 'expect(null).toBe(1);', 'expect(obj).toStrictEqual([ x, 1 ]);', 'expect(obj).toStrictEqual({ x: 1 });', 'expect(obj).not.toStrictEqual({ x: 1 });', 'expect(value).toMatchSnapshot();', "expect(catchError()).toStrictEqual({ message: 'oh noes!' })", 'expect("something");',
-  //
-  'expect(null).not.toEqual();', 'expect(null).toBe();', 'expect(null).toMatchSnapshot();', 'expect("a string").toMatchSnapshot(null);', 'expect("a string").not.toMatchSnapshot();', 'expect(null).toBe'],
-  invalid: [{
-    code: 'expect(null).toBe(null);',
-    output: 'expect(null).toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect(null).toEqual(null);',
-    output: 'expect(null).toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect(null).toEqual(null,);',
-    output: 'expect(null).toBeNull();',
-    parserOptions: {
-      ecmaVersion: 2017
-    },
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect(null).toStrictEqual(null);',
-    output: 'expect(null).toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toBe(null);',
-    output: 'expect("a string").not.toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not["toBe"](null);',
-    output: 'expect("a string").not[\'toBeNull\']();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string")["not"]["toBe"](null);',
-    output: 'expect("a string")["not"][\'toBeNull\']();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 27,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toEqual(null);',
-    output: 'expect("a string").not.toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toStrictEqual(null);',
-    output: 'expect("a string").not.toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 24,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-to-be: undefined', _preferToBe.default, {
-  valid: ['expect(undefined).toBeUndefined();', 'expect(true).toBeDefined();', 'expect({}).toEqual({});', 'expect(something).toBe()', 'expect(something).toBe(somethingElse)', 'expect(something).toEqual(somethingElse)', 'expect(something).not.toBe(somethingElse)', 'expect(something).not.toEqual(somethingElse)', 'expect(undefined).toBe', 'expect("something");'],
-  invalid: [{
-    code: 'expect(undefined).toBe(undefined);',
-    output: 'expect(undefined).toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 19,
-      line: 1
-    }]
-  }, {
-    code: 'expect(undefined).toEqual(undefined);',
-    output: 'expect(undefined).toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 19,
-      line: 1
-    }]
-  }, {
-    code: 'expect(undefined).toStrictEqual(undefined);',
-    output: 'expect(undefined).toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 19,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toBe(undefined);',
-    output: 'expect("a string").toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").rejects.not.toBe(undefined);',
-    output: 'expect("a string").rejects.toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").rejects.not["toBe"](undefined);',
-    output: 'expect("a string").rejects[\'toBeDefined\']();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toEqual(undefined);',
-    output: 'expect("a string").toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toStrictEqual(undefined);',
-    output: 'expect("a string").toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 24,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-to-be: NaN', _preferToBe.default, {
-  valid: ['expect(NaN).toBeNaN();', 'expect(true).not.toBeNaN();', 'expect({}).toEqual({});', 'expect(something).toBe()', 'expect(something).toBe(somethingElse)', 'expect(something).toEqual(somethingElse)', 'expect(something).not.toBe(somethingElse)', 'expect(something).not.toEqual(somethingElse)', 'expect(undefined).toBe', 'expect("something");'],
-  invalid: [{
-    code: 'expect(NaN).toBe(NaN);',
-    output: 'expect(NaN).toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 13,
-      line: 1
-    }]
-  }, {
-    code: 'expect(NaN).toEqual(NaN);',
-    output: 'expect(NaN).toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 13,
-      line: 1
-    }]
-  }, {
-    code: 'expect(NaN).toStrictEqual(NaN);',
-    output: 'expect(NaN).toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 13,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toBe(NaN);',
-    output: 'expect("a string").not.toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").rejects.not.toBe(NaN);',
-    output: 'expect("a string").rejects.not.toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string")["rejects"].not.toBe(NaN);',
-    output: 'expect("a string")["rejects"].not.toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 35,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toEqual(NaN);',
-    output: 'expect("a string").not.toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toStrictEqual(NaN);',
-    output: 'expect("a string").not.toBeNaN();',
-    errors: [{
-      messageId: 'useToBeNaN',
-      column: 24,
-      line: 1
-    }]
-  }]
-});
-ruleTester.run('prefer-to-be: undefined vs defined', _preferToBe.default, {
-  valid: ['expect(NaN).toBeNaN();', 'expect(true).not.toBeNaN();', 'expect({}).toEqual({});', 'expect(something).toBe()', 'expect(something).toBe(somethingElse)', 'expect(something).toEqual(somethingElse)', 'expect(something).not.toBe(somethingElse)', 'expect(something).not.toEqual(somethingElse)', 'expect(undefined).toBe', 'expect("something");'],
-  invalid: [{
-    code: 'expect(undefined).not.toBeDefined();',
-    output: 'expect(undefined).toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 23,
-      line: 1
-    }]
-  }, {
-    code: 'expect(undefined).resolves.not.toBeDefined();',
-    output: 'expect(undefined).resolves.toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 32,
-      line: 1
-    }]
-  }, {
-    code: 'expect(undefined).resolves.toBe(undefined);',
-    output: 'expect(undefined).resolves.toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 28,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toBeUndefined();',
-    output: 'expect("a string").toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").rejects.not.toBeUndefined();',
-    output: 'expect("a string").rejects.toBeDefined();',
-    errors: [{
-      messageId: 'useToBeDefined',
-      column: 32,
-      line: 1
-    }]
-  }]
-});
-new _utils.TSESLint.RuleTester({
-  parser: require.resolve('@typescript-eslint/parser')
-}).run('prefer-to-be: typescript edition', _preferToBe.default, {
-  valid: ["(expect('Model must be bound to an array if the multiple property is true') as any).toHaveBeenTipped()"],
-  invalid: [{
-    code: 'expect(null).toEqual(1 as unknown as string as unknown as any);',
-    output: 'expect(null).toBe(1 as unknown as string as unknown as any);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect(null).toEqual(-1 as unknown as string as unknown as any);',
-    output: 'expect(null).toBe(-1 as unknown as string as unknown as any);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toStrictEqual("string" as number);',
-    output: 'expect("a string").not.toBe("string" as number);',
-    errors: [{
-      messageId: 'useToBe',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect(null).toBe(null as unknown as string as unknown as any);',
-    output: 'expect(null).toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 14,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").not.toEqual(null as number);',
-    output: 'expect("a string").not.toBeNull();',
-    errors: [{
-      messageId: 'useToBeNull',
-      column: 24,
-      line: 1
-    }]
-  }, {
-    code: 'expect(undefined).toBe(undefined as unknown as string as any);',
-    output: 'expect(undefined).toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 19,
-      line: 1
-    }]
-  }, {
-    code: 'expect("a string").toEqual(undefined as number);',
-    output: 'expect("a string").toBeUndefined();',
-    errors: [{
-      messageId: 'useToBeUndefined',
-      column: 20,
-      line: 1
-    }]
-  }]
-});