eslint-plugin-jest 22.15.0 → 22.17.0

package/README.md

@@ -104,46 +104,47 @@ installations requiring long-term consistency.
 
 ## Rules
 
-| Rule                         | Description                                                       | Recommended      | Fixable             |
-| ---------------------------- | ----------------------------------------------------------------- | ---------------- | ------------------- |
-| [consistent-test-it][]       | Enforce consistent test or it keyword                             |                  | ![fixable-green][]  |
-| [expect-expect][]            | Enforce assertion to be made in a test body                       |                  |                     |
-| [lowercase-name][]           | Disallow capitalized test names                                   |                  | ![fixable-green][]  |
-| [no-alias-methods][]         | Disallow alias methods                                            | ![recommended][] | ![fixable-green][]  |
-| [no-commented-out-tests][]   | Disallow commented out tests                                      |                  |                     |
-| [no-disabled-tests][]        | Disallow disabled tests                                           | ![recommended][] |                     |
-| [no-duplicate-hooks][]       | Disallow duplicate hooks within a `describe` block                |                  |                     |
-| [no-empty-title][]           | Disallow empty titles                                             |                  |                     |
-| [no-expect-resolves][]       | Disallow using `expect().resolves`                                |                  |                     |
-| [no-export][]                | Disallow export from test files                                   |                  |                     |
-| [no-focused-tests][]         | Disallow focused tests                                            | ![recommended][] |                     |
-| [no-hooks][]                 | Disallow setup and teardown hooks                                 |                  |                     |
-| [no-identical-title][]       | Disallow identical titles                                         | ![recommended][] |                     |
-| [no-if][]                    | Disallow conditional logic                                        |                  |                     |
-| [no-jasmine-globals][]       | Disallow Jasmine globals                                          | ![recommended][] | ![fixable-yellow][] |
-| [no-jest-import][]           | Disallow importing `jest`                                         | ![recommended][] |                     |
-| [no-large-snapshots][]       | Disallow large snapshots                                          |                  |                     |
-| [no-mocks-import][]          | Disallow manually importing from `__mocks__`                      |                  |                     |
-| [no-standalone-expect][]     | Prevents `expect` statements outside of a `test` or `it` block    |                  |                     |
-| [no-test-callback][]         | Using a callback in asynchronous tests                            |                  | ![fixable-green][]  |
-| [no-test-prefixes][]         | Disallow using `f` & `x` prefixes to define focused/skipped tests | ![recommended][] | ![fixable-green][]  |
-| [no-test-return-statement][] | Disallow explicitly returning from tests                          |                  |                     |
-| [no-truthy-falsy][]          | Disallow using `toBeTruthy()` & `toBeFalsy()`                     |                  |                     |
-| [no-try-expect][]            | Prevent `catch` assertions in tests                               |                  |                     |
-| [prefer-called-with][]       | Suggest using `toBeCalledWith()` OR `toHaveBeenCalledWith()`      |                  |                     |
-| [prefer-expect-assertions][] | Suggest using `expect.assertions()` OR `expect.hasAssertions()`   |                  |                     |
-| [prefer-inline-snapshots][]  | Suggest using `toMatchInlineSnapshot()`                           |                  | ![fixable-green][]  |
-| [prefer-spy-on][]            | Suggest using `jest.spyOn()`                                      |                  | ![fixable-green][]  |
-| [prefer-strict-equal][]      | Suggest using `toStrictEqual()`                                   |                  | ![fixable-green][]  |
-| [prefer-to-be-null][]        | Suggest using `toBeNull()`                                        |                  | ![fixable-green][]  |
-| [prefer-to-be-undefined][]   | Suggest using `toBeUndefined()`                                   |                  | ![fixable-green][]  |
-| [prefer-to-contain][]        | Suggest using `toContain()`                                       |                  | ![fixable-green][]  |
-| [prefer-to-have-length][]    | Suggest using `toHaveLength()`                                    |                  | ![fixable-green][]  |
-| [prefer-todo][]              | Suggest using `test.todo()`                                       |                  | ![fixable-green][]  |
-| [require-tothrow-message][]  | Require that `toThrow()` and `toThrowError` includes a message    |                  |                     |
-| [valid-describe][]           | Enforce valid `describe()` callback                               | ![recommended][] |                     |
-| [valid-expect-in-promise][]  | Enforce having return statement when testing with promises        | ![recommended][] |                     |
-| [valid-expect][]             | Enforce valid `expect()` usage                                    | ![recommended][] |                     |
+| Rule                           | Description                                                       | Recommended      | Fixable             |
+| ------------------------------ | ----------------------------------------------------------------- | ---------------- | ------------------- |
+| [consistent-test-it][]         | Enforce consistent test or it keyword                             |                  | ![fixable-green][]  |
+| [expect-expect][]              | Enforce assertion to be made in a test body                       |                  |                     |
+| [lowercase-name][]             | Disallow capitalized test names                                   |                  | ![fixable-green][]  |
+| [no-alias-methods][]           | Disallow alias methods                                            | ![recommended][] | ![fixable-green][]  |
+| [no-commented-out-tests][]     | Disallow commented out tests                                      |                  |                     |
+| [no-disabled-tests][]          | Disallow disabled tests                                           | ![recommended][] |                     |
+| [no-duplicate-hooks][]         | Disallow duplicate hooks within a `describe` block                |                  |                     |
+| [no-empty-title][]             | Disallow empty titles                                             |                  |                     |
+| [no-expect-resolves][]         | Disallow using `expect().resolves`                                |                  |                     |
+| [no-export][]                  | Disallow export from test files                                   |                  |                     |
+| [no-focused-tests][]           | Disallow focused tests                                            | ![recommended][] |                     |
+| [no-hooks][]                   | Disallow setup and teardown hooks                                 |                  |                     |
+| [no-identical-title][]         | Disallow identical titles                                         | ![recommended][] |                     |
+| [no-if][]                      | Disallow conditional logic                                        |                  |                     |
+| [no-jasmine-globals][]         | Disallow Jasmine globals                                          | ![recommended][] | ![fixable-yellow][] |
+| [no-jest-import][]             | Disallow importing `jest`                                         | ![recommended][] |                     |
+| [no-large-snapshots][]         | Disallow large snapshots                                          |                  |                     |
+| [no-mocks-import][]            | Disallow manually importing from `__mocks__`                      |                  |                     |
+| [no-standalone-expect][]       | Prevents `expect` statements outside of a `test` or `it` block    |                  |                     |
+| [no-test-callback][]           | Using a callback in asynchronous tests                            |                  | ![fixable-green][]  |
+| [no-test-prefixes][]           | Disallow using `f` & `x` prefixes to define focused/skipped tests | ![recommended][] | ![fixable-green][]  |
+| [no-test-return-statement][]   | Disallow explicitly returning from tests                          |                  |                     |
+| [no-truthy-falsy][]            | Disallow using `toBeTruthy()` & `toBeFalsy()`                     |                  |                     |
+| [no-try-expect][]              | Prevent `catch` assertions in tests                               |                  |                     |
+| [prefer-called-with][]         | Suggest using `toBeCalledWith()` OR `toHaveBeenCalledWith()`      |                  |                     |
+| [prefer-expect-assertions][]   | Suggest using `expect.assertions()` OR `expect.hasAssertions()`   |                  |                     |
+| [prefer-inline-snapshots][]    | Suggest using `toMatchInlineSnapshot()`                           |                  | ![fixable-green][]  |
+| [prefer-spy-on][]              | Suggest using `jest.spyOn()`                                      |                  | ![fixable-green][]  |
+| [prefer-strict-equal][]        | Suggest using `toStrictEqual()`                                   |                  | ![fixable-green][]  |
+| [prefer-to-be-null][]          | Suggest using `toBeNull()`                                        |                  | ![fixable-green][]  |
+| [prefer-to-be-undefined][]     | Suggest using `toBeUndefined()`                                   |                  | ![fixable-green][]  |
+| [prefer-to-contain][]          | Suggest using `toContain()`                                       |                  | ![fixable-green][]  |
+| [prefer-to-have-length][]      | Suggest using `toHaveLength()`                                    |                  | ![fixable-green][]  |
+| [prefer-todo][]                | Suggest using `test.todo()`                                       |                  | ![fixable-green][]  |
+| [require-top-level-describe][] | Require a top-level `describe` block                              |                  |                     |
+| [require-tothrow-message][]    | Require that `toThrow()` and `toThrowError` includes a message    |                  |                     |
+| [valid-describe][]             | Enforce valid `describe()` callback                               | ![recommended][] |                     |
+| [valid-expect-in-promise][]    | Enforce having return statement when testing with promises        | ![recommended][] |                     |
+| [valid-expect][]               | Enforce valid `expect()` usage                                    | ![recommended][] |                     |
 
 ## Credit
 
