feat(await-async-query,await-async-utils,await-fire-event): support handling promises with jest-extended's .toResolve & .toRejects

docs/rules/await-async-query.md

@@ -19,6 +19,7 @@ problems in the tests. The promise will be considered as handled when:
 - wrapped within `Promise.all` or `Promise.allSettled` methods
 - chaining the `then` method
 - chaining `resolves` or `rejects` from jest
+- chaining `toResolve()` or `toReject()` from [jest-extended](https://github.com/jest-community/jest-extended#promise)
 - it's returned from a function (in this case, that particular function will be analyzed by this rule too)
 
 Examples of **incorrect** code for this rule:
@@ -90,6 +91,12 @@ expect(findByTestId('alert')).resolves.toBe('Success');
 expect(findByTestId('alert')).rejects.toBe('Error');
 ```
 
+```js
+// using a toResolve/toReject matcher is also correct
+expect(findByTestId('alert')).toResolve();
+expect(findByTestId('alert')).toReject();
+```
+
 ```js
 // sync queries don't need to handle any promise
 const element = getByRole('role');

docs/rules/await-async-utils.md

@@ -20,6 +20,7 @@ problems in the tests. The promise will be considered as handled when:
 - wrapped within `Promise.all` or `Promise.allSettled` methods
 - chaining the `then` method
 - chaining `resolves` or `rejects` from jest
+- chaining `toResolve()` or `toReject()` from [jest-extended](https://github.com/jest-community/jest-extended#promise)
 - it's returned from a function (in this case, that particular function will be analyzed by this rule too)
 
 Examples of **incorrect** code for this rule:
@@ -85,6 +86,13 @@ test('something correctly', async () => {
     waitFor(() => getByLabelText('email')),
     waitForElementToBeRemoved(() => document.querySelector('div.getOuttaHere')),
   ]);
+
+  // Using jest resolves or rejects
+  expect(waitFor(() => getByLabelText('email'))).resolves.toBeUndefined();
+
+  // Using jest-extended a toResolve/toReject matcher is also correct
+  expect(waitFor(() => getByLabelText('email'))).toResolve();
+
 });
 ```
 

docs/rules/await-fire-event.md

@@ -7,6 +7,15 @@ properly.
 
 This rule aims to prevent users from forgetting to handle promise returned from `fireEvent`
 methods.
+The promise will be considered as handled when:
+
+- using the `await` operator
+- wrapped within `Promise.all` or `Promise.allSettled` methods
+- chaining the `then` method
+- chaining `resolves` or `rejects` from jest
+- chaining `toResolve()` or `toReject()` from [jest-extended](https://github.com/jest-community/jest-extended#promise)
+- it's returned from a function (in this case, that particular function will be analyzed by this rule too)
+
 
 > ⚠️ `fireEvent` methods are async only on following Testing Library packages:
 >
@@ -55,6 +64,13 @@ await Promise.all([
   fireEvent.focus(getByLabelText('username')),
   fireEvent.blur(getByLabelText('username')),
 ]);
+
+
+  // Using jest resolves or rejects
+  expect(fireEvent.focus(getByLabelText('username'))).resolves.toBeUndefined();
+
+  // Using jest-extended a toResolve/toReject matcher is also correct
+  expect(waitFor(() => getByLabelText('email'))).toResolve();
 ```
 
 ## When Not To Use It

lib/node-utils/index.ts

@@ -191,6 +191,7 @@ export function isPromisesArrayResolved(node: TSESTree.Node): boolean {
  * - it's chained with the `then` method
  * - it's returned from a function
  * - has `resolves` or `rejects` jest methods
+ * - has `toResolve` or `toReject` jest-extended matchers
  */
 export function isPromiseHandled(nodeIdentifier: TSESTree.Identifier): boolean {
   const closestCallExpressionNode = findClosestCallExpressionNode(
@@ -462,9 +463,17 @@ export function getAssertNodeInfo(
   return { matcher, isNegated };
 }
 
+const matcherNamesHandlePromise = [
+  'resolves',
+  'rejects',
+  'toResolve',
+  'toReject',
+];
+
 /**
  * Determines whether a node belongs to an async assertion
- * fulfilled by `resolves` or `rejects` properties.
+ * fulfilled by `resolves` or `rejects` properties or
+ *  by `toResolve` or `toReject` jest-extended matchers
  *
  */
 export function hasClosestExpectResolvesRejects(node: TSESTree.Node): boolean {
@@ -478,7 +487,7 @@ export function hasClosestExpectResolvesRejects(node: TSESTree.Node): boolean {
     const expectMatcher = node.parent.property;
     return (
       ASTUtils.isIdentifier(expectMatcher) &&
-      (expectMatcher.name === 'resolves' || expectMatcher.name === 'rejects')
+      matcherNamesHandlePromise.includes(expectMatcher.name)
     );
   }
 

tests/lib/rules/await-async-query.test.ts

@@ -222,6 +222,13 @@ ruleTester.run(RULE_NAME, rule, {
         expect(wrappedQuery(${query}("foo"))).resolves.toBe("bar")
       `
     ),
+    // async queries with toResolve matchers are valid
+    ...createTestCase(
+      (query) => `
+        expect(${query}("foo")).toResolve()
+        expect(wrappedQuery(${query}("foo"))).toResolve()
+      `
+    ),
 
     // async queries with rejects matchers are valid
     ...createTestCase(
@@ -231,6 +238,14 @@ ruleTester.run(RULE_NAME, rule, {
       `
     ),
 
+    // async queries with toReject matchers are valid
+    ...createTestCase(
+      (query) => `
+        expect(${query}("foo")).toReject()
+        expect(wrappedQuery(${query}("foo"))).toReject()
+      `
+    ),
+
     // unresolved async queries with aggressive reporting opted-out are valid
     ...ALL_ASYNC_COMBINATIONS_TO_TEST.map((query) => ({
       settings: { 'testing-library/utils-module': 'test-utils' },