docs: Add Documentation for valid-expect-in-promise Rule (#581)

* docs: valid-expect-in-promise

* docs: update README

* refactor: typo and remove

README.md

@@ -206,6 +206,7 @@ export default [
 | [valid-describe-callback](docs/rules/valid-describe-callback.md)                                                         | enforce valid describe callback                                       | ✅  | 🌐 |    |    |    |
 | [valid-expect](docs/rules/valid-expect.md)                                                                               | enforce valid `expect()` usage                                        | ✅  | 🌐 | 🔧 |    |    |
 | [valid-title](docs/rules/valid-title.md)                                                                                 | enforce valid titles                                                  | ✅  | 🌐 | 🔧 |    |    |
+| [valid-expect-in-promise](docs/rules/valid-expect-in-promise.md)                                                                                 | require promises that have expectations in their chain to be valid                                                  |    | 🌐 |   |    |    |
 
 <!-- end auto-generated rules list -->
 

docs/rules/valid-expect-in-promise.md

@@ -0,0 +1,51 @@
+# Require promises that have expectations in their chain to be valid (`vitest/valid-expect-in-promise`)
+
+⚠️ This rule _warns_ in the 🌐 `all` config.
+
+<!-- end auto-generated rule header -->
+
+This rule flags any promises within the body of a test that include expectations that have either not been returned or awaited.
+
+The following patterns is considered warning:
+
+```js
+test('promise test', async () => {
+  something().then((value) => {
+    expect(value).toBe('red');
+  });
+});
+
+test('promises test', () => {
+  const onePromise = something().then((value) => {
+    expect(value).toBe('red');
+  });
+  const twoPromise = something().then((value) => {
+    expect(value).toBe('blue');
+  });
+
+  return Promise.any([onePromise, twoPromise]);
+});
+```
+
+The following pattern is not warning:
+
+```js
+
+test('promise test', async () => {
+  await something().then((value) => {
+    expect(value).toBe('red');
+  });
+});
+
+test('promises test', () => {
+  const onePromise = something().then((value) => {
+    expect(value).toBe('red');
+  });
+  const twoPromise = something().then((value) => {
+    expect(value).toBe('blue');
+  });
+
+  return Promise.all([onePromise, twoPromise]);
+});
+
+```

src/index.ts

@@ -7,7 +7,7 @@ import noFocusedTests, { RULE_NAME as noFocusedTestsName } from './rules/no-focu
 import noConditionalTest, { RULE_NAME as noConditionalTests } from './rules/no-conditional-tests'
 import expectExpect, { RULE_NAME as expectedExpect } from './rules/expect-expect'
 import consistentTestIt, { RULE_NAME as useConsistentTestIt } from './rules/consistent-test-it'
-import preferToBe, { RULE_NAME as usePreferTobe } from './rules/prefer-to-be'
+import preferToBe, { RULE_NAME as usePreferToBe } from './rules/prefer-to-be'
 import noHooks, { RULE_NAME as noHooksName } from './rules/no-hooks'
 import noRestrictedViMethods, { RULE_NAME as noRestrictedViMethodsName } from './rules/no-restricted-vi-methods'
 import consistentTestFilename, { RULE_NAME as useConsistentTestFilename } from './rules/consistent-test-filename'
@@ -128,7 +128,7 @@ const allRules = {
   [preferComparisonMatcherName]: 'warn',
   [preferToContainName]: 'warn',
   [preferExpectAssertionsName]: 'warn',
-  [usePreferTobe]: 'warn',
+  [usePreferToBe]: 'warn',
   [paddingAroundAfterAllBlocksName]: 'warn',
   [paddingAroundAfterEachBlocksName]: 'warn',
   [paddingAroundAllName]: 'warn',
@@ -172,7 +172,7 @@ const plugin = {
     [noConditionalTests]: noConditionalTest,
     [expectedExpect]: expectExpect,
     [useConsistentTestIt]: consistentTestIt,
-    [usePreferTobe]: preferToBe,
+    [usePreferToBe]: preferToBe,
     [noHooksName]: noHooks,
     [noRestrictedViMethodsName]: noRestrictedViMethods,
     [useConsistentTestFilename]: consistentTestFilename,

src/rules/valid-expect.ts

@@ -322,7 +322,6 @@ export default createEslintRule<[
 
         const isParentArrayExpression
           = parentNode.parent.type === AST_NODE_TYPES.ArrayExpression
-        const orReturned = alwaysAwait ? '' : ' or returned'
 
         const targetNode = getParentIfThenified(parentNode)
         const finalNode = findPromiseCallExpressionNode(targetNode) || targetNode