mm_cachebase 1.8.4 → 1.8.6

package/test_compatibility_fixes.js

@@ -0,0 +1,272 @@
+const { CacheBase } = require('./index');
+
+/**
+ * 测试CacheBase方法与Redis的兼容性
+ */
+async function testCompatibilityFixes() {
+  console.log('开始测试兼容性修复...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_compatibility', { persist: false });
+  
+  // 测试计数器
+  let passed = 0;
+  let total = 0;
+  
+  // 测试函数
+  const test = async (name, testFn) => {
+    total++;
+    console.log(`\n测试 ${name}...`);
+    try {
+      await testFn();
+      passed++;
+      console.log(`✅ ${name} 通过`);
+    } catch (error) {
+      console.error(`❌ ${name} 失败:`, error);
+    }
+  };
+  
+  try {
+    // 测试set方法
+    await test('set方法兼容性', async () => {
+      // 测试基本设置
+      const result = await cache.set('test:set', 'value');
+      if (result !== 'OK') {
+        throw new Error(`set应返回'OK'，但得到了${result}`);
+      }
+      
+      const value = await cache.get('test:set');
+      if (value !== 'value') {
+        throw new Error(`设置的值与获取的值不匹配: ${value}`);
+      }
+      
+      // 测试带过期时间
+      await cache.set('test:set:expire', 'expire_value', 1);
+      const expireValue = await cache.get('test:set:expire');
+      if (expireValue !== 'expire_value') {
+        throw new Error(`带过期时间的set失败: ${expireValue}`);
+      }
+    });
+    
+    // 测试del方法
+    await test('del方法兼容性', async () => {
+      // 设置测试键
+      await cache.set('test:del', 'del_value');
+      
+      // 删除存在的键
+      const deleted = await cache.del('test:del');
+      if (deleted !== 1) {
+        throw new Error(`删除存在的键应返回1，但得到了${deleted}`);
+      }
+      
+      // 验证键已删除
+      const value = await cache.get('test:del');
+      if (value !== undefined) {
+        throw new Error(`键应已删除，但仍然存在: ${value}`);
+      }
+      
+      // 删除不存在的键
+      const deletedNonExistent = await cache.del('test:del:non_existent');
+      if (deletedNonExistent !== 0) {
+        throw new Error(`删除不存在的键应返回0，但得到了${deletedNonExistent}`);
+      }
+    });
+    
+    // 测试clear方法
+    await test('clear方法兼容性', async () => {
+      // 设置测试键
+      await cache.set('test:clear:1', 'value1');
+      await cache.set('test:clear:2', 'value2');
+      await cache.set('other:key', 'other_value');
+      
+      // 测试带模式的clear
+      const result1 = await cache.clear('test:clear:*');
+      if (result1 !== 'OK') {
+        throw new Error(`带模式的clear应返回'OK'，但得到了${result1}`);
+      }
+      
+      // 验证匹配的键已删除，其他键保留
+      const value1 = await cache.get('test:clear:1');
+      const value2 = await cache.get('test:clear:2');
+      const otherValue = await cache.get('other:key');
+      
+      if (value1 !== undefined || value2 !== undefined || otherValue !== 'other_value') {
+        throw new Error(`clear模式匹配失败: value1=${value1}, value2=${value2}, otherValue=${otherValue}`);
+      }
+      
+      // 测试清空所有
+      const result2 = await cache.clear();
+      if (result2 !== 'OK') {
+        throw new Error(`清空所有的clear应返回'OK'，但得到了${result2}`);
+      }
+      
+      // 验证所有键已删除
+      const afterClear = await cache.get('other:key');
+      if (afterClear !== undefined) {
+        throw new Error(`clear应清空所有键，但键仍然存在: ${afterClear}`);
+      }
+    });
+    
+    // 测试exists方法
+    await test('exists方法兼容性', async () => {
+      // 设置测试键
+      await cache.set('test:exists:1', 'value1');
+      await cache.set('test:exists:2', 'value2');
+      
+      // 测试单键存在
+      const exists1 = await cache.exists('test:exists:1');
+      if (exists1 !== 1) {
+        throw new Error(`exists应返回1表示键存在，但得到了${exists1}`);
+      }
+      
+      // 测试单键不存在
+      const existsNonExistent = await cache.exists('test:exists:non_existent');
+      if (existsNonExistent !== 0) {
+        throw new Error(`exists应返回0表示键不存在，但得到了${existsNonExistent}`);
+      }
+      
+      // 测试多键存在
+      const existsMultiple = await cache.exists(['test:exists:1', 'test:exists:2', 'test:exists:non_existent']);
+      if (existsMultiple !== 2) {
+        throw new Error(`多键exists应返回存在的键数量2，但得到了${existsMultiple}`);
+      }
+    });
+    
+    // 测试hset方法
+    await test('hset方法兼容性', async () => {
+      // 测试创建新字段
+      const newFieldResult = await cache.hset('test:hash', 'field1', 'value1');
+      if (newFieldResult !== 1) {
+        throw new Error(`hset创建新字段应返回1，但得到了${newFieldResult}`);
+      }
+      
+      // 验证字段值
+      const field1Value = await cache.hget('test:hash', 'field1');
+      if (field1Value !== 'value1') {
+        throw new Error(`hset设置的字段值与获取的值不匹配: ${field1Value}`);
+      }
+      
+      // 测试更新现有字段
+      const updateFieldResult = await cache.hset('test:hash', 'field1', 'updated_value');
+      if (updateFieldResult !== 0) {
+        throw new Error(`hset更新字段应返回0，但得到了${updateFieldResult}`);
+      }
+      
+      // 验证更新后的值
+      const updatedValue = await cache.hget('test:hash', 'field1');
+      if (updatedValue !== 'updated_value') {
+        throw new Error(`hset更新的值与获取的值不匹配: ${updatedValue}`);
+      }
+    });
+    
+    // 测试ttl方法
+    await test('ttl方法兼容性', async () => {
+      // 测试永不过期的键
+      await cache.set('test:ttl:never', 'never_expire');
+      const ttlNever = await cache.ttl('test:ttl:never');
+      if (ttlNever !== -1) {
+        throw new Error(`永不过期的键ttl应返回-1，但得到了${ttlNever}`);
+      }
+      
+      // 测试带过期时间的键
+      await cache.set('test:ttl:expire', 'expire_value', 5);
+      const ttlExpire = await cache.ttl('test:ttl:expire');
+      if (ttlExpire < 0 || ttlExpire > 5) {
+        throw new Error(`带过期时间的键ttl应在0-5之间，但得到了${ttlExpire}`);
+      }
+      
+      // 测试不存在的键
+      const ttlNonExistent = await cache.ttl('test:ttl:non_existent');
+      if (ttlNonExistent !== -2) {
+        throw new Error(`不存在的键ttl应返回-2，但得到了${ttlNonExistent}`);
+      }
+    });
+    
+    // 测试decr方法
+    await test('decr方法兼容性', async () => {
+      // 测试不存在的键（初始化为0后减1）
+      const result1 = await cache.decr('test:decr:new');
+      if (result1 !== -1) {
+        throw new Error(`decr不存在的键应返回-1，但得到了${result1}`);
+      }
+      
+      // 测试已存在的数字键
+      await cache.set('test:decr:number', 5);
+      const result2 = await cache.decr('test:decr:number');
+      if (result2 !== 4) {
+        throw new Error(`decr数字键应返回4，但得到了${result2}`);
+      }
+      
+      // 测试非数字值（应视为0）
+      await cache.set('test:decr:string', 'not_a_number');
+      const result3 = await cache.decr('test:decr:string');
+      if (result3 !== -1) {
+        throw new Error(`decr非数字值应返回-1，但得到了${result3}`);
+      }
+    });
+    
+    // 测试mset方法
+    await test('mset方法兼容性', async () => {
+      // 测试批量设置
+      const result = await cache.mset({
+        'test:mset:1': 'value1',
+        'test:mset:2': 'value2',
+        'test:mset:3': 'value3'
+      });
+      
+      if (result !== 'OK') {
+        throw new Error(`mset应返回'OK'，但得到了${result}`);
+      }
+      
+      // 验证设置的值
+      const value1 = await cache.get('test:mset:1');
+      const value2 = await cache.get('test:mset:2');
+      const value3 = await cache.get('test:mset:3');
+      
+      if (value1 !== 'value1' || value2 !== 'value2' || value3 !== 'value3') {
+        throw new Error(`mset设置的值与获取的值不匹配: value1=${value1}, value2=${value2}, value3=${value3}`);
+      }
+    });
+    
+    // 测试mget方法
+    await test('mget方法兼容性', async () => {
+      // 确保测试键存在
+      await cache.set('test:mget:1', 'value1');
+      await cache.set('test:mget:2', 'value2');
+      
+      // 测试批量获取
+      const results = await cache.mget(['test:mget:1', 'test:mget:2', 'test:mget:non_existent']);
+      
+      if (!Array.isArray(results)) {
+        throw new Error(`mget应返回数组，但得到了${typeof results}`);
+      }
+      
+      if (results.length !== 3) {
+        throw new Error(`mget应返回长度为3的数组，但得到了长度${results.length}`);
+      }
+      
+      if (results[0] !== 'value1' || results[1] !== 'value2' || results[2] !== undefined) {
+        throw new Error(`mget返回的值与预期不符: ${JSON.stringify(results)}`);
+      }
+    });
+    
+    // 清理测试数据
+    await cache.clear();
+    await cache.dispose();
+    
+    // 输出测试结果
+    console.log(`\n测试完成: ${passed}/${total} 测试通过`);
+    if (passed === total) {
+      console.log('🎉 所有兼容性修复测试通过!');
+    } else {
+      console.log(`❌ 有 ${total - passed} 个测试失败`);
+    }
+    
+  } catch (error) {
+    console.error('测试过程中发生错误:', error);
+    await cache.dispose();
+  }
+}
+
+// 运行测试
+testCompatibilityFixes();

