mm_cachebase 1.5.0 → 1.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mm_cachebase",
-    "version": "1.5.0",
-    "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统。",
+    "version": "1.7.0",
+    "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统和多文件持久化功能。",
     "main": "index.js",
     "scripts": {
         "test": "node test.js"
@@ -27,7 +27,10 @@
         "ttl",
         "expire",
         "incr",
-        "decr"
+        "decr",
+        "persistence",
+        "persist",
+        "scope"
     ],
     "author": "邱文武",
     "license": "MIT",

package/simple_test.js

@@ -0,0 +1,70 @@
+const { CacheBase } = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+async function simpleTest() {
+  console.log('====== 简单持久化测试 ======');
+  
+  const cacheDir = './test_simple_cache';
+  const cacheFile = path.join(cacheDir, 'simple_cache.json');
+  
+  // 清理之前的测试文件
+  if (fs.existsSync(cacheFile)) {
+    fs.unlinkSync(cacheFile);
+    console.log('已清理旧测试文件');
+  }
+  
+  // 步骤1: 创建缓存并设置数据
+  console.log('\n步骤1: 创建缓存并设置数据');
+  const cache = new CacheBase({
+    persist: true,
+    scope: 'simple',
+    dir: cacheDir
+  });
+  
+  // 直接设置数据
+  console.log('设置数据...');
+  cache.data['test_key'] = { value: 'test_value', expire: 0 };
+  cache.list = ['test_key'];
+  console.log('当前data:', cache.data);
+  console.log('当前list:', cache.list);
+  
+  // 步骤2: 手动保存
+  console.log('\n步骤2: 手动保存数据');
+  await cache.save();
+  
+  // 检查文件是否存在且有内容
+  if (fs.existsSync(cacheFile)) {
+    const content = fs.readFileSync(cacheFile, 'utf8');
+    console.log('保存的文件内容:');
+    console.log(content);
+  } else {
+    console.log('错误: 文件未创建');
+  }
+  
+  // 步骤3: 销毁缓存
+  console.log('\n步骤3: 销毁缓存');
+  await cache.dispose();
+  
+  // 步骤4: 创建新缓存，应该加载数据
+  console.log('\n步骤4: 创建新缓存，尝试加载数据');
+  const newCache = new CacheBase({
+    persist: true,
+    scope: 'simple',
+    dir: cacheDir
+  });
+  
+  // 等待一点时间让_loadData完成
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // 检查是否加载了数据
+  console.log('加载后的data:', newCache.data);
+  console.log('加载后的list:', newCache.list);
+  console.log('test_key值:', newCache.data.test_key ? newCache.data.test_key.value : 'undefined');
+  
+  // 清理
+  await newCache.dispose();
+  console.log('\n测试完成！');
+}
+
+simpleTest().catch(console.error);

package/test.js

@@ -1,78 +1,481 @@
-const CacheBase = require('./index.js');
+const { CacheBase, cachebase_admin } = require('./index.js');
 
