whistle.mock-plugins 1.0.5 → 1.0.6-beta.0

package/app/cgi-bin/test-interface.js

@@ -3,6 +3,26 @@ const path = require('path');
 const Mock = require('mockjs');
 const url = require('url');
 
+// 缓存控制
+const CONFIG = {
+  // 缓存有效期（毫秒），默认 60 秒
+  CACHE_INTERVAL: process.env.MOCK_PLUGIN_CACHE_INTERVAL || 60000
+};
+
+// 缓存控制变量
+let enabledInterfacesCache = null; // 仅缓存启用状态的接口
+let cacheTime = 0;
+
+// 获取文件修改时间
+const getFileModTime = (filePath) => {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.mtimeMs;
+  } catch (err) {
+    return 0;
+  }
+};
+
 // 生成随机数工具函数（与rules-server.js中保持一致）
 const generateRandomValue = (pattern) => {
   // 如果不是以@开头的模式，直接返回原值
@@ -11,13 +31,160 @@ const generateRandomValue = (pattern) => {
   }
   
   const formatPattern = pattern.substring(1); // 去掉@前缀
-  // 为每个x生成一个随机字符（字母或数字）
+  // 使用单次正则替换优化性能
   return formatPattern.replace(/x/g, () => {
     const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
     return chars.charAt(Math.floor(Math.random() * chars.length));
   });
 };
 
+// 正则表达式缓存
+const regexCache = new Map();
+
+// URL匹配函数，提取为纯函数减少重复代码
+const isUrlMatchPattern = (url, pattern, proxyType) => {
+  if (!url || !pattern) return false;
+  
+  try {
+    // 对于url_redirect类型，需要完全匹配
+    if (proxyType === 'url_redirect') {
+      return url === pattern;
+    }
+    
+    // 对于redirect类型，只要url以pattern开头即可命中（前缀匹配）
+    if (proxyType === 'redirect') {
+      return url.startsWith(pattern);
+    }
+    
+    // 默认的匹配逻辑（用于response类型等）
+    // 精确匹配
+    if (pattern === url) {
+      return true;
+    }
+    
+    // 正则表达式
+    if (pattern.startsWith('/') && pattern.length > 2 && pattern.endsWith('/')) {
+      // 使用缓存的正则表达式
+      const cacheKey = `regex:${pattern}`;
+      let regex = regexCache.get(cacheKey);
+      
+      if (!regex) {
+        regex = new RegExp(pattern.slice(1, -1));
+        regexCache.set(cacheKey, regex);
+      }
+      
+      return regex.test(url);
+    }
+    
+    // 通配符模式
+    if (pattern.includes('*')) {
+      // 使用缓存的正则表达式
+      const cacheKey = `wildcard:${pattern}`;
+      let regex = regexCache.get(cacheKey);
+      
+      if (!regex) {
+        const regexPattern = pattern
+          .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+          .replace(/\*/g, '.*');
+        regex = new RegExp(`^${regexPattern}$`);
+        regexCache.set(cacheKey, regex);
+      }
+      
+      return regex.test(url);
+    }
+    
+    return false;
+  } catch (e) {
+    console.error('URL匹配检查失败:', e);
+    return false;
+  }
+};
+
+// 加载启用的接口数据，带缓存
+const loadEnabledInterfaces = (dataDir, interfacesFile, featuresFile) => {
+  try {
+    const currentTime = Date.now();
+    const interfacesFileModTime = getFileModTime(interfacesFile);
+    const featuresFileModTime = getFileModTime(featuresFile);
+    
+    // 取两个文件的最后修改时间的最大值
+    const lastModTime = Math.max(interfacesFileModTime, featuresFileModTime);
+    
+    // 使用缓存
+    if (enabledInterfacesCache && 
+        currentTime - cacheTime < CONFIG.CACHE_INTERVAL &&
+        lastModTime <= cacheTime) {
+      return enabledInterfacesCache;
+    }
+    
+    // 1. 读取并解析所有功能模块
+    let enabledFeatureIds = [];
+    if (fs.existsSync(featuresFile)) {
+      try {
+        const featuresData = fs.readJsonSync(featuresFile);
+        let features = [];
+        
+        if (featuresData && Array.isArray(featuresData)) {
+          features = featuresData;
+        } else if (featuresData && featuresData.features && Array.isArray(featuresData.features)) {
+          features = featuresData.features;
+        }
+        
+        // 过滤出启用状态的功能ID
+        enabledFeatureIds = features
+          .filter(feature => feature.active === true)
+          .map(feature => feature.id);
+      } catch (err) {
+        console.error('读取功能模块失败:', err);
+      }
+    }
+    
+    // 2. 读取并解析所有接口
+    let enabledInterfaces = [];
+    if (fs.existsSync(interfacesFile)) {
+      try {
+        const interfacesData = fs.readJsonSync(interfacesFile);
+        let interfaces = [];
+        
+        if (interfacesData && Array.isArray(interfacesData)) {
+          interfaces = interfacesData;
+        } else if (interfacesData && interfacesData.interfaces && Array.isArray(interfacesData.interfaces)) {
+          interfaces = interfacesData.interfaces;
+        }
+        
+        // 过滤出启用状态的接口
+        enabledInterfaces = interfaces.filter(intf => {
+          // 首先检查接口本身是否启用
+          const isInterfaceEnabled = intf.active !== false; // 默认为true
+          
+          if (!isInterfaceEnabled) {
+            return false;
+          }
+          
+          // 如果接口有关联功能，检查功能是否启用
+          if (intf.featureId) {
+            return enabledFeatureIds.includes(intf.featureId);
+          }
+          
+          // 如果接口没有关联功能，只要接口本身启用就可以
+          return true;
+        });
+      } catch (err) {
+        console.error('读取接口配置失败:', err);
+      }
+    }
+    
+    // 更新缓存
+    enabledInterfacesCache = enabledInterfaces;
+    cacheTime = currentTime;
+    
+    return enabledInterfaces;
+  } catch (err) {
+    console.error('加载启用接口失败:', err);
+    return enabledInterfacesCache || [];
+  }
+};
+
 module.exports = async function(req, res) {
   const dataDir = this.dataDir;
   const interfacesFile = path.join(dataDir, 'interfaces.json');
@@ -45,27 +212,19 @@ module.exports = async function(req, res) {
         });
       }
       
