eslint-plugin-power-esrules 0.1.12 → 0.1.13

package/lib/rules/import-sorting.js

@@ -91,7 +91,8 @@ function getImportType(node) {
         spec.type === "ImportSpecifier" &&
         spec.imported &&
         /^[A-Z][a-zA-Z]*$/.test(spec.imported.name) && // Имя начинается с большой буквы и не все заглавные
-        spec.imported.name !== spec.imported.name.toUpperCase(), // Не константа (не все заглавные)
+        spec.imported.name !== spec.imported.name.toUpperCase() && // Не константа (не все заглавные)
+        !spec.imported.name.endsWith("Context"), // не содержит ключевого слова Context
     );
     if (isDefaultImport || hasComponentName) {
       return "component";

package/lib/rules/require-data-testid-old.js

@@ -0,0 +1,223 @@
+// /**
+//  * Rule: require-data-testid
+//  *
+//  * Проверяет наличие data-testid атрибута у корневого контейнера JSX файла
+//  * и рекомендует запустить codemod скрипт для его добавления, если атрибут отсутствует.
+//  */
+
+// const path = require("path");
+
+// const packetName = "@hubex/power-linter";
+
+// /**
+//  * Получает имя JSX элемента
+//  */
+// function getJSXName(jsxName) {
+//   if (!jsxName) return null;
+//   switch (jsxName.type) {
+//     case "JSXIdentifier":
+//       return jsxName.name || null;
+//     case "JSXMemberExpression":
+//       // Берем правую часть: UI.Button -> Button
+//       return getJSXName(jsxName.property);
+//     case "JSXNamespacedName":
+//       return `${jsxName.namespace?.name || "ns"}:${
+//         jsxName.name?.name || "Name"
+//       }`;
+//     default:
+//       return null;
+//   }
+// }
+
+// /**
+//  * Проверяет, является ли узел верхнеуровневым JSX элементом
+//  * (не вложенным в другой JSX элемент или Fragment)
+//  */
+// function isTopLevelJSX(node) {
+//   let current = node.parent;
+//   while (current) {
+//     const parentType = current.type;
+//     // Если родитель - JSX элемент или Fragment, значит это не верхнеуровневый элемент
+//     if (parentType === "JSXElement" || parentType === "JSXFragment") {
+//       return false;
+//     }
+//     // Если родитель - ReturnStatement, это возвращаемое значение компонента (верхнеуровневый)
+//     if (parentType === "ReturnStatement") {
+//       return true;
+//     }
+//     // Если родитель - ExportDefaultDeclaration или ExportNamedDeclaration,
+//     // это может быть верхнеуровневый JSX
+//     if (
+//       parentType === "ExportDefaultDeclaration" ||
+//       parentType === "ExportNamedDeclaration"
+//     ) {
+//       return true;
+//     }
+//     current = current.parent;
+//   }
+//   return false;
+// }
+
+// /**
+//  * Спускается от Fragment к первому рендеримому JSXElement
+//  */
+// function descendToFirstRenderable(node) {
+//   if (!node) return null;
+
+//   // 1) Если это JSXFragment — обходим детей
+//   if (node.type === "JSXFragment") {
+//     for (const child of node.children || []) {
+//       if (child.type === "JSXElement") {
+//         const resolved = descendToFirstRenderable(child);
+//         if (resolved) return resolved;
+//       }
+//     }
+//     return null;
+//   }
+
+//   // 2) Если это JSXElement с именем Fragment
+//   if (node.type === "JSXElement") {
+//     const name = getJSXName(node.openingElement?.name);
+//     if (name === "Fragment") {
+//       for (const child of node.children || []) {
+//         if (child.type === "JSXElement") {
+//           const resolved = descendToFirstRenderable(child);
+//           if (resolved) return resolved;
+//         }
+//       }
+//       return null;
+//     }
+//     // Иначе это реальный рендеримый элемент
+//     return node;
+//   }
+
+//   return null;
+// }
+
+// /**
+//  * Проверяет наличие data-testid или dataTestID атрибута
+//  */
+// function hasDataTestId(openingElement) {
+//   if (!openingElement || !openingElement.attributes) {
+//     return false;
+//   }
+//   return openingElement.attributes.some((attr) => {
+//     if (!attr || attr.type !== "JSXAttribute" || !attr.name) {
+//       return false;
+//     }
+//     const attrName = attr.name.name;
+//     return attrName === "data-testid" || attrName === "dataTestID";
+//   });
+// }
+
+// /**
+//  * Получает относительный путь к файлу от корня проекта
+//  */
+// function getRelativeFilePath(context) {
+//   const filename = context.getFilename();
+//   const workspaceRoot = context.getCwd ? context.getCwd() : process.cwd();
+//   return path.relative(workspaceRoot, filename);
+// }
+
+// module.exports = {
+//   meta: {
+//     type: "suggestion",
+//     docs: {
+//       description:
+//         "Проверяет наличие data-testid атрибута у корневого контейнера JSX файла и рекомендует запустить codemod",
+//       category: "Best Practices",
+//       recommended: false,
+//     },
+//     fixable: null,
+//     schema: [],
+//     messages: {
+//       missingDataTestId:
+//         "Корневой контейнер JSX не содержит атрибут data-testid. " +
+//         `Запустите: node node_modules/${packetName}/scripts/addDataTestId/run-codemod.js {{filePath}}` +
+//         ` или node node_modules/${packetName}/scripts/addDataTestId/run-codemod.js src для всего проекта`,
+//     },
+//   },
+
+//   create(context) {
+//     let hasReported = false;
+//     let rootJSXNode = null;
+
+//     return {
+//       ReturnStatement(node) {
+//         // Проверяем только один раз на файл
+//         if (hasReported || rootJSXNode) {
+//           return;
+//         }
+
+//         const returnArgument = node.argument;
+//         if (!returnArgument) {
+//           return;
+//         }
+
+//         // Если возвращается JSX элемент или Fragment
+//         if (
+//           returnArgument.type === "JSXElement" ||
+//           returnArgument.type === "JSXFragment"
+//         ) {
+//           // Проверяем, что это не вложенный JSX (не имеет JSX родителя)
+//           if (isTopLevelJSX(returnArgument)) {
+//             rootJSXNode = returnArgument;
+//           }
+//         }
+//       },
+
+//       JSXElement(node) {
+//         // Проверяем только один раз на файл
+//         if (hasReported || rootJSXNode) {
+//           return;
+//         }
+
+//         // Проверяем верхнеуровневые JSX элементы вне ReturnStatement
+//         // (например, экспортируемые напрямую)
+//         if (isTopLevelJSX(node)) {
+//           rootJSXNode = node;
+//         }
+//       },
+
+//       JSXFragment(node) {
+//         // Проверяем только один раз на файл
+//         if (hasReported || rootJSXNode) {
+//           return;
+//         }
+
+//         // Проверяем верхнеуровневые Fragment вне ReturnStatement
+//         if (isTopLevelJSX(node)) {
+//           rootJSXNode = node;
+//         }
+//       },
+
+//       "Program:exit"() {
+//         // После обхода всего файла проверяем корневой JSX элемент
+//         if (hasReported || !rootJSXNode) {
+//           return;
+//         }
+
+//         // Если это Fragment, спускаемся к первому рендеримому элементу
+//         const rootElement = descendToFirstRenderable(rootJSXNode);
+//         const elementToCheck = rootElement || rootJSXNode;
+
+//         if (!elementToCheck.openingElement) {
+//           return;
+//         }
+
+//         // Проверяем наличие data-testid
+//         if (!hasDataTestId(elementToCheck.openingElement)) {
+//           hasReported = true;
+//           const filePath = getRelativeFilePath(context);
+//           context.report({
+//             node: elementToCheck.openingElement,
+//             messageId: "missingDataTestId",
+//             data: {
+//               filePath,
+//             },
+//           });
+//         }
+//       },
+//     };
+//   },
+// };

package/lib/rules/require-data-testid.js

@@ -1,24 +1,20 @@
 /**
  * Rule: require-data-testid
  *
- * Проверяет наличие data-testid атрибута у корневого контейнера JSX файла
+ * Проверяет наличие data-testid атрибута у корневого JSX элемента React-компонента
  * и рекомендует запустить codemod скрипт для его добавления, если атрибут отсутствует.
  */
 
 const path = require("path");
-
 const packetName = "@hubex/power-linter";
 
-/**
- * Получает имя JSX элемента
- */
+/** Получает имя JSX элемента */
 function getJSXName(jsxName) {
   if (!jsxName) return null;
   switch (jsxName.type) {
     case "JSXIdentifier":
       return jsxName.name || null;
     case "JSXMemberExpression":
-      // Берем правую часть: UI.Button -> Button
       return getJSXName(jsxName.property);
     case "JSXNamespacedName":
       return `${jsxName.namespace?.name || "ns"}:${
@@ -29,42 +25,81 @@ function getJSXName(jsxName) {
   }
 }
 
-/**
- * Проверяет, является ли узел верхнеуровневым JSX элементом
- * (не вложенным в другой JSX элемент или Fragment)
- */
-function isTopLevelJSX(node) {
-  let current = node.parent;
-  while (current) {
-    const parentType = current.type;
-    // Если родитель - JSX элемент или Fragment, значит это не верхнеуровневый элемент
-    if (parentType === "JSXElement" || parentType === "JSXFragment") {
-      return false;
-    }
-    // Если родитель - ReturnStatement, это возвращаемое значение компонента (верхнеуровневый)
-    if (parentType === "ReturnStatement") {
-      return true;
-    }
-    // Если родитель - ExportDefaultDeclaration или ExportNamedDeclaration,
-    // это может быть верхнеуровневый JSX
+/** Проверка PascalCase */
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+
+/** Находит имя компонента, учитывая HOC (memo, forwardRef, observer) */
+function getComponentName(node) {
+  if (!node) return null;
+
+  // Функция объявлена напрямую
+  if (node.type === "FunctionDeclaration") {
+    return node.id?.name ?? null;
+  }
+
+  // Переменная с функцией
+  if (
+    (node.type === "ArrowFunctionExpression" ||
+      node.type === "FunctionExpression") &&
+    node.parent?.type === "VariableDeclarator"
+  ) {
+    return node.parent.id?.name ?? null;
+  }
+
+  // HOC обёртка: memo(() => {}) или forwardRef(() => {}) или observer(() => {})
+  if (node.type === "CallExpression" && node.arguments.length > 0) {
+    return getComponentName(node.arguments[0]);
+  }
+
+  return null;
+}
+
+/** Проверяет, является ли функция React-компонентом */
+function isReactComponent(node) {
+  const name = getComponentName(node);
+  return Boolean(name && isPascalCase(name));
+}
+
+/** Находит корневой JSX элемент компонента, поддержка HOC */
+function getRootJSXFromComponent(fnNode) {
+  if (!fnNode) return null;
+
+  // Разворачиваем HOC
+  if (fnNode.type === "CallExpression" && fnNode.arguments.length > 0) {
+    return getRootJSXFromComponent(fnNode.arguments[0]);
+  }
+
+  // Arrow function без блока: const X = () => <Page />
+  if (
+    fnNode.body?.type === "JSXElement" ||
+    fnNode.body?.type === "JSXFragment"
+  ) {
+    return fnNode.body;
+  }
+
+  // Function с блоком
+  if (fnNode.body?.type !== "BlockStatement") return null;
+
+  for (const stmt of fnNode.body.body) {
     if (
-      parentType === "ExportDefaultDeclaration" ||
-      parentType === "ExportNamedDeclaration"
+      stmt.type === "ReturnStatement" &&
+      stmt.argument &&
+      (stmt.argument.type === "JSXElement" ||
+        stmt.argument.type === "JSXFragment")
     ) {
-      return true;
+      return stmt.argument;
     }
-    current = current.parent;
   }
-  return false;
+
+  return null;
 }
 
-/**
- * Спускается от Fragment к первому рендеримому JSXElement
- */
+/** Рекурсивно спускается через Fragment к первому рендеримому JSXElement */
 function descendToFirstRenderable(node) {
   if (!node) return null;
 
-  // 1) Если это JSXFragment — обходим детей
   if (node.type === "JSXFragment") {
     for (const child of node.children || []) {
       if (child.type === "JSXElement") {
@@ -75,7 +110,6 @@ function descendToFirstRenderable(node) {
     return null;
   }
 
-  // 2) Если это JSXElement с именем Fragment
   if (node.type === "JSXElement") {
     const name = getJSXName(node.openingElement?.name);
     if (name === "Fragment") {
@@ -87,32 +121,24 @@ function descendToFirstRenderable(node) {
       }
       return null;
     }
-    // Иначе это реальный рендеримый элемент
     return node;
   }
 
   return null;
 }
 
-/**
- * Проверяет наличие data-testid или dataTestID атрибута
- */
+/** Проверяет наличие data-testid или dataTestID */
 function hasDataTestId(openingElement) {
-  if (!openingElement || !openingElement.attributes) {
-    return false;
-  }
+  if (!openingElement || !openingElement.attributes) return false;
+
   return openingElement.attributes.some((attr) => {
-    if (!attr || attr.type !== "JSXAttribute" || !attr.name) {
-      return false;
-    }
+    if (!attr || attr.type !== "JSXAttribute" || !attr.name) return false;
     const attrName = attr.name.name;
     return attrName === "data-testid" || attrName === "dataTestID";
   });
 }
 
-/**
- * Получает относительный путь к файлу от корня проекта
- */
+/** Получает относительный путь к файлу */
 function getRelativeFilePath(context) {
   const filename = context.getFilename();
   const workspaceRoot = context.getCwd ? context.getCwd() : process.cwd();
@@ -124,7 +150,7 @@ module.exports = {
     type: "suggestion",
     docs: {
       description:
-        "Проверяет наличие data-testid атрибута у корневого контейнера JSX файла и рекомендует запустить codemod",
+        "Проверяет наличие data-testid атрибута у корневого JSX элемента React-компонента",
       category: "Best Practices",
       recommended: false,
     },
@@ -139,83 +165,37 @@ module.exports = {
   },
 
   create(context) {
-    let hasReported = false;
-    let rootJSXNode = null;
-
-    return {
-      ReturnStatement(node) {
-        // Проверяем только один раз на файл
-        if (hasReported || rootJSXNode) {
-          return;
-        }
-
-        const returnArgument = node.argument;
-        if (!returnArgument) {
-          return;
-        }
-
-        // Если возвращается JSX элемент или Fragment
-        if (
-          returnArgument.type === "JSXElement" ||
-          returnArgument.type === "JSXFragment"
-        ) {
-          // Проверяем, что это не вложенный JSX (не имеет JSX родителя)
-          if (isTopLevelJSX(returnArgument)) {
-            rootJSXNode = returnArgument;
-          }
-        }
-      },
-
-      JSXElement(node) {
-        // Проверяем только один раз на файл
-        if (hasReported || rootJSXNode) {
-          return;
-        }
-
-        // Проверяем верхнеуровневые JSX элементы вне ReturnStatement
-        // (например, экспортируемые напрямую)
-        if (isTopLevelJSX(node)) {
-          rootJSXNode = node;
-        }
-      },
+    const components = new Set();
 
-      JSXFragment(node) {
-        // Проверяем только один раз на файл
-        if (hasReported || rootJSXNode) {
-          return;
-        }
+    function collectComponent(node) {
+      if (isReactComponent(node)) {
+        components.add(node);
+      }
+    }
 
-        // Проверяем верхнеуровневые Fragment вне ReturnStatement
-        if (isTopLevelJSX(node)) {
-          rootJSXNode = node;
-        }
-      },
+    return {
+      FunctionDeclaration: collectComponent,
+      FunctionExpression: collectComponent,
+      ArrowFunctionExpression: collectComponent,
+      // CallExpression больше не нужен, HOC разворачиваются внутри getComponentName
+      //"CallExpression": collectComponent,
 
       "Program:exit"() {
-        // После обхода всего файла проверяем корневой JSX элемент
-        if (hasReported || !rootJSXNode) {
-          return;
-        }
-
-        // Если это Fragment, спускаемся к первому рендеримому элементу
-        const rootElement = descendToFirstRenderable(rootJSXNode);
-        const elementToCheck = rootElement || rootJSXNode;
-
-        if (!elementToCheck.openingElement) {
-          return;
-        }
-
-        // Проверяем наличие data-testid
-        if (!hasDataTestId(elementToCheck.openingElement)) {
-          hasReported = true;
-          const filePath = getRelativeFilePath(context);
-          context.report({
-            node: elementToCheck.openingElement,
-            messageId: "missingDataTestId",
-            data: {
-              filePath,
-            },
-          });
+        for (const component of components) {
+          const rootJSX = getRootJSXFromComponent(component);
+          if (!rootJSX) continue;
+
+          const elementToCheck = descendToFirstRenderable(rootJSX) || rootJSX;
+          if (!elementToCheck?.openingElement) continue;
+
+          if (!hasDataTestId(elementToCheck.openingElement)) {
+            const filePath = getRelativeFilePath(context);
+            context.report({
+              node: elementToCheck.openingElement,
+              messageId: "missingDataTestId",
+              data: { filePath },
+            });
+          }
         }
       },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-power-esrules",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "custom ESLint rules",
   "main": "index.js",
   "peerDependencies": {
@@ -17,7 +17,7 @@
     "lib": "lib"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -29,6 +29,7 @@
   },
   "homepage": "https://github.com/Vollmond148259/eslint-plugin-power-esrules#readme",
   "devDependencies": {
-    "eslint": "^8.57.1"
+    "eslint": "^8.57.1",
+    "jest": "^29.3.1"
   }
 }

package/tests/props-destructuring-sort.test.js

@@ -11,42 +11,42 @@ const ruleTester = new RuleTester({
 
 ruleTester.run("props-destructuring-sort", rule, {
   valid: [
-  {
-    name: "sorted destructuring from props in functional component",
-    code: `
+    {
+      name: "sorted destructuring from props in functional component",
+      code: `
       function MyComponent(props) {
         const { alpha, beta } = props;
         return <div>{alpha}{beta}</div>;
       }
     `,
-  },
-  {
-    name: "single property from props",
-    code: `
+    },
+    {
+      name: "single property from props",
+      code: `
       function MyComponent(props) {
         const { only } = props;
         return <div>{only}</div>;
       }
     `,
-  },
-  {
-    name: "unsorted props outside React component",
-    code: `
+    },
+    {
+      name: "unsorted props outside React component",
+      code: `
       function util(props) {
         const { z, a } = props;
         return z + a;
       }
     `,
-  },
-  {
-    name: "sorted params in arrow component",
-    code: `
+    },
+    {
+      name: "sorted params in arrow component",
+      code: `
       const MyComponent = ({ alpha, beta }) => <div>{alpha}{beta}</div>;
     `,
-  },
-  {
-    name: "sorted this.props in class component",
-    code: `
+    },
+    {
+      name: "sorted this.props in class component",
+      code: `
       class MyComponent extends React.Component {
         render() {
           const { alpha, beta } = this.props;
@@ -54,62 +54,62 @@ ruleTester.run("props-destructuring-sort", rule, {
         }
       }
     `,
-  },
-  {
-    name: "rest element last when already sorted",
-    code: `
+    },
+    {
+      name: "rest element last when already sorted",
+      code: `
       function MyComponent(props) {
         const { alpha, beta, ...rest } = props;
         return <div>{alpha}</div>;
       }
     `,
-  },
+    },
   ],
 
   invalid: [
-  {
-    name: "const from props in functional component",
-    code: `
+    {
+      name: "const from props in functional component",
+      code: `
       function MyComponent(props) {
         const { zebra, alpha } = props;
         return <div>{zebra}{alpha}</div>;
       }
     `,
-    output: `
+      output: `
       function MyComponent(props) {
         const { alpha, zebra } = props;
         return <div>{zebra}{alpha}</div>;
       }
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
-  {
-    name: "destructured params in function declaration",
-    code: `
+      errors: [{ messageId: "incorrectOrder" }],
+    },
+    {
+      name: "destructured params in function declaration",
+      code: `
       function MyComponent({ zebra, alpha }) {
         return <div>{zebra}{alpha}</div>;
       }
     `,
-    output: `
+      output: `
       function MyComponent({ alpha, zebra }) {
         return <div>{zebra}{alpha}</div>;
       }
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
-  {
-    name: "destructured params in arrow component with JSX",
-    code: `
+      errors: [{ messageId: "incorrectOrder" }],
+    },
+    {
+      name: "destructured params in arrow component with JSX",
+      code: `
       const MyComponent = ({ zebra, alpha }) => <div>{zebra}{alpha}</div>;
     `,
-    output: `
+      output: `
       const MyComponent = ({ alpha, zebra }) => <div>{zebra}{alpha}</div>;
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
-  {
-    name: "this.props in class component",
-    code: `
+      errors: [{ messageId: "incorrectOrder" }],
+    },
+    {
+      name: "this.props in class component",
+      code: `
       class MyComponent extends Component {
         render() {
           const { zebra, alpha } = this.props;
@@ -117,7 +117,7 @@ ruleTester.run("props-destructuring-sort", rule, {
         }
       }
     `,
-    output: `
+      output: `
       class MyComponent extends Component {
         render() {
           const { alpha, zebra } = this.props;
@@ -125,33 +125,35 @@ ruleTester.run("props-destructuring-sort", rule, {
         }
       }
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
-  {
-    name: "rest stays last after sort",
-    code: `
+      errors: [{ messageId: "incorrectOrder" }],
+    },
+    {
+      name: "rest stays last after sort",
+      code: `
       function MyComponent(props) {
         const { zebra, alpha, ...rest } = props;
         return <div>{zebra}</div>;
       }
     `,
-    output: `
+      output: `
       function MyComponent(props) {
         const { alpha, zebra, ...rest } = props;
         return <div>{zebra}</div>;
       }
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
-  {
-    name: "memo-wrapped component params",
-    code: `
+      errors: [{ messageId: "incorrectOrder" }],
+    },
+    {
+      name: "memo-wrapped component params",
+      code: `
       const MyComponent = memo(({ zebra, alpha }) => <div>{zebra}</div>);
     `,
-    output: `
+      output: `
       const MyComponent = memo(({ alpha, zebra }) => <div>{zebra}</div>);
     `,
-    errors: [{ messageId: "incorrectOrder" }],
-  },
+      errors: [{ messageId: "incorrectOrder" }],
+    },
   ],
 });
+
+console.log("OK");

package/tests/require-data-testid.test.js

@@ -0,0 +1,112 @@
+const { RuleTester } = require("eslint");
+const rule = require("../lib/rules/require-data-testid");
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    ecmaFeatures: { jsx: true },
+  },
+});
+
+ruleTester.run("require-data-testid", rule, {
+  valid: [
+    {
+      name: "function declaration with data-testid",
+      code: `
+        function MyComponent() {
+          return <div data-testid="my-component">Hello</div>;
+        }
+      `,
+    },
+    {
+      name: "arrow component with dataTestID",
+      code: `
+        const MyComponent = () => <section dataTestID="section">Hi</section>;
+      `,
+    },
+    {
+      name: "memo-wrapped component with data-testid",
+      code: `
+        const MyComponent = memo(() => <div data-testid="memo">Memo</div>);
+      `,
+    },
+    {
+      name: "forwardRef component with data-testid",
+      code: `
+        const MyComponent = forwardRef((props, ref) => <div ref={ref} data-testid="ref">Ref</div>);
+      `,
+    },
+    {
+      name: "nested JSX inside Fragment",
+      code: `
+        const MyComponent = () => (
+          <>
+            <div data-testid="inside">Hello</div>
+          </>
+        );
+      `,
+    },
+    {
+      name: "non-PascalCase function is ignored",
+      code: `
+        function utilFunction() {
+          return <div>Hello</div>;
+        }
+      `,
+    },
+  ],
+
+  invalid: [
+    {
+      name: "function declaration without data-testid",
+      code: `
+        function MyComponent() {
+          return <div>Hello</div>;
+        }
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+    {
+      name: "arrow component missing data-testid",
+      code: `
+        const MyComponent = () => <section>Hi</section>;
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+    {
+      name: "memo-wrapped component missing data-testid",
+      code: `
+        const MyComponent = memo(() => <div>Memo</div>);
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+    {
+      name: "forwardRef component missing data-testid",
+      code: `
+        const MyComponent = forwardRef((props, ref) => <div ref={ref}>Ref</div>);
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+    {
+      name: "nested JSX in Fragment missing data-testid",
+      code: `
+        const MyComponent = () => (
+          <>
+            <div>Hello</div>
+          </>
+        );
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+    {
+      name: "HOC wrapped component without data-testid",
+      code: `
+        const MyComponent = observer(() => <div>Hello</div>);
+      `,
+      errors: [{ messageId: "missingDataTestId" }],
+    },
+  ],
+});
+
+console.log("OK");