Generate tests for all queries combinations for await-async-query rules

Author: Belco90

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

@@ -5,6 +5,10 @@
 // ------------------------------------------------------------------------------
 
 const rule = require('../../../lib/rules/await-async-query');
+const {
+  SYNC_QUERIES_COMBINATIONS,
+  ASYNC_QUERIES_COMBINATIONS,
+} = require('../../../lib/utils');
 const RuleTester = require('eslint').RuleTester;
 
 // ------------------------------------------------------------------------------
@@ -14,58 +18,79 @@ const RuleTester = require('eslint').RuleTester;
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2018 } });
 ruleTester.run('await-async-query', rule, {
   valid: [
-    {
+    // async queries declaration are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
       code: `
-        const { findByText } = setUp()
+        const { ${query} } = setUp()
       `,
-    },
-    {
+    })),
+
+    // async queries with await operator are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
       code: `async () => {
-        const foo = await findByText('foo')
+        doSomething()
+        await ${query}('foo')
       }
       `,
-    },
-    {
+    })),
+
+    // async queries with promise in variable and await operator are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
+      code: `async () => {
+        const promise = ${query}('foo')
+        await promise
+      }
+      `,
+    })),
+
+    // async queries with then method are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
       code: `() => {
-        findByText('foo').then(node => {
+        ${query}('foo').then(() => {
           done()
         })
       }
       `,
-    },
-    {
+    })),
+
+    // async queries with promise in variable and then method are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
       code: `() => {
-        const promise = findByText('foo')
-        promise.then(node => done())
+        const promise = ${query}('foo')
+        promise.then(() => done())
       }
       `,
-    },
-    {
-      code: `async () => {
-        doSomething()
-        const foo = await findByText('foo')
+    })),
+
+    // async queries with promise returned in arrow function definition are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
+      code: `anArrowFunction = () => ${query}('foo')`,
+    })),
+
+    // async queries with promise returned in regular function definition are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
+      code: `function foo() { return ${query}('foo') }`,
+    })),
+
+    // async queries with promise in variable and returned in regular function definition are valid
+    ...ASYNC_QUERIES_COMBINATIONS.map(query => ({
+      code: `function foo() {
+        const promise = ${query}('foo')
+        return promise
       }
       `,
-    },
-    {
-      code: `async () => {
+    })),
+
+    // sync queries are valid
+    ...SYNC_QUERIES_COMBINATIONS.map(query => ({
+      code: `() => {
         doSomething()
-        const foo = await findAllByText('foo')
+        ${query}('foo')
       }
       `,
-    },
-    {
-      code: `anArrowFunction = () => findByText('foo')`,
-    },
-    {
-      code: `function foo() {return findByText('foo')}`,
-    },
-    {
-      code: `function foo() {
-        const promise = findByText('foo')
-        return promise
-      }`,
-    },
+    })),
+
+    // non-existing queries are valid
     {
       code: `async () => {
         doSomething()
@@ -75,41 +100,18 @@ ruleTester.run('await-async-query', rule, {
     },
   ],
 
-  invalid: [
-    {
-      code: `async () => {
-        const foo = findByText('foo')
-      }
-      `,
-      errors: [
-        {
-          messageId: 'awaitAsyncQuery',
-        },
-      ],
-    },
-    {
+  invalid:
+    // async queries without await operator or then method are not valid
+    ASYNC_QUERIES_COMBINATIONS.map(query => ({
       code: `async () => {
         doSomething()
-        const foo = findByText('foo')
+        const foo = ${query}('foo')
       }
       `,
       errors: [
         {
           messageId: 'awaitAsyncQuery',
         },
       ],
-    },
-    {
-      code: `async () => {
-        doSomething()
-        const foo = findAllByText('foo')
-      }
-      `,
-      errors: [
-        {
-          messageId: 'awaitAsyncQuery',
-        },
-      ],
-    },
-  ],
+    })),
 });