-      // 读取接口数据
-      let interfacesData;
-      try {
-        interfacesData = fs.readJsonSync(interfacesFile);
-        if (!interfacesData || !interfacesData.interfaces) {
-          return res.status(404).json({
-            code: 404,
-            message: '未找到接口数据',
-            data: null
-          });
-        }
-      } catch (err) {
-        return res.status(500).json({
-          code: 500,
-          message: '读取接口数据失败',
+      // 读取接口数据（使用缓存）
+      const interfaces = loadEnabledInterfaces(dataDir, interfacesFile, featuresFile);
+      
+      if (!interfaces || interfaces.length === 0) {
+        return res.status(404).json({
+          code: 404,
+          message: '未找到接口数据',
           data: null
         });
       }
       
       // 查找指定接口
-      const targetInterface = interfacesData.interfaces.find(item => item.id === interfaceId);
+      const targetInterface = interfaces.find(item => item.id === interfaceId);
       
       if (!targetInterface) {
         return res.status(404).json({
@@ -75,270 +234,114 @@ module.exports = async function(req, res) {
         });
       }
       
-      // 检查接口是否已禁用
-      if (targetInterface.active === false) {
-        return res.status(400).json({
-          code: 400,
-          message: '接口已禁用，无法测试',
-          data: null
-        });
-      }
+      // 检查接口URL是否与测试URL匹配
+      const pattern = targetInterface.pattern;
+      const proxyType = targetInterface.proxyType || 'response';
       
-      // 检查功能模块是否已禁用
-      try {
-        const featuresData = fs.readJsonSync(featuresFile);
-        
-        if (featuresData && featuresData.features) {
-          const featureItem = featuresData.features.find(item => item.id === targetInterface.featureId);
-          
-          if (featureItem && featureItem.active === false) {
-            return res.status(400).json({
-              code: 400,
-              message: '所属功能模块已禁用，接口无法使用',
-              data: null
-            });
-          }
-        }
-      } catch (err) {
-        // 忽略读取错误，继续处理
-      }
+      // 使用URL匹配检查
+      const isMatch = isUrlMatchPattern(url, pattern, proxyType);
       
-      const startTime = Date.now();
+      // 如果存在method配置，检查HTTP方法是否匹配
+      const methodMatch = !targetInterface.method || 
+                          targetInterface.method === 'all' || 
+                          targetInterface.method.toLowerCase() === 'all' ||
+                          req.method.toLowerCase() === targetInterface.method.toLowerCase();
       
-      // 根据代理类型处理不同的响应
-      let responseData;
+      // 确定匹配结果
+      const matchResult = isMatch && methodMatch;
       
-      // 检查 URL 是否匹配模式
-      const isUrlMatchPattern = (url, pattern, proxyType) => {
-        if (!url || !pattern) return false;
-        
-        try {
-          // 对于url_redirect类型，需要完全匹配
-          if (proxyType === 'url_redirect') {
-            return url === pattern;
-          }
-          
-          // 对于redirect类型，只要url以pattern开头即可命中（前缀匹配）
-          if (proxyType === 'redirect') {
-            return url.indexOf(pattern) === 0;
-          }
-          
-          // 默认的匹配逻辑（用于response类型等）
-          // 如果是正则表达式
-          if (pattern.startsWith('/') && pattern.endsWith('/')) {
-            const regex = new RegExp(pattern.slice(1, -1));
-            return regex.test(url);
-          }
-          
-          // 如果是通配符模式
-          if (pattern.includes('*')) {
-            const regexPattern = pattern
-              .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-              .replace(/\*/g, '.*');
-            const regex = new RegExp(`^${regexPattern}$`);
-            return regex.test(url);
-          }
-          
-          // 精确匹配
-          return url === pattern;
-        } catch (e) {
-          console.error('URL匹配检查失败:', e);
-          return false;
+      // 构建测试结果
+      const result = {
+        interfaceId: targetInterface.id,
+        interfaceName: targetInterface.name,
+        proxyType: targetInterface.proxyType,
+        pattern: targetInterface.pattern,
+        url: url,
+        isMatch: matchResult,
+        matchDetail: {
+          urlMatch: isMatch,
+          methodMatch: methodMatch
         }
       };
       
-      // 处理不同的代理类型
-      switch (targetInterface.proxyType) {
-        case 'response':
-          // 处理内容，支持 Mock.js 模板语法
-          let responseBody = targetInterface.responseContent;
-          
-          try {
-            // 如果响应内容是JSON，则尝试应用Mock.js模板
-            if (targetInterface.contentType && targetInterface.contentType.includes('json')) {
-              // 尝试解析JSON
-              const jsonTemplate = JSON.parse(responseBody);
-              // 使用Mock.js生成随机数据
-              const mockData = Mock.mock(jsonTemplate);
-              // 将结果转换回字符串
-              responseBody = JSON.stringify(mockData);
-            }
-          } catch (err) {
-            // 如果Mock失败，使用原始内容
-          }
-          
-          // 模拟接口处理延迟
-          const delay = targetInterface.responseDelay || 0;
-          if (delay > 0) {
-            await new Promise(resolve => setTimeout(resolve, delay));
-          }
-          
-          const endTime = Date.now();
-          const duration = endTime - startTime;
-          
-          // 模拟接口处理
-          responseData = {
-            statusCode: targetInterface.httpStatus || 200,
-            contentType: targetInterface.contentType || 'application/json; charset=utf-8',
-            responseBody: responseBody,
-            mockInfo: {
-              matchedPattern: targetInterface.urlPattern,
-              requestMethod: targetInterface.httpMethod,
-              delay: delay,
-              duration: duration,
-              timestamp: new Date().toISOString()
-            }
-          };
-          break;
-          
-        case 'redirect':
-          // 处理重定向
-          const redirectTarget = targetInterface.targetUrl || '';
-          
-          // 验证目标URL是否有效
-          if (!redirectTarget) {
-            return res.status(400).json({
-              code: 400,
-              message: '重定向目标URL不能为空',
-              data: null
-            });
+      // 根据代理类型处理额外信息
+      if (matchResult) {
+        if (proxyType === 'response') {
+          // 添加响应数据（如果有）
+          if (targetInterface.response) {
+            result.responseData = targetInterface.response;
           }
-          
-          try {
-            // 验证URL格式
-            new URL(redirectTarget);
-          } catch (err) {
-            return res.status(400).json({
-              code: 400,
-              message: '重定向目标URL格式无效，必须包含http://或https://',
-              data: null
-            });
-          }
-          
-          // 验证URL匹配（前缀匹配）
-          if (url.indexOf(targetInterface.urlPattern) !== 0) {
-            return res.status(400).json({
-              code: 400,
-              message: `测试URL不匹配重定向规则，URL必须以 ${targetInterface.urlPattern} 开头`,
-              data: null
-            });
-          }
-          
-          // 处理自定义请求头，包括随机值
-          const redirectHeaders = targetInterface.customHeaders || {};
-          const processedHeaders = {};
-          
-          // 处理随机值，转换为实际值
-          Object.entries(redirectHeaders).forEach(([key, value]) => {
-            processedHeaders[key] = generateRandomValue(value);
-          });
-          
-          const formattedRedirectHeaders = Object.entries(processedHeaders)
-            .map(([key, value]) => `${key}: ${value}`)
-            .join('\n');
-          
-          responseData = {
-            statusCode: 302,
-            contentType: 'application/json; charset=utf-8',
-            proxyType: 'redirect',
-            targetUrl: redirectTarget,
-            customHeaders: processedHeaders,
-            formattedHeaders: formattedRedirectHeaders,
-            mockInfo: {
-              matchedPattern: targetInterface.urlPattern,
-              requestMethod: targetInterface.httpMethod,
-              timestamp: new Date().toISOString()
+        } else if (proxyType === 'redirect' || proxyType === 'url_redirect') {
+          // 添加重定向信息（如果有）
+          if (targetInterface.targetUrl) {
+            // 处理动态生成的目标URL
+            const targetUrl = generateRandomValue(targetInterface.targetUrl);
+            result.redirectInfo = {
+              targetUrl: targetUrl,
+              targetFormatted: targetUrl
+            };
+            
+            // 添加自定义请求头（如果有）
+            if (targetInterface.customHeaders) {
+              try {
+                result.redirectInfo.customHeaders = targetInterface.customHeaders;
+              } catch (e) {
+                console.error('解析自定义请求头失败:', e);
+              }
             }
-          };
-          break;
-          
-        case 'url_redirect':
-          // 处理URL重定向
-          const baseUrl = targetInterface.targetUrl || '';
-          
-          // 验证基础URL是否有效
-          if (!baseUrl) {
-            return res.status(400).json({
-              code: 400,
-              message: 'URL重定向目标URL不能为空',
-              data: null
-            });
-          }
-          
-          try {
-            // 验证URL格式
-            new URL(baseUrl);
-          } catch (err) {
-            return res.status(400).json({
-              code: 400,
-              message: 'URL重定向目标URL格式无效，必须包含http://或https://',
-              data: null
-            });
           }
-          
-          // 验证URL完全匹配
-          if (url !== targetInterface.urlPattern) {
-            return res.status(400).json({
-              code: 400,
-              message: `测试URL不匹配URL重定向规则，URL必须完全匹配 ${targetInterface.urlPattern}`,
-              data: null
-            });
-          }
-          
-          // 处理自定义请求头
-          const urlRedirectHeaders = targetInterface.customHeaders || {};
-          const processedUrlRedirectHeaders = {};
-          
-          // 处理随机值，转换为实际值
-          Object.entries(urlRedirectHeaders).forEach(([key, value]) => {
-            processedUrlRedirectHeaders[key] = generateRandomValue(value);
-          });
-          
-          const formattedUrlRedirectHeaders = Object.entries(processedUrlRedirectHeaders)
-            .map(([key, value]) => `${key}: ${value}`)
-            .join('\n');
-          
-          responseData = {
-            statusCode: 302,
-            contentType: 'application/json; charset=utf-8',
-            proxyType: 'url_redirect',
-            targetUrl: baseUrl,
-            customHeaders: processedUrlRedirectHeaders,
-            formattedHeaders: formattedUrlRedirectHeaders,
-            mockInfo: {
-              matchedPattern: targetInterface.urlPattern,
-              requestMethod: targetInterface.httpMethod,
-              timestamp: new Date().toISOString()
-            }
-          };
-          break;
-          
-        default:
-          // 不支持的代理类型
-          return res.status(400).json({
-            code: 400,
-            message: `不支持的代理类型: ${targetInterface.proxyType || 'undefined'}`,
-            data: null
-          });
+        }
       }
       
+      // 返回测试结果
       return res.json({
-        code: 0,
-        message: '成功',
-        data: responseData
+        code: 200,
+        message: matchResult ? '接口匹配成功' : '接口匹配失败',
+        data: result
       });
-    } else {
-      // 不支持的请求方法
-      return res.status(405).json({
-        code: 405,
-        message: '不支持的请求方法',
+    }
+    
+    // 处理缓存刷新请求
+    if (req.path === '/_flush_cache') {
+      // 清空缓存
+      enabledInterfacesCache = null;
+      cacheTime = 0;
+      
+      return res.json({
+        code: 200,
+        message: '缓存已刷新',
         data: null
       });
     }
+    
+    // 处理缓存状态请求
+    if (req.path === '/_cache_status') {
+      return res.json({
+        code: 200,
+        message: '缓存状态',
+        data: {
+          enabledInterfaces: {
+            cached: !!enabledInterfacesCache,
+            lastUpdate: cacheTime,
+            count: enabledInterfacesCache ? enabledInterfacesCache.length : 0
+          },
+          cacheInterval: CONFIG.CACHE_INTERVAL
+        }
+      });
+    }
+    
+    // 其他请求返回405
+    return res.status(405).json({
+      code: 405,
+      message: '方法不允许',
+      data: null
+    });
   } catch (err) {
+    console.error('测试接口处理错误:', err);
+    
     return res.status(500).json({
       code: 500,
-      message: '服务器内部错误: ' + err.message,
+      message: '服务器内部错误: ' + (err.message || err),
       data: null
     });
   }