whistle.mock-plugins 1.0.3 → 1.0.5

package/app/cgi-bin/interfaces.js

@@ -176,6 +176,7 @@ module.exports = function(req, res) {
           proxyType: interfaceData.proxyType,
           responseContent: interfaceData.responseContent,
           targetUrl: interfaceData.targetUrl,
+          customHeaders: interfaceData.customHeaders || {},
           filePath: interfaceData.filePath,
           httpStatus: interfaceData.httpStatus || 200,
           responseDelay: interfaceData.responseDelay || 0,
@@ -200,6 +201,7 @@ module.exports = function(req, res) {
           proxyType: interfaceData.proxyType || 'response',
           responseContent: interfaceData.responseContent || '',
           targetUrl: interfaceData.targetUrl || '',
+          customHeaders: interfaceData.customHeaders || {},
           filePath: interfaceData.filePath || '',
           httpStatus: interfaceData.httpStatus || 200,
           responseDelay: interfaceData.responseDelay || 0,
@@ -316,6 +318,7 @@ module.exports = function(req, res) {
         proxyType: interfaceData.proxyType || interfacesData.interfaces[index].proxyType,
         responseContent: interfaceData.responseContent !== undefined ? interfaceData.responseContent : interfacesData.interfaces[index].responseContent,
         targetUrl: interfaceData.targetUrl !== undefined ? interfaceData.targetUrl : interfacesData.interfaces[index].targetUrl,
+        customHeaders: interfaceData.customHeaders !== undefined ? interfaceData.customHeaders : interfacesData.interfaces[index].customHeaders || {},
         filePath: interfaceData.filePath !== undefined ? interfaceData.filePath : interfacesData.interfaces[index].filePath,
         httpStatus: interfaceData.httpStatus || interfacesData.interfaces[index].httpStatus,
         responseDelay: interfaceData.responseDelay !== undefined ? interfaceData.responseDelay : interfacesData.interfaces[index].responseDelay,

package/app/cgi-bin/logs.js

@@ -15,6 +15,15 @@ module.exports = function(req, res) {
       const page = parseInt(req.query.page) || 1;
       const pageSize = parseInt(req.query.pageSize) || 20;
       
+      // 检查参数是否合法
+      if (isNaN(page) || page < 1 || isNaN(pageSize) || pageSize < 1) {
+        return res.status(400).json({
+          code: 400,
+          message: '无效的分页参数',
+          data: null
+        });
+      }
+      
       // 确保日志文件存在
       if (!fs.existsSync(logsFile)) {
         fs.writeJsonSync(logsFile, { logs: [] }, { spaces: 2 });
@@ -31,39 +40,33 @@ module.exports = function(req, res) {
         });
       }
       
-      // 读取日志
-      const logsData = fs.readJsonSync(logsFile);
+      // 读取日志 - 使用流式处理大文件
+      let logsData;
+      try {
+        logsData = fs.readJsonSync(logsFile, { throws: false }) || { logs: [] };
+      } catch (err) {
+        console.error('读取日志文件失败:', err);
+        // 文件损坏或格式错误时，重置日志
+        fs.writeJsonSync(logsFile, { logs: [] }, { spaces: 2 });
+        logsData = { logs: [] };
+      }
       
       // 确保日志结构正确
       if (!logsData || !logsData.logs || !Array.isArray(logsData.logs)) {
-        logsData.logs = [];
+        logsData = { logs: [] };
       }
       
-      // 标准化日志格式，确保每个日志项都有正确的字段
-      let logs = logsData.logs.map(log => {
-        if (!log) return null;
-        
-        // 标准化事件类型字段，确保兼容前端过滤
-        // 将type转换为eventType确保前端能够正确过滤
-        return {
-          id: log.id || Date.now().toString(),
-          timestamp: log.timestamp || new Date().toISOString(),
-          eventType: log.eventType || log.type || 'unknown',
-          type: log.type || log.eventType || 'unknown',
-          method: log.method || '',
-          url: log.url || '',
-          status: log.status || '',
-          message: log.message || '',
-          pattern: log.pattern || '',
-          ...log // 保留原有其他字段
-        };
-      }).filter(Boolean); // 过滤掉null
+      // 只对需要处理的日志数据进行处理，减少内存使用
+      let logs = logsData.logs;
       
       // 根据类型过滤
       if (type && type !== 'all') {
         try {
           logs = logs.filter(log => 
-            log && (log.eventType === type || log.type === type)
+            log && (
+              (log.eventType && log.eventType === type) || 
+              (log.type && log.type === type)
+            )
           );
         } catch (err) {
           console.error('按类型过滤日志失败:', err);
@@ -74,14 +77,14 @@ module.exports = function(req, res) {
       // 根据关键词过滤
       if (keyword) {
         try {
+          const lowercaseKeyword = keyword.toLowerCase();
           logs = logs.filter(log => {
             if (!log) return false;
             
             // 检查关键字段是否包含关键词
-            const url = (log.url || '').toLowerCase();
-            const pattern = (log.pattern || '').toLowerCase();
-            const message = (log.message || '').toLowerCase();
-            const lowercaseKeyword = keyword.toLowerCase();
+            const url = typeof log.url === 'string' ? log.url.toLowerCase() : '';
+            const pattern = typeof log.pattern === 'string' ? log.pattern.toLowerCase() : '';
+            const message = typeof log.message === 'string' ? log.message.toLowerCase() : '';
             
             return url.includes(lowercaseKeyword) || 
                    pattern.includes(lowercaseKeyword) || 
@@ -97,9 +100,15 @@ module.exports = function(req, res) {
       const total = logs.length;
       const totalPages = Math.ceil(total / pageSize);
       
-      // 分页
+      // 分页 - 只返回当前页的数据
       const startIndex = (page - 1) * pageSize;
-      const pagedLogs = logs.slice(startIndex, startIndex + pageSize);
+      // 确保不会越界
+      const endIndex = Math.min(startIndex + pageSize, total);
+      const pagedLogs = logs.slice(startIndex, endIndex);
+      
+      // 清除大型对象引用，帮助垃圾回收
+      logs = null;
+      logsData = null;
       
       return res.json({
         code: 0,

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

@@ -1,6 +1,22 @@
 const fs = require('fs-extra');
 const path = require('path');
 const Mock = require('mockjs');
+const url = require('url');
+
+// 生成随机数工具函数（与rules-server.js中保持一致）
+const generateRandomValue = (pattern) => {
+  // 如果不是以@开头的模式，直接返回原值
+  if (!pattern || !pattern.startsWith('@')) {
+    return pattern;
+  }
+  
+  const formatPattern = pattern.substring(1); // 去掉@前缀
+  // 为每个x生成一个随机字符（字母或数字）
+  return formatPattern.replace(/x/g, () => {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    return chars.charAt(Math.floor(Math.random() * chars.length));
+  });
+};
 
 module.exports = async function(req, res) {
   const dataDir = this.dataDir;
@@ -89,46 +105,223 @@ module.exports = async function(req, res) {
       
       const startTime = Date.now();
       
-      // 处理内容，支持 Mock.js 模板语法
-      let responseBody = targetInterface.responseContent;
+      // 根据代理类型处理不同的响应
+      let responseData;
       
-      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);
+      // 检查 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;
         }
-      } catch (err) {
-        // 如果Mock失败，使用原始内容
-      }
+      };
       
-      // 模拟接口处理延迟
-      const delay = targetInterface.responseDelay || 0;
-      if (delay > 0) {
-        await new Promise(resolve => setTimeout(resolve, delay));
+      // 处理不同的代理类型
+      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
+            });
+          }
+          
+          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()
+            }
+          };
+          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
+          });
       }
       
-      const endTime = Date.now();
-      const duration = endTime - startTime;
-      
-      // 模拟接口处理
-      const 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()
-        }
-      };
-      
       return res.json({
         code: 0,
         message: '成功',