mm_mysql 2.4.1 → 2.4.3

package/test2.js

@@ -0,0 +1,381 @@
+/**
+ * MySQL错误处理测试文件
+ * @file test2.js
+ * @description 测试Mysql类的错误日志输出功能
+ */
+
+const { Mysql } = require('./index.js');
+
+/**
+ * 错误测试类
+ * @class ErrorTestMysql
+ */
+class ErrorTestMysql {
+  /**
+   * 构造函数
+   * @param {object} config - 数据库配置
+   */
+  constructor(config) {
+    this.config = {
+      host: '127.0.0.1',
+      port: 3306,
+      user: 'root',
+      password: 'Asd159357',
+      database: 'test_db',
+      debug: true,
+      ...config || {}
+    };
+    
+    this._mysql = null;
+    this._test_results = [];
+  }
+
+  /**
+   * 初始化测试
+   * @returns {Promise<boolean>}
+   */
+  async _init() {
+    try {
+      this._mysql = new Mysql(this.config);
+      await this._mysql.open();
+      console.log('=== 错误处理测试初始化完成 ===');
+      return true;
+    } catch (error) {
+      console.error('初始化失败:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * 记录测试结果
+   * @param {string} test_name - 测试名称
+   * @param {boolean} success - 是否成功
+   * @param {string} message - 测试信息
+   */
+  _recordResult(test_name, success, message) {
+    this._test_results.push({
+      test_name,
+      success,
+      message,
+      timestamp: new Date().toISOString()
+    });
+    
+    const status = success ? '✓' : '✗';
+    console.log(`${status} ${test_name}: ${message}`);
+  }
+
+  /**
+   * 测试无效表查询错误
+   * @returns {Promise<boolean>}
+   */
+  async testInvalidTable() {
+    try {
+      console.log('\n--- 测试1: 查询不存在的表 ---');
+      
+      // 执行无效SQL
+      const invalid_sql = 'SELECT * FROM non_existent_table_xyz';
+      const result = await this._mysql.run(invalid_sql);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('无效表查询', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('无效表查询', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('无效表查询', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试无效SQL语法错误
+   * @returns {Promise<boolean>}
+   */
+  async testInvalidSyntax() {
+    try {
+      console.log('\n--- 测试2: 无效SQL语法 ---');
+      
+      // 执行语法错误的SQL
+      const invalid_sql = 'SELECT FROM test_users';
+      const result = await this._mysql.run(invalid_sql);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('无效SQL语法', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('无效SQL语法', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('无效SQL语法', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试exec方法错误处理
+   * @returns {Promise<boolean>}
+   */
+  async testExecError() {
+    try {
+      console.log('\n--- 测试3: exec方法错误处理 ---');
+      
+      // 执行无效INSERT语句
+      const invalid_sql = 'INSERT INTO non_existent_table (name) VALUES (?)';
+      const result = await this._mysql.exec(invalid_sql, ['test']);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('exec方法错误', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('exec方法错误', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('exec方法错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试DB类错误处理
+   * @returns {Promise<boolean>}
+   */
+  async testDbClassError() {
+    try {
+      console.log('\n--- 测试4: DB类错误处理 ---');
+      
+      // 获取DB实例并尝试操作不存在的表
+      const db = this._mysql.db().new('non_existent_table_db', 'id');
+      
+      // 尝试获取数据
+      const result = await db.get({ id: 1 });
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('DB类错误', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('DB类错误', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('DB类错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试连接失败错误（使用错误配置）
+   * @returns {Promise<boolean>}
+   */
+  async testConnectionError() {
+    try {
+      console.log('\n--- 测试5: 连接失败错误 ---');
+      
+      // 使用错误配置创建连接
+      const bad_config = {
+        host: '127.0.0.1',
+        port: 3307, // 错误端口
+        user: 'root',
+        password: 'wrong_password',
+        database: 'test_db',
+        debug: true
+      };
+      
+      const bad_mysql = new Mysql(bad_config);
+      const result = await bad_mysql.open();
+      
+      // 连接应该失败
+      if (result === false) {
+        console.log('连接失败（预期行为）');
+        this._recordResult('连接失败错误', true, '成功检测到连接失败');
+        return true;
+      } else {
+        this._recordResult('连接失败错误', false, '连接意外成功，测试失败');
+        await bad_mysql.close();
+        return false;
+      }
+    } catch (error) {
+      console.log('捕获到异常:', error.message);
+      this._recordResult('连接失败错误', true, `成功捕获连接异常: ${error.message}`);
+      return true;
+    }
+  }
+
+  /**
+   * 测试参数验证错误
+   * @returns {Promise<boolean>}
+   */
+  async testParameterValidation() {
+    try {
+      console.log('\n--- 测试6: 参数验证错误 ---');
+      
+      // 测试无效参数类型
+      let error_count = 0;
+      
+      try {
+        await this._mysql.run(null);
+      } catch (error) {
+        console.log('参数验证错误1:', error.message);
+        error_count++;
+      }
+      
+      try {
+        await this._mysql.run('SELECT 1', 'invalid');
+      } catch (error) {
+        console.log('参数验证错误2:', error.message);
+        error_count++;
+      }
+      
+      if (error_count === 2) {
+        this._recordResult('参数验证错误', true, '成功捕获2个参数验证错误');
+        return true;
+      } else {
+        this._recordResult('参数验证错误', false, `只捕获到 ${error_count} 个错误，预期2个`);
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('参数验证错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 运行所有错误测试
+   * @returns {Promise<object>}
+   */
+  async runAllTests() {
+    console.log('\n=== 开始运行MySQL错误处理测试 ===\n');
+    
+    // 初始化测试
+    const init_success = await this._init();
+    if (!init_success) {
+      console.log('测试初始化失败');
+      return this._getTestSummary();
+    }
+    
+    // 定义测试用例
+    const test_cases = [
+      { name: '无效表查询', method: 'testInvalidTable' },
+      { name: '无效SQL语法', method: 'testInvalidSyntax' },
+      { name: 'exec方法错误', method: 'testExecError' },
+      { name: 'DB类错误', method: 'testDbClassError' },
+      { name: '连接失败错误', method: 'testConnectionError' },
+      { name: '参数验证错误', method: 'testParameterValidation' }
+    ];
+    
+    // 执行测试
+    for (const test_case of test_cases) {
+      try {
+        console.log(`执行测试: ${test_case.name}`);
+        await this[test_case.method]();
+      } catch (error) {
+        console.error(`测试异常: ${test_case.name}`, error);
+        this._recordResult(test_case.name, false, `测试执行异常: ${error.message}`);
+      }
+    }
+    
+    // 关闭连接
+    if (this._mysql) {
+      await this._mysql.close();
+    }
+    
+    return this._getTestSummary();
+  }
+
+  /**
+   * 获取测试摘要
+   * @returns {object}
+   */
+  _getTestSummary() {
+    const total = this._test_results.length;
+    const passed = this._test_results.filter(r => r.success).length;
+    const failed = total - passed;
+    
+    console.log('\n=== 测试结果摘要 ===');
+    console.log(`总测试数: ${total}`);
+    console.log(`通过: ${passed}`);
+    console.log(`失败: ${failed}`);
+    console.log(`通过率: ${((passed / total) * 100).toFixed(1)}%`);
+    
+    // 显示失败的测试
+    const failed_tests = this._test_results.filter(r => !r.success);
+    if (failed_tests.length > 0) {
+      console.log('\n失败的测试:');
+      failed_tests.forEach(test => {
+        console.log(`  ✗ ${test.test_name}: ${test.message}`);
+      });
+    }
+    
+    return {
+      total,
+      passed,
+      failed,
+      results: this._test_results
+    };
+  }
+
+  /**
+   * 主测试函数
+   * @returns {Promise<void>}
+   */
+  async main() {
+    try {
+      const summary = await this.runAllTests();
+      
+      if (summary.failed > 0) {
+        console.log('\n❌ 部分测试失败');
+        process.exit(1);
+      } else {
+        console.log('\n✅ 所有测试通过！');
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error('测试执行异常:', error);
+      process.exit(1);
+    }
+  }
+}
+
+// 模块导出
+exports.ErrorTestMysql = ErrorTestMysql;
+
+/**
+ * 快速测试函数
+ * @param {object} config - 数据库配置
+ */
+const quick_test = async function(config) {
+  const tester = new ErrorTestMysql(config);
+  await tester.main();
+};
+
+// 如果直接运行此文件，执行测试
+if (require.main === module) {
+  const test_config = {
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: parseInt(process.env.DB_PORT) || 3306,
+    user: process.env.DB_USER || 'root',
+    password: process.env.DB_PASSWORD || 'Asd159357',
+    database: process.env.DB_NAME || 'test_db',
+    debug: process.env.DEBUG === 'true'
+  };
+
+  console.log('使用配置:', {
+    ...test_config,
+    password: '***'
+  });
+  
+  quick_test(test_config);
+}
+
+exports.quick_test = quick_test;