-async function test() {
-	var bl, num, arr = [];
-	var cache = new CacheBase();
-	await cache.set("a", "张三", 18);
-	// await cache.set("ac", "张三", 10);
-	// await cache.set("b", "李四", 10);
-	// await cache.set("c", "王五", 10);
-	// await cache.set("d", "十五", 10);
-	// bl = await cache.set("age1", 10, 10);
-	bl = await cache.set("age", 13, 10);
-	setTimeout(async () => {
-		console.log(await cache.get("age"));
-	}, 9000);
-	setTimeout(async () => {
-		console.log(await cache.get("age"));
-	}, 10000);
-	// bl = await cache.addInt("age", -12);
-	// bl = await cache.add("age", 15, 5);
-	// console.log(bl);
-	// console.log(cache.list);
-	// console.log("修改" + bl);
-	console.log(await cache.get("age"));
+class TestRunner {
+  constructor() {
+    this.totalTests = 0;
+    this.passedTests = 0;
+    this.results = [];
+  }
 
-	//  bl = await cache.del("age");
-	// 	bl = await cache.add("d", "十五", 10);
-	// console.log("添加" + bl);
+  async runTest(name, testFunction) {
+    this.totalTests++;
+    try {
+      await testFunction();
+      this.passedTests++;
+      this.results.push({ name, passed: true });
+      console.log(`✅ ${name}`);
+    } catch (error) {
+      this.results.push({ name, passed: false, error: error.message });
+      console.log(`❌ ${name} - ${error.message}`);
+    }
+  }
 
-	// var num = await cache.addInt("age", 11);
-	// console.log(num);
+  displayResults() {
+    console.log('\n========== 测试结果 ==========');
+    const passRate = (this.passedTests / this.totalTests * 100).toFixed(2);
+    console.log(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
+    
+    // 显示失败的测试
+    const failedTests = this.results.filter(r => !r.passed);
+    if (failedTests.length > 0) {
+      console.log('\n失败的测试:');
+      failedTests.forEach(test => {
+        console.log(`  - ${test.name}: ${test.error}`);
+      });
+    }
+    
+    return passRate;
+  }
+}
 
-	// msg = await cache.setrange("a", 4, "asd");
-	// console.log(msg);
-	var str = await cache.addStr("a", "丰");
-	console.log("追加文本" + str);
-	// var bl = await cache.has("a");
-	// console.log("是否存在" + bl);
+async function runAllTests() {
+  const runner = new TestRunner();
+  
+  // 测试基础方法
+  await testBasicMethods(runner);
+  
+  // 测试哈希表方法
+  await testHashMethods(runner);
+  
+  // 测试批量操作
+  await testBatchOperations(runner);
+  
+  // 测试过期时间
+  await testExpiration(runner);
+  
+  // 测试数值操作
+  await testNumericOperations(runner);
+  
+  // 测试字符串操作
+  await testStringOperations(runner);
+  
+  // 测试事件触发
+  await testEvents(runner);
+  
+  // 测试管理功能
+  await testAdminFunctions(runner);
+  
+  // 显示测试结果
+  return runner.displayResults();
+}
 
-	var num = await cache.add("arr", ['第三', '第四'], 8);
-	bl = await cache.list_clear("arr", ['第三', '第四', '第w']); // 清空数组,并重新增加成员
-	console.log("清空数组" + bl);
-	// 
-	// num = await cache.list_set("arr", ['第一', '第三', '第二'], 8);
-	num = await cache.list_add("arr", '第s');
-	console.log("设置数组" + num);
-	var arr = await cache.list_get("arr", 0);
-	console.log("查到数组", arr)
+// 测试基础方法
+async function testBasicMethods(runner) {
+  console.log('\n========== 测试基础方法 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('set和get方法', async () => {
+    await cache.set('key1', 'value1');
+    const value = await cache.get('key1');
+    if (value !== 'value1') {
+      throw new Error(`预期值: value1, 实际值: ${value}`);
+    }
+  });
+  
+  await runner.runTest('del方法', async () => {
+    await cache.set('key2', 'value2');
+    const deleted = await cache.del('key2');
+    if (deleted !== 1) {
+      throw new Error(`删除失败，预期: 1, 实际: ${deleted}`);
+    }
+    const value = await cache.get('key2');
+    if (value !== undefined) {
+      throw new Error(`键未被删除，值: ${value}`);
+    }
+  });
+  
+  await runner.runTest('exists/has方法', async () => {
+    await cache.set('key3', 'value3');
+    const exists = await cache.exists('key3');
+    if (exists !== 1) {
+      throw new Error(`exists失败，预期: 1, 实际: ${exists}`);
+    }
+    const has = await cache.has('key3');
+    if (!has) {
+      throw new Error(`has失败，预期: true, 实际: ${has}`);
+    }
+  });
+  
+  await runner.runTest('keys方法', async () => {
+    await cache.flushdb();
+    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 size = await cache.dbsize();
+    if (size !== 2) {
+      throw new Error(`dbsize失败，预期: 2, 实际: ${size}`);
+    }
+  });
+  
+  await runner.runTest('getset方法', async () => {
+    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 () => {
+    let result = await cache.flushdb();
+    if (result !== 'OK') {
+      throw new Error(`flushdb失败，预期: OK, 实际: ${result}`);
+    }
+    const size = await cache.dbsize();
+    if (size !== 0) {
+      throw new Error(`flushdb后大小不为0: ${size}`);
+    }
+    
+    // 测试clear方法（兼容）
+    await cache.set('key6', 'value6');
+    result = await cache.clear();
+    if (result !== 'OK') {
+      throw new Error(`clear失败，预期: OK, 实际: ${result}`);
+    }
+    const sizeAfterClear = await cache.dbsize();
+    if (sizeAfterClear !== 0) {
+      throw new Error(`clear后大小不为0: ${sizeAfterClear}`);
+    }
+  });
+}
 
-	// time = await cache.ttl("arr");
-	// console.log(time);
-	// bl = await cache.ttl("arr", -1);
-	// console.log("设置有效期" + bl);
-	// time = await cache.ttl("arr");
-	// console.log(time);
+// 测试哈希表方法
+async function testHashMethods(runner) {
+  console.log('\n========== 测试哈希表方法 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('hset和hget方法', async () => {
+    const result1 = await cache.hset('hash1', 'field1', 'value1');
+    if (result1 !== 1) {
+      throw new Error(`hset新建失败，预期: 1, 实际: ${result1}`);
+    }
+    
+    const result2 = await cache.hset('hash1', 'field1', 'value1_updated');
+    if (result2 !== 0) {
+      throw new Error(`hset更新失败，预期: 0, 实际: ${result2}`);
+    }
+    
+    const value = await cache.hget('hash1', 'field1');
+    if (value !== 'value1_updated') {
+      throw new Error(`hget失败，预期: value1_updated, 实际: ${value}`);
+    }
+  });
+  
+  await runner.runTest('hgetall方法', async () => {
+    await cache.hset('hash1', 'field2', 'value2');
+    const hash = await cache.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 cache.hdel('hash1', 'field1');
+    if (result !== 1) {
+      throw new Error(`hdel失败，预期: 1, 实际: ${result}`);
+    }
+    const value = await cache.hget('hash1', 'field1');
+    if (value !== undefined) {
+      throw new Error(`hdel后字段未被删除，值: ${value}`);
+    }
+    
+    // 删除不存在的字段
+    const result2 = await cache.hdel('hash1', 'non_existent');
+    if (result2 !== 0) {
+      throw new Error(`hdel不存在字段失败，预期: 0, 实际: ${result2}`);
+    }
+  });
+}
 
-	var bl = await cache.list_has("arr", '第一');
-	console.log("包含", bl);
-	// await cache.sort("arr", 'asc');
-	// var ar = await cache.list_get("arr", 2);
-	// console.log(ar);
+// 测试批量操作
+async function testBatchOperations(runner) {
+  console.log('\n========== 测试批量操作 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('mset方法', async () => {
+    const result = await cache.mset({ key7: 'value7', key8: 'value8' });
+    if (result !== 'OK') {
+      throw new Error(`mset失败，预期: OK, 实际: ${result}`);
+    }
+    const value7 = await cache.get('key7');
+    const value8 = await cache.get('key8');
+    if (value7 !== 'value7' || value8 !== 'value8') {
+      throw new Error(`mset后值不匹配: key7=${value7}, key8=${value8}`);
+    }
+  });
+  
+  await runner.runTest('mget方法', async () => {
+    const values = await cache.mget(['key7', 'key8', 'non_existent']);
+    if (JSON.stringify(values) !== JSON.stringify(['value7', 'value8', undefined])) {
+      throw new Error(`mget失败，预期: ["value7","value8",undefined], 实际: ${JSON.stringify(values)}`);
+    }
+  });
+}
 
