create-fullstack-scaffold 0.1.0

package/template/lint-scripts/validators/api-coverage.validator.ts

@@ -0,0 +1,355 @@
+/**
+ * API 覆盖率验证器
+ *
+ * 检查：
+ * 1. 每个 createRoute 定义的 API 是否有对应的测试
+ * 2. 每个服务层导出的函数是否有对应的测试
+ *
+ * 路由 -> 测试映射：
+ * - getAllRolesRoute -> test("get all roles")
+ * - getPermissionsRoute -> test("get all permissions")
+ * - getUserPermissionsRoute -> test("get user permissions")
+ *
+ * 服务函数 -> 测试映射：
+ * - getAllRoles() -> test("get all roles")
+ * - getAllPermissions() -> test("get all permissions")
+ * - getUserPermissions() -> test("get user permissions")
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import type { ModuleTestsConfig, ModuleTestError } from './index.js'
+import { minimatch } from 'minimatch'
+
+interface Route {
+  name: string
+  path: string
+  method: string
+  line: number
+}
+
+interface ServiceFunction {
+  name: string
+  line: number
+}
+
+interface TestCase {
+  name: string
+  file: string
+  line: number
+}
+
+interface CoverageResult {
+  module: string
+  uncoveredRoutes: Route[]
+  uncoveredFunctions: ServiceFunction[]
+}
+
+// 解析路由文件，提取所有 createRoute 定义
+function parseRoutes(filePath: string): Route[] {
+  const content = readFileSync(filePath, 'utf-8')
+  const routes: Route[] = []
+  const lines = content.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // 匹配 const xxxRoute = createRoute({
+    const routeMatch = line.match(/const\s+(\w+Route)\s*=\s*createRoute/)
+    if (routeMatch) {
+      const routeName = routeMatch[1]
+      let method = ''
+      let path = ''
+
+      // 向下查找 method 和 path
+      for (let j = i; j < Math.min(i + 20, lines.length); j++) {
+        const methodMatch = lines[j].match(/method:\s*['"](\w+)['"]/)
+        if (methodMatch) {
+          method = methodMatch[1]
+        }
+
+        const pathMatch = lines[j].match(/path:\s*['"]([^'"]+)['"]/)
+        if (pathMatch) {
+          path = pathMatch[1]
+        }
+
+        if (method && path) {
+          break
+        }
+      }
+
+      if (routeName && path) {
+        routes.push({ name: routeName, path, method: method || 'get', line: i + 1 })
+      }
+    }
+  }
+
+  return routes
+}
+
+// 解析服务文件，提取所有导出的函数
+function parseServiceFunctions(filePath: string): ServiceFunction[] {
+  const content = readFileSync(filePath, 'utf-8')
+  const functions: ServiceFunction[] = []
+  const lines = content.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // 匹配 export function xxx() 或 export const xxx = 
+    const funcMatch = line.match(/export\s+(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s+)?\()/)
+    if (funcMatch) {
+      const funcName = funcMatch[1] || funcMatch[2]
+
+      if (funcName) {
+        // 排除类型导出和测试辅助函数
+        if (!funcName.startsWith('type') && !funcName.includes('Test') && !funcName.includes('Mock')) {
+          functions.push({ name: funcName, line: i + 1 })
+        }
+      }
+    }
+  }
+
+  return functions
+}
+
+// 解析测试文件，提取所有测试用例名称
+function parseTestCases(filePath: string): TestCase[] {
+  const content = readFileSync(filePath, 'utf-8')
+  const tests: TestCase[] = []
+  const lines = content.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // 匹配 it('xxx', ...) 或 test('xxx', ...) 或 describe('xxx', ...)
+    const testMatch = line.match(/(?:it|test|describe)\s*\(\s*['"]([^'"]+)['"]/)
+    if (testMatch) {
+      const testName = testMatch[1].toLowerCase()
+
+      tests.push({
+        name: testName,
+        file: filePath,
+        line: i + 1,
+      })
+    }
+  }
+
+  return tests
+}
+
+// 检查路由是否有对应的测试
+function isRouteCovered(route: Route, testCases: TestCase[]): boolean {
+  const routeKeywords = [
+    route.name.replace('Route', '').toLowerCase(),
+    route.path.replace(/\/:id|\/:[^/]+/g, '').toLowerCase(),
+    route.method.toLowerCase(),
+  ]
+
+  for (const test of testCases) {
+    const testName = test.name
+
+    // 检查测试名称是否包含路由关键词
+    for (const keyword of routeKeywords) {
+      // 移除特殊字符进行比较
+      const cleanKeyword = keyword.replace(/[^a-z0-9]/g, '')
+      const cleanTestName = testName.replace(/[^a-z0-9]/g, '')
+
+      if (cleanTestName.includes(cleanKeyword) && cleanKeyword.length > 2) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+// 检查服务函数是否有对应的测试
+function isFunctionCovered(func: ServiceFunction, testCases: TestCase[]): boolean {
+  const funcKeywords = [
+    func.name.toLowerCase(),
+    // 移除常见前缀/后缀
+    func.name.replace(/^(get|create|update|delete|find|fetch)/i, '').toLowerCase(),
+  ]
+
+  for (const test of testCases) {
+    const testName = test.name
+
+    for (const keyword of funcKeywords) {
+      const cleanKeyword = keyword.replace(/[^a-z0-9]/g, '')
+      const cleanTestName = testName.replace(/[^a-z0-9]/g, '')
+
+      if (cleanTestName.includes(cleanKeyword) && cleanKeyword.length > 2) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+// 查找模块的测试文件
+function findTestFiles(modulePath: string, testsDir: string): string[] {
+  const testFiles: string[] = []
+  const fullTestsDir = join(modulePath, testsDir)
+
+  if (!existsSync(fullTestsDir)) {
+    return testFiles
+  }
+
+  const entries = readdirSync(fullTestsDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    if (entry.isFile() && (entry.name.endsWith('.test.ts') || entry.name.endsWith('.spec.ts'))) {
+      testFiles.push(join(fullTestsDir, entry.name))
+    }
+  }
+
+  return testFiles
+}
+
+// 检查模块的 API 覆盖率
+function checkModuleCoverage(modulePath: string, testsDir: string): CoverageResult {
+  const moduleName = relative(process.cwd(), modulePath)
+  const uncoveredRoutes: Route[] = []
+  const uncoveredFunctions: ServiceFunction[] = []
+
+  // 查找路由文件
+  const routesDir = join(modulePath, 'routes')
+  let routes: Route[] = []
+
+  if (existsSync(routesDir)) {
+    const routeFiles = readdirSync(routesDir).filter(f => f.endsWith('.ts'))
+
+    for (const routeFile of routeFiles) {
+      const filePath = join(routesDir, routeFile)
+      routes = routes.concat(parseRoutes(filePath))
+    }
+  }
+
+  // 查找服务文件
+  const servicesDir = join(modulePath, 'services')
+  let functions: ServiceFunction[] = []
+
+  if (existsSync(servicesDir)) {
+    const serviceFiles = readdirSync(servicesDir).filter(f => f.endsWith('-service.ts') || f.endsWith('.ts'))
+
+    for (const serviceFile of serviceFiles) {
+      const filePath = join(servicesDir, serviceFile)
+      functions = functions.concat(parseServiceFunctions(filePath))
+    }
+  }
+
+  // 收集所有测试用例
+  const testFiles = findTestFiles(modulePath, testsDir)
+  const allTestCases: TestCase[] = []
+
+  for (const testFile of testFiles) {
+    allTestCases.push(...parseTestCases(testFile))
+  }
+
+  // 检查路由覆盖率
+  for (const route of routes) {
+    if (!isRouteCovered(route, allTestCases)) {
+      uncoveredRoutes.push(route)
+    }
+  }
+
+  // 检查函数覆盖率
+  for (const func of functions) {
+    if (!isFunctionCovered(func, allTestCases)) {
+      uncoveredFunctions.push(func)
+    }
+  }
+
+  return {
+    module: moduleName,
+    uncoveredRoutes,
+    uncoveredFunctions,
+  }
+}
+
+export function validateAPICoverage(config: ModuleTestsConfig, rootPath: string): ModuleTestError[] {
+  const errors: ModuleTestError[] = []
+  const modules: string[] = []
+
+  // 查找所有模块
+  function scanDir(dir: string) {
+    if (!existsSync(dir)) return
+
+    const entries = readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (minimatch(entry.name, config.modulePattern)) {
+          modules.push(fullPath)
+        } else if (!config.ignoreDirs.includes(entry.name)) {
+          scanDir(fullPath)
+        }
+      }
+    }
+  }
+
+  for (const checkDir of config.checkDirs) {
+    scanDir(join(rootPath, checkDir))
+  }
+
+  // 检查每个模块的覆盖率
+  for (const modulePath of modules) {
+    const coverage = checkModuleCoverage(modulePath, config.testsDir)
+
+    const missing: string[] = []
+
+    if (coverage.uncoveredRoutes.length > 0) {
+      missing.push(
+        `${coverage.uncoveredRoutes.length} uncovered route(s): ${coverage.uncoveredRoutes.map(r => r.name).join(', ')}`
+      )
+    }
+
+    if (coverage.uncoveredFunctions.length > 0) {
+      missing.push(
+        `${coverage.uncoveredFunctions.length} uncovered function(s): ${coverage.uncoveredFunctions.map(f => f.name).join(', ')}`
+      )
+    }
+
+    if (missing.length > 0) {
+      errors.push({
+        module: coverage.module,
+        missingTests: missing,
+        suggestion: `添加缺失的测试用例覆盖以下路由和函数`,
+      })
+    }
+  }
+
+  return errors
+}
+
+export function formatAPICoverageErrors(errors: ModuleTestError[]): string {
+  if (errors.length === 0) return ''
+
+  let output = `❌ Found API coverage issues:\n\n`
+
+  for (const err of errors) {
+    output += `  📁 ${err.module}\n`
+
+    for (const issue of err.missingTests) {
+      output += `     ${issue}\n`
+    }
+
+    output += `     Suggestion: ${err.suggestion}\n\n`
+  }
+
+  output += `📋 How to fix:\n\n`
+  output += `  1. 确保每个 createRoute 都有对应的测试用例\n`
+  output += `  2. 确保每个导出的服务函数都有对应的测试用例\n`
+  output += `  3. 测试名称应该包含被测对象的关键词\n\n`
+  output += `  示例:\n`
+  output += `    // 路由: getAllRolesRoute (path: /permissions/roles)\n`
+  output += `    it('should get all roles')      // ✅ 匹配\n`
+  output += `    it('get roles')                 // ✅ 匹配\n`
+  output += `    it('fetch roles')               // ✅ 匹配\n\n`
+
+  return output
+}

package/template/lint-scripts/validators/client-rpc.validator.ts

@@ -0,0 +1,190 @@
+/**
+ * 客户端 RPC 调用验证器
+ *
+ * 检查客户端代码是否符合 API 调用规范：
+ * 1. 必须使用 apiClient 进行 API 调用
+ * 2. 必须使用类型安全的方法（$get, $post, $ws, $sse 等）
+ * 3. 禁止直接使用 fetch 调用内部 API
+ * 4. 禁止直接使用 WebSocket/EventSource
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import type { ClientRPCConfig, ClientRPCError } from './index.js'
+
+export function validateClientRPCInFile(
+  filePath: string,
+  rootPath: string,
+  config: ClientRPCConfig,
+  fileContent?: string
+): ClientRPCError[] {
+  const content = fileContent || readFileSync(filePath, 'utf-8')
+  const errors: ClientRPCError[] = []
+
+  if (config.forbidDirectFetch) {
+    const fetchPattern = /(?:await\s+)?fetch\s*\(\s*['"`](\/api\/|\/ws\/)/g
+    let match
+    while ((match = fetchPattern.exec(content)) !== null) {
+      const lineNumber = content.substring(0, match.index).split('\n').length
+      const matchedText = match[0]
+
+      errors.push({
+        file: relative(rootPath, filePath),
+        line: lineNumber,
+        message: `Direct fetch() call to internal API detected: ${matchedText}`,
+        suggestion: `Use apiClient instead: apiClient.api.todos.$get()`,
+      })
+    }
+  }
+
+  if (config.requireAPIClient) {
+    const hasAPIClientImport =
+      /import\s+.*apiClient.*from\s+['"]@client\/services\/apiClient['"]/.test(content)
+    const hasAPIClientUsage = /apiClient\s*\.\s*api\s*\./.test(content)
+
+    const hasAPIPathUsage = /['"`](\/api\/\w+)['"`]/.test(content)
+
+    if (hasAPIPathUsage && !hasAPIClientImport && !hasAPIClientUsage) {
+      const lineNumber = content.split('\n').findIndex(line => /['"`]\/api\//.test(line)) + 1
+      errors.push({
+        file: relative(rootPath, filePath),
+        line: lineNumber || 1,
+        message: 'API path detected but apiClient is not used',
+        suggestion: `Import and use apiClient: import { apiClient } from '@client/services/apiClient'`,
+      })
+    }
+  }
+
+  if (config.requireAPIClient) {
+    const nonTypeSafePattern = /apiClient\s*\.\s*api\s*\.\s*\w+\s*\(\s*\)/g
+    let match
+    while ((match = nonTypeSafePattern.exec(content)) !== null) {
+      const matchedText = match[0]
+      if (!matchedText.includes('$')) {
+        const lineNumber = content.substring(0, match.index).split('\n').length
+        errors.push({
+          file: relative(rootPath, filePath),
+          line: lineNumber,
+          message: `Non-type-safe API method call: ${matchedText}`,
+          suggestion: `Use type-safe method with $ prefix: apiClient.api.todos.$get()`,
+        })
+      }
+    }
+  }
+
+  if (config.forbidDirectWebSocket !== false) {
+    const wsPattern = /new\s+WebSocket\s*\(/g
+    let match
+    while ((match = wsPattern.exec(content)) !== null) {
+      const lineNumber = content.substring(0, match.index).split('\n').length
+      errors.push({
+        file: relative(rootPath, filePath),
+        line: lineNumber,
+        message: 'Direct new WebSocket() is not allowed',
+        suggestion: `Use type-safe $ws() method: apiClient.api.chat.ws.$ws()`,
+      })
+    }
+  }
+
+  if (config.forbidDirectEventSource !== false) {
+    const isImplementationFile =
+      filePath.endsWith('wsClient.ts') ||
+      filePath.endsWith('sseClient.ts') ||
+      filePath.includes('/services/wsClient.ts') ||
+      filePath.includes('/services/sseClient.ts')
+
+    if (!isImplementationFile) {
+      const ssePattern = /new\s+EventSource\s*\(/g
+      let match
+      while ((match = ssePattern.exec(content)) !== null) {
+        const lineNumber = content.substring(0, match.index).split('\n').length
+        errors.push({
+          file: relative(rootPath, filePath),
+          line: lineNumber,
+          message: 'Direct new EventSource() is not allowed',
+          suggestion: `Use type-safe $sse() method: await apiClient.api.notifications.stream.$sse()`,
+        })
+      }
+    }
+  }
+
+  return errors
+}
+
+function scanDirectory(
+  rootPath: string,
+  targetDir: string,
+  config: ClientRPCConfig
+): ClientRPCError[] {
+  const errors: ClientRPCError[] = []
+  const targetPath = join(rootPath, targetDir)
+
+  if (!existsSync(targetPath)) {
+    return errors
+  }
+
+  function scanDir(dir: string) {
+    const entries = readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (!config.ignoreDirs.includes(entry.name)) {
+          scanDir(fullPath)
+        }
+      } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+        const fileErrors = validateClientRPCInFile(fullPath, rootPath, config)
+        errors.push(...fileErrors)
+      }
+    }
+  }
+
+  scanDir(targetPath)
+  return errors
+}
+
+export function validateClientRPC(config: ClientRPCConfig, rootPath: string): ClientRPCError[] {
+  const allErrors: ClientRPCError[] = []
+
+  for (const dir of config.checkDirs) {
+    const errors = scanDirectory(rootPath, dir, config)
+    allErrors.push(...errors)
+  }
+
+  return allErrors
+}
+
+export function formatClientRPCErrors(errors: ClientRPCError[]): string {
+  if (errors.length === 0) return ''
+
+  let output = `❌ Found ${errors.length} client RPC usage error(s):\n\n`
+
+  for (const err of errors) {
+    output += `  ${err.file}:${err.line}\n`
+    output += `    Error: ${err.message}\n`
+    output += `    Suggestion: ${err.suggestion}\n\n`
+  }
+
+  output += '📋 Client RPC Guidelines:\n'
+  output += '  ✅ DO: Use apiClient with type-safe methods\n'
+  output += "    import { apiClient } from '@client/services/apiClient'\n"
+  output += '    const response = await apiClient.api.todos.$get()\n'
+  output += '    const result = await response.json()\n\n'
+  output += '  ✅ DO: Use $ws() for WebSocket\n'
+  output += '    const ws = apiClient.api.chat.ws.$ws()\n'
+  output += '    const result = await ws.call("echo", { message: "hello" })\n\n'
+  output += '  ✅ DO: Use $sse() for SSE\n'
+  output += '    const conn = await apiClient.api.notifications.stream.$sse()\n'
+  output += '    conn.on("notification", (n) => { ... })\n\n'
+  output += "  ❌ DON'T: Use direct fetch for internal APIs\n"
+  output += "    const response = await fetch('/api/todos')\n\n"
+  output += "  ❌ DON'T: Use non-type-safe methods\n"
+  output += '    apiClient.api.todos()  // Missing $ prefix\n\n'
+  output += "  ❌ DON'T: Use direct WebSocket/EventSource\n"
+  output += '    new WebSocket(...)  // Use $ws() instead\n'
+  output += '    new EventSource(...)  // Use $sse() instead\n\n'
+  output += '  📖 See: .claude/rules/client-service-rules.md\n'
+
+  return output
+}

package/template/lint-scripts/validators/client-tests.validator.ts

@@ -0,0 +1,155 @@
+/**
+ * Client 测试覆盖验证器
+ *
+ * 检查 client 端文件是否有对应的测试文件：
+ * 1. components/*.tsx -> components/__tests__/*.test.tsx
+ * 2. pages/*.tsx -> pages/__tests__/*.test.tsx
+ * 3. stores/*.ts -> stores/__tests__/*.test.ts
+ * 4. hooks/*.ts -> hooks/__tests__/*.test.ts
+ */
+
+import { readdirSync, existsSync } from 'node:fs'
+import { join, relative, dirname, basename } from 'node:path'
+import type { ClientTestsConfig, ClientTestError, ClientTestRule } from './index.js'
+import { minimatch } from 'minimatch'
+
+interface SourceFile {
+  path: string
+  relativePath: string
+  dir: string
+  name: string
+}
+
+function findSourceFiles(rootPath: string, config: ClientTestsConfig): Map<string, SourceFile[]> {
+  const filesByRule = new Map<string, SourceFile[]>()
+
+  for (const rule of config.rules) {
+    filesByRule.set(rule.dir, [])
+  }
+
+  function scanDir(dir: string) {
+    if (!existsSync(dir)) return
+
+    const entries = readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (!config.ignoreDirs.includes(entry.name)) {
+          scanDir(fullPath)
+        }
+      } else if (entry.isFile()) {
+        const relativePath = relative(rootPath, fullPath)
+        const fileDir = dirname(relativePath)
+        const fileName = basename(entry.name)
+
+        if (config.ignoreFiles.some(pattern => minimatch(relativePath, pattern))) {
+          continue
+        }
+
+        for (const rule of config.rules) {
+          if (fileDir === rule.dir && minimatch(fileName, rule.filePattern)) {
+            const files = filesByRule.get(rule.dir) || []
+            files.push({
+              path: fullPath,
+              relativePath,
+              dir: rule.dir,
+              name: fileName,
+            })
+            filesByRule.set(rule.dir, files)
+          }
+        }
+      }
+    }
+  }
+
+  for (const checkDir of config.checkDirs) {
+    scanDir(join(rootPath, checkDir))
+  }
+
+  return filesByRule
+}
+
+function checkTestExists(sourceFile: SourceFile, rule: ClientTestRule, rootPath: string): boolean {
+  const testsDir = join(rootPath, rule.dir, '__tests__')
+  if (!existsSync(testsDir)) {
+    return false
+  }
+
+  const testFiles = readdirSync(testsDir)
+  const baseName = sourceFile.name.replace(/\.(tsx?|jsx?)$/, '')
+
+  return testFiles.some(file => {
+    const testBaseName = file.replace(/\.test\.(tsx?|jsx?)$/, '')
+    return (
+      testBaseName === baseName || minimatch(file, rule.testPattern.replace('{name}', baseName))
+    )
+  })
+}
+
+export function validateClientTests(
+  config: ClientTestsConfig,
+  rootPath: string
+): ClientTestError[] {
+  const errors: ClientTestError[] = []
+  const filesByRule = findSourceFiles(rootPath, config)
+
+  for (const rule of config.rules) {
+    const files = filesByRule.get(rule.dir) || []
+
+    for (const file of files) {
+      const hasTest = checkTestExists(file, rule, rootPath)
+
+      if (!hasTest) {
+        const baseName = file.name.replace(/\.(tsx?|jsx?)$/, '')
+        errors.push({
+          file: file.relativePath,
+          expectedTest: `${rule.dir}/__tests__/${baseName}.test.tsx`,
+          suggestion: `为 ${file.relativePath} 添加测试文件: ${rule.dir}/__tests__/${baseName}.test.tsx`,
+        })
+      }
+    }
+  }
+
+  return errors
+}
+
+export function formatClientTestErrors(errors: ClientTestError[]): string {
+  if (errors.length === 0) return ''
+
+  let output = `❌ Found ${errors.length} client file(s) without tests:\n\n`
+
+  for (const err of errors) {
+    output += `  📄 ${err.file}\n`
+    output += `     Expected test: ${err.expectedTest}\n`
+    output += `     Suggestion: ${err.suggestion}\n\n`
+  }
+
+  output += '📋 测试文件位置: src/client/{components,pages}/__tests__/*.test.tsx\n\n'
+
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'
+  output += '📚 测试规范文档\n'
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n'
+  output += '  📖 测试规范: .trae/rules/60-testing-standards.md\n'
+  output += '  📖 组件规范: .trae/rules/30-client-components.md\n\n'
+
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'
+  output += '🎯 测试价值 & 快速上手\n'
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n'
+  output += '  💡 为什么测试？防止回归 | 文档作用 | 重构信心\n\n'
+  output += '  📝 示例:\n'
+  output += "     import { render, screen } from '@testing-library/react'\n"
+  output += "     import { Button } from '../Button'\n"
+  output += '     \n'
+  output += "     describe('Button', () => {\n"
+  output += "       it('renders label', () => {\n"
+  output += '         render(<Button label="Click" onClick={() => {}} />)\n'
+  output += "         expect(screen.getByText('Click')).toBeInTheDocument()\n"
+  output += '       })\n'
+  output += '     })\n\n'
+
+  output += '  💡 提示: 测试用户行为而非实现细节 | Mock 外部依赖\n\n'
+
+  return output
+}