package/test_compatibility_improvements.js

@@ -0,0 +1,147 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+async function testCompatibility() {
+  console.log('开始测试兼容性改进...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_compatibility');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 set 方法兼容性');
+    // 测试set方法
+    const setResult = await cache.set('test_key', 'test_value');
+    assert.strictEqual(setResult, 'OK', 'set方法应返回OK');
+    const getResult = await cache.get('test_key');
+    assert.strictEqual(getResult, 'test_value', 'set方法设置的值应正确');
+    console.log('✓ set 方法测试通过');
+    
+    console.log('\n2. 测试 del 方法兼容性');
+    // 测试del方法删除存在的键
+    const delResult1 = await cache.del('test_key');
+    assert.strictEqual(delResult1, 1, 'del方法应返回删除的键数量1');
+    const exists1 = await cache.exists('test_key');
+    assert.strictEqual(exists1, 0, '删除的键不应再存在');
+    
+    // 测试del方法删除不存在的键
+    const delResult2 = await cache.del('non_existent_key');
+    assert.strictEqual(delResult2, 0, '删除不存在的键应返回0');
+    console.log('✓ del 方法测试通过');
+    
+    console.log('\n3. 测试 exists 方法兼容性');
+    // 设置一些测试键
+    await cache.set('exists_key1', 'value1');
+    await cache.set('exists_key2', 'value2', 1); // 1秒过期
+    
+    // 测试单个键存在
+    const existsResult1 = await cache.exists('exists_key1');
+    assert.strictEqual(existsResult1, 1, 'exists方法应返回存在的键数量1');
+    
+    // 测试多个键存在
+    const existsResult2 = await cache.exists(['exists_key1', 'exists_key2', 'non_existent']);
+    assert.strictEqual(existsResult2, 2, 'exists方法应返回存在的键数量2');
+    
+    // 测试不存在的键
+    const existsResult3 = await cache.exists('non_existent');
+    assert.strictEqual(existsResult3, 0, '不存在的键应返回0');
+    console.log('✓ exists 方法测试通过');
+    
+    console.log('\n4. 测试 ttl 方法兼容性');
+    // 设置带过期时间的键
+    await cache.set('ttl_key', 'ttl_value', 10); // 10秒过期
+    
+    // 测试永不过期的键
+    await cache.set('ttl_key_forever', 'forever_value');
+    const ttlForever = await cache.ttl('ttl_key_forever');
+    assert.strictEqual(ttlForever, -1, '永不过期的键ttl应返回-1');
+    
+    // 测试存在但已过期的键
+    await cache.set('ttl_key_expire', 'expire_value', 1); // 1秒过期
+    await new Promise(resolve => setTimeout(resolve, 1500)); // 等待过期
+    const ttlExpired = await cache.ttl('ttl_key_expire');
+    assert.strictEqual(ttlExpired, -2, '已过期的键ttl应返回-2');
+    
+    // 测试不存在的键
+    const ttlNonExistent = await cache.ttl('non_existent_ttl');
+    assert.strictEqual(ttlNonExistent, -2, '不存在的键ttl应返回-2');
+    
+    // 测试有过期时间的键
+    await cache.set('ttl_key_with_ttl', 'value_with_ttl', 2); // 2秒过期
+    const ttlWithTtl = await cache.ttl('ttl_key_with_ttl');
+    assert.ok(ttlWithTtl >= 0 && ttlWithTtl <= 2, '有过期时间的键应返回剩余秒数');
+    console.log('✓ ttl 方法测试通过');
+    
+    console.log('\n5. 测试 clear 方法兼容性');
+    // 设置一些测试键
+    await cache.set('clear_key1', 'value1');
+    await cache.set('clear_key2', 'value2');
+    await cache.set('test_pattern1', 'pattern1');
+    await cache.set('test_pattern2', 'pattern2');
+    
+    // 测试模式匹配清除
+    await cache.clear('test_pattern*');
+    const existsPattern1 = await cache.exists('test_pattern1');
+    const existsPattern2 = await cache.exists('test_pattern2');
+    const existsClear1 = await cache.exists('clear_key1');
+    assert.strictEqual(existsPattern1, 0, '模式匹配的键应被清除');
+    assert.strictEqual(existsPattern2, 0, '模式匹配的键应被清除');
+    assert.strictEqual(existsClear1, 1, '非模式匹配的键应保留');
+    
+    // 测试全部清除
+    await cache.clear();
+    const existsAfterClear = await cache.exists(['clear_key1', 'clear_key2']);
+    assert.strictEqual(existsAfterClear, 0, 'clear方法应清除所有键');
+    console.log('✓ clear 方法测试通过');
+    
+    // 新添加的测试：addInt、addStr、addFloat、mset、mget
+    console.log('\n6. 测试 addInt 方法兼容性');
+    const intResult1 = await cache.addInt('int_key', 10);
+    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
+    const intResult2 = await cache.addInt('int_key', 5);
+    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
+    console.log('✓ addInt 方法测试通过');
+    
+    console.log('\n7. 测试 addStr 方法兼容性');
+    const strResult1 = await cache.addStr('str_key', 'hello');
+    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
+    const strResult2 = await cache.addStr('str_key', ' world');
+    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
+    console.log('✓ addStr 方法测试通过');
+    
+    console.log('\n8. 测试 addFloat 方法兼容性');
+    const floatResult1 = await cache.addFloat('float_key', 10.5);
+    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
+    const floatResult2 = await cache.addFloat('float_key', 2.5);
+    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
+    console.log('✓ addFloat 方法测试通过');
+    
+    console.log('\n9. 测试 mset 方法兼容性');
+    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
+    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
+    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
+    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
+    console.log('✓ mset 方法测试通过');
+    
+    console.log('\n10. 测试 mget 方法兼容性');
+    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
+    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
+    console.log('✓ mget 方法测试通过');
+    
+    console.log('\n所有兼容性测试通过!');
+    return true;
+  } catch (error) {
+    console.error('测试失败:', error);
+    return false;
+  } finally {
+    // 清理测试数据
+    await cache.clear();
+    await cache.save();
+  }
+}
+
+// 运行测试
+testCompatibility().then(success => {
+  process.exit(success ? 0 : 1);
+});

