@vitest/eslint-plugin 1.1.7 → 1.1.9

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { isAbsolute, posix } from 'node:path';
 import ts from 'typescript';
 import { createRequire } from 'node:module';
 
-const version = "1.1.6";
+const version = "1.1.8";
 
 function createEslintRule(rule) {
   const createRule = ESLintUtils.RuleCreator(
@@ -346,7 +346,7 @@ const getFirstMatcherArg = (expectFnCall) => {
 const isTypeCastExpression$1 = (node) => node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
 const followTypeAssertionChain$1 = (expression) => isTypeCastExpression$1(expression) ? followTypeAssertionChain$1(expression.expression) : expression;
 
-const RULE_NAME$Y = "prefer-lowercase-title";
+const RULE_NAME$Z = "prefer-lowercase-title";
 const hasStringAsFirstArgument = (node) => node.arguments[0] && isStringNode(node.arguments[0]);
 const populateIgnores = (ignore) => {
   const ignores = [];
@@ -365,7 +365,7 @@ const populateIgnores = (ignore) => {
   return ignores;
 };
 const lowerCaseTitle = createEslintRule({
-  name: RULE_NAME$Y,
+  name: RULE_NAME$Z,
   meta: {
     type: "problem",
     docs: {
@@ -462,9 +462,9 @@ const lowerCaseTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$X = "max-nested-describe";
+const RULE_NAME$Y = "max-nested-describe";
 const maxNestedDescribe = createEslintRule({
-  name: RULE_NAME$X,
+  name: RULE_NAME$Y,
   meta: {
     type: "problem",
     docs: {
@@ -522,13 +522,13 @@ const maxNestedDescribe = createEslintRule({
   }
 });
 
-const RULE_NAME$W = "no-identical-title";
+const RULE_NAME$X = "no-identical-title";
 const newDescribeContext = () => ({
   describeTitles: [],
   testTitles: []
 });
 const noIdenticalTitle = createEslintRule({
-  name: RULE_NAME$W,
+  name: RULE_NAME$X,
   meta: {
     type: "problem",
     docs: {
@@ -586,7 +586,7 @@ const noIdenticalTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$V = "no-focused-tests";
+const RULE_NAME$W = "no-focused-tests";
 const isTestOrDescribe = (node) => {
   return node.type === "Identifier" && ["it", "test", "describe"].includes(node.name);
 };
@@ -594,7 +594,7 @@ const isOnly = (node) => {
   return node.type === "Identifier" && node.name === "only";
 };
 const noFocusedTests = createEslintRule({
-  name: RULE_NAME$V,
+  name: RULE_NAME$W,
   meta: {
     type: "problem",
     docs: {
@@ -666,9 +666,9 @@ const noFocusedTests = createEslintRule({
   }
 });
 
-const RULE_NAME$U = "no-conditional-tests";
+const RULE_NAME$V = "no-conditional-tests";
 const noConditionalTest = createEslintRule({
-  name: RULE_NAME$U,
+  name: RULE_NAME$V,
   meta: {
     type: "problem",
     docs: {
@@ -708,7 +708,7 @@ function parsePluginSettings(settings) {
   };
 }
 
-const RULE_NAME$T = "expect-expect";
+const RULE_NAME$U = "expect-expect";
 function matchesAssertFunctionName(nodeName, patterns) {
   return patterns.some(
     (p) => new RegExp(
@@ -722,7 +722,7 @@ function matchesAssertFunctionName(nodeName, patterns) {
   );
 }
 const expectExpect = createEslintRule({
-  name: RULE_NAME$T,
+  name: RULE_NAME$U,
   meta: {
     type: "suggestion",
     docs: {
@@ -735,7 +735,7 @@ const expectExpect = createEslintRule({
         properties: {
           assertFunctionNames: {
             type: "array",
-            items: [{ type: "string" }]
+            items: { type: "string" }
           },
           additionalTestBlockFunctions: {
             type: "array",
@@ -798,7 +798,7 @@ const expectExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$S = "consistent-test-it";
+const RULE_NAME$T = "consistent-test-it";
 const buildFixer = (callee, nodeName, preferredTestKeyword) => (fixer) => [
   fixer.replaceText(
     callee.type === AST_NODE_TYPES.MemberExpression ? callee.object : callee,
@@ -816,7 +816,7 @@ function getOppositeTestKeyword(test) {
   return TestCaseName.test;
 }
 const consistentTestIt = createEslintRule({
-  name: RULE_NAME$S,
+  name: RULE_NAME$T,
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -914,7 +914,7 @@ const consistentTestIt = createEslintRule({
   }
 });
 
-const RULE_NAME$R = "prefer-to-be";
+const RULE_NAME$S = "prefer-to-be";
 const isNullLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === null;
 const isNullEqualityMatcher = (expectFnCall) => isNullLiteral(getFirstMatcherArg(expectFnCall));
 const isFirstArgumentIdentifier = (expectFnCall, name) => isIdentifier(getFirstMatcherArg(expectFnCall), name);
@@ -950,7 +950,7 @@ const reportPreferToBe = (context, whatToBe, expectFnCall, func, modifierNode) =
   });
 };
 const preferToBe = createEslintRule({
-  name: RULE_NAME$R,
+  name: RULE_NAME$S,
   meta: {
     type: "suggestion",
     docs: {
@@ -1002,9 +1002,9 @@ const preferToBe = createEslintRule({
   }
 });
 
-const RULE_NAME$Q = "no-hooks";
+const RULE_NAME$R = "no-hooks";
 const noHooks = createEslintRule({
-  name: RULE_NAME$Q,
+  name: RULE_NAME$R,
   meta: {
     type: "suggestion",
     docs: {
@@ -1043,9 +1043,9 @@ const noHooks = createEslintRule({
   }
 });
 
-const RULE_NAME$P = "no-restricted-vi-methods";
+const RULE_NAME$Q = "no-restricted-vi-methods";
 const noRestrictedViMethods = createEslintRule({
-  name: RULE_NAME$P,
+  name: RULE_NAME$Q,
   meta: {
     type: "suggestion",
     docs: {
@@ -1085,11 +1085,11 @@ const noRestrictedViMethods = createEslintRule({
   }
 });
 
-const RULE_NAME$O = "consistent-test-filename";
+const RULE_NAME$P = "consistent-test-filename";
 const defaultPattern = /.*\.test\.[tj]sx?$/;
 const defaultTestsPattern = /.*\.(test|spec)\.[tj]sx?$/;
 const consistentTestFilename = createEslintRule({
-  name: RULE_NAME$O,
+  name: RULE_NAME$P,
   meta: {
     type: "problem",
     docs: {
@@ -1144,9 +1144,9 @@ const consistentTestFilename = createEslintRule({
   }
 });
 
-const RULE_NAME$N = "max-expects";
+const RULE_NAME$O = "max-expects";
 const maxExpect = createEslintRule({
-  name: RULE_NAME$N,
+  name: RULE_NAME$O,
   meta: {
     docs: {
       requiresTypeChecking: false,
@@ -1202,9 +1202,9 @@ const maxExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$M = "no-alias-methods";
+const RULE_NAME$N = "no-alias-methods";
 const noAliasMethod = createEslintRule({
-  name: RULE_NAME$M,
+  name: RULE_NAME$N,
   meta: {
     docs: {
       description: "disallow alias methods",
@@ -1254,12 +1254,12 @@ const noAliasMethod = createEslintRule({
   }
 });
 
-const RULE_NAME$L = "no-commented-out-tests";
+const RULE_NAME$M = "no-commented-out-tests";
 function hasTests(node) {
   return /^\s*[xf]?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\(/mu.test(node.value);
 }
 const noCommentedOutTests = createEslintRule({
-  name: RULE_NAME$L,
+  name: RULE_NAME$M,
   meta: {
     docs: {
       description: "disallow commented out tests",
@@ -1289,10 +1289,10 @@ const noCommentedOutTests = createEslintRule({
   }
 });
 
-const RULE_NAME$K = "no-conditional-expect";
+const RULE_NAME$L = "no-conditional-expect";
 const isCatchCall = (node) => node.callee.type === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "catch");
 const noConditionalExpect = createEslintRule({
-  name: RULE_NAME$K,
+  name: RULE_NAME$L,
   meta: {
     type: "problem",
     docs: {
@@ -1358,9 +1358,9 @@ const noConditionalExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$J = "no-import-node-test";
+const RULE_NAME$K = "no-import-node-test";
 const noImportNodeTest = createEslintRule({
-  name: RULE_NAME$J,
+  name: RULE_NAME$K,
   meta: {
     docs: {
       description: "disallow importing `node:test`",
@@ -1392,9 +1392,9 @@ const noImportNodeTest = createEslintRule({
   }
 });
 
-const RULE_NAME$I = "no-conditional-in-test";
+const RULE_NAME$J = "no-conditional-in-test";
 const noConditionalInTest = createEslintRule({
-  name: RULE_NAME$I,
+  name: RULE_NAME$J,
   meta: {
     docs: {
       description: "disallow conditional tests",
@@ -1422,9 +1422,9 @@ const noConditionalInTest = createEslintRule({
   }
 });
 
-const RULE_NAME$H = "no-disabled-tests";
+const RULE_NAME$I = "no-disabled-tests";
 const noDisabledTests = createEslintRule({
-  name: RULE_NAME$H,
+  name: RULE_NAME$I,
   meta: {
     type: "suggestion",
     docs: {
@@ -1493,7 +1493,7 @@ const noDisabledTests = createEslintRule({
   }
 });
 
-const RULE_NAME$G = "no-done-callback";
+const RULE_NAME$H = "no-done-callback";
 const findCallbackArg = (node, isVitestEach, context) => {
   if (isVitestEach)
     return node.arguments[1];
@@ -1505,7 +1505,7 @@ const findCallbackArg = (node, isVitestEach, context) => {
   return null;
 };
 const noDoneCallback = createEslintRule({
-  name: RULE_NAME$G,
+  name: RULE_NAME$H,
   meta: {
     type: "suggestion",
     docs: {
@@ -1605,9 +1605,9 @@ const noDoneCallback = createEslintRule({
   }
 });
 
-const RULE_NAME$F = "no-duplicate-hooks";
+const RULE_NAME$G = "no-duplicate-hooks";
 const noDuplicateHooks = createEslintRule({
-  name: RULE_NAME$F,
+  name: RULE_NAME$G,
   meta: {
     docs: {
       recommended: false,
@@ -1650,7 +1650,7 @@ const noDuplicateHooks = createEslintRule({
   }
 });
 
-const RULE_NAME$E = "no-large-snapshots";
+const RULE_NAME$F = "no-large-snapshots";
 const reportOnViolation = (context, node, { maxSize: lineLimit = 50, allowedSnapshots = {} }) => {
   const startLine = node.loc.start.line;
   const endLine = node.loc.end.line;
@@ -1683,7 +1683,7 @@ const reportOnViolation = (context, node, { maxSize: lineLimit = 50, allowedSnap
   }
 };
 const noLargeSnapshots = createEslintRule({
-  name: RULE_NAME$E,
+  name: RULE_NAME$F,
   meta: {
     docs: {
       description: "disallow large snapshots",
@@ -1741,9 +1741,9 @@ const noLargeSnapshots = createEslintRule({
   }
 });
 
-const RULE_NAME$D = "no-interpolation-in-snapshots";
+const RULE_NAME$E = "no-interpolation-in-snapshots";
 const nonInterpolationInSnapShots = createEslintRule({
-  name: RULE_NAME$D,
+  name: RULE_NAME$E,
   meta: {
     type: "problem",
     docs: {
@@ -1784,9 +1784,9 @@ const nonInterpolationInSnapShots = createEslintRule({
 const mocksDirName = "__mocks__";
 const isMockPath = (path) => path.split(posix.sep).includes(mocksDirName);
 const isMockImportLiteral = (expression) => isStringNode(expression) && isMockPath(getStringValue(expression));
-const RULE_NAME$C = "no-mocks-import";
+const RULE_NAME$D = "no-mocks-import";
 const noMocksImport = createEslintRule({
-  name: RULE_NAME$C,
+  name: RULE_NAME$D,
   meta: {
     type: "problem",
     docs: {
@@ -1814,14 +1814,14 @@ const noMocksImport = createEslintRule({
   }
 });
 
-const RULE_NAME$B = "no-restricted-matchers";
+const RULE_NAME$C = "no-restricted-matchers";
 const isChainRestricted = (chain, restriction) => {
   if (ModifierName.hasOwnProperty(restriction) || restriction.endsWith(".not"))
     return chain.startsWith(restriction);
   return chain === restriction;
 };
 const noRestrictedMatchers = createEslintRule({
-  name: RULE_NAME$B,
+  name: RULE_NAME$C,
   meta: {
     docs: {
       description: "disallow the use of certain matchers",
@@ -1867,7 +1867,7 @@ const noRestrictedMatchers = createEslintRule({
   }
 });
 
-const RULE_NAME$A = "no-standalone-expect";
+const RULE_NAME$B = "no-standalone-expect";
 const getBlockType = (statement, context) => {
   const func = statement.parent;
   if (!func)
@@ -1884,7 +1884,7 @@ const getBlockType = (statement, context) => {
   return null;
 };
 const noStandaloneExpect = createEslintRule({
-  name: RULE_NAME$A,
+  name: RULE_NAME$B,
   meta: {
     docs: {
       description: "disallow using `expect` outside of `it` or `test` blocks",
@@ -1957,9 +1957,9 @@ const noStandaloneExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$z = "no-test-prefixes";
+const RULE_NAME$A = "no-test-prefixes";
 const noTestPrefixes = createEslintRule({
-  name: RULE_NAME$z,
+  name: RULE_NAME$A,
   meta: {
     docs: {
       description: "disallow using `test` as a prefix",
@@ -1998,7 +1998,7 @@ const noTestPrefixes = createEslintRule({
   }
 });
 
-const RULE_NAME$y = "no-test-return-statement";
+const RULE_NAME$z = "no-test-return-statement";
 const getBody = (args) => {
   const [, secondArg] = args;
   if (secondArg && isFunction(secondArg) && secondArg.body.type === AST_NODE_TYPES.BlockStatement)
@@ -2006,7 +2006,7 @@ const getBody = (args) => {
   return [];
 };
 const noTestReturnStatement = createEslintRule({
-  name: RULE_NAME$y,
+  name: RULE_NAME$z,
   meta: {
     type: "problem",
     docs: {
@@ -2044,9 +2044,9 @@ const noTestReturnStatement = createEslintRule({
   }
 });
 
-const RULE_NAME$x = "prefer-called-with";
+const RULE_NAME$y = "prefer-called-with";
 const preferCalledWith = createEslintRule({
-  name: RULE_NAME$x,
+  name: RULE_NAME$y,
   meta: {
     docs: {
       description: "enforce using `toBeCalledWith()` or `toHaveBeenCalledWith()`",
@@ -2085,7 +2085,7 @@ const preferCalledWith = createEslintRule({
   }
 });
 
-const RULE_NAME$w = "valid-title";
+const RULE_NAME$x = "valid-title";
 const trimFXPrefix = (word) => ["f", "x"].includes(word.charAt(0)) ? word.substring(1) : word;
 const quoteStringValue = (node) => node.type === AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
 const MatcherAndMessageSchema = {
@@ -2135,7 +2135,7 @@ const doesBinaryExpressionContainStringNode = (binaryExp) => {
   return isStringNode(binaryExp.left);
 };
 const validTitle = createEslintRule({
-  name: RULE_NAME$w,
+  name: RULE_NAME$x,
   meta: {
     docs: {
       description: "enforce valid titles",
@@ -2315,8 +2315,8 @@ const validTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$v = "valid-expect";
-const defaultAsyncMatchers = ["toReject", "toResolve"];
+const RULE_NAME$w = "valid-expect";
+const defaultAsyncMatchers$1 = ["toReject", "toResolve"];
 const getPromiseCallExpressionNode = (node) => {
   if (node.type === AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === AST_NODE_TYPES.CallExpression)
     node = node.parent;
@@ -2345,7 +2345,7 @@ const isAcceptableReturnNode = (node, allowReturn) => {
   ].includes(node.type);
 };
 const validExpect = createEslintRule({
-  name: RULE_NAME$v,
+  name: RULE_NAME$w,
   meta: {
     docs: {
       description: "enforce valid `expect()` usage",
@@ -2388,11 +2388,11 @@ const validExpect = createEslintRule({
   },
   defaultOptions: [{
     alwaysAwait: false,
-    asyncMatchers: defaultAsyncMatchers,
+    asyncMatchers: defaultAsyncMatchers$1,
     minArgs: 1,
     maxArgs: 1
   }],
-  create: (context, [{ alwaysAwait, asyncMatchers = defaultAsyncMatchers, minArgs = 1, maxArgs = 1 }]) => {
+  create: (context, [{ alwaysAwait, asyncMatchers = defaultAsyncMatchers$1, minArgs = 1, maxArgs = 1 }]) => {
     const arrayExceptions = /* @__PURE__ */ new Set();
     const pushPromiseArrayException = (loc) => arrayExceptions.add(promiseArrayExceptionKey(loc));
     const promiseArrayExceptionExists = (loc) => arrayExceptions.has(promiseArrayExceptionKey(loc));
@@ -2519,9 +2519,9 @@ const isBooleanEqualityMatcher = (expectFnCall) => {
 const isInstanceOfBinaryExpression = (node, className) => node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && isSupportedAccessor(node.right, className);
 const hasOnlyOneArgument = (call) => call.arguments.length === 1;
 
-const RULE_NAME$u = "prefer-to-be-object";
+const RULE_NAME$v = "prefer-to-be-object";
 const preferToBeObject = createEslintRule({
-  name: RULE_NAME$u,
+  name: RULE_NAME$v,
   meta: {
     type: "suggestion",
     docs: {
@@ -2594,10 +2594,10 @@ const preferToBeObject = createEslintRule({
   }
 });
 
-const RULE_NAME$t = "prefer-to-be-truthy";
+const RULE_NAME$u = "prefer-to-be-truthy";
 const isTrueLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === true;
 const preferToBeTruthy = createEslintRule({
-  name: RULE_NAME$t,
+  name: RULE_NAME$u,
   meta: {
     type: "suggestion",
     docs: {
@@ -2632,10 +2632,10 @@ const preferToBeTruthy = createEslintRule({
   }
 });
 
-const RULE_NAME$s = "prefer-to-be-falsy";
+const RULE_NAME$t = "prefer-to-be-falsy";
 const isFalseLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === false;
 const preferToBeFalsy = createEslintRule({
-  name: RULE_NAME$s,
+  name: RULE_NAME$t,
   meta: {
     type: "suggestion",
     docs: {
@@ -2670,9 +2670,9 @@ const preferToBeFalsy = createEslintRule({
   }
 });
 
-const RULE_NAME$r = "prefer-to-have-length";
+const RULE_NAME$s = "prefer-to-have-length";
 const preferToHaveLength = createEslintRule({
-  name: RULE_NAME$r,
+  name: RULE_NAME$s,
   meta: {
     type: "suggestion",
     docs: {
@@ -2720,9 +2720,9 @@ const preferToHaveLength = createEslintRule({
   }
 });
 
-const RULE_NAME$q = "prefer-equality-matcher";
+const RULE_NAME$r = "prefer-equality-matcher";
 const preferEqualityMatcher = createEslintRule({
-  name: RULE_NAME$q,
+  name: RULE_NAME$r,
   meta: {
     type: "suggestion",
     docs: {
@@ -2794,9 +2794,9 @@ const preferEqualityMatcher = createEslintRule({
   }
 });
 
-const RULE_NAME$p = "prefer-strict-equal";
+const RULE_NAME$q = "prefer-strict-equal";
 const preferStrictEqual = createEslintRule({
-  name: RULE_NAME$p,
+  name: RULE_NAME$q,
   meta: {
     type: "suggestion",
     docs: {
@@ -2837,9 +2837,9 @@ const preferStrictEqual = createEslintRule({
   }
 });
 
-const RULE_NAME$o = "prefer-expect-resolves";
+const RULE_NAME$p = "prefer-expect-resolves";
 const preferExpectResolves = createEslintRule({
-  name: RULE_NAME$o,
+  name: RULE_NAME$p,
   meta: {
     type: "suggestion",
     docs: {
@@ -2882,9 +2882,9 @@ const preferExpectResolves = createEslintRule({
   })
 });
 
-const RULE_NAME$n = "prefer-each";
+const RULE_NAME$o = "prefer-each";
 const preferEach = createEslintRule({
-  name: RULE_NAME$n,
+  name: RULE_NAME$o,
   meta: {
     type: "suggestion",
     docs: {
@@ -2943,9 +2943,9 @@ const preferEach = createEslintRule({
   }
 });
 
-const RULE_NAME$m = "prefer-hooks-on-top";
+const RULE_NAME$n = "prefer-hooks-on-top";
 const preferHooksOnTop = createEslintRule({
-  name: RULE_NAME$m,
+  name: RULE_NAME$n,
   meta: {
     type: "suggestion",
     docs: {
@@ -2979,10 +2979,10 @@ const preferHooksOnTop = createEslintRule({
   }
 });
 
-const RULE_NAME$l = "prefer-hooks-in-order";
+const RULE_NAME$m = "prefer-hooks-in-order";
 const HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
 const preferHooksInOrder = createEslintRule({
-  name: RULE_NAME$l,
+  name: RULE_NAME$m,
   meta: {
     type: "suggestion",
     docs: {
@@ -3037,7 +3037,7 @@ const preferHooksInOrder = createEslintRule({
   }
 });
 
-const RULE_NAME$k = "prefer-mock-promise-shorthand";
+const RULE_NAME$l = "prefer-mock-promise-shorthand";
 const withOnce = (name, addOnce) => {
   return `${name}${addOnce ? "Once" : ""}`;
 };
@@ -3049,7 +3049,7 @@ const findSingleReturnArgumentNode = (fnNode) => {
   return null;
 };
 const preferMockPromiseShorthand = createEslintRule({
-  name: RULE_NAME$k,
+  name: RULE_NAME$l,
   meta: {
     type: "suggestion",
     docs: {
@@ -3151,10 +3151,10 @@ const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.sta
 const isTypeCastExpression = (node) => node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
 const followTypeAssertionChain = (expression) => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
 
-const RULE_NAME$j = "prefer-vi-mocked";
+const RULE_NAME$k = "prefer-vi-mocked";
 const mockTypes = ["Mock", "MockedFunction", "MockedClass", "MockedObject"];
 const preferViMocked = createEslintRule({
-  name: RULE_NAME$j,
+  name: RULE_NAME$k,
   meta: {
     type: "suggestion",
     docs: {
@@ -3203,7 +3203,7 @@ const preferViMocked = createEslintRule({
   }
 });
 
-const RULE_NAME$i = "prefer-snapshot-hint";
+const RULE_NAME$j = "prefer-snapshot-hint";
 const snapshotMatchers = ["toMatchSnapshot", "toThrowErrorMatchingSnapshot"];
 const snapshotMatcherNames = snapshotMatchers;
 const isSnapshotMatcherWithoutHint = (expectFnCall) => {
@@ -3217,7 +3217,7 @@ const isSnapshotMatcherWithoutHint = (expectFnCall) => {
   return !isStringNode(arg);
 };
 const preferSnapshotHint = createEslintRule({
-  name: RULE_NAME$i,
+  name: RULE_NAME$j,
   meta: {
     type: "suggestion",
     docs: {
@@ -3295,7 +3295,7 @@ const preferSnapshotHint = createEslintRule({
   }
 });
 
-const RULE_NAME$h = "valid-describe-callback";
+const RULE_NAME$i = "valid-describe-callback";
 const paramsLocation = (params) => {
   const [first] = params;
   const last = params[params.length - 1];
@@ -3305,7 +3305,7 @@ const paramsLocation = (params) => {
   };
 };
 const validDescribeCallback = createEslintRule({
-  name: RULE_NAME$h,
+  name: RULE_NAME$i,
   meta: {
     type: "problem",
     docs: {
@@ -3377,9 +3377,9 @@ const validDescribeCallback = createEslintRule({
   }
 });
 
-const RULE_NAME$g = "require-top-level-describe";
+const RULE_NAME$h = "require-top-level-describe";
 const requireTopLevelDescribe = createEslintRule({
-  name: RULE_NAME$g,
+  name: RULE_NAME$h,
   meta: {
     docs: {
       description: "enforce that all tests are in a top-level describe",
@@ -3448,9 +3448,9 @@ const requireTopLevelDescribe = createEslintRule({
   }
 });
 
-const RULE_NAME$f = "require-to-throw-message";
+const RULE_NAME$g = "require-to-throw-message";
 const requireToThrowMessage = createEslintRule({
-  name: RULE_NAME$f,
+  name: RULE_NAME$g,
   meta: {
     type: "suggestion",
     docs: {
@@ -3483,7 +3483,7 @@ const requireToThrowMessage = createEslintRule({
   }
 });
 
-const RULE_NAME$e = "require-hook";
+const RULE_NAME$f = "require-hook";
 const isVitestFnCall = (node, context) => {
   if (parseVitestFnCall(node, context))
     return true;
@@ -3510,7 +3510,7 @@ const shouldBeInHook = (node, context, allowedFunctionCalls = []) => {
   }
 };
 const requireHook = createEslintRule({
-  name: RULE_NAME$e,
+  name: RULE_NAME$f,
   meta: {
     docs: {
       description: "require setup and teardown to be within a hook",
@@ -3566,9 +3566,9 @@ const requireHook = createEslintRule({
   }
 });
 
-const RULE_NAME$d = "require-local-test-context-for-concurrent-snapshots";
+const RULE_NAME$e = "require-local-test-context-for-concurrent-snapshots";
 const requireLocalTestContextForConcurrentSnapshots = createEslintRule({
-  name: RULE_NAME$d,
+  name: RULE_NAME$e,
   meta: {
     docs: {
       description: "require local Test Context for concurrent snapshot tests",
@@ -3617,7 +3617,7 @@ const requireLocalTestContextForConcurrentSnapshots = createEslintRule({
   }
 });
 
-const RULE_NAME$c = "prefer-todo";
+const RULE_NAME$d = "prefer-todo";
 const isTargetedTestCase = (vitestFnCall) => {
   if (vitestFnCall.members.some((s) => getAccessorValue(s) !== "skip"))
     return false;
@@ -3636,7 +3636,7 @@ function createTodoFixer(vitestFnCall, fixer) {
   return fixer.replaceText(vitestFnCall.head.node, `${vitestFnCall.head.local}.todo`);
 }
 const preferTodo = createEslintRule({
-  name: RULE_NAME$c,
+  name: RULE_NAME$d,
   meta: {
     type: "layout",
     docs: {
@@ -3680,7 +3680,7 @@ const preferTodo = createEslintRule({
   }
 });
 
-const RULE_NAME$b = "prefer-spy-on";
+const RULE_NAME$c = "prefer-spy-on";
 const findNodeObject = (node) => {
   if ("object" in node)
     return node.object;
@@ -3708,7 +3708,7 @@ const getAutoFixMockImplementation = (vitestFnCall, context) => {
   return argSource ? `.mockImplementation(${argSource})` : ".mockImplementation()";
 };
 const preferSpyOn = createEslintRule({
-  name: RULE_NAME$b,
+  name: RULE_NAME$c,
   meta: {
     type: "suggestion",
     docs: {
@@ -3755,7 +3755,7 @@ const preferSpyOn = createEslintRule({
   }
 });
 
-const RULE_NAME$a = "prefer-comparison-matcher";
+const RULE_NAME$b = "prefer-comparison-matcher";
 const isString = (node) => {
   return isStringNode(node) || node?.type === AST_NODE_TYPES.TemplateLiteral;
 };
@@ -3790,7 +3790,7 @@ const determineMatcher = (operator, negated) => {
   return null;
 };
 const preferComparisonMatcher = createEslintRule({
-  name: RULE_NAME$a,
+  name: RULE_NAME$b,
   meta: {
     type: "suggestion",
     docs: {
@@ -3854,10 +3854,10 @@ const preferComparisonMatcher = createEslintRule({
   }
 });
 
-const RULE_NAME$9 = "prefer-to-contain";
+const RULE_NAME$a = "prefer-to-contain";
 const isFixableIncludesCallExpression = (node) => node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "includes") && hasOnlyOneArgument(node) && node.arguments[0].type !== AST_NODE_TYPES.SpreadElement;
 const preferToContain = createEslintRule({
-  name: RULE_NAME$9,
+  name: RULE_NAME$a,
   meta: {
     docs: {
       description: "enforce using toContain()",
@@ -3916,7 +3916,7 @@ const preferToContain = createEslintRule({
   }
 });
 
-const RULE_NAME$8 = "prefer-expect-assertions";
+const RULE_NAME$9 = "prefer-expect-assertions";
 const isFirstStatement = (node) => {
   let parent = node;
   while (parent) {
@@ -4289,7 +4289,7 @@ const createPaddingRule = (name, description, configs, deprecated = false) => {
   });
 };
 
-const RULE_NAME$7 = "padding-around-after-all-blocks";
+const RULE_NAME$8 = "padding-around-after-all-blocks";
 const config$6 = [
   {
     paddingType: PaddingType.Always,
@@ -4302,9 +4302,9 @@ const config$6 = [
     nextStatementType: StatementType.Any
   }
 ];
-const paddingAroundAfterAllBlocks = createPaddingRule(RULE_NAME$7, "Enforce padding around `afterAll` blocks", config$6);
+const paddingAroundAfterAllBlocks = createPaddingRule(RULE_NAME$8, "Enforce padding around `afterAll` blocks", config$6);
 
-const RULE_NAME$6 = "padding-around-after-each-blocks";
+const RULE_NAME$7 = "padding-around-after-each-blocks";
 const config$5 = [
   {
     paddingType: PaddingType.Always,
@@ -4317,9 +4317,9 @@ const config$5 = [
     nextStatementType: StatementType.Any
   }
 ];
-const paddingAroundAfterEachBlocks = createPaddingRule(RULE_NAME$6, "Enforce padding around `afterEach` blocks", config$5);
+const paddingAroundAfterEachBlocks = createPaddingRule(RULE_NAME$7, "Enforce padding around `afterEach` blocks", config$5);
 
-const RULE_NAME$5 = "padding-around-before-all-blocks";
+const RULE_NAME$6 = "padding-around-before-all-blocks";
 const config$4 = [
   {
     paddingType: PaddingType.Always,
@@ -4332,9 +4332,9 @@ const config$4 = [
     nextStatementType: StatementType.Any
   }
 ];
-const paddingAroundBeforeAllBlocks = createPaddingRule(RULE_NAME$5, "Enforce padding around `beforeAll` blocks", config$4);
+const paddingAroundBeforeAllBlocks = createPaddingRule(RULE_NAME$6, "Enforce padding around `beforeAll` blocks", config$4);
 
-const RULE_NAME$4 = "padding-around-before-each-blocks";
+const RULE_NAME$5 = "padding-around-before-each-blocks";
 const config$3 = [
   {
     paddingType: PaddingType.Always,
@@ -4348,12 +4348,12 @@ const config$3 = [
   }
 ];
 const paddingAroundBeforeEachBlocks = createPaddingRule(
-  RULE_NAME$4,
+  RULE_NAME$5,
   "Enforce padding around `beforeEach` blocks",
   config$3
 );
 
-const RULE_NAME$3 = "padding-around-describe-blocks";
+const RULE_NAME$4 = "padding-around-describe-blocks";
 const config$2 = [
   {
     paddingType: PaddingType.Always,
@@ -4375,12 +4375,12 @@ const config$2 = [
   }
 ];
 const paddingAroundDescribeBlocks = createPaddingRule(
-  RULE_NAME$3,
+  RULE_NAME$4,
   "Enforce padding around `describe` blocks",
   config$2
 );
 
-const RULE_NAME$2 = "padding-around-expect-groups";
+const RULE_NAME$3 = "padding-around-expect-groups";
 const config$1 = [
   {
     paddingType: PaddingType.Always,
@@ -4399,12 +4399,12 @@ const config$1 = [
   }
 ];
 const paddingAroundExpectGroups = createPaddingRule(
-  RULE_NAME$2,
+  RULE_NAME$3,
   "Enforce padding around `expect` groups",
   config$1
 );
 
-const RULE_NAME$1 = "padding-around-test-blocks";
+const RULE_NAME$2 = "padding-around-test-blocks";
 const config = [
   {
     paddingType: PaddingType.Always,
@@ -4430,14 +4430,14 @@ const config = [
   }
 ];
 const paddingAroundTestBlocks = createPaddingRule(
-  RULE_NAME$1,
+  RULE_NAME$2,
   "Enforce padding around afterAll blocks",
   config
 );
 
-const RULE_NAME = "padding-around-all";
+const RULE_NAME$1 = "padding-around-all";
 const paddingAroundAll = createPaddingRule(
-  RULE_NAME,
+  RULE_NAME$1,
   "Enforce padding around vitest functions",
   [
     ...config$6,
@@ -4450,6 +4450,256 @@ const paddingAroundAll = createPaddingRule(
   ]
 );
 
+const RULE_NAME = "valid-expect-in-promise";
+const defaultAsyncMatchers = ["toRejectWith", "toResolveWith"];
+const isPromiseChainCall = (node) => {
+  if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property)) {
+    if (node.arguments.length === 0) {
+      return false;
+    }
+    switch (getAccessorValue(node.callee.property)) {
+      case "then":
+        return node.arguments.length < 3;
+      case "catch":
+      case "finally":
+        return node.arguments.length < 2;
+    }
+  }
+  return false;
+};
+const isTestCaseCallWithCallbackArg = (node, context) => {
+  const vitestCallFn = parseVitestFnCall(node, context);
+  if (vitestCallFn?.type !== "test") {
+    return false;
+  }
+  const isVitestEach = vitestCallFn.members.some(
+    (s) => getAccessorValue(s) === "each"
+  );
+  if (isVitestEach && node.callee.type !== AST_NODE_TYPES.TaggedTemplateExpression) {
+    return true;
+  }
+  const [, callback] = node.arguments;
+  const callbackArgIndex = Number(isVitestEach);
+  return callback && isFunction(callback) && callback.params.length === 1 + callbackArgIndex;
+};
+const isPromiseMethodThatUsesValue = (node, identifier) => {
+  const { name } = identifier;
+  if (node.argument === null) {
+    return false;
+  }
+  if (node.argument.type === AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+    const nodeName = getNodeName(node.argument);
+    if (["Promise.all", "Promise.allSettled"].includes(nodeName)) {
+      const [firstArg] = node.argument.arguments;
+      if (firstArg.type === AST_NODE_TYPES.ArrayExpression && firstArg.elements.some((nod) => nod && isIdentifier(nod, name))) {
+        return true;
+      }
+    }
+    if (["Promise.resolve", "Promise.reject"].includes(nodeName) && node.argument.arguments.length === 1) {
+      return isIdentifier(node.argument.arguments[0], name);
+    }
+  }
+  return isIdentifier(node.argument, name);
+};
+const isValueAwaitedInElements = (name, elements) => {
+  for (const element of elements) {
+    if (element?.type === AST_NODE_TYPES.AwaitExpression && isIdentifier(element.argument, name)) {
+      return true;
+    }
+    if (element?.type === AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
+      return true;
+    }
+  }
+  return false;
+};
+const isValueAwaitedInArguments = (name, call) => {
+  let node = call;
+  while (node) {
+    if (node.type === AST_NODE_TYPES.CallExpression) {
+      if (isValueAwaitedInElements(name, node.arguments)) {
+        return true;
+      }
+      node = node.callee;
+    }
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
+    node = node.object;
+  }
+  return false;
+};
+const getLeftMostCallExpression = (call) => {
+  let leftMostCallExpression = call;
+  let node = call;
+  while (node) {
+    if (node.type === AST_NODE_TYPES.CallExpression) {
+      leftMostCallExpression = node;
+      node = node.callee;
+    }
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
+    node = node.object;
+  }
+  return leftMostCallExpression;
+};
+const isValueAwaitedOrReturned = (identifier, body, context) => {
+  const { name } = identifier;
+  for (const node of body) {
+    if (node.range[0] <= identifier.range[0]) {
+      continue;
+    }
+    if (node.type === AST_NODE_TYPES.ReturnStatement) {
+      return isPromiseMethodThatUsesValue(node, identifier);
+    }
+    if (node.type === AST_NODE_TYPES.ExpressionStatement) {
+      if (node.expression.type === AST_NODE_TYPES.CallExpression) {
+        if (isValueAwaitedInArguments(name, node.expression)) {
+          return true;
+        }
+        const leftMostCall = getLeftMostCallExpression(node.expression);
+        const vitestFnCall = parseVitestFnCall(node.expression, context);
+        if (vitestFnCall?.type === "expect" && leftMostCall.arguments.length > 0 && isIdentifier(leftMostCall.arguments[0], name)) {
+          if (vitestFnCall.members.some((m) => {
+            const v = getAccessorValue(m);
+            return v === ModifierName.resolves || v === ModifierName.rejects;
+          })) {
+            return true;
+          }
+        }
+      }
+      if (node.expression.type === AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
+        return true;
+      }
+      if (node.expression.type === AST_NODE_TYPES.AssignmentExpression) {
+        if (isIdentifier(node.expression.left, name) && getNodeName(node.expression.right)?.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+          continue;
+        }
+        break;
+      }
+    }
+    if (node.type === AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body, context)) {
+      return true;
+    }
+  }
+  return false;
+};
+const findFirstBlockBodyUp = (node) => {
+  let parent = node;
+  while (parent) {
+    if (parent.type === AST_NODE_TYPES.BlockStatement) {
+      return parent.body;
+    }
+    parent = parent.parent;
+  }
+  throw new Error(
+    `Could not find BlockStatement - please file a github issue at https://github.com/vitest-dev/eslint-plugin-vitest`
+  );
+};
+const isDirectlyWithinTestCaseCall = (node, context) => {
+  let parent = node;
+  while (parent) {
+    if (isFunction(parent)) {
+      parent = parent.parent;
+      return parent?.type === AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(parent, context, ["test"]);
+    }
+    parent = parent.parent;
+  }
+  return false;
+};
+const isVariableAwaitedOrReturned = (variable, context) => {
+  const body = findFirstBlockBodyUp(variable);
+  if (!isIdentifier(variable.id)) {
+    return true;
+  }
+  return isValueAwaitedOrReturned(variable.id, body, context);
+};
+const validExpectInPromise = createEslintRule({
+  name: __filename,
+  meta: {
+    docs: {
+      description: "Require promises that have expectations in their chain to be valid"
+    },
+    messages: {
+      expectInFloatingPromise: "This promise should either be returned or awaited to ensure the expects in its chain are called"
+    },
+    type: "suggestion",
+    schema: []
+  },
+  defaultOptions: [{
+    alwaysAwait: false,
+    asyncMatchers: defaultAsyncMatchers,
+    minArgs: 1,
+    maxArgs: 1
+  }],
+  create(context) {
+    let inTestCaseWithDoneCallback = false;
+    const chains = [];
+    return {
+      CallExpression(node) {
+        if (isTestCaseCallWithCallbackArg(node, context)) {
+          inTestCaseWithDoneCallback = true;
+          return;
+        }
+        if (isPromiseChainCall(node)) {
+          chains.unshift(false);
+          return;
+        }
+        if (chains.length > 0 && isTypeOfVitestFnCall(node, context, ["expect"])) {
+          chains[0] = true;
+        }
+      },
+      "CallExpression:exit"(node) {
+        if (inTestCaseWithDoneCallback) {
+          if (isTypeOfVitestFnCall(node, context, ["test"])) {
+            inTestCaseWithDoneCallback = false;
+          }
+          return;
+        }
+        if (!isPromiseChainCall(node)) {
+          return;
+        }
+        const hasExpectCall = chains.shift();
+        if (!hasExpectCall) {
+          return;
+        }
+        const { parent } = findTopMostCallExpression(node);
+        if (!parent || !isDirectlyWithinTestCaseCall(parent, context)) {
+          return;
+        }
+        switch (parent.type) {
+          case AST_NODE_TYPES.VariableDeclarator: {
+            if (isVariableAwaitedOrReturned(parent, context)) {
+              return;
+            }
+            break;
+          }
+          case AST_NODE_TYPES.AssignmentExpression: {
+            if (parent.left.type === AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(
+              parent.left,
+              findFirstBlockBodyUp(parent),
+              context
+            )) {
+              return;
+            }
+            break;
+          }
+          case AST_NODE_TYPES.ExpressionStatement:
+            break;
+          case AST_NODE_TYPES.ReturnStatement:
+          case AST_NODE_TYPES.AwaitExpression:
+          default:
+            return;
+        }
+        context.report({
+          messageId: "expectInFloatingPromise",
+          node: parent
+        });
+      }
+    };
+  }
+});
+
 const createConfig = (rules) => Object.keys(rules).reduce((acc, ruleName) => {
   return {
     ...acc,
@@ -4466,17 +4716,18 @@ const createConfigLegacy = (rules) => ({
   }, {})
 });
 const allRules = {
+  [RULE_NAME$Z]: "warn",
   [RULE_NAME$Y]: "warn",
-  [RULE_NAME$X]: "warn",
+  [RULE_NAME$W]: "warn",
   [RULE_NAME$V]: "warn",
-  [RULE_NAME$U]: "warn",
-  [RULE_NAME$S]: "warn",
+  [RULE_NAME$T]: "warn",
+  [RULE_NAME$R]: "warn",
   [RULE_NAME$Q]: "warn",
   [RULE_NAME$P]: "warn",
   [RULE_NAME$O]: "warn",
   [RULE_NAME$N]: "warn",
-  [RULE_NAME$M]: "warn",
-  [RULE_NAME$K]: "warn",
+  [RULE_NAME$L]: "warn",
+  [RULE_NAME$J]: "warn",
   [RULE_NAME$I]: "warn",
   [RULE_NAME$H]: "warn",
   [RULE_NAME$G]: "warn",
@@ -4488,10 +4739,10 @@ const allRules = {
   [RULE_NAME$A]: "warn",
   [RULE_NAME$z]: "warn",
   [RULE_NAME$y]: "warn",
-  [RULE_NAME$x]: "warn",
-  [RULE_NAME$s]: "warn",
-  [RULE_NAME$u]: "warn",
   [RULE_NAME$t]: "warn",
+  [RULE_NAME$v]: "warn",
+  [RULE_NAME$u]: "warn",
+  [RULE_NAME$s]: "warn",
   [RULE_NAME$r]: "warn",
   [RULE_NAME$q]: "warn",
   [RULE_NAME$p]: "warn",
@@ -4501,34 +4752,34 @@ const allRules = {
   [RULE_NAME$l]: "warn",
   [RULE_NAME$k]: "warn",
   [RULE_NAME$j]: "warn",
-  [RULE_NAME$i]: "warn",
+  [RULE_NAME$h]: "warn",
   [RULE_NAME$g]: "warn",
   [RULE_NAME$f]: "warn",
-  [RULE_NAME$e]: "warn",
+  [RULE_NAME$d]: "warn",
   [RULE_NAME$c]: "warn",
   [RULE_NAME$b]: "warn",
   [RULE_NAME$a]: "warn",
   [RULE_NAME$9]: "warn",
+  [RULE_NAME$S]: "warn",
   [RULE_NAME$8]: "warn",
-  [RULE_NAME$R]: "warn",
   [RULE_NAME$7]: "warn",
+  [RULE_NAME$1]: "warn",
   [RULE_NAME$6]: "warn",
-  [RULE_NAME]: "warn",
   [RULE_NAME$5]: "warn",
   [RULE_NAME$4]: "warn",
   [RULE_NAME$3]: "warn",
   [RULE_NAME$2]: "warn",
-  [RULE_NAME$1]: "warn"
+  [RULE_NAME]: "warn"
 };
 const recommended = {
-  [RULE_NAME$T]: "error",
-  [RULE_NAME$W]: "error",
-  [RULE_NAME$L]: "error",
+  [RULE_NAME$U]: "error",
+  [RULE_NAME$X]: "error",
+  [RULE_NAME$M]: "error",
+  [RULE_NAME$x]: "error",
   [RULE_NAME$w]: "error",
-  [RULE_NAME$v]: "error",
-  [RULE_NAME$h]: "error",
-  [RULE_NAME$d]: "error",
-  [RULE_NAME$J]: "error"
+  [RULE_NAME$i]: "error",
+  [RULE_NAME$e]: "error",
+  [RULE_NAME$K]: "error"
 };
 const plugin = {
   meta: {
@@ -4536,67 +4787,68 @@ const plugin = {
     version
   },
   rules: {
-    [RULE_NAME$Y]: lowerCaseTitle,
-    [RULE_NAME$X]: maxNestedDescribe,
-    [RULE_NAME$W]: noIdenticalTitle,
-    [RULE_NAME$V]: noFocusedTests,
-    [RULE_NAME$U]: noConditionalTest,
-    [RULE_NAME$T]: expectExpect,
-    [RULE_NAME$S]: consistentTestIt,
-    [RULE_NAME$R]: preferToBe,
-    [RULE_NAME$Q]: noHooks,
-    [RULE_NAME$P]: noRestrictedViMethods,
-    [RULE_NAME$O]: consistentTestFilename,
-    [RULE_NAME$N]: maxExpect,
-    [RULE_NAME$M]: noAliasMethod,
-    [RULE_NAME$L]: noCommentedOutTests,
-    [RULE_NAME$K]: noConditionalExpect,
-    [RULE_NAME$I]: noConditionalInTest,
-    [RULE_NAME$H]: noDisabledTests,
-    [RULE_NAME$G]: noDoneCallback,
-    [RULE_NAME$F]: noDuplicateHooks,
-    [RULE_NAME$E]: noLargeSnapshots,
-    [RULE_NAME$D]: nonInterpolationInSnapShots,
-    [RULE_NAME$C]: noMocksImport,
-    [RULE_NAME$B]: noRestrictedMatchers,
-    [RULE_NAME$A]: noStandaloneExpect,
-    [RULE_NAME$z]: noTestPrefixes,
-    [RULE_NAME$y]: noTestReturnStatement,
-    [RULE_NAME$J]: noImportNodeTest,
-    [RULE_NAME$x]: preferCalledWith,
-    [RULE_NAME$w]: validTitle,
-    [RULE_NAME$v]: validExpect,
-    [RULE_NAME$s]: preferToBeFalsy,
-    [RULE_NAME$u]: preferToBeObject,
-    [RULE_NAME$t]: preferToBeTruthy,
-    [RULE_NAME$r]: preferToHaveLength,
-    [RULE_NAME$q]: preferEqualityMatcher,
-    [RULE_NAME$p]: preferStrictEqual,
-    [RULE_NAME$o]: preferExpectResolves,
-    [RULE_NAME$n]: preferEach,
-    [RULE_NAME$m]: preferHooksOnTop,
-    [RULE_NAME$l]: preferHooksInOrder,
-    [RULE_NAME$d]: requireLocalTestContextForConcurrentSnapshots,
-    [RULE_NAME$k]: preferMockPromiseShorthand,
-    [RULE_NAME$j]: preferViMocked,
-    [RULE_NAME$i]: preferSnapshotHint,
-    [RULE_NAME$h]: validDescribeCallback,
-    [RULE_NAME$g]: requireTopLevelDescribe,
-    [RULE_NAME$f]: requireToThrowMessage,
-    [RULE_NAME$e]: requireHook,
-    [RULE_NAME$c]: preferTodo,
-    [RULE_NAME$b]: preferSpyOn,
-    [RULE_NAME$a]: preferComparisonMatcher,
-    [RULE_NAME$9]: preferToContain,
-    [RULE_NAME$8]: preferExpectAssertions,
-    [RULE_NAME$7]: paddingAroundAfterAllBlocks,
-    [RULE_NAME$6]: paddingAroundAfterEachBlocks,
-    [RULE_NAME]: paddingAroundAll,
-    [RULE_NAME$5]: paddingAroundBeforeAllBlocks,
-    [RULE_NAME$4]: paddingAroundBeforeEachBlocks,
-    [RULE_NAME$3]: paddingAroundDescribeBlocks,
-    [RULE_NAME$2]: paddingAroundExpectGroups,
-    [RULE_NAME$1]: paddingAroundTestBlocks
+    [RULE_NAME$Z]: lowerCaseTitle,
+    [RULE_NAME$Y]: maxNestedDescribe,
+    [RULE_NAME$X]: noIdenticalTitle,
+    [RULE_NAME$W]: noFocusedTests,
+    [RULE_NAME$V]: noConditionalTest,
+    [RULE_NAME$U]: expectExpect,
+    [RULE_NAME$T]: consistentTestIt,
+    [RULE_NAME$S]: preferToBe,
+    [RULE_NAME$R]: noHooks,
+    [RULE_NAME$Q]: noRestrictedViMethods,
+    [RULE_NAME$P]: consistentTestFilename,
+    [RULE_NAME$O]: maxExpect,
+    [RULE_NAME$N]: noAliasMethod,
+    [RULE_NAME$M]: noCommentedOutTests,
+    [RULE_NAME$L]: noConditionalExpect,
+    [RULE_NAME$J]: noConditionalInTest,
+    [RULE_NAME$I]: noDisabledTests,
+    [RULE_NAME$H]: noDoneCallback,
+    [RULE_NAME$G]: noDuplicateHooks,
+    [RULE_NAME$F]: noLargeSnapshots,
+    [RULE_NAME$E]: nonInterpolationInSnapShots,
+    [RULE_NAME$D]: noMocksImport,
+    [RULE_NAME$C]: noRestrictedMatchers,
+    [RULE_NAME$B]: noStandaloneExpect,
+    [RULE_NAME$A]: noTestPrefixes,
+    [RULE_NAME$z]: noTestReturnStatement,
+    [RULE_NAME$K]: noImportNodeTest,
+    [RULE_NAME$y]: preferCalledWith,
+    [RULE_NAME$x]: validTitle,
+    [RULE_NAME$w]: validExpect,
+    [RULE_NAME$t]: preferToBeFalsy,
+    [RULE_NAME$v]: preferToBeObject,
+    [RULE_NAME$u]: preferToBeTruthy,
+    [RULE_NAME$s]: preferToHaveLength,
+    [RULE_NAME$r]: preferEqualityMatcher,
+    [RULE_NAME$q]: preferStrictEqual,
+    [RULE_NAME$p]: preferExpectResolves,
+    [RULE_NAME$o]: preferEach,
+    [RULE_NAME$n]: preferHooksOnTop,
+    [RULE_NAME$m]: preferHooksInOrder,
+    [RULE_NAME$e]: requireLocalTestContextForConcurrentSnapshots,
+    [RULE_NAME$l]: preferMockPromiseShorthand,
+    [RULE_NAME$k]: preferViMocked,
+    [RULE_NAME$j]: preferSnapshotHint,
+    [RULE_NAME$i]: validDescribeCallback,
+    [RULE_NAME$h]: requireTopLevelDescribe,
+    [RULE_NAME$g]: requireToThrowMessage,
+    [RULE_NAME$f]: requireHook,
+    [RULE_NAME$d]: preferTodo,
+    [RULE_NAME$c]: preferSpyOn,
+    [RULE_NAME$b]: preferComparisonMatcher,
+    [RULE_NAME$a]: preferToContain,
+    [RULE_NAME$9]: preferExpectAssertions,
+    [RULE_NAME$8]: paddingAroundAfterAllBlocks,
+    [RULE_NAME$7]: paddingAroundAfterEachBlocks,
+    [RULE_NAME$1]: paddingAroundAll,
+    [RULE_NAME$6]: paddingAroundBeforeAllBlocks,
+    [RULE_NAME$5]: paddingAroundBeforeEachBlocks,
+    [RULE_NAME$4]: paddingAroundDescribeBlocks,
+    [RULE_NAME$3]: paddingAroundExpectGroups,
+    [RULE_NAME$2]: paddingAroundTestBlocks,
+    [RULE_NAME]: validExpectInPromise
   },
   configs: {
     "legacy-recommended": createConfigLegacy(recommended),