@@ -193,6 +194,7 @@ https://github.com/dangreenisrael/eslint-plugin-jest-formatting
 [prefer-to-contain]: docs/rules/prefer-to-contain.md
 [prefer-to-have-length]: docs/rules/prefer-to-have-length.md
 [prefer-todo]: docs/rules/prefer-todo.md
+[require-top-level-describe]: docs/rules/require-top-level-describe.md
 [require-tothrow-message]: docs/rules/require-tothrow-message.md
 [valid-describe]: docs/rules/valid-describe.md
 [valid-expect-in-promise]: docs/rules/valid-expect-in-promise.md

package/docs/rules/prefer-to-be-null.md

@@ -5,7 +5,8 @@ asserting expections on null value.
 
 ## Rule details
 
-This rule triggers a warning if `toBe()` is used to assert a null value.
+This rule triggers a warning if `toBe()`, `isEqual()` or `toStrictEqual()` is
+used to assert a null value.
 
 ```js
 expect(null).toBe(null);
@@ -15,10 +16,14 @@ This rule is enabled by default.
 
 ### Default configuration
 
-The following pattern is considered warning:
+The following patterns are considered warnings:
 
 ```js
 expect(null).toBe(null);
+
+expect(null).isEqual(null);
+
+expect(null).toStrictEqual(null);
 ```
 
 The following pattern is not warning:

package/docs/rules/prefer-to-be-undefined.md

@@ -5,7 +5,8 @@ asserting expections on undefined value.
 
 ## Rule details
 
-This rule triggers a warning if `toBe()` is used to assert a undefined value.
+This rule triggers a warning if `toBe()`, `isEqual()` or `toStrictEqual()` is
+used to assert an undefined value.
 
 ```js
 expect(undefined).toBe(undefined);