-	//console.log("取值" + JSON.stringify(arr));
+// 测试过期时间
+async function testExpiration(runner) {
+  console.log('\n========== 测试过期时间 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('set带过期时间', async () => {
+    await cache.set('expire1', 'value1', 1); // 1秒过期
+    let ttl = await cache.ttl('expire1');
+    if (ttl <= 0) {
+      throw new Error(`ttl初始值错误: ${ttl}`);
+    }
+    
+    // 等待过期
+    await new Promise(resolve => setTimeout(resolve, 1100));
+    
+    ttl = await cache.ttl('expire1');
+    if (ttl !== -2) {
+      throw new Error(`过期后ttl错误，预期: -2, 实际: ${ttl}`);
+    }
+    
+    const value = await cache.get('expire1');
+    if (value !== undefined) {
+      throw new Error(`过期后键仍存在: ${value}`);
+    }
+  });
+  
+  await runner.runTest('expire方法', async () => {
+    await cache.set('expire2', 'value2');
+    const result = await cache.expire('expire2', 1);
+    if (result !== 1) {
+      throw new Error(`expire设置失败，预期: 1, 实际: ${result}`);
+    }
+    let ttl = await cache.ttl('expire2');
+    if (ttl <= 0) {
+      throw new Error(`expire后ttl错误: ${ttl}`);
+    }
+  });
+  
+  await runner.runTest('persist方法', async () => {
+    await cache.set('expire3', 'value3', 30);
+    const result = await cache.persist('expire3');
+    if (result !== 1) {
+      throw new Error(`persist设置失败，预期: 1, 实际: ${result}`);
+    }
+    const ttl = await cache.ttl('expire3');
+    if (ttl !== -1) {
+      throw new Error(`persist后ttl错误，预期: -1, 实际: ${ttl}`);
+    }
+  });
+}
 
