eslint-plugin-jest 27.2.1 → 27.2.2

package/lib/rules/__tests__/prefer-each.test.js

@@ -0,0 +1,295 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _preferEach = _interopRequireDefault(require("../prefer-each"));
+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-each', _preferEach.default, {
+  valid: ['it("is true", () => { expect(true).toBe(false) });', (0, _dedent.default)`
+      it.each(getNumbers())("only returns numbers that are greater than seven", number => {
+        expect(number).toBeGreaterThan(7);
+      });
+    `,
+  // while these cases could be done with .each, it's reasonable to have more
+  // complex cases that would not look good in .each, so we consider this valid
+  (0, _dedent.default)`
+      it("returns numbers that are greater than five", function () {
+        for (const number of getNumbers()) {
+          expect(number).toBeGreaterThan(5);
+        }
+      });
+    `, (0, _dedent.default)`
+      it("returns things that are less than ten", function () {
+        for (const thing in things) {
+          expect(thing).toBeLessThan(10);
+        }
+      });
+    `, (0, _dedent.default)`
+      it("only returns numbers that are greater than seven", function () {
+        const numbers = getNumbers();
+
+        for (let i = 0; i < numbers.length; i++) {
+          expect(numbers[i]).toBeGreaterThan(7);
+        }
+      });
+    `],
+  invalid: [{
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          describe(\`when the input is $\{input}\`, () => {
+            it(\`results in $\{expected}\`, () => {
+              expect(fn(input)).toBe(expected)
+            });
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'describe'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          describe(\`when the input is $\{input}\`, () => {
+            it(\`results in $\{expected}\`, () => {
+              expect(fn(input)).toBe(expected)
+            });
+          });
+        }
+
+        for (const [input, expected] of data) {
+          it.skip(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'describe'
+      },
+      messageId: 'preferEach'
+    }, {
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it.skip(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('is true', () => {
+          expect(true).toBe(false);
+        });
+
+        for (const [input, expected] of data) {
+          it.skip(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it.skip(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+
+        it('is true', () => {
+          expect(true).toBe(false);
+        });
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('is true', () => {
+          expect(true).toBe(false);
+        });
+
+        for (const [input, expected] of data) {
+          it.skip(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+
+        it('is true', () => {
+          expect(true).toBe(false);
+        });
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'describe'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+
+        for (const [input, expected] of data) {
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }, {
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+
+        for (const [input, expected] of data) {
+          test(\`results in $\{expected}\`, () => {
+            expect(fn(input)).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }, {
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          beforeEach(() => setupSomething(input));
+
+          test(\`results in $\{expected}\`, () => {
+            expect(doSomething()).toBe(expected)
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'describe'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          it("only returns numbers that are greater than seven", function () {
+            const numbers = getNumbers(input);
+  
+            for (let i = 0; i < numbers.length; i++) {
+              expect(numbers[i]).toBeGreaterThan(7);
+            }
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'it'
+      },
+      messageId: 'preferEach'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        for (const [input, expected] of data) {
+          beforeEach(() => setupSomething(input));
+
+          it("only returns numbers that are greater than seven", function () {
+            const numbers = getNumbers();
+  
+            for (let i = 0; i < numbers.length; i++) {
+              expect(numbers[i]).toBeGreaterThan(7);
+            }
+          });
+        }
+      `,
+    errors: [{
+      data: {
+        fn: 'describe'
+      },
+      messageId: 'preferEach'
+    }]
+  }]
+});

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

@@ -0,0 +1,184 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _preferEqualityMatcher = _interopRequireDefault(require("../prefer-equality-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 expectSuggestions = output => {
+  return ['toBe', 'toEqual', 'toStrictEqual'].map(equalityMatcher => ({
+    messageId: 'suggestEqualityMatcher',
+    data: {
+      equalityMatcher
+    },
+    output: output(equalityMatcher)
+  }));
+};
+ruleTester.run('prefer-equality-matcher: ===', _preferEqualityMatcher.default, {
+  valid: ['expect.hasAssertions', 'expect.hasAssertions()', 'expect.assertions(1)', 'expect(true).toBe(...true)', 'expect(a == 1).toBe(true)', 'expect(1 == a).toBe(true)', 'expect(a == b).toBe(true)'],
+  invalid: [{
+    code: 'expect(a === b).toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).${equalityMatcher}(b);`),
+      column: 17,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b,).toBe(true,);',
+    parserOptions: {
+      ecmaVersion: 2017
+    },
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a,).${equalityMatcher}(b,);`),
+      column: 18,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).not.${equalityMatcher}(b);`),
+      column: 17,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).resolves.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 26,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).resolves.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.not.${equalityMatcher}(b);`),
+      column: 26,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).not.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).not.${equalityMatcher}(b);`),
+      column: 21,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).not.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).${equalityMatcher}(b);`),
+      column: 21,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).resolves.not.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.not.${equalityMatcher}(b);`),
+      column: 30,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b).resolves.not.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 30,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b)["resolves"].not.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 33,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a === b)["resolves"]["not"]["toBe"](false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 36,
+      line: 1
+    }]
+  }]
+});
+ruleTester.run('prefer-equality-matcher: !==', _preferEqualityMatcher.default, {
+  valid: ['expect.hasAssertions', 'expect.hasAssertions()', 'expect.assertions(1)', 'expect(true).toBe(...true)', 'expect(a != 1).toBe(true)', 'expect(1 != a).toBe(true)', 'expect(a != b).toBe(true)'],
+  invalid: [{
+    code: 'expect(a !== b).toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).not.${equalityMatcher}(b);`),
+      column: 17,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).${equalityMatcher}(b);`),
+      column: 17,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).resolves.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.not.${equalityMatcher}(b);`),
+      column: 26,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).resolves.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 26,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).not.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).${equalityMatcher}(b);`),
+      column: 21,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).not.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).not.${equalityMatcher}(b);`),
+      column: 21,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).resolves.not.toBe(true);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.${equalityMatcher}(b);`),
+      column: 30,
+      line: 1
+    }]
+  }, {
+    code: 'expect(a !== b).resolves.not.toBe(false);',
+    errors: [{
+      messageId: 'useEqualityMatcher',
+      suggestions: expectSuggestions(equalityMatcher => `expect(a).resolves.not.${equalityMatcher}(b);`),
+      column: 30,
+      line: 1
+    }]
+  }]
+});