eslint-plugin-jest 27.2.1 → 27.2.2

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

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

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

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