-	// await cache.del('a_c');
-	// ret = await cache.clear(); // 清空缓存
-	// console.log(ret);
-	var ret = await cache.getrange("a", 2, 3);
-	console.log("这是？", ret);
-	// var arr = await cache.keys("a*");
-	// console.log(arr);
-	// ret = await cache.clear('a*'); // 清空缓存
-	// console.log(ret);
-	console.log("存储的数据字典", cache.dict);
-	console.log("存储的数据列表", cache.list);
-	// cache.dispose() // 销毁资源
+// 测试数值操作
+async function testNumericOperations(runner) {
+  console.log('\n========== 测试数值操作 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('incr方法', async () => {
+    const result1 = await cache.incr('counter');
+    if (result1 !== 1) {
+      throw new Error(`incr初始值失败，预期: 1, 实际: ${result1}`);
+    }
+    const result2 = await cache.incr('counter');
+    if (result2 !== 2) {
+      throw new Error(`incr递增失败，预期: 2, 实际: ${result2}`);
+    }
+  });
+  
+  await runner.runTest('decr方法', async () => {
+    const result = await cache.decr('counter');
+    if (result !== 1) {
+      throw new Error(`decr递减失败，预期: 1, 实际: ${result}`);
+    }
+  });
+  
+  await runner.runTest('incrby方法', async () => {
+    const result = await cache.incrby('counter', 5);
+    if (result !== 6) {
+      throw new Error(`incrby增加失败，预期: 6, 实际: ${result}`);
+    }
+  });
+  
+  await runner.runTest('decrby方法', async () => {
+    const result = await cache.decrby('counter', 2);
+    if (result !== 4) {
+      throw new Error(`decrby减少失败，预期: 4, 实际: ${result}`);
+    }
+  });
+  
+  await runner.runTest('incrbyfloat方法', async () => {
+    const result = await cache.incrbyfloat('counter', 0.5);
+    if (result !== 4.5) {
+      throw new Error(`incrbyfloat增加失败，预期: 4.5, 实际: ${result}`);
+    }
+  });
+  
+  await runner.runTest('add方法（兼容）', async () => {
+    const result = await cache.add('counter', 10);
+    if (result !== 14.5) {
+      throw new Error(`add增加失败，预期: 14.5, 实际: ${result}`);
+    }
+  });
+  
+  await runner.runTest('addFloat方法（兼容）', async () => {
+    const result = await cache.addFloat('counter', 0.5);
+    if (result !== 15) {
+      throw new Error(`addFloat增加失败，预期: 15, 实际: ${result}`);
+    }
+  });
 }