@@ -15,10 +16,14 @@ This rule is enabled by default.
 
 ### Default configuration
 
-The following pattern is considered warning:
+The following patterns are considered warnings:
 
 ```js
 expect(undefined).toBe(undefined);
+
+expect(undefined).isEqual(undefined);
+
+expect(undefined).toStrictEqual(undefined);
 ```
 
 The following pattern is not warning:

package/docs/rules/prefer-to-contain.md

@@ -5,8 +5,8 @@ asserting expectations on an array containing an object.
 
 ## Rule details
 
-This rule triggers a warning if `toBe()` or `isEqual()` is used to assert object
-inclusion in an array
+This rule triggers a warning if `toBe()`, `isEqual()` or `toStrictEqual()` is
+used to assert object inclusion in an array
 
 ```js
 expect(a.includes(b)).toBe(true);
@@ -22,26 +22,24 @@ expect(a.includes(b)).toBe(false);
 
 ### Default configuration
 
-The following patterns are considered a warning:
+The following patterns are considered warnings:
 
 ```js
 expect(a.includes(b)).toBe(true);
-```
 
-```js
 expect(a.includes(b)).not.toBe(true);
-```
 
-```js
 expect(a.includes(b)).toBe(false);
+
+expect(a.includes(b)).toEqual(true);
+
+expect(a.includes(b)).toStrictEqual(true);
 ```
 
-The following patterns are not a warning:
+The following patterns are not considered warnings:
 
 ```js
 expect(a).toContain(b);
