no-deprecated-functions.test.ts

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, { JestVersion } from '../no-deprecated-functions';

const ruleTester = new TSESLint.RuleTester();

/**
 * 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');

  await fs.mkdirSync(jestPackagePath, { recursive: true });
  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 } } as const;
  const errors: [TSESLint.TestCaseError<'deprecatedFunction'>] = [
    {
      messageId: 'deprecatedFunction' as const,
      data: { deprecation, replacement },
    },
  ];

  return [
    {
      code: `${deprecation}()`,
      output: `${replacement}()`,
      settings,
      errors,
    },
    {
      code: `${deprecatedName}['${deprecatedFunc}']()`,
      output: `${replacementName}['${replacementFunc}']()`,
      settings,
      errors,
    },
  ];
};

// a few sanity checks before doing our massive loop
ruleTester.run('no-deprecated-functions', rule, {
  valid: [
    'jest',
    'require("fs")',
    ...generateValidCases(14, 'jest.resetModuleRegistry'),
    ...generateValidCases(17, 'require.requireActual'),
    ...generateValidCases(25, 'jest.genMockFromModule'),
  ],
  invalid: [
    ...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',
      );
    });
  });
});