eslint-plugin-jest 27.2.1 → 27.2.2

package/lib/rules/__tests__/no-deprecated-functions.test.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _noDeprecatedFunctions = _interopRequireDefault(require("../no-deprecated-functions"));
+var _detectJestVersion = require("../utils/detectJestVersion");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+jest.mock('../utils/detectJestVersion');
+const detectJestVersionMock = _detectJestVersion.detectJestVersion;
+const ruleTester = new _utils.TSESLint.RuleTester();
+const generateValidCases = (jestVersion, functionCall) => {
+  const [name, func] = functionCall.split('.');
+  const settings = {
+    jest: {
+      version: jestVersion
+    }
+  };
+  return [{
+    settings,
+    code: `${functionCall}()`
+  }, {
+    settings,
+    code: `${functionCall}`
+  }, {
+    settings,
+    code: `${name}['${func}']()`
+  }, {
+    settings,
+    code: `${name}['${func}']`
+  }];
+};
+const generateInvalidCases = (jestVersion, deprecation, replacement) => {
+  const [deprecatedName, deprecatedFunc] = deprecation.split('.');
+  const [replacementName, replacementFunc] = replacement.split('.');
+  const settings = {
+    jest: {
+      version: jestVersion
+    }
+  };
+  const errors = [{
+    messageId: 'deprecatedFunction',
+    data: {
+      deprecation,
+      replacement
+    }
+  }];
+  return [{
+    code: `${deprecation}()`,
+    output: `${replacement}()`,
+    settings,
+    errors
+  }, {
+    code: `${deprecatedName}['${deprecatedFunc}']()`,
+    output: `${replacementName}['${replacementFunc}']()`,
+    settings,
+    errors
+  }];
+};
+
+// contains the cache-clearing beforeEach so we can test the cache too
+describe('the rule', () => {
+  // a few sanity checks before doing our massive loop
+  ruleTester.run('no-deprecated-functions', _noDeprecatedFunctions.default, {
+    valid: [{
+      code: 'jest',
+      settings: {
+        jest: {
+          version: 14
+        }
+      }
+    }, {
+      code: 'require("fs")',
+      settings: {
+        jest: {
+          version: 14
+        }
+      }
+    }, ...generateValidCases(14, 'jest.resetModuleRegistry'), ...generateValidCases(17, 'require.requireActual'), ...generateValidCases(25, 'jest.genMockFromModule'), ...generateValidCases('25.1.1', 'jest.genMockFromModule'), ...generateValidCases('17.2', 'require.requireActual')],
+    invalid: [...generateInvalidCases(21, 'jest.resetModuleRegistry', 'jest.resetModules'), ...generateInvalidCases(24, 'jest.addMatchers', 'expect.extend'), ...generateInvalidCases(26, 'jest.genMockFromModule', 'jest.createMockFromModule'), ...generateInvalidCases('26.0.0-next.11', 'jest.genMockFromModule', 'jest.createMockFromModule')]
+  });
+  describe.each([14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27])('when using jest version %i', jestVersion => {
+    beforeEach(async () => {
+      detectJestVersionMock.mockReturnValue(jestVersion);
+    });
+    const allowedFunctions = [];
+    const deprecations = [[15, 'jest.resetModuleRegistry', 'jest.resetModules'], [17, 'jest.addMatchers', 'expect.extend'], [21, 'require.requireMock', 'jest.requireMock'], [21, 'require.requireActual', 'jest.requireActual'], [22, 'jest.runTimersToTime', 'jest.advanceTimersByTime'], [26, 'jest.genMockFromModule', 'jest.createMockFromModule']].filter(deprecation => {
+      if (deprecation[0] > jestVersion) {
+        allowedFunctions.push(deprecation[1]);
+        return false;
+      }
+      return true;
+    });
+    ruleTester.run('explict jest version', _noDeprecatedFunctions.default, {
+      valid: ['jest', 'require("fs")', ...allowedFunctions.map(func => generateValidCases(jestVersion, func)).reduce((acc, arr) => acc.concat(arr), [])],
+      invalid: deprecations.map(([, deprecation, replacement]) => generateInvalidCases(jestVersion, deprecation, replacement)).reduce((acc, arr) => acc.concat(arr), [])
+    });
+    ruleTester.run('detected jest version', _noDeprecatedFunctions.default, {
+      valid: ['jest', 'require("fs")', ...allowedFunctions.map(func => generateValidCases(undefined, func)).reduce((acc, arr) => acc.concat(arr), [])],
+      invalid: deprecations.map(([, deprecation, replacement]) => generateInvalidCases(undefined, deprecation, replacement)).reduce((acc, arr) => acc.concat(arr), [])
+    });
+  });
+  describe('when there is an error in detecting the jest version', () => {
+    beforeEach(() => {
+      detectJestVersionMock.mockImplementation(() => {
+        throw new Error('oh noes!');
+      });
+    });
+    it('bubbles the error up', () => {
+      expect(() => {
+        const linter = new _utils.TSESLint.Linter();
+        linter.defineRule('no-deprecated-functions', _noDeprecatedFunctions.default);
+        linter.verify('jest.resetModuleRegistry()', {
+          rules: {
+            'no-deprecated-functions': 'error'
+          }
+        });
+      }).toThrow('oh noes!');
+    });
+  });
+});