-```
 
-```js
 expect(a).not.toContain(b);
 ```

package/docs/rules/prefer-to-have-length.md

@@ -5,8 +5,8 @@ asserting expectations on object's length property.
 
 ## Rule details
 
-This rule triggers a warning if `toBe()` is used to assert object's length
-property.
+This rule triggers a warning if `toBe()`, `isEqual()` or `toStrictEqual()` is
+used to assert object's length property.
 
 ```js
 expect(files.length).toBe(1);
@@ -16,10 +16,14 @@ This rule is enabled by default.
 
 ### Default configuration
 
-The following pattern is considered warning:
+The following patterns are considered warnings:
 
 ```js
 expect(files.length).toBe(1);
+
+expect(files.length).toEqual(1);
+
+expect(files.length).toStrictEqual(1);
 ```
 
 The following pattern is not warning:

package/docs/rules/require-top-level-describe.md

@@ -0,0 +1,52 @@
+# Require top-level describe block (require-top-level-describe)
+
+Jest allows you to organise your test files the way you want it. However, the
+more your codebase grows, the more it becomes hard to navigate in your test
+files. This rule makes sure that you provide at least a top-level describe block
+in your test file.
+
+## Rule Details
+
+This rule triggers a warning if a test case (`test` and `it`) or a hook
+(`beforeAll`, `beforeEach`, `afterEach`, `afterAll`) is not located in a
+top-level describe block.
+
+The following patterns are considered warnings:
+
+```js
+// Above a describe block
+test('my test', () => {});
+describe('test suite', () => {
+  it('test', () => {});
+});
+
+// Below a describe block
+describe('test suite', () => {});
+test('my test', () => {});
+
+// Same for hooks
+beforeAll('my beforeAll', () => {});
+describe('test suite', () => {});
+afterEach('my afterEach', () => {});
+```
+
+The following patterns are **not** considered warnings:
+
+```js
+// In a describe block
+describe('test suite', () => {
+  test('my test', () => {});
+});
+
+// In a nested describe block
+describe('test suite', () => {
+  test('my test', () => {});
+  describe('another test suite', () => {
+    test('my other test', () => {});
+  });
+});
+```
+
+## When Not To Use It
+
+Don't use this rule on non-jest test files.

package/lib/__tests__/rules.test.js

@@ -4,11 +4,12 @@ var _fs = require("fs");
 
 var _path = require("path");
 
-var _ = require("../");
+var _ = _interopRequireDefault(require("../"));
 