-test();
+
+// 测试字符串操作
+async function testStringOperations(runner) {
+  console.log('\n========== 测试字符串操作 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('append方法', async () => {
+    await cache.set('str', 'hello');
+    const result = await cache.append('str', ' world');
+    if (result !== 11) {
+      throw new Error(`append长度错误，预期: 11, 实际: ${result}`);
+    }
+    const value = await cache.get('str');
+    if (value !== 'hello world') {
+      throw new Error(`append值错误，预期: hello world, 实际: ${value}`);
+    }
+  });
+  
+  await runner.runTest('strlen方法', async () => {
+    const result = await cache.strlen('str');
+    if (result !== 11) {
+      throw new Error(`strlen长度错误，预期: 11, 实际: ${result}`);
+    }
+    
+    // 不存在的键
+    const result2 = await cache.strlen('non_existent');
+    if (result2 !== 0) {
+      throw new Error(`strlen不存在键错误，预期: 0, 实际: ${result2}`);
+    }
+  });
+  
+  await runner.runTest('addStr方法（兼容）', async () => {
+    const result = await cache.addStr('str', '!');
+    if (result !== 12) {
+      throw new Error(`addStr长度错误，预期: 12, 实际: ${result}`);
+    }
+    const value = await cache.get('str');
+    if (value !== 'hello world!') {
+      throw new Error(`addStr值错误，预期: hello world!, 实际: ${value}`);
+    }
+  });
+}
+
+// 测试事件触发
+async function testEvents(runner) {
+  console.log('\n========== 测试事件触发 ==========');
+  const cache = new CacheBase();
+  
+  await runner.runTest('set事件触发', async () => {
+    return new Promise(async (resolve, reject) => {
+      let beforeTriggered = false;
+      let afterTriggered = false;
+      
+      cache.once('set_before', (data) => {
+        if (data.key === 'event_key' && data.value === 'event_value') {
+          beforeTriggered = true;
+        }
+      });
+      
+      cache.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 cache.set('event_key', 'event_value');
+    });
+  });
+  
+  // 注意：已移除get事件触发测试，因为get方法不再触发事件以提高性能
+  
+  await runner.runTest('error事件触发', async () => {
+    return new Promise(async (resolve, reject) => {
+      cache.once('mset_error', (data) => {
+        if (data.error && data.error.message.includes('必须是对象')) {
+          resolve();
+        } else {
+          reject(new Error('mset_error事件触发但消息不正确'));
+        }
+      });
+      
+      try {
+        await cache.mset(null);
+        reject(new Error('mset应抛出错误但没有'));
+      } catch (error) {
+        // 预期的错误，等待事件触发
+        setTimeout(() => {
+          reject(new Error('mset_error事件未触发'));
+        }, 100);
+      }
+    });
+  });
+}
+
+// 测试管理功能
+async function testAdminFunctions(runner) {
+  console.log('\n========== 测试管理功能 ==========');
+  
+  await runner.runTest('cachebase_admin创建实例', async () => {
+    const cache1 = cachebase_admin('test_scope');
+    const cache2 = cachebase_admin('test_scope');
+    if (cache1 !== cache2) {
+      throw new Error('cachebase_admin应返回相同实例但没有');
+    }
+    
+    const cache3 = cachebase_admin('another_scope');
+    if (cache1 === cache3) {
+      throw new Error('cachebase_admin应返回不同作用域的不同实例但没有');
+    }
+  });
+  
+  await runner.runTest('dispose方法', async () => {
+    const cache = new CacheBase();
+    await cache.set('key_to_dispose', 'value');
+    cache.dispose();
+    
+    const size = await cache.dbsize();
+    if (size !== 0) {
+      throw new Error(`dispose后大小不为0: ${size}`);
+    }
+  });
+}
+
+// 运行所有测试
+runAllTests().then(passRate => {
+  console.log(`\n测试完成！通过率: ${passRate}%`);
+}).catch(error => {
+  console.error('测试运行失败:', error);
+});

package/test_cache/scope1.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414864
+}

package/test_cache/scope2.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414866
+}

package/test_cache/scope3.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414869
+}

package/test_cache/test_scope.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920431894
+}