eslint-plugin-jest-formatting 1.2.0 → 3.1.0

package/src/rules/padding.ts

@@ -9,6 +9,8 @@
  */
 
 import { AST, Rule, SourceCode } from 'eslint';
+// This is because we are using @types/estree that are brought in with eslint
+// eslint-disable-next-line import/no-extraneous-dependencies
 import { Node } from 'estree';
 import * as astUtils from '../ast-utils';
 
@@ -40,12 +42,6 @@ export const enum PaddingType {
   Always,
 }
 
-type PaddingTester = (
-  prevNode: Node,
-  nextNode: Node,
-  paddingContext: PaddingContext,
-) => void;
-
 // A configuration object for padding type and the two statement types
 export interface Config {
   paddingType: PaddingType;
@@ -53,14 +49,6 @@ export interface Config {
   nextStatementType: StatementTypes;
 }
 
-// Tracks position in scope and prevNode. Used to compare current and prev node
-// and then to walk back up to the parent scope or down into the next one.
-// And so on...
-interface Scope {
-  upper: Scope | null;
-  prevNode: Node | null;
-}
-
 interface ScopeInfo {
   prevNode: Node | null;
   enter: () => void;
@@ -74,16 +62,37 @@ interface PaddingContext {
   configs: Config[];
 }
 
+type PaddingTester = (
+  prevNode: Node,
+  nextNode: Node,
+  paddingContext: PaddingContext,
+) => void;
+
+// Tracks position in scope and prevNode. Used to compare current and prev node
+// and then to walk back up to the parent scope or down into the next one.
+// And so on...
+interface Scope {
+  upper: Scope | null;
+  prevNode: Node | null;
+}
+
 // Creates a StatementTester to test an ExpressionStatement's first token name
 const createTokenTester = (tokenName: string): StatementTester => {
   return (node: Node, sourceCode: SourceCode): boolean => {
-    const token = sourceCode.getFirstToken(node);
+    let activeNode = node;
 
-    return (
-      node.type === 'ExpressionStatement' &&
-      token.type === 'Identifier' &&
-      token.value === tokenName
-    );
+    if (activeNode.type === 'ExpressionStatement') {
+      // In the case of `await`, we actually care about its argument
+      if (activeNode.expression.type === 'AwaitExpression') {
+        activeNode = activeNode.expression.argument;
+      }
+
+      const token = sourceCode.getFirstToken(activeNode);
+
+      return token.type === 'Identifier' && token.value === tokenName;
+    }
+
+    return false;
   };
 };
 
@@ -134,35 +143,34 @@ const paddingAlwaysTester = (
     message: 'Expected blank line before this statement.',
     fix(fixer: Rule.RuleFixer): Rule.Fix {
       let prevToken = astUtils.getActualLastToken(sourceCode, prevNode);
-      const nextToken =
-        sourceCode.getFirstTokenBetween(prevToken, nextNode, {
-          includeComments: true,
-          /**
-           * Skip the trailing comments of the previous node.
-           * This inserts a blank line after the last trailing comment.
-           *
-           * For example:
-           *
-           *     foo(); // trailing comment.
-           *     // comment.
-           *     bar();
-           *
-           * Get fixed to:
-           *
-           *     foo(); // trailing comment.
-           *
-           *     // comment.
-           *     bar();
-           */
-          filter(token: AST.Token): boolean {
-            if (astUtils.areTokensOnSameLine(prevToken, token)) {
-              prevToken = token;
-              return false;
-            }
-
-            return true;
-          },
-        }) || nextNode;
+      const nextToken = (sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+        includeComments: true,
+        /**
+         * Skip the trailing comments of the previous node.
+         * This inserts a blank line after the last trailing comment.
+         *
+         * For example:
+         *
+         *     foo(); // trailing comment.
+         *     // comment.
+         *     bar();
+         *
+         * Get fixed to:
+         *
+         *     foo(); // trailing comment.
+         *
+         *     // comment.
+         *     bar();
+         */
+        filter(token: AST.Token): boolean {
+          if (astUtils.areTokensOnSameLine(prevToken, token)) {
+            prevToken = token;
+            return false;
+          }
+
+          return true;
+        },
+      }) || nextNode) as AST.Token;
 
       const insertText = astUtils.areTokensOnSameLine(prevToken, nextToken)
         ? '\n\n'
@@ -219,7 +227,7 @@ const nodeMatchesType = (
   // If it's an array recursively check if any of the statement types match
   // the node
   if (Array.isArray(statementType)) {
-    return statementType.some(type =>
+    return statementType.some((type) =>
       nodeMatchesType(innerStatementNode, type, paddingContext),
     );
   }
@@ -271,8 +279,8 @@ const verifyNode = (node: Node, paddingContext: PaddingContext): void => {
   //  ESTree.Node doesn't support the parent property which is added by
   //  ESLint during traversal. Our best bet is to ignore the property access
   //  here as it's the only place that it's checked.
-  // @ts-ignore
-  if (!astUtils.isValidParent(node.parent.type)) {
+  //  eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (!astUtils.isValidParent((node as any).parent.type)) {
     return;
   }
 
@@ -314,7 +322,7 @@ const verifyNode = (node: Node, paddingContext: PaddingContext): void => {
  */
 export const createRule = (
   configs: Config[],
-  deprecated: boolean = false,
+  deprecated = false,
 ): Rule.RuleModule => ({
   meta: {
     fixable: 'whitespace',

package/tests/catfood.js

@@ -4,6 +4,8 @@
  * globs.
  */
 
+/* eslint-disable @typescript-eslint/no-empty-function */
+
 beforeAll(() => {});
 beforeEach(() => {});
 afterAll(() => {});

package/tests/dogfood.spec.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+
 beforeAll(() => {});
 
 beforeEach(() => {});

package/tests/lib/rules/padding-around-after-all-blocks.spec.js

@@ -108,7 +108,8 @@ ruleTester.run('padding-before-after-all-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-after-each-blocks.spec.js

@@ -106,7 +106,8 @@ ruleTester.run('padding-before-after-each-blocks', rule, {
           line: 17,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-before-all-blocks.spec.js

@@ -108,7 +108,8 @@ ruleTester.run('padding-before-before-all-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-before-each-blocks.spec.js

@@ -108,7 +108,8 @@ ruleTester.run('padding-before-before-each-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-describe-blocks.spec.js

@@ -146,7 +146,8 @@ ruleTester.run('padding-around-describe-blocks', rule, {
           line: 27,
           column: 1
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-expect-groups.spec.js

@@ -11,7 +11,7 @@ const rule = require('../../../lib').rules['padding-around-expect-groups'];
 
 const ruleTester = new RuleTester({
   parserOptions: {
-    ecmaVersion: 6,
+    ecmaVersion: 2017,
   },
 });
 
@@ -63,6 +63,29 @@ describe('someText', () => {
     });
   });
 });
+
+test('awaited expect', async () => {
+  const abc = 123;
+  const hasAPromise = () => Promise.resolve('foo');
+
+  await expect(hasAPromise()).resolves.toEqual('foo');
+  expect(abc).toEqual(123);
+
+  const efg = 456;
+
+  expect(123).toEqual(abc);
+  await expect(hasAPromise()).resolves.toEqual('foo');
+
+  const hij = 789;
+
+  await expect(hasAPromise()).resolves.toEqual('foo');
+  await expect(hasAPromise()).resolves.toEqual('foo');
+
+  const somethingElseAsync = () => Promise.resolve('bar');
+  await somethingElseAsync();
+
+  await expect(hasAPromise()).resolves.toEqual('foo');
+});
 `;
 
 const invalid = `
@@ -103,6 +126,25 @@ describe('someText', () => {
     });
   });
 });
+
+test('awaited expect', async () => {
+  const abc = 123;
+  const hasAPromise = () => Promise.resolve('foo');
+  await expect(hasAPromise()).resolves.toEqual('foo');
+  expect(abc).toEqual(123);
+
+  const efg = 456;
+  expect(123).toEqual(abc);
+  await expect(hasAPromise()).resolves.toEqual('foo');
+
+  const hij = 789;
+  await expect(hasAPromise()).resolves.toEqual('foo');
+  await expect(hasAPromise()).resolves.toEqual('foo');
+
+  const somethingElseAsync = () => Promise.resolve('bar');
+  await somethingElseAsync();
+  await expect(hasAPromise()).resolves.toEqual('foo');
+});
 `;
 
 ruleTester.run('padding-around-expect-groups', rule, {
@@ -111,7 +153,7 @@ ruleTester.run('padding-around-expect-groups', rule, {
     {
       code: invalid,
       filename: 'src/component.test.jsx',
-      errors: 6,
+      errors: 10,
       output: valid,
     },
     {
@@ -148,7 +190,28 @@ ruleTester.run('padding-around-expect-groups', rule, {
           line: 32,
           column: 7
         },
-      ]
+        {
+          message: 'Expected blank line before this statement.',
+          line: 43,
+          column: 3
+        },
+        {
+          message: 'Expected blank line before this statement.',
+          line: 47,
+          column: 3
+        },
+        {
+          message: 'Expected blank line before this statement.',
+          line: 51,
+          column: 3
+        },
+        {
+          message: 'Expected blank line before this statement.',
+          line: 56,
+          column: 3
+        },
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-test-blocks.spec.js

@@ -156,6 +156,7 @@ ruleTester.run('padding-around-test-blocks', rule, {
           column: 1
         },
       ],
+      output: valid,
     },
   ],
 });

package/.nvmrc

@@ -1 +0,0 @@
-v8.10.0

package/tests/lib/rules/padding-before-after-all-blocks.spec.js

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before afterAll blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-before-after-all-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-afterAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  afterAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-all-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 3,
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 3,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 9,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 16,
-          column: 3
-        },
-      ]
-    },
-  ]
-});

package/tests/lib/rules/padding-before-after-each-blocks.spec.js

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before afterEach blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-before-after-each-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-afterEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  afterEach(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterEach(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-each-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      errors: 3,
-      filename: 'src/component.test.jsx',
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 3,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 9,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 16,
-          column: 3
-        },
-      ]
-    },
-  ]
-});

package/tests/lib/rules/padding-before-before-all-blocks.spec.js

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before beforeAll blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-before-before-all-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-beforeAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  beforeAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  beforeAll(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-beforeAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  beforeAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  beforeAll(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-before-all-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 3,
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 3,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 9,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 16,
-          column: 3
-        },
-      ]
-    },
-  ]
-});