eslint-plugin-jest 27.2.2 → 27.2.3

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

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

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