mm_redis 1.9.0 → 1.9.2

package/index.js

@@ -17,24 +17,13 @@ class Redis extends eventEmitter {
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
+	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
-	constructor(scope, dir) {
+	constructor(scope, config) {
 		super();
 		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
-		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
-
+		this.scope = scope;
 		// 配置参数
 		this.config = {
 			// 服务器地址
@@ -42,7 +31,7 @@ class Redis extends eventEmitter {
 			// 端口号
 			"port": 6379,
 			// 密码
-			"password": "asd159357",
+			"password": "",
 			// 数据库
 			"database": 0,
 			// 前缀
@@ -54,6 +43,7 @@ class Redis extends eventEmitter {
 			// 重试间隔(ms)
 			"retry_delay": 1000
 		};
+		this.setConfig(config);
 		// 连接池配置
 		this.connectionPool = {
 			available: [], // 可用连接数组
@@ -183,8 +173,12 @@ Redis.prototype.setConfig = function (cg) {
 	let obj = {};
 	if (typeof cg === 'string') {
 		obj = cg.loadJson(__dirname);
-	} else {
-		obj = cg;
+	} else if (cg) {
+	// 合并配置参数
+		Object.assign(this.config, cg);
+	}
+	else {
+		return;
 	}
 	// 使用Object.assign替代$.push来合并配置
 	this.config = Object.assign({}, this.config || {}, obj);
@@ -2926,16 +2920,16 @@ if (!$.pool.redis) {
 /**
  * @description Redis管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
+ * @param {Object} config 配置参数
  * @return {Object} 返回一个Redis类实例
  */
-function redis_admin(scope, dir) {
+function redis_admin(scope, config) {
 	if (!scope) {
 		scope = 'sys';
 	}
 	var obj = $.pool.redis[scope];
 	if (!obj) {
-		$.pool.redis[scope] = new Redis(scope, dir);
+		$.pool.redis[scope] = new Redis(scope, config);
 		obj = $.pool.redis[scope];
 	}
 	return obj;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_redis",
-    "version": "1.9.0",
+    "version": "1.9.2",
     "description": "高效的Redis客户端封装库，提供连接池管理、数据类型操作、错误处理和批量操作优化",
     "main": "index.js",
     "scripts": {

package/test.js

@@ -3,9 +3,8 @@ const { redis_admin } = require('./index.js');
 async function test() {
 	try {
 		var bl, num, arr = [];
-		var rs = redis_admin('sys');
 		var config = './config.json'.loadJson(__dirname);
-		rs.setConfig(config);
+		var rs = redis_admin('sys', config);
 		await rs.open();
 		
 		// 测试基本的set和get操作

package/compatibility_table.md

@@ -1,63 +0,0 @@
-```markdown
-# 三种缓存方式方法兼容性对比表格
-
-## 核心缓存方法
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| set | ✅ | ✅ | ✅ | 完全兼容 |
-| get | ✅ | ✅ | ✅ | 完全兼容 |
-| del | ✅ | ✅ | ✅ | 完全兼容 |
-| has | ✅ | ✅ | ✅ | 完全兼容 |
-| clear | ✅ | ✅ | ✅ | 完全兼容 |
-| keys | ✅ | ✅ | ✅ | 完全兼容 |
-| ttl | ✅ | ✅ | ✅ | 完全兼容 |
-| add | ✅ | ✅ | ✅ | 完全兼容 |
-| addInt | ✅ | ✅ | ✅ | 完全兼容 |
-| addStr | ✅ | ✅ | ✅ | 完全兼容 |
-| sort | ✅ | ✅ | ✅ | 模拟实现 |
-
-## Redis兼容方法 - 哈希表操作
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| hset | ✅ | ✅ | ✅ | 模拟实现，通过set对象方式 |
-| hget | ✅ | ✅ | ✅ | 模拟实现，通过get对象方式 |
-| hgetall | ✅ | ✅ | ✅ | 模拟实现，返回完整对象 |
-| hdel | ✅ | ✅ | ✅ | 模拟实现，删除对象属性 |
-| hexists | ✅ | ❌ | ❌ | 完全实现 |
-| hkeys | ✅ | ❌ | ❌ | 完全实现 |
-| hvals | ✅ | ❌ | ❌ | 完全实现 |
-
-## Redis兼容方法 - 集合操作
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| sadd | ✅ | ❌ | ❌ | 完全实现 |
-| srem | ✅ | ❌ | ❌ | 完全实现 |
-| sismember | ✅ | ❌ | ❌ | 完全实现 |
-| smembers | ✅ | ❌ | ❌ | 完全实现 |
-| scard | ✅ | ❌ | ❌ | 完全实现 |
-
-## Redis兼容方法 - 有序集合操作
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| zadd | ✅ | ❌ | ❌ | 完全实现 |
-| zrem | ✅ | ❌ | ❌ | 完全实现 |
-| zrange | ✅ | ❌ | ❌ | 完全实现 |
-| zscore | ✅ | ❌ | ❌ | 完全实现 |
-
-## Redis兼容方法 - 其他常用命令
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| expire | ✅ | ✅ | ✅ | 兼容，内部映射到ttl |
-| incr | ✅ | ⚠️ | ✅ | Redis原生支持，MongoDB返回undefined，CacheBase通过addInt模拟 |
-| decr | ✅ | ⚠️ | ✅ | Redis原生支持，MongoDB返回undefined，CacheBase通过addInt模拟 |
-| exists | ✅ | ✅ | ✅ | 兼容，内部映射到has |
-| mget | ✅ | ⚠️ | ✅ | 已修复为返回数组格式，与原生Redis一致 |
-| mset | ✅ | ✅ | ✅ | 已修复参数格式处理，添加了格式验证 |
-
-注：✅ 完全兼容/功能正常 | ⚠️ 部分兼容/有异常 | ❌ 不兼容/未实现
-```

package/test_all_methods.js

@@ -1,317 +0,0 @@
-// 全面测试Redis模块的所有方法和事件
-const fs = require('fs');
-const path = require('path');
-
-// 简单的日志函数
-function log(message, data = null) {
-    const timestamp = new Date().toISOString();
-    if (data) {
-        console.log(`[${timestamp}] ${message}`, typeof data === 'object' ? JSON.stringify(data, null, 2) : data);
-    } else {
-        console.log(`[${timestamp}] ${message}`);
-    }
-}
-
-// 加载配置文件的函数
-function loadConfig(configPath) {
-    try {
-        const configContent = fs.readFileSync(configPath, 'utf8');
-        return JSON.parse(configContent);
-    } catch (error) {
-        log(`错误：无法加载配置文件 ${configPath}: ${error.message}`);
-        return null;
-    }
-}
-
-// 测试结果统计
-const testResults = {
-    total: 0,
-    passed: 0,
-    failed: 0,
-    skipped: 0,
-    failedTests: [] // 记录失败的测试名称
-};
-
-// 测试函数包装器
-async function runTest(name, testFunc) {
-    testResults.total++;
-    log(`\n🔍 测试 ${name} 开始...`);
-    
-    try {
-        await testFunc();
-        log(`✅ 测试 ${name} 通过！`);
-        testResults.passed++;
-        return true;
-    } catch (error) {
-        log(`❌ 测试 ${name} 失败: ${error.message}`);
-        log(error.stack);
-        testResults.failed++;
-        testResults.failedTests.push(name); // 记录失败的测试名称
-        return false;
-    }
-}
-
-// 主测试函数
-async function runComprehensiveTest() {
-    log('开始全面测试Redis模块的所有方法和事件...');
-    
-    try {
-        // 加载Redis模块
-        const RedisModule = require('./index.js');
-        const Redis = RedisModule.default || RedisModule;
-        const redis_admin = RedisModule.redis_admin;
-        
-        log(`Redis类类型: ${typeof Redis}`);
-        log(`redis_admin函数类型: ${typeof redis_admin}`);
-        
-        // 加载配置
-        const configPath = path.join(__dirname, 'config.json');
-        const config = loadConfig(configPath);
-        
-        if (!config) {
-            log('无法继续测试，配置文件加载失败');
-            return;
-        }
-        
-        log('加载配置成功:', config);
-        
-        // 创建测试实例
-        const redisInstance = redis_admin('test_comprehensive');
-        redisInstance.setConfig(config);
-        
-        // 测试连接
-        await runTest('Redis连接', async () => {
-            await redisInstance.open();
-            log('✅ Redis连接成功');
-        });
-        
-        // 基础键值操作测试
-        await runTest('基础set/get操作', async () => {
-            const testKey = 'comprehensive_test_key';
-            const testValue = { name: '测试对象', value: 123, timestamp: new Date().toISOString() };
-            
-            await redisInstance.set(testKey, testValue);
-            const retrievedValue = await redisInstance.get(testKey);
-            
-            if (JSON.stringify(retrievedValue) !== JSON.stringify(testValue)) {
-                throw new Error('获取的值与设置的值不匹配');
-            }
-            
-            // 清理测试数据
-            await redisInstance.del([testKey]);
-        });
-        
-        // 过期时间测试
-        await runTest('过期时间设置', async () => {
-            const testKey = 'comprehensive_test_ttl';
-            await redisInstance.set(testKey, '临时值', 10); // 10秒过期
-            
-            const ttl = await redisInstance.ttl(testKey);
-            if (typeof ttl !== 'number' || ttl <= 0) {
-                throw new Error('过期时间设置失败: ' + ttl);
-            }
-            
-            // 清理测试数据
-            await redisInstance.del([testKey]);
-        });
-        
-        // 数值操作测试
-        await runTest('数值增减操作', async () => {
-            const counterKey = 'comprehensive_counter';
-            
-            // 设置初始值
-            await redisInstance.set(counterKey, 10);
-            log(`设置初始值为10`);
-            
-            // 增加
-            const afterAdd = await redisInstance.addInt(counterKey, 5);
-            log(`增加5后的值: ${afterAdd}`);
-            if (afterAdd !== 15) {
-                throw new Error(`数值增加失败，预期15，实际${afterAdd}`);
-            }
-            
-            // 减少
-            const afterSub = await redisInstance.addInt(counterKey, -3);
-            log(`减少3后的值: ${afterSub}`);
-            if (afterSub !== 12) {
-                throw new Error(`数值减少失败，预期12，实际${afterSub}`);
-            }
-            
-            // 清理测试数据
-            await redisInstance.del([counterKey]);
-        });
-        
-        // 列表操作测试
-        await runTest('列表操作', async () => {
-            const listKey = 'comprehensive_list';
-            const testList = ['item1', 'item2', 'item3']; // 简化列表，避免对象序列化问题
-            
-            log(`设置列表数据: ${JSON.stringify(testList)}`);
-            
-            // 设置列表
-            await redisInstance.list_set(listKey, testList);
-            log('列表设置完成');
-            
-            // 获取列表
-            const retrievedList = await redisInstance.list_get(listKey);
-            log(`获取到的列表: ${JSON.stringify(retrievedList)}`);
-            log(`预期长度: ${testList.length}, 实际长度: ${retrievedList.length}`);
-            
-            if (!retrievedList || !Array.isArray(retrievedList)) {
-                throw new Error('获取的列表不是有效的数组');
-            }
-            
-            if (retrievedList.length !== testList.length) {
-                throw new Error(`列表长度不匹配，预期${testList.length}，实际${retrievedList.length}`);
-            }
-            
-            // 验证内容
-            for (let i = 0; i < testList.length; i++) {
-                if (retrievedList[i] !== testList[i]) {
-                    throw new Error(`列表内容不匹配，索引${i}：预期"${testList[i]}"，实际"${retrievedList[i]}"`);
-                }
-            }
-            
-            log('列表内容验证通过');
-            
-            // 清理测试数据
-            await redisInstance.del([listKey]);
-            log('测试数据清理完成');
-        });
-        
-        // 键前缀测试
-        await runTest('键前缀支持', async () => {
-            const originalPrefix = redisInstance.config.prefix;
-            const testKey = 'prefixed_test';
-            
-            // 设置临时前缀
-            redisInstance.config.prefix = 'test_prefix:';
-            
-            // 设置带前缀的键
-            await redisInstance.set(testKey, '带前缀的值');
-            
-            // 验证获取
-            const value = await redisInstance.get(testKey);
-            if (value !== '带前缀的值') {
-                throw new Error('带前缀的键获取失败');
-            }
-            
-            // 恢复原始前缀
-            redisInstance.config.prefix = originalPrefix;
-            
-            // 清理测试数据（使用完整键名）
-            await redisInstance.del(['test_prefix:' + testKey]);
-        });
-        
-        // 批量操作测试
-        await runTest('批量操作', async () => {
-            const batchData = {
-                'batch_key1': '值1',
-                'batch_key2': 123,
-                'batch_key3': { test: '对象' }
-            };
-            
-            // 批量设置
-            await redisInstance.mset(batchData);
-            
-            // 批量获取
-            const keys = Object.keys(batchData);
-            const results = await redisInstance.mget(keys);
-            
-            if (results.length !== keys.length) {
-                throw new Error(`批量获取结果数量不匹配，预期${keys.length}，实际${results.length}`);
-            }
-            
-            // 清理测试数据
-            await redisInstance.del(keys);
-        });
-        
-        // 键存在检查测试
-        await runTest('键存在检查', async () => {
-            const existKey = 'comprehensive_exist_key';
-            
-            // 设置键
-            await redisInstance.set(existKey, '测试值');
-            
-            // 检查存在
-            const exists = await redisInstance.has(existKey);
-            if (!exists) {
-                throw new Error('已存在的键检查失败');
-            }
-            
-            // 检查不存在的键
-            const notExists = await redisInstance.has('non_existent_key_' + Date.now());
-            if (notExists) {
-                throw new Error('不存在的键检查失败');
-            }
-            
-            // 清理测试数据
-            await redisInstance.del([existKey]);
-        });
-        
-        // 发布订阅测试（暂时跳过，因为可能存在环境兼容性问题）
-        // 我们可以将这个测试标记为跳过，专注于测试核心功能
-        log('\n🔍 测试 发布订阅功能 开始...');
-        log('⚠️  发布订阅测试已跳过，因为可能存在环境兼容性问题');
-        testResults.skipped++;
-        
-        // 如果需要，可以在这里添加注释，说明如何在合适的环境中测试发布订阅功能
-        log('📝 注意：在支持发布订阅的环境中，可以取消以下代码的注释进行测试：');
-        log('// const testChannel = "test_channel";');
-        log('// await redisInstance.publish(testChannel, "测试消息");');
-        
-        // 前缀方法测试
-        await runTest('前缀方法测试', async () => {
-            const originalPrefix = redisInstance.config.prefix;
-            redisInstance.config.prefix = 'test_prefix:';
-            
-            const testKey = 'test_key';
-            const prefixedKey = redisInstance.applyPrefix(testKey);
-            
-            if (prefixedKey !== 'test_prefix:test_key') {
-                throw new Error(`前缀应用失败，预期'test_prefix:test_key'，实际'${prefixedKey}'`);
-            }
-            
-            const removedPrefixKey = redisInstance.removePrefix(prefixedKey);
-            if (removedPrefixKey !== testKey) {
-                throw new Error(`前缀移除失败，预期'test_key'，实际'${removedPrefixKey}'`);
-            }
-            
-            // 恢复原始前缀
-            redisInstance.config.prefix = originalPrefix;
-        });
-        
-        // 关闭连接测试
-        await runTest('关闭连接', async () => {
-            await redisInstance.close();
-            log('✅ 连接已成功关闭');
-        });
-        
-        // 打印测试结果统计
-        log('\n======= 测试结果统计 =======');
-        log(`总测试数: ${testResults.total}`);
-        log(`通过: ${testResults.passed}`);
-        log(`失败: ${testResults.failed}`);
-        log(`跳过: ${testResults.skipped}`);
-        
-        if (testResults.failed > 0) {
-            log(`❌ 有测试失败，失败的测试: ${testResults.failedTests.join(', ')}`);
-        } else {
-            log('🎉 所有测试通过！Redis模块功能正常！');
-        }
-        
-    } catch (error) {
-        log(`❌ 测试过程中出现严重错误: ${error.message}`);
-        log(error.stack);
-    }
-    
-    log('\n全面测试完成!');
-}
-
-// 运行测试
-runComprehensiveTest().then(() => {
-    process.exit(testResults.failed > 0 ? 1 : 0);
-}).catch(err => {
-    log(`❌ 测试执行失败: ${err.message}`);
-    process.exit(1);
-});

package/test_crud_events.js

@@ -1,441 +0,0 @@
-const { Redis } = require('./index');
-
-// Redis连接配置
-const REDIS_CONFIG = {
-    host: 'localhost',  // Redis主机地址
-    port: 6379,         // Redis端口
-    password: 'asd159357',       // Redis密码，如果没有密码则为空字符串
-    database: 0,         // Redis数据库索引
-    prefix: 'test_mm_redis_'
-};
-
-// 测试结果统计
-const testResults = {
-    total: 0,
-    passed: 0,
-    failed: 0,
-    skipped: 0,
-    failedTests: []
-};
-
-// 测试用的键名前缀，避免冲突
-const TEST_PREFIX = 'test_mm_redis_';
-
-// 创建Redis实例的辅助函数，使用统一配置
-function createRedisInstance() {
-    // 尝试连接并测试，如果需要认证错误，则尝试不带密码的连接
-    const redis = new Redis('test');
-    // 使用setConfig方法正确设置配置
-    redis.setConfig(REDIS_CONFIG);
-    return redis;
-}
-
-// 生成测试键名
-function getTestKey(name) {
-    return `${TEST_PREFIX}${name}`;
-}
-
-// 清理测试数据
-async function cleanup() {
-    console.log('开始清理测试数据...');
-    const redis = new Redis('test');
-    try {
-        // 获取所有测试键并删除
-        const keys = await redis.keys(`${TEST_PREFIX}*`);
-        if (keys.length > 0) {
-            console.log(`找到 ${keys.length} 个测试键，准备删除...`);
-            for (const key of keys) {
-                await redis.del(key);
-            }
-            console.log('测试数据清理完成');
-        } else {
-            console.log('没有找到测试数据需要清理');
-        }
-    } catch (error) {
-        console.error('清理测试数据时出错:', error);
-    } finally {
-        await redis.close();
-    }
-}
-
-// 运行单个测试
-async function runTest(name, testFn) {
-    testResults.total++;
-    console.log(`\n正在运行测试: ${name}...`);
-    
-    try {
-        await testFn();
-        console.log(`✅ 测试通过: ${name}`);
-        testResults.passed++;
-        return true;
-    } catch (error) {
-        console.error(`❌ 测试失败: ${name}`, error);
-        testResults.failed++;
-        testResults.failedTests.push(name);
-        return false;
-    }
-}
-
-// 测试字符串操作方法
-async function testStringOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('string_op');
-    
-    // 测试set和get方法
-    await redis.set(key, 'hello world');
-    const value = await redis.get(key);
-    if (value !== 'hello world') {
-        throw new Error(`set/get 测试失败，期望值: 'hello world', 实际值: ${value}`);
-    }
-    
-    // 测试addInt方法
-    await redis.set(key, '10');
-    const incrValue = await redis.addInt(key, 5);
-    if (incrValue !== 15) {
-        throw new Error(`addInt 测试失败，期望值: 15, 实际值: ${incrValue}`);
-    }
-    
-    // 测试del方法
-    const delResult = await redis.del(key);
-    if (delResult !== true) {
-        throw new Error(`del 测试失败，期望值: true, 实际值: ${delResult}`);
-    }
-    
-    // 测试has方法
-    const hasResult = await redis.has(key);
-    if (hasResult !== false) {
-        throw new Error(`has 测试失败，期望值: false, 实际值: ${hasResult}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试事件处理
-async function testEvents() {
-    const redis = createRedisInstance();
-    const key = getTestKey('event_test');
-    let beforeEventTriggered = false;
-    let afterEventTriggered = false;
-    
-    // 监听before事件
-    redis.on('set_before', (data) => {
-        console.log('set_before 事件触发:', data);
-        beforeEventTriggered = true;
-    });
-    
-    // 监听after事件
-    redis.on('set_after', (data) => {
-        console.log('set_after 事件触发:', data);
-        afterEventTriggered = true;
-    });
-    
-    // 触发事件
-    await redis.set(key, 'event test value');
-    
-    // 验证事件是否触发
-    if (!beforeEventTriggered) {
-        throw new Error('set_before 事件未触发');
-    }
-    if (!afterEventTriggered) {
-        throw new Error('set_after 事件未触发');
-    }
-    
-    await redis.close();
-}
-
-// 测试列表操作方法
-async function testListOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('list_op');
-    
-    // 测试list_set和list_get方法
-    const listData = ['item1', 'item2', 'item3'];
-    const setLength = await redis.list_set(key, listData);
-    if (setLength !== 3) {
-        throw new Error(`list_set 测试失败，期望值: 3, 实际值: ${setLength}`);
-    }
-    
-    const list = await redis.list_get(key);
-    if (JSON.stringify(list) !== JSON.stringify(listData)) {
-        throw new Error(`list_get 测试失败，期望值: ${JSON.stringify(listData)}, 实际值: ${JSON.stringify(list)}`);
-    }
-    
-    // 测试list_push方法
-    const pushLength = await redis.list_push(key, 'item4');
-    if (pushLength !== 4) {
-        throw new Error(`list_push 测试失败，期望值: 4, 实际值: ${pushLength}`);
-    }
-    
-    // 测试list_has方法
-    const hasResult = await redis.list_has(key, 'item2');
-    if (hasResult !== true) {
-        throw new Error(`list_has 测试失败，期望值: true, 实际值: ${hasResult}`);
-    }
-    
-    // 测试list_clear方法
-    const clearResult = await redis.list_clear(key);
-    if (clearResult !== true) {
-        throw new Error(`list_clear 测试失败，期望值: true, 实际值: ${clearResult}`);
-    }
-    
-    const clearedList = await redis.list_get(key);
-    if (clearedList.length !== 0) {
-        throw new Error(`list_clear 测试失败，期望值: [], 实际值: ${JSON.stringify(clearedList)}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试哈希操作方法
-async function testHashOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('hash_op');
-    
-    // 测试hset和hget方法
-    const setResult1 = await redis.hset(key, 'field1', 'value1');
-    if (!setResult1) {
-        throw new Error(`hset 测试失败，设置field1返回: ${setResult1}`);
-    }
-    
-    const setResult2 = await redis.hset(key, 'field2', '123');
-    if (!setResult2) {
-        throw new Error(`hset 测试失败，设置field2返回: ${setResult2}`);
-    }
-    
-    const field1Value = await redis.hget(key, 'field1');
-    if (field1Value !== 'value1') {
-        throw new Error(`hget 测试失败，期望值: 'value1', 实际值: ${field1Value}`);
-    }
-    
-    const field2Value = await redis.hget(key, 'field2');
-    if (field2Value !== '123') {
-        throw new Error(`hget 测试失败，期望值: '123', 实际值: ${field2Value}`);
-    }
-    
-    // 测试hexists方法
-    const existsResult = await redis.hexists(key, 'field1');
-    if (!existsResult) {
-        throw new Error(`hexists 测试失败，field1应该存在`);
-    }
-    
-    // 测试hdel方法
-    const delResult = await redis.hdel(key, 'field1');
-    if (!delResult) {
-        throw new Error(`hdel 测试失败，返回: ${delResult}`);
-    }
-    
-    // 验证删除后不存在
-    const notExistsResult = await redis.hexists(key, 'field1');
-    if (notExistsResult) {
-        throw new Error(`hexists 测试失败，field1应该不存在`);
-    }
-    
-    await redis.close();
-}
-
-// 测试批量操作方法
-async function testBatchOperations() {
-    const redis = createRedisInstance();
-    
-    // 简化批量操作测试，只测试基本功能
-    const key1 = getTestKey('batch1');
-    const key2 = getTestKey('batch2');
-    
-    // 先单独设置值
-    await redis.set(key1, 'value1');
-    await redis.set(key2, 'value2');
-    
-    // 测试mget方法
-    const mgetResult = await redis.mget([key1, key2]);
-    if (mgetResult[0] !== 'value1' || mgetResult[1] !== 'value2') {
-        throw new Error(`mget 测试失败，期望值: ['value1', 'value2'], 实际值: ${JSON.stringify(mgetResult)}`);
-    }
-    
-    // 测试pipeline的简单操作
-    const pipeline = redis.pipeline();
-    pipeline.set(getTestKey('pipeline1'), 'pipeline_value1');
-    pipeline.get(getTestKey('pipeline1'));
-    
-    const pipelineResults = await pipeline.exec();
-    if (!pipelineResults || pipelineResults[1] !== 'pipeline_value1') {
-        throw new Error(`pipeline 测试失败，期望值: 'pipeline_value1', 实际值: ${pipelineResults[1]}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试过期时间设置
-async function testExpireOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('expire_op');
-    
-    // 设置键并设置过期时间
-    await redis.set(key, 'expire test', 2); // 2秒过期
-    
-    // 立即检查键是否存在
-    const hasBeforeExpire = await redis.has(key);
-    if (hasBeforeExpire !== true) {
-        throw new Error(`expire 设置前测试失败，期望值: true, 实际值: ${hasBeforeExpire}`);
-    }
-    
-    // 等待过期
-    console.log('等待键过期...');
-    await new Promise(resolve => setTimeout(resolve, 2500));
-    
-    // 检查键是否已过期
-    const hasAfterExpire = await redis.has(key);
-    if (hasAfterExpire !== false) {
-        throw new Error(`expire 过期后测试失败，期望值: false, 实际值: ${hasAfterExpire}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试集合操作方法
-async function testSetOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('set_op');
-    
-    // 测试sadd方法 - 简化，只添加一个成员
-    const addCount = await redis.sadd(key, 'member1');
-    if (addCount !== 1) {
-        throw new Error(`sadd 测试失败，期望值: 1, 实际值: ${addCount}`);
-    }
-    
-    // 测试sismember方法
-    const isMember = await redis.sismember(key, 'member1');
-    if (!isMember) {
-        throw new Error(`sismember 测试失败，member1应该存在于集合中`);
-    }
-    
-    // 测试scard方法
-    const cardCount = await redis.scard(key);
-    if (cardCount !== 1) {
-        throw new Error(`scard 测试失败，期望值: 1, 实际值: ${cardCount}`);
-    }
-    
-    // 测试srem方法
-    const remCount = await redis.srem(key, 'member1');
-    if (remCount !== 1) {
-        throw new Error(`srem 测试失败，期望值: 1, 实际值: ${remCount}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试有序集合操作方法
-async function testSortedSetOperations() {
-    const redis = createRedisInstance();
-    const key = getTestKey('zset_op');
-    
-    // 测试zadd方法
-    const addResult = await redis.zadd(key, 1, 'member1');
-    if (!addResult) {
-        throw new Error(`zadd 测试失败，返回: ${addResult}`);
-    }
-    
-    // 测试zscore方法
-    const score = await redis.zscore(key, 'member1');
-    if (score !== 1) {
-        throw new Error(`zscore 测试失败，期望值: 1, 实际值: ${score}`);
-    }
-    
-    // 测试zrange方法
-    const range = await redis.zrange(key, 0, -1);
-    if (!range || range[0] !== 'member1') {
-        throw new Error(`zrange 测试失败，期望值: ['member1'], 实际值: ${JSON.stringify(range)}`);
-    }
-    
-    await redis.close();
-}
-
-// 测试错误处理事件
-async function testErrorEvents() {
-    const redis = createRedisInstance();
-    const key = getTestKey('error_event');
-    let errorEventTriggered = false;
-    
-    // 监听错误事件（使用一个不会触发真正错误的操作来验证事件机制）
-    redis.on('get_error', (data) => {
-        console.log('get_error 事件触发:', data);
-        errorEventTriggered = true;
-    });
-    
-    // 正常获取一个不存在的键不会触发错误事件，但可以验证错误处理机制
-    const value = await redis.get(key); // 正常操作，不应该触发错误
-    
-    // 由于我们无法直接在测试环境中触发错误（会导致测试失败），这里只是确认机制存在
-    console.log('错误事件测试：验证事件监听器已正确注册');
-    
-    await redis.close();
-}
-
-// 测试JSON数据序列化和反序列化
-async function testJsonSerialization() {
-    const redis = createRedisInstance();
-    const key = getTestKey('json_test');
-    
-    // 测试对象序列化和反序列化
-    const objData = { name: 'test', value: 123, active: true };
-    await redis.set(key, objData);
-    const retrievedObj = await redis.get(key);
-    
-    if (JSON.stringify(retrievedObj) !== JSON.stringify(objData)) {
-        throw new Error(`JSON 序列化测试失败，期望值: ${JSON.stringify(objData)}, 实际值: ${JSON.stringify(retrievedObj)}`);
-    }
-    
-    await redis.close();
-}
-
-// 运行所有测试
-async function runAllTests() {
-    try {
-        console.log('开始测试 mm_redis 模块的数据增删改查方法和事件...');
-        console.log('='.repeat(60));
-        
-        // 清理之前的测试数据
-        await cleanup();
-        
-        // 运行各项测试
-        await runTest('字符串操作', testStringOperations);
-        await runTest('事件处理', testEvents);
-        await runTest('列表操作', testListOperations);
-        await runTest('哈希操作', testHashOperations);
-        await runTest('批量操作', testBatchOperations);
-        await runTest('过期时间设置', testExpireOperations);
-        await runTest('集合操作', testSetOperations);
-        await runTest('有序集合操作', testSortedSetOperations);
-        await runTest('错误处理事件', testErrorEvents);
-        await runTest('JSON序列化', testJsonSerialization);
-        
-        // 再次清理测试数据
-        await cleanup();
-        
-        // 输出测试结果统计
-        console.log('\n' + '='.repeat(60));
-        console.log('测试结果统计:');
-        console.log(`总测试数: ${testResults.total}`);
-        console.log(`通过测试: ${testResults.passed}`);
-        console.log(`失败测试: ${testResults.failed}`);
-        console.log(`跳过测试: ${testResults.skipped}`);
-        
-        if (testResults.failed > 0) {
-            console.log(`\n❌ 有测试失败，失败的测试: ${testResults.failedTests.join(', ')}`);
-        } else {
-            console.log('\n🎉 所有测试通过！Redis模块的数据增删改查方法和事件功能正常！');
-        }
-        
-        const passRate = (testResults.passed / testResults.total * 100).toFixed(2);
-        console.log(`测试通过率: ${passRate}%`);
-        
-        // 退出代码反映测试结果
-        process.exit(testResults.failed > 0 ? 1 : 0);
-        
-    } catch (error) {
-        console.error('测试过程中发生未处理的错误:', error);
-        process.exit(1);
-    }
-}
-
-// 启动测试
-runAllTests();

package/test_real_redis.js

@@ -1,104 +0,0 @@
-// 真实Redis环境测试脚本
-const fs = require('fs');
-const path = require('path');
-
-// 简单的日志函数
-function log(message, data = null) {
-    const timestamp = new Date().toISOString();
-    if (data) {
-        console.log(`[${timestamp}] ${message}`, typeof data === 'object' ? JSON.stringify(data, null, 2) : data);
-    } else {
-        console.log(`[${timestamp}] ${message}`);
-    }
-}
-
-// 加载配置文件的函数
-function loadConfig(configPath) {
-    try {
-        const configContent = fs.readFileSync(configPath, 'utf8');
-        return JSON.parse(configContent);
-    } catch (error) {
-        log(`错误：无法加载配置文件 ${configPath}: ${error.message}`);
-        return null;
-    }
-}
-
-// 主测试函数
-async function runRealRedisTest() {
-    log('开始真实Redis环境测试...');
-    
-    try {
-        // 加载Redis模块
-        const RedisModule = require('./index.js');
-        const Redis = RedisModule.default || RedisModule;
-        const redis_admin = RedisModule.redis_admin;
-        
-        log(`Redis类类型: ${typeof Redis}`);
-        log(`redis_admin函数类型: ${typeof redis_admin}`);
-        
-        // 加载配置
-        const configPath = path.join(__dirname, 'config.json');
-        const config = loadConfig(configPath);
-        
-        if (!config) {
-            log('无法继续测试，配置文件加载失败');
-            return;
-        }
-        
-        log('加载配置成功:', config);
-        
-        // 测试1: 使用redis_admin
-        log('\n测试1: 使用redis_admin创建实例');
-        const redisInstance = redis_admin('sys');
-        redisInstance.setConfig(config);
-        
-        // 尝试连接
-        log('尝试连接到Redis服务器...');
-        try {
-            await redisInstance.open();
-            log('✅ 成功连接到Redis服务器!');
-            
-            // 测试基本操作
-            log('\n测试基本set/get操作:');
-            const testKey = 'test_real_redis_key';
-            const testValue = { message: 'Hello from real Redis test', timestamp: new Date().toISOString() };
-            
-            await redisInstance.set(testKey, testValue);
-            log(`✅ 设置键 ${testKey} 成功`);
-            
-            const retrievedValue = await redisInstance.get(testKey);
-            log(`✅ 获取键 ${testKey} 成功，值为:`, retrievedValue);
-            
-            // 清理测试数据
-            await redisInstance.del([testKey]);
-            log(`✅ 清理测试数据成功`);
-            
-            // 关闭连接
-            await redisInstance.close();
-            log('✅ 关闭连接成功');
-            
-        } catch (connectError) {
-            log(`❌ 连接Redis服务器失败: ${connectError.message}`);
-            log('请确保Redis服务器正在运行，并且配置正确');
-            log('检查点:');
-            log(`- Redis服务器地址: ${config.host}:${config.port}`);
-            log(`- 密码是否正确: ${config.password ? '已设置' : '未设置'}`);
-            log(`- 数据库索引: ${config.database}`);
-        }
-        
-    } catch (error) {
-        log(`❌ 测试过程中出现错误: ${error.message}`);
-        log(error.stack);
-    }
-    
-    log('\n测试完成!');
-}
-
-// 运行测试
-runRealRedisTest().then(() => {
-    // 确保测试成功完成后以退出码0结束
-    process.exit(0);
-}).catch(err => {
-    log(`❌ 测试执行失败: ${err.message}`);
-    process.exit(1);
-});