feat(no-deprecated-functions): support jest version setting (#564)

* feat(no-deprecated-functions): support jest `version` setting * chore(no-deprecated-functions): cache jest version
jest-community · May 9, 2020 · 05f20b8 · 05f20b8
1 parent 0d9dce0
commit 05f20b8
Show file tree

Hide file tree

Showing 6 changed files with 360 additions and 51 deletions.
diff --git a/README.md b/README.md
@@ -56,6 +56,23 @@ You can also whitelist the environment variables provided by Jest by doing:
 }
 ```
 
+The behaviour of some rules (specifically `no-deprecated-functions`) change
+depending on the version of `jest` being used.
+
+This setting is detected automatically based off the version of the `jest`
+package installed in `node_modules`, but it can also be provided explicitly if
+desired:
+
+```json
+{
+  "settings": {
+    "jest": {
+      "version": 26
+    }
+  }
+}
+```
+
 ## Shareable configurations
 
 ### Recommended

diff --git a/docs/rules/no-deprecated-functions.md b/docs/rules/no-deprecated-functions.md
@@ -9,10 +9,20 @@ of majors, eventually they are removed completely.
 ## Rule details
 
 This rule warns about calls to deprecated functions, and provides details on
-what to replace them with.
+what to replace them with, based on the version of Jest that is installed.
 
 This rule can also autofix a number of these deprecations for you.
 
+### `jest.resetModuleRegistry`
+
+This function was renamed to `resetModules` in Jest 15, and is scheduled for
+removal in Jest 27.
+
+### `jest.addMatchers`
+
+This function was replaced with `expect.extend` in Jest 17, and is scheduled for
+removal in Jest 27.
+
 ### `require.requireActual` & `require.requireMock`
 
 These functions were replaced in Jest 21 and removed in Jest 26.
@@ -25,16 +35,6 @@ for type checkers to handle, and their use via `require` deprecated. Finally,
 the release of Jest 26 saw them removed from the `require` function all
 together.
 
-### `jest.addMatchers`
-
-This function was replaced with `expect.extend` in Jest 17, and is scheduled for
-removal in Jest 27.
-
-### `jest.resetModuleRegistry`
-
-This function was renamed to `resetModules` in Jest 15, and is scheduled for
-removal in Jest 27.
-
 ### `jest.runTimersToTime`
 
 This function was renamed to `advanceTimersByTime` in Jest 22, and is scheduled

diff --git a/package.json b/package.json
@@ -46,6 +46,7 @@
     "@babel/preset-typescript": "^7.3.3",
     "@commitlint/cli": "^8.2.0",
     "@commitlint/config-conventional": "^8.2.0",
+    "@schemastore/package": "^0.0.5",
     "@semantic-release/changelog": "^3.0.5",
     "@semantic-release/git": "^7.0.17",
     "@types/eslint": "^6.1.3",

diff --git a/src/rules/__tests__/no-deprecated-functions.test.ts b/src/rules/__tests__/no-deprecated-functions.test.ts
@@ -1,49 +1,265 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { JSONSchemaForNPMPackageJsonFiles } from '@schemastore/package';
 import { TSESLint } from '@typescript-eslint/experimental-utils';
-import rule from '../no-deprecated-functions';
+import rule, {
+  JestVersion,
+  _clearCachedJestVersion,
+} from '../no-deprecated-functions';
 
 const ruleTester = new TSESLint.RuleTester();
 
-[
-  ['require.requireMock', 'jest.requireMock'],
-  ['require.requireActual', 'jest.requireActual'],
-  ['jest.addMatchers', 'expect.extend'],
-  ['jest.resetModuleRegistry', 'jest.resetModules'],
-  ['jest.runTimersToTime', 'jest.advanceTimersByTime'],
-  ['jest.genMockFromModule', 'jest.createMockFromModule'],
-].forEach(([deprecation, replacement]) => {
+/**
+ * Makes a new temp directory, prefixed with `eslint-plugin-jest-`
+ *
+ * @return {Promise<string>}
+ */
+const makeTempDir = async () =>
+  fs.mkdtempSync(path.join(os.tmpdir(), 'eslint-plugin-jest-'));
+
+/**
+ * Sets up a fake project with a `package.json` file located in
+ * `node_modules/jest` whose version is set to the given `jestVersion`.
+ *
+ * @param {JestVersion} jestVersion
+ *
+ * @return {Promise<string>}
+ */
+const setupFakeProjectDirectory = async (
+  jestVersion: JestVersion,
+): Promise<string> => {
+  const jestPackageJson: JSONSchemaForNPMPackageJsonFiles = {
+    name: 'jest',
+    version: `${jestVersion}.0.0`,
+  };
+
+  const tempDir = await makeTempDir();
+  const jestPackagePath = path.join(tempDir, 'node_modules', 'jest');
+
+  // todo: remove in node@10 & replace with { recursive: true }
+  fs.mkdirSync(path.join(tempDir, 'node_modules'));
+
+  fs.mkdirSync(jestPackagePath);
+  await fs.writeFileSync(
+    path.join(jestPackagePath, 'package.json'),
+    JSON.stringify(jestPackageJson),
+  );
+
+  return tempDir;
+};
+
+const generateValidCases = (
+  jestVersion: JestVersion | undefined,
+  functionCall: string,
+): Array<TSESLint.ValidTestCase<never>> => {
+  const [name, func] = functionCall.split('.');
+  const settings = { jest: { version: jestVersion } } as const;
+
+  return [
+    { settings, code: `${functionCall}()` },
+    { settings, code: `${functionCall}` },
+    { settings, code: `${name}['${func}']()` },
+    { settings, code: `${name}['${func}']` },
+  ];
+};
+
+const generateInvalidCases = (
+  jestVersion: JestVersion | undefined,
+  deprecation: string,
+  replacement: string,
+): Array<TSESLint.InvalidTestCase<'deprecatedFunction', never>> => {
   const [deprecatedName, deprecatedFunc] = deprecation.split('.');
   const [replacementName, replacementFunc] = replacement.split('.');
+  const settings = { jest: { version: jestVersion } };
+  const errors: [TSESLint.TestCaseError<'deprecatedFunction'>] = [
+    { messageId: 'deprecatedFunction', data: { deprecation, replacement } },
+  ];
+
+  return [
+    {
+      code: `${deprecation}()`,
+      output: `${replacement}()`,
+      settings,
+      errors,
+    },
+    {
+      code: `${deprecatedName}['${deprecatedFunc}']()`,
+      output: `${replacementName}['${replacementFunc}']()`,
+      settings,
+      errors,
+    },
+  ];
+};
+
+describe('the jest version cache', () => {
+  beforeEach(async () => process.chdir(await setupFakeProjectDirectory(17)));
+
+  // change the jest version *after* each test case
+  afterEach(async () => {
+    const jestPackageJson: JSONSchemaForNPMPackageJsonFiles = {
+      name: 'jest',
+      version: '24.0.0',
+    };
+
+    const tempDir = process.cwd();
+
+    await fs.writeFileSync(
+      path.join(tempDir, 'node_modules', 'jest', 'package.json'),
+      JSON.stringify(jestPackageJson),
+    );
+  });
+
+  ruleTester.run('no-deprecated-functions', rule, {
+    valid: [
+      'require("fs")', // this will cause jest version to be read & cached
+      'jest.requireActual()', // deprecated after jest 17
+    ],
+    invalid: [],
+  });
+});
 
-  ruleTester.run(`${deprecation} -> ${replacement}`, rule, {
+// contains the cache-clearing beforeEach so we can test the cache too
+describe('the rule', () => {
+  beforeEach(() => _clearCachedJestVersion());
+
+  // a few sanity checks before doing our massive loop
+  ruleTester.run('no-deprecated-functions', rule, {
     valid: [
       'jest',
       'require("fs")',
-      `${replacement}()`,
-      replacement,
-      `${replacementName}['${replacementFunc}']()`,
-      `${replacementName}['${replacementFunc}']`,
+      ...generateValidCases(14, 'jest.resetModuleRegistry'),
+      ...generateValidCases(17, 'require.requireActual'),
+      ...generateValidCases(25, 'jest.genMockFromModule'),
     ],
     invalid: [
-      {
-        code: `${deprecation}()`,
-        output: `${replacement}()`,
-        errors: [
-          {
-            messageId: 'deprecatedFunction',
-            data: { deprecation, replacement },
-          },
-        ],
-      },
-      {
-        code: `${deprecatedName}['${deprecatedFunc}']()`,
-        output: `${replacementName}['${replacementFunc}']()`,
-        errors: [
-          {
-            messageId: 'deprecatedFunction',
-            data: { deprecation, replacement },
-          },
-        ],
-      },
+      ...generateInvalidCases(
+        21,
+        'jest.resetModuleRegistry',
+        'jest.resetModules',
+      ),
+      ...generateInvalidCases(24, 'jest.addMatchers', 'expect.extend'),
+      ...generateInvalidCases(
+        26,
+        'jest.genMockFromModule',
+        'jest.createMockFromModule',
+      ),
     ],
   });
+
+  describe.each<JestVersion>([
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+  ])('when using jest version %i', jestVersion => {
+    beforeEach(async () =>
+      process.chdir(await setupFakeProjectDirectory(jestVersion)),
+    );
+
+    const allowedFunctions: string[] = [];
+    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'],
+    ] as const).filter(deprecation => {
+      if (deprecation[0] > jestVersion) {
+        allowedFunctions.push(deprecation[1]);
+
+        return false;
+      }
+
+      return true;
+    });
+
+    ruleTester.run('explict jest version', rule, {
+      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', rule, {
+      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 no jest version is provided', () => {
+    describe('when the jest package.json is missing the version property', () => {
+      beforeEach(async () => {
+        const tempDir = await setupFakeProjectDirectory(1);
+
+        await fs.writeFileSync(
+          path.join(tempDir, 'node_modules', 'jest', 'package.json'),
+          JSON.stringify({}),
+        );
+
+        process.chdir(tempDir);
+      });
+
+      it('requires the version to be set explicitly', () => {
+        expect(() => {
+          const linter = new TSESLint.Linter();
+
+          linter.defineRule('no-deprecated-functions', rule);
+
+          linter.verify('jest.resetModuleRegistry()', {
+            rules: { 'no-deprecated-functions': 'error' },
+          });
+        }).toThrow(
+          'Unable to detect Jest version - please ensure jest package is installed, or otherwise set version explicitly',
+        );
+      });
+    });
+
+    describe('when the jest package.json is not found', () => {
+      beforeEach(async () => process.chdir(await makeTempDir()));
+
+      it('requires the version to be set explicitly', () => {
+        expect(() => {
+          const linter = new TSESLint.Linter();
+
+          linter.defineRule('no-deprecated-functions', rule);
+
+          linter.verify('jest.resetModuleRegistry()', {
+            rules: { 'no-deprecated-functions': 'error' },
+          });
+        }).toThrow(
+          'Unable to detect Jest version - please ensure jest package is installed, or otherwise set version explicitly',
+        );
+      });
+    });
+  });
 });