mm_cachebase 1.9.7 → 2.0.0

package/test.js

@@ -1,536 +1,728 @@
-const assert = require('assert');
-const { CacheBase, cachebaseAdmin } = require('./index.js');
-
-class TestRunner {
-  constructor() {
-    this.totalTests = 0;
-    this.passedTests = 0;
-    this.results = [];
-  }
-
-  async runTest(name, testFunction) {
-    this.totalTests++;
-    try {
-      await testFunction();
-      this.passedTests++;
-      this.results.push({ name, passed: true });
-      $.log.debug(`✅ ${name}`);
-    } catch (error) {
-      this.results.push({ name, passed: false, error: error.message });
-      $.log.debug(`❌ ${name} - ${error.message}`);
-    }
-  }
-
-  displayResults() {
-    $.log.debug('\n========== 测试结果 ==========');
-    const passRate = (this.passedTests / this.totalTests * 100).toFixed(2);
-    $.log.debug(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
-    
-    // 显示失败的测试
-    const failedTests = this.results.filter(r => !r.passed);
-    if (failedTests.length > 0) {
-      $.log.debug('\n失败的测试:');
-      failedTests.forEach(test => {
-        $.log.debug(`  - ${test.name}: ${test.error}`);
-      });
-    }
-    
-    return passRate;
-  }
-}
-
-async function test() {
-  $.log.debug('[CacheBase] ==============================');
-  $.log.debug('[CacheBase] 开始兼容性测试');
-  $.log.debug('[CacheBase] ==============================');
-  
-  try {
-    const runner = new TestRunner();
-    
-    // 测试基础方法
-    $.log.debug('[CacheBase] \n========== 测试基础方法 ==========');
-    
-    await runner.runTest('set和get方法', async () => {
-        const cache = new CacheBase({ scope: 'test_set_get' });
-        await cache.init();
-        
-        await cache.set('test_key', 'test_value');
-        const value = await cache.get('test_key');
-        
-        assert.equal(value, 'test_value', 'set和get方法测试失败');
-        
-        await cache.del('test_key');
-        const deleted_value = await cache.get('test_key');
-        
-        assert.equal(deleted_value, null, 'del方法测试失败');
-        
-        await cache.close();
-      });
-    
-    await runner.runTest('del方法', async () => {
-      const cache = new CacheBase({ scope: 'test_del' });
-      await cache.set('key2', 'value2');
-      const deleted = await cache.del('key2');
-      if (deleted !== true) {
-        throw new Error(`删除失败，预期: true, 实际: ${deleted}`);
-      }
-      const value = await cache.get('key2');
-      if (value !== null) {
-        throw new Error(`键未被删除，值: ${value}`);
-      }
-    });
-    
-    await runner.runTest('exists/has方法', async () => {
-      const cache = new CacheBase({ scope: 'test_exists_has' });
-      await cache.set('key3', 'value3');
-      const exists = await cache.exists('key3');
-      if (exists !== true) {
-        throw new Error(`exists失败，预期: true, 实际: ${exists}`);
-      }
-      const has = await cache.has('key3');
-      if (!has) {
-        throw new Error(`has失败，预期: true, 实际: ${has}`);
-      }
-    });
-    
-    await runner.runTest('keys方法', async () => {
-      const cache = new CacheBase({ 
-        persist: true,
-        scope: 'test_keys' 
-      });
-      await cache.set('key4', 'value4');
-      await cache.set('key5', 'value5');
-      const keys = await cache.keys();
-      if (keys.length !== 2 || !keys.includes('key4') || !keys.includes('key5')) {
-        throw new Error(`keys失败，预期包含key4和key5, 实际: ${JSON.stringify(keys)}`);
-      }
-      const filteredKeys = await cache.keys('key4*');
-      if (filteredKeys.length !== 1 || filteredKeys[0] !== 'key4') {
-        throw new Error(`keys过滤失败，预期: ["key4"], 实际: ${JSON.stringify(filteredKeys)}`);
-      }
-    });
-    
-    await runner.runTest('dbsize方法', async () => {
-      const cache = new CacheBase({ 
-        persist: true,
-        scope: 'test_dbsize' 
-      });
-      await cache.set('key4', 'value4');
-      await cache.set('key5', 'value5');
-      const size = await cache.dbsize();
-      if (size !== 2) {
-        throw new Error(`dbsize失败，预期: 2, 实际: ${size}`);
-      }
-    });
-    
-    await runner.runTest('getset方法', async () => {
-      const cache = new CacheBase({ scope: 'test_getset' });
-      await cache.set('key4', 'value4');
-      const oldValue = await cache.getset('key4', 'newvalue4');
-      if (oldValue !== 'value4') {
-        throw new Error(`getset失败，预期旧值: value4, 实际: ${oldValue}`);
-      }
-      const newValue = await cache.get('key4');
-      if (newValue !== 'newvalue4') {
-        throw new Error(`getset失败，预期新值: newvalue4, 实际: ${newValue}`);
-      }
-    });
-    
-    await runner.runTest('flushdb/clear方法', async () => {
-      const cache = new CacheBase({ 
-        persist: true,
-        scope: 'test_flushdb' 
-      });
-      await cache.set('key6', 'value6');
-      let result = await cache.clear();
-      if (result !== true) {
-        throw new Error(`flushdb失败，预期: true, 实际: ${result}`);
-      }
-      const size = await cache.dbsize();
-      if (size !== 0) {
-        throw new Error(`flushdb后大小不为0: ${size}`);
-      }
-      
-      // 测试clear方法（兼容）
-      await cache.set('key7', 'value7');
-      result = await cache.clear();
-      if (result !== true) {
-        throw new Error(`clear失败，预期: true, 实际: ${result}`);
-      }
-      const sizeAfterClear = await cache.dbsize();
-      if (sizeAfterClear !== 0) {
-        throw new Error(`clear后大小不为0: ${sizeAfterClear}`);
-      }
-    });
-    
-    // 测试哈希表方法
-    $.log.debug('[CacheBase] \n========== 测试哈希表方法 ==========');
-    const hashCache = new CacheBase({ scope: 'test_hash' });
-    
-    await runner.runTest('hset和hget方法', async () => {
-      const result1 = await hashCache.hset('hash1', 'field1', 'value1');
-      if (result1 !== 1) {
-        throw new Error(`hset新建失败，预期: 1, 实际: ${result1}`);
-      }
-      
-      const result2 = await hashCache.hset('hash1', 'field1', 'value1_updated');
-      if (result2 !== 0) {
-        throw new Error(`hset更新失败，预期: 0, 实际: ${result2}`);
-      }
-      
-      const value = await hashCache.hget('hash1', 'field1');
-      if (value !== 'value1_updated') {
-        throw new Error(`hget失败，预期: value1_updated, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('hgetall方法', async () => {
-      await hashCache.hset('hash1', 'field2', 'value2');
-      const hash = await hashCache.hgetall('hash1');
-      if (JSON.stringify(hash) !== JSON.stringify({ field1: 'value1_updated', field2: 'value2' })) {
-        throw new Error(`hgetall失败，预期: {"field1":"value1_updated","field2":"value2"}, 实际: ${JSON.stringify(hash)}`);
-      }
-    });
-    
-    await runner.runTest('hdel方法', async () => {
-      const result = await hashCache.hdel('hash1', 'field1');
-      if (result !== true) {
-        throw new Error(`hdel失败，预期: true, 实际: ${result}`);
-      }
-      const value = await hashCache.hget('hash1', 'field1');
-      if (value !== undefined) {
-        throw new Error(`hdel后字段未被删除，值: ${value}`);
-      }
-      
-      // 删除不存在的字段
-      const result2 = await hashCache.hdel('hash1', 'non_existent');
-      if (result2 !== false) {
-        throw new Error(`hdel不存在字段失败，预期: false, 实际: ${result2}`);
-      }
-    });
-    
-    // 测试批量操作
-    $.log.debug('[CacheBase] \n========== 测试批量操作 ==========');
-    const batchCache = new CacheBase({ scope: 'test_batch' });
-    
-    await runner.runTest('mset方法', async () => {
-      const result = await batchCache.mset('key7', 'value7', 'key8', 'value8');
-      if (result !== true) {
-        throw new Error(`mset失败，预期: true, 实际: ${result}`);
-      }
-      const value7 = await batchCache.get('key7');
-      const value8 = await batchCache.get('key8');
-      if (value7 !== 'value7' || value8 !== 'value8') {
-        throw new Error(`mset设置失败，value7: ${value7}, value8: ${value8}`);
-      }
-    });
-    
-    await runner.runTest('mget方法', async () => {
-      const values = await batchCache.mget(['key7', 'key8', 'nonExistentKey']);
-      if (JSON.stringify(values) !== JSON.stringify(['value7', 'value8', null])) {
-        throw new Error(`mget失败，预期: ["value7","value8",null], 实际: ${JSON.stringify(values)}`);
-      }
-    });
-    
-    // 测试过期时间
-    $.log.debug('[CacheBase] \n========== 测试过期时间 ==========');
-    const expireCache = new CacheBase({ scope: 'test_expire' });
-    
-    await runner.runTest('set带过期时间', async () => {
-      await expireCache.set('expire1', 'value1', 1); // 1秒过期
-      let ttl = await expireCache.ttl('expire1');
-      if (ttl <= 0) {
-        throw new Error(`ttl初始值错误: ${ttl}`);
-      }
-      
-      // 等待过期
-      await new Promise(resolve => setTimeout(resolve, 1100));
-      
-      ttl = await expireCache.ttl('expire1');
-      if (ttl !== -2) {
-        throw new Error(`过期后ttl错误，预期: -2, 实际: ${ttl}`);
-      }
-      
-      const value = await expireCache.get('expire1');
-      if (value !== null) {
-        throw new Error(`过期后键仍存在: ${value}`);
-      }
-    });
-    
-    await runner.runTest('expire方法', async () => {
-      await expireCache.set('expire2', 'value2');
-      const result = await expireCache.expire('expire2', 1);
-      if (result !== true) {
-        throw new Error(`expire设置失败，预期: true, 实际: ${result}`);
-      }
-      let ttl = await expireCache.ttl('expire2');
-      if (ttl <= 0) {
-        throw new Error(`expire后ttl错误: ${ttl}`);
-      }
-    });
-    
-    await runner.runTest('persist方法', async () => {
-      await expireCache.set('expire3', 'value3', 30);
-      const result = await expireCache.persist('expire3');
-      if (result !== true) {
-        throw new Error(`persist设置失败，预期: true, 实际: ${result}`);
-      }
-      const ttl = await expireCache.ttl('expire3');
-      if (ttl !== -1) {
-        throw new Error(`persist后ttl错误，预期: -1, 实际: ${ttl}`);
-      }
-    });
-    
-    // 测试数值操作
-    $.log.debug('[CacheBase] \n========== 测试数值操作 ==========');
-    const numCache = new CacheBase({ scope: 'test_num' });
-    
-    await runner.runTest('incr方法', async () => {
-      const result1 = await numCache.incr('counter');
-      if (result1 !== 1) {
-        throw new Error(`incr初始值失败，预期: 1, 实际: ${result1}`);
-      }
-      const value1 = await numCache.get('counter');
-      if (value1 !== 1) {
-        throw new Error(`incr值错误，预期: 1, 实际: ${value1}`);
-      }
-      
-      const result2 = await numCache.incr('counter');
-      if (result2 !== 2) {
-        throw new Error(`incr递增失败，预期: 2, 实际: ${result2}`);
-      }
-      const value2 = await numCache.get('counter');
-      if (value2 !== 2) {
-        throw new Error(`incr递增后值错误，预期: 2, 实际: ${value2}`);
-      }
-    });
-    
-    await runner.runTest('decr方法', async () => {
-      const result = await numCache.decr('counter');
-      if (result !== 1) {
-        throw new Error(`decr递减失败，预期: 1, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 1) {
-        throw new Error(`decr递减后值错误，预期: 1, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('incrby方法', async () => {
-      const result = await numCache.incrby('counter', 5);
-      if (result !== 6) {
-        throw new Error(`incrby增加失败，预期: 6, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 6) {
-        throw new Error(`incrby增加后值错误，预期: 6, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('decrby方法', async () => {
-      const result = await numCache.decrby('counter', 2);
-      if (result !== 4) {
-        throw new Error(`decrby减少失败，预期: 4, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 4) {
-        throw new Error(`decrby减少后值错误，预期: 4, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('incrbyfloat方法', async () => {
-      const result = await numCache.incrbyfloat('counter', 0.5);
-      if (result !== 4.5) {
-        throw new Error(`incrbyfloat增加失败，预期: 4.5, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 4.5) {
-        throw new Error(`incrbyfloat增加后值错误，预期: 4.5, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('add方法（兼容）', async () => {
-      // 先删除键，确保它不存在
-      await numCache.del('counter');
-      const result = await numCache.add('counter', 10);
-      if (result !== true) {
-        throw new Error(`add增加失败，预期: true, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 10) {
-        throw new Error(`add增加后值错误，预期: 10, 实际: ${value}`);
-      }
-      
-      // 测试键已存在时的行为（不应修改值）
-      const result2 = await numCache.add('counter', 20);
-      if (result2 !== false) {
-        throw new Error(`add键已存在时失败，预期: false, 实际: ${result2}`);
-      }
-      const value2 = await numCache.get('counter');
-      if (value2 !== 10) {
-        throw new Error(`add键已存在时值不应改变，预期: 10, 实际: ${value2}`);
-      }
-    });
-    
-    await runner.runTest('addFloat方法（兼容）', async () => {
-      const result = await numCache.addFloat('counter', 0.5);
-      if (result !== 10.5) {
-        throw new Error(`addFloat增加失败，预期: 10.5, 实际: ${result}`);
-      }
-      const value = await numCache.get('counter');
-      if (value !== 10.5) {
-        throw new Error(`addFloat增加后值错误，预期: 10.5, 实际: ${value}`);
-      }
-    });
-    
-    // 测试字符串操作
-    $.log.debug('[CacheBase] \n========== 测试字符串操作 ==========');
-    const strCache = new CacheBase({ scope: 'test_str' });
-    
-    await runner.runTest('append方法', async () => {
-      await strCache.set('str', 'hello');
-      const result = await strCache.append('str', ' world');
-      if (result !== 11) {
-        throw new Error(`append长度错误，预期: 11, 实际: ${result}`);
-      }
-      const value = await strCache.get('str');
-      if (value !== 'hello world') {
-        throw new Error(`append值错误，预期: hello world, 实际: ${value}`);
-      }
-    });
-    
-    await runner.runTest('strlen方法', async () => {
-      const result = await strCache.strlen('str');
-      if (result !== 11) {
-        throw new Error(`strlen长度错误，预期: 11, 实际: ${result}`);
-      }
-      
-      // 不存在的键
-      const result2 = await strCache.strlen('non_existent');
-      if (result2 !== 0) {
-        throw new Error(`strlen不存在键错误，预期: 0, 实际: ${result2}`);
-      }
-    });
-    
-    await runner.runTest('addStr方法（兼容）', async () => {
-      const result = await strCache.addStr('str', '!');
-      if (result !== 12) {
-        throw new Error(`addStr长度错误，预期: 12, 实际: ${result}`);
-      }
-      const value = await strCache.get('str');
-      if (value !== 'hello world!') {
-        throw new Error(`addStr值错误，预期: hello world!, 实际: ${value}`);
-      }
-    });
-    
-    // 测试事件触发
-    $.log.debug('[CacheBase] \n========== 测试事件触发 ==========');
-    const eventCache = new CacheBase({ scope: 'test_event' });
-    
-    await runner.runTest('set事件触发', async () => {
-      return new Promise(async (resolve, reject) => {
-        let beforeTriggered = false;
-        let afterTriggered = false;
-        
-        eventCache.once('set_before', (data) => {
-          if (data.key === 'event_key' && data.value === 'event_value') {
-            beforeTriggered = true;
-          }
-        });
-        
-        eventCache.once('set_after', (data) => {
-          if (data.key === 'event_key' && data.value === 'event_value' && data.result === 'OK') {
-            afterTriggered = true;
-            setTimeout(() => {
-              if (beforeTriggered && afterTriggered) {
-                resolve();
-              } else {
-                reject(new Error('set事件未全部触发'));
-              }
-            }, 10);
-          }
-        });
-        
-        await eventCache.set('event_key', 'event_value');
-      });
-    });
-    
-    await runner.runTest('error事件触发', async () => {
-      return new Promise(async (resolve, reject) => {
-        eventCache.once('mset_error', (data) => {
-          if (data.error && data.error.message.includes('参数数量必须为偶数')) {
-            resolve();
-          } else {
-            reject(new Error('mset_error事件触发但消息不正确'));
-          }
-        });
-        
-        try {
-          await eventCache.mset(null);
-          reject(new Error('mset应抛出错误但没有'));
-        } catch (error) {
-          // 预期的错误，等待事件触发
-          setTimeout(() => {
-            reject(new Error('mset_error事件未触发'));
-          }, 100);
-        }
-      });
-    });
-    
-    // 测试管理功能
-    $.log.debug('[CacheBase] \n========== 测试管理功能 ==========');
-    
-    await runner.runTest('cachebaseAdmin创建实例', async () => {
-      const cache1 = cachebaseAdmin('test_scope');
-      const cache2 = cachebaseAdmin('test_scope');
-      if (cache1 !== cache2) {
-        throw new Error('cachebaseAdmin应返回相同实例但没有');
-      }
-      
-      const cache3 = cachebaseAdmin('another_scope');
-      if (cache1 === cache3) {
-        throw new Error('cachebaseAdmin应返回不同作用域的不同实例但没有');
-      }
-    });
-    
-    await runner.runTest('dispose方法', async () => {
-      const disposeCache = new CacheBase({ 
-        persist: true,
-        scope: 'test_dispose' 
-      });
-      await disposeCache.set('key_to_dispose', 'value');
-      disposeCache.dispose();
-      
-      const size = await disposeCache.dbsize();
-      if (size !== 0) {
-        throw new Error(`dispose后大小不为0: ${size}`);
-      }
-    });
-    
-    // 显示测试结果
-    const passRate = runner.displayResults();
-    $.log.debug(`[CacheBase] \n测试完成！通过率: ${passRate}%`);
-    
-    $.log.debug('[CacheBase] \n==============================');
-    $.log.debug('[CacheBase] 所有兼容性测试完成!');
-    $.log.debug('[CacheBase] ==============================');
-    
-  } catch (error) {
-    $.log.error('[CacheBase] 测试过程中出现错误:', error);
-  }
-}
-
-test().then(() => {
-  // 测试成功完成
-  $.log.debug('[CacheBase] 测试脚本正常退出');
-  process.exit(0);
-}).catch(err => {
-  $.log.error('[CacheBase] 未捕获的错误:', err);
-  process.exit(1);
-});
-
-// 添加超时保护，但让Promise处理正常结束
-setTimeout(() => {
-  $.log.warn('[CacheBase] 测试脚本超时');
-  process.exit(1);
-}, 10000); // 10秒超时
+const assert = require('assert');
+const { CacheBase, cachebaseAdmin } = require('./index.js');
+
+class TestRunner {
+  constructor() {
+    this.totalTests = 0;
+    this.passedTests = 0;
+    this.results = [];
+  }
+
+  async runTest(name, testFunction) {
+    this.totalTests++;
+    try {
+      await testFunction();
+      this.passedTests++;
+      this.results.push({ name, passed: true });
+      $.log.debug(`✅ ${name}`);
+    } catch (error) {
+      this.results.push({ name, passed: false, error: error.message });
+      $.log.debug(`❌ ${name} - ${error.message}`);
+    }
+  }
+
+  displayResults() {
+    $.log.debug('\n========== 测试结果 ==========');
+    const passRate = (this.passedTests / this.totalTests * 100).toFixed(2);
+    $.log.debug(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
+    
+    // 显示失败的测试
+    const failedTests = this.results.filter(r => !r.passed);
+    if (failedTests.length > 0) {
+      $.log.debug('\n失败的测试:');
+      failedTests.forEach(test => {
+        $.log.debug(`  - ${test.name}: ${test.error}`);
+      });
+    }
+    
+    return passRate;
+  }
+}
+
+async function test() {
+  $.log.debug('[CacheBase] ==============================');
+  $.log.debug('[CacheBase] 开始兼容性测试（对齐 mm_redis 接口）');
+  $.log.debug('[CacheBase] ==============================');
+  
+  try {
+    const runner = new TestRunner();
+    
+    // 测试基础方法
+    $.log.debug('[CacheBase] \n========== 测试基础方法 ==========');
+    
+    await runner.runTest('set和get方法', async () => {
+        const cache = new CacheBase({ scope: 'test_set_get' });
+        await cache.init();
+        
+        await cache.set('test_key', 'test_value');
+        const value = await cache.get('test_key');
+        
+        assert.equal(value, 'test_value', 'set和get方法测试失败');
+        
+        await cache.del('test_key');
+        const deleted_value = await cache.get('test_key');
+        
+        assert.equal(deleted_value, null, 'del方法测试失败');
+        
+        await cache.close();
+      });
+    
+    await runner.runTest('del方法（返回删除数量）', async () => {
+      const cache = new CacheBase({ scope: 'test_del' });
+      await cache.set('key2', 'value2');
+      const deleted = await cache.del('key2');
+      // del 返回删除的数量，对齐 mm_redis
+      if (deleted !== 1) {
+        throw new Error(`删除失败，预期: 1, 实际: ${deleted}`);
+      }
+      const value = await cache.get('key2');
+      if (value !== null) {
+        throw new Error(`键未被删除，值: ${value}`);
+      }
+      // 删除不存在的键返回 0
+      const deleted2 = await cache.del('not_exist');
+      if (deleted2 !== 0) {
+        throw new Error(`删除不存在键预期: 0, 实际: ${deleted2}`);
+      }
+    });
+    
+    await runner.runTest('exists/has方法（返回数字）', async () => {
+      const cache = new CacheBase({ scope: 'test_exists_has' });
+      await cache.set('key3', 'value3');
+      const exists = await cache.exists('key3');
+      // exists 返回 0/1，对齐 mm_redis
+      if (exists !== 1) {
+        throw new Error(`exists失败，预期: 1, 实际: ${exists}`);
+      }
+      const has = await cache.has('key3');
+      if (!has) {
+        throw new Error(`has失败，预期: true, 实际: ${has}`);
+      }
+      // 不存在的键返回 0
+      const exists2 = await cache.exists('not_exist');
+      if (exists2 !== 0) {
+        throw new Error(`exists不存在键预期: 0, 实际: ${exists2}`);
+      }
+    });
+    
+    await runner.runTest('keys方法', async () => {
+      const cache = new CacheBase({ 
+        persist: false,
+        scope: 'test_keys' 
+      });
+      await cache.set('key4', 'value4');
+      await cache.set('key5', 'value5');
+      const keys = await cache.keys();
+      if (keys.length !== 2 || !keys.includes('key4') || !keys.includes('key5')) {
+        throw new Error(`keys失败，预期包含key4和key5, 实际: ${JSON.stringify(keys)}`);
+      }
+      const filteredKeys = await cache.keys('key4*');
+      if (filteredKeys.length !== 1 || filteredKeys[0] !== 'key4') {
+        throw new Error(`keys过滤失败，预期: ["key4"], 实际: ${JSON.stringify(filteredKeys)}`);
+      }
+    });
+    
+    await runner.runTest('dbsize方法', async () => {
+      const cache = new CacheBase({ 
+        persist: false,
+        scope: 'test_dbsize' 
+      });
+      await cache.set('key4', 'value4');
+      await cache.set('key5', 'value5');
+      const size = await cache.dbsize();
+      if (size !== 2) {
+        throw new Error(`dbsize失败，预期: 2, 实际: ${size}`);
+      }
+    });
+    
+    await runner.runTest('getset方法', async () => {
+      const cache = new CacheBase({ scope: 'test_getset' });
+      await cache.set('key4', 'value4');
+      const oldValue = await cache.getset('key4', 'newvalue4');
+      if (oldValue !== 'value4') {
+        throw new Error(`getset失败，预期旧值: value4, 实际: ${oldValue}`);
+      }
+      const newValue = await cache.get('key4');
+      if (newValue !== 'newvalue4') {
+        throw new Error(`getset失败，预期新值: newvalue4, 实际: ${newValue}`);
+      }
+    });
+    
+    await runner.runTest('flushdb/clear方法', async () => {
+      const cache = new CacheBase({ 
+        persist: false,
+        scope: 'test_flushdb' 
+      });
+      await cache.set('key6', 'value6');
+      let result = await cache.clear();
+      if (result !== true) {
+        throw new Error(`flushdb失败，预期: true, 实际: ${result}`);
+      }
+      const size = await cache.dbsize();
+      if (size !== 0) {
+        throw new Error(`flushdb后大小不为0: ${size}`);
+      }
+      
+      await cache.set('key7', 'value7');
+      result = await cache.clear();
+      if (result !== true) {
+        throw new Error(`clear失败，预期: true, 实际: ${result}`);
+      }
+      const sizeAfterClear = await cache.dbsize();
+      if (sizeAfterClear !== 0) {
+        throw new Error(`clear后大小不为0: ${sizeAfterClear}`);
+      }
+    });
+    
+    await runner.runTest('open/close/isConnected方法', async () => {
+      const cache = new CacheBase({ scope: 'test_open_close' });
+      // 等待构造函数中异步 init 完成
+      await cache.init();
+      const connected1 = cache.isConnected();
+      if (!connected1) {
+        throw new Error(`init后应已连接，实际: ${connected1}`);
+      }
+      const openResult = await cache.open();
+      if (!openResult) {
+        throw new Error(`open 失败，实际: ${openResult}`);
+      }
+      const closeResult = await cache.close();
+      if (!closeResult) {
+        throw new Error(`close 失败，实际: ${closeResult}`);
+      }
+      const connected2 = cache.isConnected();
+      if (connected2) {
+        throw new Error(`close后应未连接，实际: ${connected2}`);
+      }
+    });
+    
+    // 测试哈希表方法
+    $.log.debug('[CacheBase] \n========== 测试哈希表方法 ==========');
+    const hashCache = new CacheBase({ scope: 'test_hash' });
+    
+    await runner.runTest('hset和hget方法（返回Boolean）', async () => {
+      // hset 返回 true/false，对齐 mm_redis
+      const result1 = await hashCache.hset('hash1', 'field1', 'value1');
+      if (result1 !== true) {
+        throw new Error(`hset新建失败，预期: true, 实际: ${result1}`);
+      }
+      
+      const result2 = await hashCache.hset('hash1', 'field1', 'value1_updated');
+      if (result2 !== true) {
+        throw new Error(`hset更新失败，预期: true, 实际: ${result2}`);
+      }
+      
+      const value = await hashCache.hget('hash1', 'field1');
+      if (value !== 'value1_updated') {
+        throw new Error(`hget失败，预期: value1_updated, 实际: ${value}`);
+      }
+      // 不存在字段返回 null，对齐 mm_redis
+      const value2 = await hashCache.hget('hash1', 'non_existent');
+      if (value2 !== null) {
+        throw new Error(`hget不存在字段预期: null, 实际: ${value2}`);
+      }
+    });
+    
+    await runner.runTest('hgetall方法', async () => {
+      await hashCache.hset('hash1', 'field2', 'value2');
+      const hash = await hashCache.hgetall('hash1');
+      if (JSON.stringify(hash) !== JSON.stringify({ field1: 'value1_updated', field2: 'value2' })) {
+        throw new Error(`hgetall失败，预期: {"field1":"value1_updated","field2":"value2"}, 实际: ${JSON.stringify(hash)}`);
+      }
+    });
+    
+    await runner.runTest('hdel方法（返回删除数量）', async () => {
+      // hdel 返回删除的字段数量，对齐 mm_redis
+      const result = await hashCache.hdel('hash1', 'field1');
+      if (result !== 1) {
+        throw new Error(`hdel失败，预期: 1, 实际: ${result}`);
+      }
+      const value = await hashCache.hget('hash1', 'field1');
+      if (value !== null) {
+        throw new Error(`hdel后字段未被删除，值: ${value}`);
+      }
+      
+      // 删除不存在的字段返回 0
+      const result2 = await hashCache.hdel('hash1', 'non_existent');
+      if (result2 !== 0) {
+        throw new Error(`hdel不存在字段失败，预期: 0, 实际: ${result2}`);
+      }
+    });
+    
+    // 测试批量操作
+    $.log.debug('[CacheBase] \n========== 测试批量操作 ==========');
+    const batchCache = new CacheBase({ scope: 'test_batch' });
+    
+    await runner.runTest('mset方法（对象参数）', async () => {
+      // mset 接受对象参数，对齐 mm_redis
+      const result = await batchCache.mset({ key7: 'value7', key8: 'value8' });
+      if (result !== true) {
+        throw new Error(`mset失败，预期: true, 实际: ${result}`);
+      }
+      const value7 = await batchCache.get('key7');
+      const value8 = await batchCache.get('key8');
+      if (value7 !== 'value7' || value8 !== 'value8') {
+        throw new Error(`mset设置失败，value7: ${value7}, value8: ${value8}`);
+      }
+    });
+    
+    await runner.runTest('mget方法', async () => {
+      const values = await batchCache.mget(['key7', 'key8', 'nonExistentKey']);
+      if (JSON.stringify(values) !== JSON.stringify(['value7', 'value8', null])) {
+        throw new Error(`mget失败，预期: ["value7","value8",null], 实际: ${JSON.stringify(values)}`);
+      }
+    });
+    
+    // 测试过期时间
+    $.log.debug('[CacheBase] \n========== 测试过期时间 ==========');
+    const expireCache = new CacheBase({ scope: 'test_expire' });
+    
+    await runner.runTest('set带过期时间', async () => {
+      await expireCache.set('expire1', 'value1', 1); // 1秒过期
+      let ttl = await expireCache.ttl('expire1');
+      if (ttl <= 0) {
+        throw new Error(`ttl初始值错误: ${ttl}`);
+      }
+      
+      // 等待过期
+      await new Promise(resolve => setTimeout(resolve, 1100));
+      
+      ttl = await expireCache.ttl('expire1');
+      if (ttl !== -2) {
+        throw new Error(`过期后ttl错误，预期: -2, 实际: ${ttl}`);
+      }
+      
+      const value = await expireCache.get('expire1');
+      if (value !== null) {
+        throw new Error(`过期后键仍存在: ${value}`);
+      }
+    });
+    
+    await runner.runTest('expire方法', async () => {
+      await expireCache.set('expire2', 'value2');
+      const result = await expireCache.expire('expire2', 1);
+      if (result !== true) {
+        throw new Error(`expire设置失败，预期: true, 实际: ${result}`);
+      }
+      let ttl = await expireCache.ttl('expire2');
+      if (ttl <= 0) {
+        throw new Error(`expire后ttl错误: ${ttl}`);
+      }
+    });
+    
+    await runner.runTest('persist方法', async () => {
+      await expireCache.set('expire3', 'value3', 30);
+      const result = await expireCache.persist('expire3');
+      if (result !== true) {
+        throw new Error(`persist设置失败，预期: true, 实际: ${result}`);
+      }
+      const ttl = await expireCache.ttl('expire3');
+      if (ttl !== -1) {
+        throw new Error(`persist后ttl错误，预期: -1, 实际: ${ttl}`);
+      }
+    });
+    
+    await runner.runTest('pexpire方法（毫秒过期）', async () => {
+      await expireCache.set('expire4', 'value4');
+      const result = await expireCache.pexpire('expire4', 500); // 500毫秒过期
+      if (result !== true) {
+        throw new Error(`pexpire设置失败，预期: true, 实际: ${result}`);
+      }
+      // 等待过期
+      await new Promise(resolve => setTimeout(resolve, 600));
+      const value = await expireCache.get('expire4');
+      if (value !== null) {
+        throw new Error(`pexpire过期后键仍存在: ${value}`);
+      }
+    });
+    
+    // 测试数值操作
+    $.log.debug('[CacheBase] \n========== 测试数值操作 ==========');
+    const numCache = new CacheBase({ scope: 'test_num' });
+    
+    await runner.runTest('incr方法', async () => {
+      const result1 = await numCache.incr('counter');
+      if (result1 !== 1) {
+        throw new Error(`incr初始值失败，预期: 1, 实际: ${result1}`);
+      }
+      const value1 = await numCache.get('counter');
+      if (value1 !== 1) {
+        throw new Error(`incr值错误，预期: 1, 实际: ${value1}`);
+      }
+      
+      const result2 = await numCache.incr('counter');
+      if (result2 !== 2) {
+        throw new Error(`incr递增失败，预期: 2, 实际: ${result2}`);
+      }
+    });
+    
+    await runner.runTest('decr方法', async () => {
+      const result = await numCache.decr('counter');
+      if (result !== 1) {
+        throw new Error(`decr递减失败，预期: 1, 实际: ${result}`);
+      }
+    });
+    
+    await runner.runTest('incrby方法（带seconds）', async () => {
+      // incrby 带 seconds 参数，对齐 mm_redis
+      const result = await numCache.incrby('counter', 5);
+      if (result !== 6) {
+        throw new Error(`incrby增加失败，预期: 6, 实际: ${result}`);
+      }
+      // 测试带 TTL 的 incrby
+      const result2 = await numCache.incrby('counter_ttl', 10, 100);
+      if (result2 !== 10) {
+        throw new Error(`incrby带TTL失败，预期: 10, 实际: ${result2}`);
+      }
+      const ttl = await numCache.ttl('counter_ttl');
+      if (ttl <= 0 || ttl > 100) {
+        throw new Error(`incrby带TTL的ttl错误: ${ttl}`);
+      }
+    });
+    
+    await runner.runTest('decrby方法（带seconds）', async () => {
+      const result = await numCache.decrby('counter', 2);
+      if (result !== 4) {
+        throw new Error(`decrby减少失败，预期: 4, 实际: ${result}`);
+      }
+    });
+    
+    await runner.runTest('incrbyfloat方法', async () => {
+      const result = await numCache.incrbyfloat('counter', 0.5);
+      if (result !== 4.5) {
+        throw new Error(`incrbyfloat增加失败，预期: 4.5, 实际: ${result}`);
+      }
+    });
+    
+    await runner.runTest('add方法（兼容）', async () => {
+      await numCache.del('counter');
+      const result = await numCache.add('counter', 10);
+      if (result !== true) {
+        throw new Error(`add增加失败，预期: true, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 10) {
+        throw new Error(`add增加后值错误，预期: 10, 实际: ${value}`);
+      }
+      
+      const result2 = await numCache.add('counter', 20);
+      if (result2 !== false) {
+        throw new Error(`add键已存在时失败，预期: false, 实际: ${result2}`);
+      }
+    });
+    
+    await runner.runTest('addFloat方法（兼容）', async () => {
+      const result = await numCache.addFloat('counter', 0.5);
+      if (result !== 10.5) {
+        throw new Error(`addFloat增加失败，预期: 10.5, 实际: ${result}`);
+      }
+    });
+    
+    // 测试字符串操作
+    $.log.debug('[CacheBase] \n========== 测试字符串操作 ==========');
+    const strCache = new CacheBase({ scope: 'test_str' });
+    
+    await runner.runTest('append方法', async () => {
+      await strCache.set('str', 'hello');
+      const result = await strCache.append('str', ' world');
+      if (result !== 11) {
+        throw new Error(`append长度错误，预期: 11, 实际: ${result}`);
+      }
+      const value = await strCache.get('str');
+      if (value !== 'hello world') {
+        throw new Error(`append值错误，预期: hello world, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('strlen方法', async () => {
+      const result = await strCache.strlen('str');
+      if (result !== 11) {
+        throw new Error(`strlen长度错误，预期: 11, 实际: ${result}`);
+      }
+      const result2 = await strCache.strlen('non_existent');
+      if (result2 !== 0) {
+        throw new Error(`strlen不存在键错误，预期: 0, 实际: ${result2}`);
+      }
+    });
+    
+    await runner.runTest('setrange方法（原addStr）', async () => {
+      // addStr 已重命名为 setrange，对齐 mm_redis
+      const result = await strCache.setrange('str', '!');
+      if (result !== 12) {
+        throw new Error(`setrange长度错误，预期: 12, 实际: ${result}`);
+      }
+      const value = await strCache.get('str');
+      if (value !== 'hello world!') {
+        throw new Error(`setrange值错误，预期: hello world!, 实际: ${value}`);
+      }
+    });
+    
+    // 测试集合操作
+    $.log.debug('[CacheBase] \n========== 测试集合操作 ==========');
+    const setCache = new CacheBase({ scope: 'test_set' });
+    
+    await runner.runTest('sadd/smembers/scard方法', async () => {
+      const added = await setCache.sadd('set1', ['a', 'b', 'c']);
+      if (added !== 3) {
+        throw new Error(`sadd失败，预期: 3, 实际: ${added}`);
+      }
+      // 重复添加返回 0
+      const added2 = await setCache.sadd('set1', ['a', 'd']);
+      if (added2 !== 1) {
+        throw new Error(`sadd重复失败，预期: 1, 实际: ${added2}`);
+      }
+      const members = await setCache.smembers('set1');
+      if (members.length !== 4 || !members.includes('a') || !members.includes('d')) {
+        throw new Error(`smembers失败，实际: ${JSON.stringify(members)}`);
+      }
+      const card = await setCache.scard('set1');
+      if (card !== 4) {
+        throw new Error(`scard失败，预期: 4, 实际: ${card}`);
+      }
+    });
+    
+    await runner.runTest('sismember方法', async () => {
+      const result1 = await setCache.sismember('set1', 'a');
+      if (result1 !== true) {
+        throw new Error(`sismember失败，预期: true, 实际: ${result1}`);
+      }
+      const result2 = await setCache.sismember('set1', 'z');
+      if (result2 !== false) {
+        throw new Error(`sismember不存在预期: false, 实际: ${result2}`);
+      }
+    });
+    
+    await runner.runTest('srem方法', async () => {
+      const removed = await setCache.srem('set1', ['a', 'b']);
+      if (removed !== 2) {
+        throw new Error(`srem失败，预期: 2, 实际: ${removed}`);
+      }
+      const card = await setCache.scard('set1');
+      if (card !== 2) {
+        throw new Error(`srem后scard失败，预期: 2, 实际: ${card}`);
+      }
+    });
+    
+    await runner.runTest('sinter/sunion/sdiff方法', async () => {
+      await setCache.sadd('setA', ['1', '2', '3']);
+      await setCache.sadd('setB', ['2', '3', '4']);
+      
+      const inter = await setCache.sinter('setA', 'setB');
+      if (inter.length !== 2 || !inter.includes('2') || !inter.includes('3')) {
+        throw new Error(`sinter失败，实际: ${JSON.stringify(inter)}`);
+      }
+      
+      const union = await setCache.sunion('setA', 'setB');
+      if (union.length !== 4) {
+        throw new Error(`sunion失败，预期长度4, 实际: ${JSON.stringify(union)}`);
+      }
+      
+      const diff = await setCache.sdiff('setA', 'setB');
+      if (diff.length !== 1 || diff[0] !== '1') {
+        throw new Error(`sdiff失败，实际: ${JSON.stringify(diff)}`);
+      }
+    });
+    
+    // 测试有序集合操作
+    $.log.debug('[CacheBase] \n========== 测试有序集合操作 ==========');
+    const zsetCache = new CacheBase({ scope: 'test_zset' });
+    
+    await runner.runTest('zadd/zcard/zscore方法', async () => {
+      const added1 = await zsetCache.zadd('zset1', 10, 'member1');
+      if (added1 !== true) {
+        throw new Error(`zadd新成员失败，预期: true, 实际: ${added1}`);
+      }
+      const added2 = await zsetCache.zadd('zset1', 20, 'member2');
+      if (added2 !== true) {
+        throw new Error(`zadd新成员2失败，预期: true, 实际: ${added2}`);
+      }
+      // 更新已有成员返回 false
+      const added3 = await zsetCache.zadd('zset1', 15, 'member1');
+      if (added3 !== false) {
+        throw new Error(`zadd更新成员失败，预期: false, 实际: ${added3}`);
+      }
+      const card = await zsetCache.zcard('zset1');
+      if (card !== 2) {
+        throw new Error(`zcard失败，预期: 2, 实际: ${card}`);
+      }
+      const score = await zsetCache.zscore('zset1', 'member1');
+      if (score !== 15) {
+        throw new Error(`zscore失败，预期: 15, 实际: ${score}`);
+      }
+    });
+    
+    await runner.runTest('zrank/zrange方法', async () => {
+      const rank1 = await zsetCache.zrank('zset1', 'member1');
+      if (rank1 !== 0) {
+        throw new Error(`zrank失败，预期: 0, 实际: ${rank1}`);
+      }
+      const range = await zsetCache.zrange('zset1', 0, -1);
+      if (range.length !== 2 || range[0] !== 'member1' || range[1] !== 'member2') {
+        throw new Error(`zrange失败，实际: ${JSON.stringify(range)}`);
+      }
+      const rangeWithScores = await zsetCache.zrange('zset1', 0, -1, true);
+      if (rangeWithScores.length !== 2 || rangeWithScores[0].member !== 'member1' || rangeWithScores[0].score !== 15) {
+        throw new Error(`zrange带分数失败，实际: ${JSON.stringify(rangeWithScores)}`);
+      }
+    });
+    
+    await runner.runTest('zincrby/zrem方法', async () => {
+      const newScore = await zsetCache.zincrby('zset1', 5, 'member1');
+      if (newScore !== 20) {
+        throw new Error(`zincrby失败，预期: 20, 实际: ${newScore}`);
+      }
+      const removed = await zsetCache.zrem('zset1', 'member1');
+      if (removed !== 1) {
+        throw new Error(`zrem失败，预期: 1, 实际: ${removed}`);
+      }
+      const card = await zsetCache.zcard('zset1');
+      if (card !== 1) {
+        throw new Error(`zrem后zcard失败，预期: 1, 实际: ${card}`);
+      }
+    });
+    
+    // 测试发布订阅
+    $.log.debug('[CacheBase] \n========== 测试发布订阅 ==========');
+    
+    await runner.runTest('subscribe/publish方法', async () => {
+      const pubsubCache = new CacheBase({ scope: 'test_pubsub' });
+      let receivedMessage = null;
+      await pubsubCache.subscribe('channel1', (msg) => {
+        receivedMessage = msg;
+      });
+      const count = await pubsubCache.publish('channel1', 'hello');
+      if (count !== 1) {
+        throw new Error(`publish接收者数量失败，预期: 1, 实际: ${count}`);
+      }
+      if (receivedMessage !== 'hello') {
+        throw new Error(`订阅未收到消息，预期: hello, 实际: ${receivedMessage}`);
+      }
+    });
+    
+    await runner.runTest('unsubscribe方法', async () => {
+      const pubsubCache = new CacheBase({ scope: 'test_unsub' });
+      let received = false;
+      await pubsubCache.subscribe('channel2', () => { received = true; });
+      await pubsubCache.unsubscribe('channel2');
+      const count = await pubsubCache.publish('channel2', 'hello');
+      if (count !== 0) {
+        throw new Error(`unsubscribe后publish预期: 0, 实际: ${count}`);
+      }
+      if (received) {
+        throw new Error(`unsubscribe后仍收到消息`);
+      }
+    });
+    
+    // 测试事件触发（冒号风格）
+    $.log.debug('[CacheBase] \n========== 测试事件触发（冒号风格） ==========');
+    const eventCache = new CacheBase({ scope: 'test_event' });
+    
+    await runner.runTest('set事件触发（冒号风格）', async () => {
+      return new Promise(async (resolve, reject) => {
+        let beforeTriggered = false;
+        let afterTriggered = false;
+        
+        // 事件名改为冒号风格，对齐 mm_redis
+        eventCache.once('set:before', (data) => {
+          if (data.key === 'event_key' && data.value === 'event_value') {
+            beforeTriggered = true;
+          }
+        });
+        
+        eventCache.once('set:after', (data) => {
+          if (data.key === 'event_key' && data.value === 'event_value' && data.success === true) {
+            afterTriggered = true;
+            setTimeout(() => {
+              if (beforeTriggered && afterTriggered) {
+                resolve();
+              } else {
+                reject(new Error('set事件未全部触发'));
+              }
+            }, 10);
+          }
+        });
+        
+        await eventCache.set('event_key', 'event_value');
+      });
+    });
+    
+    await runner.runTest('error事件触发（冒号风格）', async () => {
+      return new Promise(async (resolve, reject) => {
+        // 事件名改为冒号风格
+        eventCache.once('mset:error', (data) => {
+          if (data.error) {
+            resolve();
+          } else {
+            reject(new Error('mset:error事件触发但数据不正确'));
+          }
+        });
+        
+        // 传入非法参数触发错误，mset 内部 catch 后返回 false 并触发 mset:error 事件
+        const result = await eventCache.mset(null);
+        if (result !== false) {
+          reject(new Error(`mset应返回false但返回: ${result}`));
+        }
+        // 超时保护，若事件未触发则失败
+        setTimeout(() => {
+          reject(new Error('mset:error事件未触发'));
+        }, 100);
+      });
+    });
+    
+    // 测试管理功能
+    $.log.debug('[CacheBase] \n========== 测试管理功能 ==========');
+    
+    await runner.runTest('cachebaseAdmin创建实例', async () => {
+      const cache1 = cachebaseAdmin('test_scope');
+      const cache2 = cachebaseAdmin('test_scope');
+      if (cache1 !== cache2) {
+        throw new Error('cachebaseAdmin应返回相同实例但没有');
+      }
+      
+      const cache3 = cachebaseAdmin('another_scope');
+      if (cache1 === cache3) {
+        throw new Error('cachebaseAdmin应返回不同作用域的不同实例但没有');
+      }
+    });
+    
+    await runner.runTest('dispose方法', async () => {
+      const disposeCache = new CacheBase({ 
+        persist: false,
+        scope: 'test_dispose' 
+      });
+      await disposeCache.set('key_to_dispose', 'value');
+      disposeCache.dispose();
+      
+      const size = await disposeCache.dbsize();
+      if (size !== 0) {
+        throw new Error(`dispose后大小不为0: ${size}`);
+      }
+    });
+    
+    // 显示测试结果
+    const passRate = runner.displayResults();
+    $.log.debug(`[CacheBase] \n测试完成！通过率: ${passRate}%`);
+    
+    $.log.debug('[CacheBase] \n==============================');
+    $.log.debug('[CacheBase] 所有兼容性测试完成!');
+    $.log.debug('[CacheBase] ==============================');
+    
+  } catch (error) {
+    $.log.error('[CacheBase] 测试过程中出现错误:', error);
+  }
+}
+
+test().then(() => {
+  // 测试成功完成
+  $.log.debug('[CacheBase] 测试脚本正常退出');
+  process.exit(0);
+}).catch(err => {
+  $.log.error('[CacheBase] 未捕获的错误:', err);
+  process.exit(1);
+});
+
+// 添加超时保护
+setTimeout(() => {
+  $.log.warn('[CacheBase] 测试脚本超时');
+  process.exit(1);
+}, 15000); // 15秒超时