package/test_list_and_decr_compatibility.js

@@ -0,0 +1,99 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+async function testCompatibilityImprovements() {
+  console.log('开始测试兼容性改进方法...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_compatibility_methods');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 decr 方法兼容性');
+    // 测试decr方法初始值
+    const decrResult1 = await cache.decr('decr_key');
+    assert.strictEqual(decrResult1, -1, 'decr初始值应为-1');
+    
+    // 测试decr方法增加值
+    const decrResult2 = await cache.decr('decr_key');
+    assert.strictEqual(decrResult2, -2, 'decr减少后应为-2');
+    
+    // 测试已有数值的decr
+    await cache.set('decr_existing', 5);
+    const decrResult3 = await cache.decr('decr_existing');
+    assert.strictEqual(decrResult3, 4, '现有数值decr后应为4');
+    console.log('✓ decr 方法测试通过');
+    
+    console.log('\n2. 测试 list_set 方法兼容性');
+    // 测试list_set返回列表长度
+    const listSetResult1 = await cache.list_set('list_key', ['item1', 'item2']);
+    assert.strictEqual(listSetResult1, 2, 'list_set应返回列表长度');
+    
+    // 测试非数组值
+    const listSetResult2 = await cache.list_set('list_key_single', 'single_item');
+    assert.strictEqual(listSetResult2, 1, '非数组值list_set应返回1');
+    const listContent = await cache.list_get('list_key_single');
+    assert.deepStrictEqual(listContent, ['single_item'], '非数组值应被包装为数组');
+    console.log('✓ list_set 方法测试通过');
+    
+    console.log('\n3. 测试 list_add 方法兼容性');
+    // 测试list_add返回列表长度
+    await cache.list_set('add_list', ['initial']);
+    const listAddResult1 = await cache.list_add('add_list', 'new_item');
+    assert.strictEqual(listAddResult1, 2, 'list_add应返回添加后列表长度');
+    
+    // 测试空列表添加
+    const listAddResult2 = await cache.list_add('new_list', 'first_item');
+    assert.strictEqual(listAddResult2, 1, '空列表添加应返回1');
+    console.log('✓ list_add 方法测试通过');
+    
+    console.log('\n4. 测试 list_has 方法兼容性');
+    // 设置测试列表
+    await cache.list_set('has_list', ['item1', 'item2', 'item3']);
+    
+    // 测试存在的项
+    const hasResult1 = await cache.list_has('has_list', 'item2');
+    assert.strictEqual(hasResult1, 1, '存在的项应返回1');
+    
+    // 测试不存在的项
+    const hasResult2 = await cache.list_has('has_list', 'item4');
+    assert.strictEqual(hasResult2, 0, '不存在的项应返回0');
+    
+    // 测试不存在的键
+    const hasResult3 = await cache.list_has('non_existent_list', 'anything');
+    assert.strictEqual(hasResult3, 0, '不存在的键应返回0');
+    console.log('✓ list_has 方法测试通过');
+    
+    console.log('\n5. 测试 list_get 方法兼容性');
+    // 设置测试列表
+    await cache.list_set('range_list', ['item0', 'item1', 'item2', 'item3', 'item4']);
+    
+    // 测试全量获取
+    const getResult1 = await cache.list_get('range_list');
+    assert.deepStrictEqual(getResult1, ['item0', 'item1', 'item2', 'item3', 'item4'], '默认应返回全部元素');
+    
+    // 测试范围获取
+    const getResult2 = await cache.list_get('range_list', 1, 3);
+    assert.deepStrictEqual(getResult2, ['item1', 'item2', 'item3'], '范围获取应返回指定元素');
+    
+    // 测试起始索引获取
+    const getResult3 = await cache.list_get('range_list', 2);
+    assert.deepStrictEqual(getResult3, ['item2', 'item3', 'item4'], '只指定起始索引应返回从该索引到末尾');
+    
+    // 测试不存在的键
+    const getResult4 = await cache.list_get('non_existent_range');
+    assert.deepStrictEqual(getResult4, [], '不存在的键应返回空数组');
+    console.log('✓ list_get 方法测试通过');
+    
+    // 清理测试数据
+    await cache.clear();
+    console.log('\n所有兼容性改进方法测试通过!');
+    
+  } catch (error) {
+    console.error('兼容性改进方法测试失败:', error);
+    process.exit(1);
+  }
+}
+
+testCompatibilityImprovements();

