feat(rules): no-standalone-expect

docs/rules/no-standalone-expect.md

@@ -0,0 +1,67 @@
+# No standalone expect in a describe block (no-standalone-expect)
+
+Prevents expects outside of a test or it block. An expect within a helper
+function (but outside of a test or it block) will not trigger this rule.
+
+## Rule Details
+
+This rule aims to eliminate expects that will not be executed. An expect inside
+of a describe block but outside of a test or it block or outside of a describe
+will not execute and therefore will trigger this rule. It is viable, however, to
+have an expect in a helper function that is called from within a test or it
+block so expects in a function will not trigger this rule.
+
+Statements like `expect.hasAssertions()` will NOT trigger this rule since these
+calls will execute if they are not in a test block.
+
+Examples of **incorrect** code for this rule:
+
+```js
+// in describe
+describe('a test', () => {
+  expect(1).toBe(1);
+});
+
+// below other tests
+describe('a test', () => {
+  it('an it', () => {
+    expect(1).toBe(1);
+  });
+
+  expect(1).toBe(1);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+// in it block
+describe('a test', () => {
+  it('an it', () => {
+    expect(1).toBe(1);
+  });
+});
+
+// in helper function
+describe('a test', () => {
+  const helper = () => {
+    expect(1).toBe(1);
+  };
+
+  it('an it', () => {
+    helper();
+  });
+});
+
+describe('a test', () => {
+  expect.hasAssertions(1);
+});
+```
+
+\*Note that this rule will not trigger if the helper function is never used even
+thought the expect will not execute. Rely on a rule like no-unused-vars for this
+case.
+
+## When Not To Use It
+
+Don't use this rule on non-jest test files.

src/__tests__/rules.test.js

@@ -3,7 +3,7 @@ import { resolve } from 'path';
 import { rules } from '../';
 
 const ruleNames = Object.keys(rules);
-const numberOfRules = 36;
+const numberOfRules = 37;
 
 describe('rules', () => {
   it('should have a corresponding doc for each rule', () => {

src/rules/__tests__/no-standalone-expect-test.ts

@@ -0,0 +1,44 @@
+import { TSESLint } from '@typescript-eslint/experimental-utils';
+import rule from '../no-standalone-expect';
+
+const ruleTester = new TSESLint.RuleTester({
+  parserOptions: {
+    ecmaVersion: 2015,
+  },
+});
+
+ruleTester.run('no-standalone-expect', rule, {
+  valid: [
+    'describe("a test", () => { it("an it", () => {expect(1).toBe(1); }); });',
+    'describe("a test", () => { it("an it", () => { const func = () => { expect(1).toBe(1); }; }); });',
+    'describe("a test", () => { const func = () => { expect(1).toBe(1); }; });',
+    'describe("a test", () => { function func() { expect(1).toBe(1); }; });',
+    'describe("a test", () => { const func = function(){ expect(1).toBe(1); }; });',
+    'const func = function(){ expect(1).toBe(1); };',
+    'expect.hasAssertions()',
+  ],
+  invalid: [
+    {
+      code: 'describe("a test", () => { expect(1).toBe(1); });',
+      errors: [{ endColumn: 37, column: 28, messageId: 'unexpectedExpect' }],
+    },
+    {
+      code:
+        'describe("a test", () => { const func = () => { expect(1).toBe(1); }; expect(1).toBe(1); });',
+      errors: [{ endColumn: 80, column: 71, messageId: 'unexpectedExpect' }],
+    },
+    {
+      code:
+        'describe("a test", () => {  it(() => { expect(1).toBe(1); }); expect(1).toBe(1); });',
+      errors: [{ endColumn: 72, column: 63, messageId: 'unexpectedExpect' }],
+    },
+    {
+      code: 'expect(1).toBe(1);',
+      errors: [{ endColumn: 10, column: 1, messageId: 'unexpectedExpect' }],
+    },
+    {
+      code: 'expect(1).toBe',
+      errors: [{ endColumn: 10, column: 1, messageId: 'unexpectedExpect' }],
+    },
+  ],
+});

src/rules/no-standalone-expect.ts

@@ -0,0 +1,70 @@
+import {
+  AST_NODE_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import { createRule, isDescribe, isExpectCall, isFunction } from './tsUtils';
+
+const getBlockType = (stmt: TSESTree.BlockStatement) => {
+  const func = stmt.parent;
+  // functionDeclaration: function func() {}
+  if (func && func.type === AST_NODE_TYPES.FunctionDeclaration) {
+    return 'function';
+  } else if (func && isFunction(func) && func.parent) {
+    const expr = func.parent;
+    // arrowfunction or function expr
+    if (expr.type === AST_NODE_TYPES.VariableDeclarator) {
+      return 'function';
+      // if it's not a variable, it will be callExpr, we only care about describe
+    } else if (
+      expr.type === AST_NODE_TYPES.CallExpression &&
+      isDescribe(expr)
+    ) {
+      return 'describe';
+    }
+    return 'callExpr';
+  }
+  return false;
+};
+
+export default createRule({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prevents expects that are outside of an it or test block.',
+      recommended: false,
+    },
+    messages: {
+      unexpectedExpect: 'Expect must be inside of a test block.',
+    },
+    type: 'suggestion',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const callStack: String[] = [];
+
+    return {
+      CallExpression(node) {
+        if (isExpectCall(node)) {
+          const parent = callStack[callStack.length - 1];
+          if (!parent || parent === 'describe') {
+            context.report({ node, messageId: 'unexpectedExpect' });
+          }
+        }
+      },
+      BlockStatement(stmt: TSESTree.BlockStatement) {
+        const blockType = getBlockType(stmt);
+        if (blockType) {
+          callStack.push(blockType);
+        }
+      },
+      'BlockStatement:exit'(stmt: TSESTree.BlockStatement) {
+        const blockType = getBlockType(stmt);
+        if (blockType && blockType === callStack[callStack.length - 1]) {
+          callStack.pop();
+        }
+      },
+    };
+  },
+});