First approach for await-async-queries implementation

Author: Belco90

docs/rules/await-async-queries.md

@@ -0,0 +1,36 @@
+# Enforce async queries (`findBy*`, `findAllBy*`) to have proper `await` (await-async-queries)
+
+TODO: Please describe the origin of the rule here.
+
+
+## Rule Details
+
+This rule aims to...
+
+Examples of **incorrect** code for this rule:
+
+```js
+
+// fill me in
+
+```
+
+Examples of **correct** code for this rule:
+
+```js
+
+// fill me in
+
+```
+
+### Options
+
+If there are any options, describe them here. Otherwise, delete this section.
+
+## When Not To Use It
+
+Give a short description of when it would be appropriate to turn off this rule.
+
+## Further Reading
+
+If there are other links that describe the issue this rule addresses, please include them here in a bulleted list.

jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testMatch: ['**/tests/**/*.js'],
+};

lib/rules/await-async-queries.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const VALID_PARENTS = [
+  'AwaitExpression',
+  'ArrowFunctionExpression',
+  'ReturnStatement',
+];
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce async queries (`findBy*`, `findAllBy*`) to have proper `await`',
+      category: 'Best Practices',
+      recommended: true,
+      url: 'TODO',
+    },
+    fixable: null,
+    schema: [],
+  },
+
+  create: function(context) {
+    return {
+      'CallExpression Identifier[name=/^find(All)?By.*/]'(node) {
+        let hasError = true;
+        try {
+          if (VALID_PARENTS.includes(node.parent.parent.type)) {
+            hasError = false;
+          }
+        } catch (e) {
+          // not necessary to do anything
+        }
+
+        if (hasError) {
+          context.report({
+            node,
+            message: `\`${node.name}\` must have \`await\` operator`,
+          });
+        }
+      },
+    };
+  },
+};

tests/lib/rules/await-async-queries.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const rule = require('../../../lib/rules/await-async-queries');
+const RuleTester = require('eslint').RuleTester;
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2018 } });
+ruleTester.run('await-async-queries', rule, {
+  valid: [
+    {
+      code: `async () => {
+        const foo = await findByText('foo')
+      }
+      `,
+    },
+    {
+      code: `async () => {
+        doSomething()
+        const foo = await findByText('foo')
+      }
+      `,
+    },
+    {
+      code: `async () => {
+        doSomething()
+        const foo = await findAllByText('foo')
+      }
+      `,
+    },
+    {
+      code: `anArrowFunction = () => findByText('foo')`,
+    },
+    {
+      code: `function foo() {return findByText('foo')}`,
+    },
+    {
+      code: `function foo() {
+        const promise = findByText('foo')
+        return promise
+      }`,
+    },
+  ],
+
+  invalid: [
+    {
+      code: `async () => {
+        const foo = findByText('foo')
+      }
+      `,
+      errors: [
+        {
+          message: '`findByText` must have `await` operator',
+        },
+      ],
+    },
+    {
+      code: `async () => {
+        doSomething()
+        const foo = findByText('foo')
+      }
+      `,
+      errors: [
+        {
+          message: '`findByText` must have `await` operator',
+        },
+      ],
+    },
+    {
+      code: `async () => {
+        doSomething()
+        const foo = findAllByText('foo')
+      }
+      `,
+      errors: [
+        {
+          message: '`findAllByText` must have `await` operator',
+        },
+      ],
+    },
+  ],
+});