package/test_undocumented_methods.js

@@ -0,0 +1,57 @@
+const assert = require('assert');
+const { CacheBase } = require('./index');
+
+async function testUndocumentedMethods() {
+  console.log('开始测试文档与实现不一致的方法...');
+  
+  // 创建缓存实例
+  const cache = new CacheBase('test_undocumented');
+  
+  try {
+    // 清空之前的测试数据
+    await cache.clear();
+    
+    console.log('\n1. 测试 addInt 方法');
+    const intResult1 = await cache.addInt('int_key', 10);
+    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
+    const intResult2 = await cache.addInt('int_key', 5);
+    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
+    console.log('✓ addInt 方法测试通过');
+    
+    console.log('\n2. 测试 addStr 方法');
+    const strResult1 = await cache.addStr('str_key', 'hello');
+    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
+    const strResult2 = await cache.addStr('str_key', ' world');
+    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
+    console.log('✓ addStr 方法测试通过');
+    
+    console.log('\n3. 测试 addFloat 方法');
+    const floatResult1 = await cache.addFloat('float_key', 10.5);
+    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
+    const floatResult2 = await cache.addFloat('float_key', 2.5);
+    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
+    console.log('✓ addFloat 方法测试通过');
+    
+    console.log('\n4. 测试 mset 方法');
+    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
+    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
+    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
+    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
+    console.log('✓ mset 方法测试通过');
+    
+    console.log('\n5. 测试 mget 方法');
+    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
+    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
+    console.log('✓ mget 方法测试通过');
+    
+    // 清理测试数据
+    await cache.clear();
+    console.log('\n所有测试通过！');
+    
+  } catch (error) {
+    console.error('测试失败:', error);
+    process.exit(1);
+  }
+}
+
+testUndocumentedMethods();