eslint-config-typed 3.13.7 → 3.14.1

package/src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.mts

@@ -0,0 +1,42 @@
+import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
+
+type MessageIds = 'preferAssertOverAssertNotOk';
+
+type Options = readonly [];
+
+export const preferAssertNotOkOverAssertIsNotOkRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Prefer assert.notOk(X) over assert.isNotOk(X).',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertOverAssertNotOk:
+        'Use assert.notOk(X) instead of assert.isNotOk(X).',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    MemberExpression: (node) => {
+      if (
+        node.object.type === AST_NODE_TYPES.Identifier &&
+        node.object.name === 'assert' &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
+        node.property.name === 'isNotOk' &&
+        node.parent.type === AST_NODE_TYPES.CallExpression &&
+        node.parent.callee === node
+      ) {
+        context.report({
+          node,
+          messageId: 'preferAssertOverAssertNotOk',
+          fix: (fixer) => fixer.replaceText(node, 'assert.notOk'),
+        });
+      }
+    },
+  }),
+};

package/src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.mts

@@ -0,0 +1,74 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESLint,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+type MessageIds = 'preferAssertNotOkOverExpectFalse';
+
+type Options = readonly [];
+
+export const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertNotOkOverExpectFalse:
+        'Use assert.notOk(X) instead of expect(X).toBe(false)',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      CallExpression: (node) => {
+        if (
+          node.callee.type === AST_NODE_TYPES.MemberExpression &&
+          node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+          node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+          node.callee.object.callee.name === 'expect' &&
+          node.callee.property.type === AST_NODE_TYPES.Identifier &&
+          node.callee.property.name === 'toBe' &&
+          Arr.isArrayOfLength(node.arguments, 1) &&
+          node.arguments[0].type === AST_NODE_TYPES.Literal &&
+          node.arguments[0].value === false
+        ) {
+          const arg = node.callee.object.arguments[0];
+
+          if (arg !== undefined) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+
+            const type = checker.getTypeAtLocation(tsNode);
+
+            const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+
+            if (!isBoolean) {
+              return;
+            }
+          }
+
+          const argText = context.sourceCode.getText(arg);
+
+          context.report({
+            node,
+            messageId: 'preferAssertNotOkOverExpectFalse',
+            fix: (fixer) => fixer.replaceText(node, `assert.notOk(${argText})`),
+          });
+        }
+      },
+    };
+  },
+};

package/src/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.mts

@@ -0,0 +1,42 @@
+import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
+
+type MessageIds = 'preferAssertOverAssertOk';
+
+type Options = readonly [];
+
+export const preferAssertOverAssertOkRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Prefer assert(X) over assert.ok(X), assert.isOk(X).',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertOverAssertOk:
+        'Use assert(X) instead of assert.ok(X), assert.isOk(X).',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    MemberExpression: (node) => {
+      if (
+        node.object.type === AST_NODE_TYPES.Identifier &&
+        node.object.name === 'assert' &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
+        (node.property.name === 'ok' || node.property.name === 'isOk') &&
+        node.parent.type === AST_NODE_TYPES.CallExpression &&
+        node.parent.callee === node
+      ) {
+        context.report({
+          node,
+          messageId: 'preferAssertOverAssertOk',
+          fix: (fixer) => fixer.replaceText(node, 'assert'),
+        });
+      }
+    },
+  }),
+};

package/src/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.mts

@@ -0,0 +1,74 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESLint,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+type MessageIds = 'preferAssertOverExpectTrue';
+
+type Options = readonly [];
+
+export const preferAssertOverExpectTrueRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertOverExpectTrue:
+        'Use assert(X) instead of expect(X).toBe(true)',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      CallExpression: (node) => {
+        if (
+          node.callee.type === AST_NODE_TYPES.MemberExpression &&
+          node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+          node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+          node.callee.object.callee.name === 'expect' &&
+          node.callee.property.type === AST_NODE_TYPES.Identifier &&
+          node.callee.property.name === 'toBe' &&
+          Arr.isArrayOfLength(node.arguments, 1) &&
+          node.arguments[0].type === AST_NODE_TYPES.Literal &&
+          node.arguments[0].value === true
+        ) {
+          const arg = node.callee.object.arguments[0];
+
+          if (arg !== undefined) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+
+            const type = checker.getTypeAtLocation(tsNode);
+
+            const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+
+            if (!isBoolean) {
+              return;
+            }
+          }
+
+          const argText = context.sourceCode.getText(arg);
+
+          context.report({
+            node,
+            messageId: 'preferAssertOverExpectTrue',
+            fix: (fixer) => fixer.replaceText(node, `assert(${argText})`),
+          });
+        }
+      },
+    };
+  },
+};

package/src/plugins/vitest-coding-style/rules/rules.mts

@@ -1,6 +1,18 @@
 import { type ESLintPlugin } from '../../../types/index.mjs';
 import { noExpectToStrictEqualRule } from './no-expect-to-strict-equal.mjs';
+import { preferAssertNotOkOverAssertIsNotOkRule } from './prefer-assert-not-ok-over-assert-is-not-ok.mjs';
+import { preferAssertNotOkOverExpectFalseRule } from './prefer-assert-not-ok-over-expect-false.mjs';
+import { preferAssertOverAssertOkRule } from './prefer-assert-over-assert-ok.mjs';
+import { preferAssertOverExpectTrueRule } from './prefer-assert-over-expect-true.mjs';
 
 export const vitestCodingStyleRules = {
   'no-expect-to-strict-equal': noExpectToStrictEqualRule,
+
+  'prefer-assert-over-assert-ok': preferAssertOverAssertOkRule,
+  'prefer-assert-not-ok-over-assert-is-not-ok':
+    preferAssertNotOkOverAssertIsNotOkRule,
+
+  'prefer-assert-over-expect-true': preferAssertOverExpectTrueRule,
+  'prefer-assert-not-ok-over-expect-false':
+    preferAssertNotOkOverExpectFalseRule,
 } as const satisfies ESLintPlugin['rules'];

package/src/rules/eslint-jest-rules.mts

@@ -82,4 +82,6 @@ export const eslintJestRules = {
   'jest/unbound-method': withDefaultOption('error'),
   'jest/valid-expect-in-promise': 'error',
   'jest/prefer-ending-with-an-expect': withDefaultOption('error'),
+
+  'jest/valid-mock-module-path': withDefaultOption('error'),
 } as const satisfies EslintJestRules;

package/src/rules/eslint-vitest-coding-style-rules.mts

@@ -2,4 +2,8 @@ import { type EslintVitestCodingStyleRules } from '../types/index.mjs';
 
 export const eslintVitestCodingStyleRules = {
   'vitest-coding-style/no-expect-to-strict-equal': 'error',
+  'vitest-coding-style/prefer-assert-over-assert-ok': 'error',
+  'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': 'error',
+  'vitest-coding-style/prefer-assert-over-expect-true': 'error',
+  'vitest-coding-style/prefer-assert-not-ok-over-expect-false': 'error',
 } as const satisfies EslintVitestCodingStyleRules;

package/src/rules/eslint-vitest-rules.mts

@@ -107,6 +107,17 @@ export const eslintVitestRules = {
   'vitest/warn-todo': 'error',
   'vitest/require-awaited-expect-poll': 'error',
 
+  'vitest/consistent-each-for': [
+    'error',
+    {
+      test: 'each',
+      it: 'each',
+      describe: 'each',
+      suite: 'each',
+    },
+  ],
+  'vitest/require-import-vi-mock': 'error',
+
   // deprecated
   'vitest/no-done-callback': 0,
 } as const satisfies EslintVitestRules;