-// @ts-ignore
-const ruleNames = Object.keys(_.rules);
-const numberOfRules = 38;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const ruleNames = Object.keys(_.default.rules);
+const numberOfRules = 39;
 describe('rules', () => {
   it('should have a corresponding doc for each rule', () => {
     ruleNames.forEach(rule => {

package/lib/index.js

@@ -29,14 +29,13 @@ const importDefault = moduleName => // eslint-disable-next-line @typescript-esli
 interopRequireDefault(require(moduleName)).default;
 
 const rulesDir = (0, _path.join)(__dirname, 'rules');
-const excludedFiles = ['__tests__', 'util', 'tsUtils'];
+const excludedFiles = ['__tests__', 'utils'];
 const rules = (0, _fs.readdirSync)(rulesDir).map(rule => (0, _path.parse)(rule).name).filter(rule => !excludedFiles.includes(rule)).reduce((acc, curr) => Object.assign(acc, {
   [curr]: importDefault((0, _path.join)(rulesDir, curr))
 }), {});
 const allRules = Object.keys(rules).reduce((rules, key) => _objectSpread({}, rules, {
   [`jest/${key}`]: 'error'
-}), {}); // eslint-disable-next-line import/no-commonjs
-
+}), {});
 module.exports = {
   configs: {
     all: {

package/lib/rules/consistent-test-it.js

@@ -7,9 +7,9 @@ exports.default = void 0;
 
 var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -48,17 +48,17 @@ var _default = (0, _tsUtils.createRule)({
     let describeNestingLevel = 0;
     return {
       CallExpression(node) {
-        const nodeName = (0, _tsUtils.getNodeName)(node.callee);
+        const nodeName = (0, _utils.getNodeName)(node.callee);
 
         if (!nodeName) {
           return;
         }
 
-        if ((0, _tsUtils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node)) {
           describeNestingLevel++;
         }
 
-        if ((0, _tsUtils.isTestCase)(node) && describeNestingLevel === 0 && nodeName.indexOf(testKeyword) === -1) {
+        if ((0, _utils.isTestCase)(node) && describeNestingLevel === 0 && !nodeName.includes(testKeyword)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeyword);
           context.report({
             messageId: 'consistentMethod',
@@ -77,7 +77,7 @@ var _default = (0, _tsUtils.createRule)({
           });
         }
 
-        if ((0, _tsUtils.isTestCase)(node) && describeNestingLevel > 0 && nodeName.indexOf(testKeywordWithinDescribe) === -1) {
+        if ((0, _utils.isTestCase)(node) && describeNestingLevel > 0 && !nodeName.includes(testKeywordWithinDescribe)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeywordWithinDescribe);
           context.report({
             messageId: 'consistentMethodWithingDescribe',
@@ -98,7 +98,7 @@ var _default = (0, _tsUtils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _tsUtils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node)) {
           describeNestingLevel--;
         }
       }

package/lib/rules/expect-expect.js

@@ -7,13 +7,13 @@ exports.default = void 0;
 
 var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 /*
  * This implementation is adapted from eslint-plugin-jasmine.
  * MIT license, Remco Haszing.
  */
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -48,7 +48,7 @@ var _default = (0, _tsUtils.createRule)({
     const unchecked = [];
     return {
       CallExpression(node) {
-        const name = (0, _tsUtils.getNodeName)(node.callee);
+        const name = (0, _utils.getNodeName)(node.callee);
 
         if (name === 'it' || name === 'test') {
           unchecked.push(node);

package/lib/rules/lowercase-name.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 
 var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
 
@@ -19,7 +19,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 const hasStringAsFirstArgument = node => node.arguments && node.arguments[0] && (node.arguments[0].type === _experimentalUtils.AST_NODE_TYPES.Literal || node.arguments[0].type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral);
 
-const isJestFunctionWithLiteralArg = node => ((0, _tsUtils.isTestCase)(node) || (0, _tsUtils.isDescribe)(node)) && node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && hasStringAsFirstArgument(node);
+const isJestFunctionWithLiteralArg = node => ((0, _utils.isTestCase)(node) || (0, _utils.isDescribe)(node)) && node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && hasStringAsFirstArgument(node);
 
 const testDescription = argument => {
   if (argument.type === _experimentalUtils.AST_NODE_TYPES.Literal) {
@@ -55,7 +55,7 @@ const jestFunctionName = node => {
   return null;
 };
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     type: 'suggestion',

package/lib/rules/no-alias-methods.js

@@ -5,42 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _utils = require("./utils");
 
-var _default = {
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Disallow alias methods',
+      recommended: 'warn'
     },
     messages: {
       replaceAlias: `Replace {{ replace }}() with its canonical name of {{ canonical }}()`
     },
     fixable: 'code',
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     // The Jest methods which have aliases. The canonical name is the first
     // index of each item.
+    // todo: replace w/ Map
     const methodNames = [['toHaveBeenCalled', 'toBeCalled'], ['toHaveBeenCalledTimes', 'toBeCalledTimes'], ['toHaveBeenCalledWith', 'toBeCalledWith'], ['toHaveBeenLastCalledWith', 'lastCalledWith'], ['toHaveBeenNthCalledWith', 'nthCalledWith'], ['toHaveReturned', 'toReturn'], ['toHaveReturnedTimes', 'toReturnTimes'], ['toHaveReturnedWith', 'toReturnWith'], ['toHaveLastReturnedWith', 'lastReturnedWith'], ['toHaveNthReturnedWith', 'nthReturnedWith'], ['toThrow', 'toThrowError']];
     return {
       CallExpression(node) {
-        if (!(0, _util.expectCaseWithParent)(node)) {
+        if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
 
-        let targetNode = (0, _util.method)(node);
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              matcher = _parseExpectCall.matcher;
 
-        if (targetNode.name === 'resolves' || targetNode.name === 'rejects' || targetNode.name === 'not') {
-          targetNode = (0, _util.method)(node.parent);
-        }
-
-        if (!targetNode) {
+        if (!matcher) {
           return;
         } // Check if the method used matches any of ours
 
 
-        const methodItem = methodNames.find(item => item[1] === targetNode.name);
+        const methodItem = methodNames.find(item => item[1] === matcher.name);
 
         if (methodItem) {
           context.report({
@@ -49,8 +52,8 @@ var _default = {
               replace: methodItem[1],
               canonical: methodItem[0]
             },
-            node: targetNode,
-            fix: fixer => [fixer.replaceText(targetNode, methodItem[0])]
+            node: matcher.node.property,
+            fix: fixer => [fixer.replaceText(matcher.node.property, methodItem[0])]
           });
         }
       }
@@ -58,5 +61,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;

package/lib/rules/no-commented-out-tests.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 function hasTests(node) {
   return /^\s*(x|f)?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\(/m.test(node.value);
 }
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {

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

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -50,7 +50,7 @@ var _default = (0, _tsUtils.createRule)({
       },
 
       CallExpression(node) {
-        const functionName = (0, _tsUtils.getNodeName)(node.callee);
+        const functionName = (0, _utils.getNodeName)(node.callee);
 
         switch (functionName) {
           case 'describe.skip':
@@ -71,7 +71,7 @@ var _default = (0, _tsUtils.createRule)({
       },
 
       'CallExpression[callee.name="pending"]'(node) {
-        if ((0, _tsUtils.scopeHasLocalReference)(context.getScope(), 'pending')) {
+        if ((0, _utils.scopeHasLocalReference)(context.getScope(), 'pending')) {
           return;
         }
 

package/lib/rules/no-duplicate-hooks.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 const newHookContext = () => ({
   beforeAll: 0,
@@ -14,7 +14,7 @@ const newHookContext = () => ({
   afterEach: 0
 });
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -34,11 +34,11 @@ var _default = (0, _tsUtils.createRule)({
     const hookContexts = [newHookContext()];
     return {
       CallExpression(node) {
-        if ((0, _tsUtils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node)) {
           hookContexts.push(newHookContext());
         }
 
-        if ((0, _tsUtils.isHook)(node)) {
+        if ((0, _utils.isHook)(node)) {
           const currentLayer = hookContexts[hookContexts.length - 1];
           currentLayer[node.callee.name] += 1;
 
@@ -55,7 +55,7 @@ var _default = (0, _tsUtils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _tsUtils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node)) {
           hookContexts.pop();
         }
       }

package/lib/rules/no-empty-title.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
 
@@ -15,7 +15,7 @@ function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d =
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -35,27 +35,21 @@ var _default = (0, _tsUtils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _tsUtils.isDescribe)(node) && !(0, _tsUtils.isTestCase)(node)) {
+        if (!(0, _utils.isDescribe)(node) && !(0, _utils.isTestCase)(node)) {
           return;
         }
 
         const _node$arguments = _slicedToArray(node.arguments, 1),
               firstArgument = _node$arguments[0];
 
-        if (!(0, _tsUtils.isStringNode)(firstArgument)) {
+        if (!firstArgument || !(0, _utils.isStringNode)(firstArgument, '')) {
           return;
         }
 
-        if ((0, _tsUtils.isTemplateLiteral)(firstArgument) && (0, _tsUtils.hasExpressions)(firstArgument)) {
-          return;
-        }
-
-        if ((0, _tsUtils.getStringValue)(firstArgument) === '') {
-          context.report({
-            messageId: (0, _tsUtils.isDescribe)(node) ? 'describe' : 'test',
-            node
-          });
-        }
+        context.report({
+          messageId: (0, _utils.isDescribe)(node) ? 'describe' : 'test',
+          node
+        });
       }
 
     };