eslint-plugin-jest 27.2.1 → 27.2.2

package/lib/rules/utils/__tests__/parseJestFnCall.test.js

@@ -0,0 +1,809 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _testUtils = require("../../__tests__/test-utils");
+var _utils2 = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const findESLintVersion = () => {
+  const eslintPath = require.resolve('eslint/package.json');
+  const eslintPackageJson =
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require(eslintPath);
+  if (!eslintPackageJson.version) {
+    throw new Error('eslint package.json does not have a version!');
+  }
+  const [majorVersion] = eslintPackageJson.version.split('.');
+  return parseInt(majorVersion, 10);
+};
+const eslintVersion = findESLintVersion();
+const ruleTester = new _utils.TSESLint.RuleTester({
+  parser: _testUtils.espreeParser,
+  parserOptions: {
+    ecmaVersion: 2015
+  }
+});
+const isNode = obj => {
+  if (typeof obj === 'object' && obj !== null) {
+    return ['type', 'loc', 'range', 'parent'].every(p => p in obj);
+  }
+  return false;
+};
+const rule = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Possible Errors',
+      description: 'Fake rule for testing parseJestFnCall',
+      recommended: false
+    },
+    messages: {
+      details: '{{ data }}'
+    },
+    schema: [],
+    type: 'problem'
+  },
+  defaultOptions: [],
+  create: context => ({
+    CallExpression(node) {
+      const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+      if (jestFnCall) {
+        const sorted = {
+          // ...jestFnCall,
+          name: jestFnCall.name,
+          type: jestFnCall.type,
+          head: jestFnCall.head,
+          members: jestFnCall.members
+        };
+        context.report({
+          messageId: 'details',
+          node,
+          data: {
+            data: JSON.stringify(sorted, (_key, value) => {
+              if (isNode(value)) {
+                if ((0, _utils2.isSupportedAccessor)(value)) {
+                  return (0, _utils2.getAccessorValue)(value);
+                }
+                return undefined;
+              }
+              return value;
+            })
+          }
+        });
+      }
+    }
+  })
+});
+// const sortParsedJestFnCallResults = ()
+
+const expectedParsedJestFnCallResultData = result => ({
+  data: JSON.stringify({
+    name: result.name,
+    type: result.type,
+    head: result.head,
+    members: result.members
+  })
+});
+ruleTester.run('nonexistent methods', rule, {
+  valid: ['describe.something()', 'describe.me()', 'test.me()', 'it.fails()', 'context()', 'context.each``()', 'context.each()', 'describe.context()', 'describe.concurrent()()', 'describe.concurrent``()', 'describe.every``()', '/regex/.test()', '"something".describe()', '[].describe()', 'new describe().only()', '``.test()', 'test.only``()', 'test``.only()'],
+  invalid: []
+});
+ruleTester.run('expect', rule, {
+  valid: [{
+    code: (0, _dedent.default)`
+        import { expect } from './test-utils';
+
+        expect(x).toBe(y);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect(x).not.resolves.toBe(x);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  },
+  // {
+  //   code: dedent`
+  //     import { expect } from '@jest/globals';
+  //
+  //     expect(x).not().toBe(x);
+  //   `,
+  //   parserOptions: { sourceType: 'module' },
+  // },
+  {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect(x).is.toBe(x);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect;
+        expect(x);
+        expect(x).toBe;
+        expect(x).not.toBe;
+        //expect(x).toBe(x).not();
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }],
+  invalid: [{
+    code: 'expect(x).toBe(y);',
+    parserOptions: {
+      sourceType: 'script'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: null,
+          local: 'expect',
+          type: 'global',
+          node: 'expect'
+        },
+        members: ['toBe']
+      }),
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect.assertions();
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['assertions']
+      }),
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect(x).toBe(y);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['toBe']
+      }),
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect(x).not(y);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['not']
+      }),
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect(x).not.toBe(y);
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['not', 'toBe']
+      }),
+      column: 1,
+      line: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { expect } from '@jest/globals';
+
+        expect.assertions();
+        expect.hasAssertions();
+        expect.anything();
+        expect.not.arrayContaining();
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['assertions']
+      }),
+      column: 1,
+      line: 3
+    }, {
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['hasAssertions']
+      }),
+      column: 1,
+      line: 4
+    }, {
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['anything']
+      }),
+      column: 1,
+      line: 5
+    }, {
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'expect',
+        type: 'expect',
+        head: {
+          original: 'expect',
+          local: 'expect',
+          type: 'import',
+          node: 'expect'
+        },
+        members: ['not', 'arrayContaining']
+      }),
+      column: 1,
+      line: 6
+    }]
+  }]
+});
+ruleTester.run('esm', rule, {
+  valid: [{
+    code: (0, _dedent.default)`
+        import { it } from './test-utils';
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { defineFeature, loadFeature } from "jest-cucumber";
+
+        const feature = loadFeature("some/feature");
+
+        defineFeature(feature, (test) => {
+          test("A scenario", ({ given, when, then }) => {});
+        });
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { describe } from './test-utils';
+
+        describe('a function that is not from jest', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { fn as it } from './test-utils';
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import * as jest from '@jest/globals';
+        const { it } = jest;
+
+        it('is not supported', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import ByDefault from './myfile';
+
+        ByDefault.sayHello();
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        async function doSomething() {
+          const build = await rollup(config);
+          build.generate();
+        }
+      `,
+    parserOptions: {
+      sourceType: 'module',
+      ecmaVersion: 2017
+    }
+  }],
+  invalid: []
+});
+if (eslintVersion >= 8) {
+  ruleTester.run('esm (dynamic)', rule, {
+    valid: [{
+      code: (0, _dedent.default)`
+          const { it } = await import('./test-utils');
+
+          it('is not a jest function', () => {});
+        `,
+      parserOptions: {
+        sourceType: 'module',
+        ecmaVersion: 2022
+      }
+    }, {
+      code: (0, _dedent.default)`
+          const { it } = await import(\`./test-utils\`);
+
+          it('is not a jest function', () => {});
+        `,
+      parserOptions: {
+        sourceType: 'module',
+        ecmaVersion: 2022
+      }
+    }],
+    invalid: [{
+      code: (0, _dedent.default)`
+          const { it } = await import("@jest/globals");
+  
+          it('is a jest function', () => {});
+        `,
+      parserOptions: {
+        sourceType: 'module',
+        ecmaVersion: 2022
+      },
+      errors: [{
+        messageId: 'details',
+        data: expectedParsedJestFnCallResultData({
+          name: 'it',
+          type: 'test',
+          head: {
+            original: 'it',
+            local: 'it',
+            type: 'import',
+            node: 'it'
+          },
+          members: []
+        }),
+        column: 1,
+        line: 3
+      }]
+    }, {
+      code: (0, _dedent.default)`
+          const { it } = await import(\`@jest/globals\`);
+  
+          it('is a jest function', () => {});
+        `,
+      parserOptions: {
+        sourceType: 'module',
+        ecmaVersion: 2022
+      },
+      errors: [{
+        messageId: 'details',
+        data: expectedParsedJestFnCallResultData({
+          name: 'it',
+          type: 'test',
+          head: {
+            original: 'it',
+            local: 'it',
+            type: 'import',
+            node: 'it'
+          },
+          members: []
+        }),
+        column: 1,
+        line: 3
+      }]
+    }]
+  });
+}
+ruleTester.run('cjs', rule, {
+  valid: [{
+    code: (0, _dedent.default)`
+        const { it } = require('./test-utils');
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { it } = require(\`./test-utils\`);
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { describe } = require('./test-utils');
+
+        describe('a function that is not from jest', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { fn: it } = require('./test-utils');
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { fn: it } = require('@jest/globals');
+
+        it('is not considered a test function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { it } = aliasedRequire('@jest/globals');
+
+        it('is not considered a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { it } = require();
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { it } = require(pathToMyPackage);
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        const { [() => {}]: it } = require('@jest/globals');
+
+        it('is not a jest function', () => {});
+      `,
+    parserOptions: {
+      sourceType: 'script'
+    }
+  }],
+  invalid: []
+});
+ruleTester.run('global aliases', rule, {
+  valid: [{
+    code: 'xcontext("skip this please", () => {});',
+    settings: {
+      jest: {
+        globalAliases: {
+          describe: ['context']
+        }
+      }
+    }
+  }],
+  invalid: [{
+    code: 'context("when there is an error", () => {})',
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'describe',
+        type: 'describe',
+        head: {
+          original: 'describe',
+          local: 'context',
+          type: 'global',
+          node: 'context'
+        },
+        members: []
+      }),
+      column: 1,
+      line: 1
+    }],
+    settings: {
+      jest: {
+        globalAliases: {
+          describe: ['context']
+        }
+      }
+    }
+  }, {
+    code: 'context.skip("when there is an error", () => {})',
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'describe',
+        type: 'describe',
+        head: {
+          original: 'describe',
+          local: 'context',
+          type: 'global',
+          node: 'context'
+        },
+        members: ['skip']
+      }),
+      column: 1,
+      line: 1
+    }],
+    settings: {
+      jest: {
+        globalAliases: {
+          describe: ['context']
+        }
+      }
+    }
+  }, {
+    code: (0, _dedent.default)`
+        context("when there is an error", () => {})
+        xcontext("skip this please", () => {});
+      `,
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'xdescribe',
+        type: 'describe',
+        head: {
+          original: 'xdescribe',
+          local: 'xcontext',
+          type: 'global',
+          node: 'xcontext'
+        },
+        members: []
+      }),
+      column: 1,
+      line: 2
+    }],
+    settings: {
+      jest: {
+        globalAliases: {
+          xdescribe: ['xcontext']
+        }
+      }
+    }
+  }, {
+    code: (0, _dedent.default)`
+        context("when there is an error", () => {})
+        describe("when there is an error", () => {})
+        xcontext("skip this please", () => {});
+      `,
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'describe',
+        type: 'describe',
+        head: {
+          original: 'describe',
+          local: 'context',
+          type: 'global',
+          node: 'context'
+        },
+        members: []
+      }),
+      column: 1,
+      line: 1
+    }, {
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'describe',
+        type: 'describe',
+        head: {
+          original: null,
+          local: 'describe',
+          type: 'global',
+          node: 'describe'
+        },
+        members: []
+      }),
+      column: 1,
+      line: 2
+    }],
+    settings: {
+      jest: {
+        globalAliases: {
+          describe: ['context']
+        }
+      }
+    }
+  }]
+});
+ruleTester.run('typescript', rule, {
+  valid: [{
+    code: (0, _dedent.default)`
+        const { test };
+
+        test('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser')
+  }, {
+    code: (0, _dedent.default)`
+        import type { it } from '@jest/globals';
+
+        it('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import jest = require('@jest/globals');
+        const { it } = jest;
+
+        it('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        function it(message: string, fn: () => void): void;
+        function it(cases: unknown[], message: string, fn: () => void): void;
+        function it(...all: any[]): void {}
+
+        it('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        interface it {}
+        function it(...all: any[]): void {}
+
+        it('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import { it } from '@jest/globals';
+        import { it } from '../it-utils';
+
+        it('is not a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, {
+    code: (0, _dedent.default)`
+        import dedent = require('dedent');
+
+        dedent();
+      `,
+    parser: require.resolve('@typescript-eslint/parser')
+  }],
+  invalid: [{
+    code: (0, _dedent.default)`
+        import { it } from '../it-utils';
+        import { it } from '@jest/globals';
+
+        it('is a jest function', () => {});
+      `,
+    parser: require.resolve('@typescript-eslint/parser'),
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'details',
+      data: expectedParsedJestFnCallResultData({
+        name: 'it',
+        type: 'test',
+        head: {
+          original: 'it',
+          local: 'it',
+          type: 'import',
+          node: 'it'
+        },
+        members: []
+      }),
+      column: 1,
+      line: 4
+    }]
+  }]
+});