Merge pull request #767 from fierysunset/prefer-ember-test-helpers

Add new rule `prefer-ember-test-helpers`

Author: bmish

README.md

@@ -187,6 +187,7 @@ Rules are grouped by category to help you understand their purpose. Each rule ha
 | :white_check_mark: | [no-test-import-export](./docs/rules/no-test-import-export.md) | disallow importing of "-test.js" in a test file and exporting from a test file |
 | :white_check_mark: | [no-test-module-for](./docs/rules/no-test-module-for.md) | disallow usage of `moduleFor`, `moduleForComponent`, etc |
 |  | [no-test-this-render](./docs/rules/no-test-this-render.md) | disallow usage of the `this.render` in tests, recommending to use @ember/test-helpers' `render` instead. |
+|  | [prefer-ember-test-helpers](./docs/rules/prefer-ember-test-helpers.md) | enforce usage of `@ember/test-helpers` methods over native window methods |
 
 <!--RULES_TABLE_END-->
 

docs/rules/prefer-ember-test-helpers.md

@@ -0,0 +1,64 @@
+# prefer-ember-test-helpers
+
+This rule ensures the correct Ember test helper is imported when using methods that have a native window counterpart.
+
+There are currently 3 Ember test helper methods that have a native window counterpart:
+
+* blur
+* find
+* focus
+
+If these methods are not properly imported from Ember's test-helpers suite, and the native window method version is used instead, any intended asynchronous functions won't work as intended, which can cause tests to fail silently.
+
+## Examples
+
+Examples of **incorrect** code for this rule:
+
+```js
+test('foo', async (assert) => {
+  await blur('.some-element');
+});
+```
+
+```js
+test('foo', async (assert) => {
+  await find('.some-element');
+});
+```
+
+```js
+test('foo', async (assert) => {
+  await focus('.some-element');
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+import { blur } from '@ember/test-helpers';
+
+test('foo', async (assert) => {
+  await blur('.some-element');
+});
+```
+
+```js
+import { find } from '@ember/test-helpers';
+
+test('foo', async (assert) => {
+  await find('.some-element');
+});
+```
+
+```js
+import { focus } from '@ember/test-helpers';
+
+test('foo', async (assert) => {
+  await focus('.some-element');
+});
+```
+
+## References
+
+* [Web API Window Methods](https://developer.mozilla.org/en-US/docs/Web/API/Window#Methods)
+* [Ember Test Helpers API Methods](https://github.com/emberjs/ember-test-helpers/blob/master/API.md)

lib/index.js

@@ -61,6 +61,7 @@ module.exports = {
     'order-in-controllers': require('./rules/order-in-controllers'),
     'order-in-models': require('./rules/order-in-models'),
     'order-in-routes': require('./rules/order-in-routes'),
+    'prefer-ember-test-helpers': require('./rules/prefer-ember-test-helpers'),
     'require-computed-macros': require('./rules/require-computed-macros'),
     'require-computed-property-dependencies': require('./rules/require-computed-property-dependencies'),
     'require-return-from-computed': require('./rules/require-return-from-computed'),

lib/rules/prefer-ember-test-helpers.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const emberUtils = require('../utils/ember');
+
+const getImportName = (node, namedImportIdentifier) => {
+  return node.specifiers
+    .filter((specifier) => {
+      return (
+        (specifier.type === 'ImportSpecifier' &&
+          specifier.imported.name === namedImportIdentifier) ||
+        (!namedImportIdentifier && specifier.type === 'ImportDefaultSpecifier')
+      );
+    })
+    .map((specifier) => specifier.local.name)
+    .pop();
+};
+
+//-------------------------------------------------------------------------------------
+// Rule Definition
+//-------------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce usage of `@ember/test-helpers` methods over native window methods',
+      category: 'Testing',
+      recommended: false,
+      url:
+        'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/prefer-ember-test-helpers.md',
+    },
+    schema: [],
+  },
+
+  create: (context) => {
+    if (!emberUtils.isTestFile(context.getFilename())) {
+      return {};
+    }
+
+    let hasBlurFunction = undefined;
+    let hasFindFunction = undefined;
+    let hasFocusFunction = undefined;
+
+    const markMethodsAsPresent = (fnName) => {
+      if (fnName === 'blur') {
+        hasBlurFunction = true;
+      } else if (fnName === 'find') {
+        hasFindFunction = true;
+      } else if (fnName === 'focus') {
+        hasFocusFunction = true;
+      }
+    };
+
+    const showErrorMessage = (node, methodName) => {
+      context.report({
+        data: { methodName },
+        message: 'Import the `{{methodName}}()` method from @ember/test-helpers',
+        node,
+      });
+    };
+
+    return {
+      ImportDeclaration(node) {
+        hasBlurFunction = getImportName(node, 'blur');
+        hasFindFunction = getImportName(node, 'find');
+        hasFocusFunction = getImportName(node, 'focus');
+      },
+      FunctionDeclaration(node) {
+        const fnName = node.id.name;
+
+        markMethodsAsPresent(fnName);
+      },
+      FunctionExpression(node) {
+        const nodeParent = node.parent;
+
+        if (nodeParent && nodeParent.type === 'VariableDeclarator') {
+          const fnName = nodeParent.id.name;
+
+          markMethodsAsPresent(fnName);
+        }
+      },
+      ArrowFunctionExpression(node) {
+        const nodeParent = node.parent;
+
+        if (nodeParent && nodeParent.type === 'VariableDeclarator') {
+          const fnName = nodeParent.id.name;
+
+          markMethodsAsPresent(fnName);
+        }
+      },
+      CallExpression(node) {
+        if (!hasBlurFunction) {
+          if (node.callee.name === 'blur') {
+            showErrorMessage(node, 'blur');
+          }
+        }
+
+        if (!hasFindFunction) {
+          if (node.callee.name === 'find') {
+            showErrorMessage(node, 'find');
+          }
+        }
+
+        if (!hasFocusFunction) {
+          if (node.callee.name === 'focus') {
+            showErrorMessage(node, 'focus');
+          }
+        }
+      },
+    };
+  },
+};