package/lib/rules/__tests__/no-disabled-tests.test.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noDisabledTests = _interopRequireDefault(require("../no-disabled-tests"));
+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,
+    sourceType: 'module'
+  }
+});
+ruleTester.run('no-disabled-tests', _noDisabledTests.default, {
+  valid: ['describe("foo", function () {})', 'it("foo", function () {})', 'describe.only("foo", function () {})', 'it.only("foo", function () {})', 'it.each("foo", () => {})', 'it.concurrent("foo", function () {})', 'test("foo", function () {})', 'test.only("foo", function () {})', 'test.concurrent("foo", function () {})', 'describe[`${"skip"}`]("foo", function () {})', 'it.todo("fill this later")', 'var appliedSkip = describe.skip; appliedSkip.apply(describe)', 'var calledSkip = it.skip; calledSkip.call(it)', '({ f: function () {} }).f()', '(a || b).f()', 'itHappensToStartWithIt()', 'testSomething()', 'xitSomethingElse()', 'xitiViewMap()', (0, _dedent.default)`
+      import { pending } from "actions"
+
+      test("foo", () => {
+        expect(pending()).toEqual({})
+      })
+    `, (0, _dedent.default)`
+      const { pending } = require("actions")
+
+      test("foo", () => {
+        expect(pending()).toEqual({})
+      })
+    `, (0, _dedent.default)`
+      test("foo", () => {
+        const pending = getPending()
+        expect(pending()).toEqual({})
+      })
+    `, (0, _dedent.default)`
+      test("foo", () => {
+        expect(pending()).toEqual({})
+      })
+
+      function pending() {
+        return {}
+      }
+    `, {
+    code: (0, _dedent.default)`
+        import { test } from './test-utils';
+
+        test('something');
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }],
+  invalid: [{
+    code: 'describe.skip("foo", function () {})',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'describe.skip.each([1, 2, 3])("%s", (a, b) => {});',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xdescribe.each([1, 2, 3])("%s", (a, b) => {});',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'describe[`skip`]("foo", function () {})',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'describe["skip"]("foo", function () {})',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it.skip("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it["skip"]("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'test.skip("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it.skip.each``("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'test.skip.each``("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it.skip.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'test.skip.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'test["skip"]("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xdescribe("foo", function () {})',
+    errors: [{
+      messageId: 'disabledSuite',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit.each``("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest.each``("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xit.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'xtest.each([])("foo", function () {})',
+    errors: [{
+      messageId: 'disabledTest',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it("has title but no callback")',
+    errors: [{
+      messageId: 'missingFunction',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'test("has title but no callback")',
+    errors: [{
+      messageId: 'missingFunction',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'it("contains a call to pending", function () { pending() })',
+    errors: [{
+      messageId: 'pendingTest',
+      column: 48,
+      line: 1
+    }]
+  }, {
+    code: 'pending();',
+    errors: [{
+      messageId: 'pending',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'describe("contains a call to pending", function () { pending() })',
+    errors: [{
+      messageId: 'pendingSuite',
+      column: 54,
+      line: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { test } from '@jest/globals';
+
+        test('something');
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'missingFunction',
+      column: 1,
+      line: 3
+    }]
+  }]
+});