mm_session 1.5.2 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_session",
-    "version": "1.5.2",
+    "version": "1.5.3",
     "description": "这是超级美眉session函数模块，用于web服务端session缓存",
     "main": "index.js",
     "scripts": {
@@ -29,11 +29,11 @@
         "url": "https://gitee.com/qiuwenwu91/mm_session/issues"
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_session#readme",
-    "dependencies": {
-        "mm_cachebase": "^1.9.2"
-    },
     "devDependencies": {
         "eslint-plugin-jsdoc": "^61.5.0",
-        "mm_eslint": "^1.0.3"
+        "mm_eslint": "^1.0.8"
+    },
+    "dependencies": {
+        "mm_cache": "^1.4.7"
     }
 }

package/test.js

@@ -1,190 +1,328 @@
-const { Session, Store } = require('./index.js');
+'use strict';
 
-String.prototype.aes_encode = function(key) {
-  // 简单的AES编码模拟
-  return Buffer.from(this).toString('base64') + '_' + key.substring(0, 8);
-};
+const { session, Session, Store } = require('./index.js');
 
-// 模拟Koa应用
-class MockKoaApp {
-  constructor() {
-    this.middlewares = [];
-  }
-
-  use(middleware) {
-    this.middlewares.push(middleware);
-  }
-
-  async handleRequest(ctx) {
-    // 执行中间件链
-    const executeMiddleware = async (index) => {
-      if (index < this.middlewares.length) {
-        const middleware = this.middlewares[index];
-        await middleware(ctx, () => executeMiddleware(index + 1));
-      }
-    };
-    
-    await executeMiddleware(0);
-  }
-}
-
-// 模拟Koa的上下文对象
+/**
+ * 模拟Koa上下文对象
+ * @class MockContext
+ * @param {object} headers HTTP请求头
+ * @param {object} cookies cookie数据
+ */
 class MockContext {
-  constructor() {
-    this.cookies = new MockCookies();
-    this.headers = {};
+  /**
+   * 构造函数
+   * @param {object} headers HTTP请求头
+   * @param {object} cookies cookie数据
+   */
+  constructor(headers = {}, cookies = {}) {
+    this.headers = headers;
+    this._cookies = cookies;
     this.ip = '127.0.0.1';
-    this.request = {
-      header: {
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+    this.body = null;
+    this.status = null;
+
+    // 模拟cookies对象
+    this.cookies = {
+      get: (name) => {
+        return this._cookies[name] || null;
+      },
+      set: (name, value, options = {}) => {
+        this._cookies[name] = value;
       }
     };
-    this.session = null;
   }
 }
 
-// 模拟Koa的cookies对象
-class MockCookies {
-  constructor() {
-    this._cookies = new Map();
-  }
+/**
+ * 模拟Koa next函数
+ * @returns {Promise<void>} 空Promise
+ */
+const mock_next = () => Promise.resolve();
 
-  get(key, options) {
-    return this._cookies.get(key);
-  }
+/**
+ * 测试基本session中间件功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testBasicSession() {
+  console.log('1. 测试基本session中间件功能');
+  try {
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, mock_next);
 
-  set(key, value, options) {
-    if (value === null) {
-      this._cookies.delete(key);
+    if (ctx.session) {
+      console.log('✓ session对象创建成功');
+      console.log('✓ session ID:', ctx.session.getId());
     } else {
-      this._cookies.set(key, value);
+      console.log('✗ session对象创建失败');
     }
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
   }
 }
 
-// 测试session模块
-async function testSession() {
-  console.log('开始测试session模块...\n');
-
+/**
+ * 测试session数据读写功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionDataRW() {
+  console.log('\n2. 测试session数据读写功能');
   try {
-    // 测试1: 创建Session实例
-    console.log('测试1: 创建Session实例');
-    const session = new Session({
-      key: 'test_session',
-      max_age: 3600
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, async () => {
+      // 在中间件中设置session数据
+      ctx.session.user_id = 123;
+      ctx.session.username = 'testuser';
+      ctx.session.is_logged_in = true;
     });
-    console.log('✅ Session实例创建成功\n');
 
-    // 测试2: 创建Koa应用并注册中间件
-    console.log('测试2: 创建Koa应用并注册中间件');
-    const app = new MockKoaApp();
-    
-    // 使用Koa标准方式注册session中间件
-    app.use(session.middleware());
-    
-    // 添加一个业务中间件来测试session功能
-    app.use(async (ctx, next) => {
-      // 测试session数据操作
-      if (!ctx.session.user_id) {
-        ctx.session.user_id = 123;
-        ctx.session.username = 'test_user';
-      }
-      
-      await next();
+    console.log('✓ session数据设置成功');
+    console.log('  - user_id:', ctx.session.user_id);
+    console.log('  - username:', ctx.session.username);
+    console.log('  - is_logged_in:', ctx.session.is_logged_in);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 创建测试session
+ * @param {Function} session_mw session中间件
+ * @returns {Promise<object>} 包含session ID和上下文的对象
+ */
+async function createTestSession(session_mw) {
+  const ctx1 = new MockContext();
+
+  // 使用标准的中间件调用方式，确保保存逻辑被执行
+  await session_mw(ctx1, async () => {
+    // 在next()函数中设置session数据
+    ctx1.session.test_data = 'persistent_data';
+    // 强制标记session为已修改状态
+    ctx1.session._modified = true;
+
+    // 调试：检查session对象在设置数据后的状态
+    console.log('  - 第一次请求session对象状态:', {
+      uuid: ctx1.session.uuid,
+      test_data: ctx1.session.test_data,
+      _modified: ctx1.session._modified,
+      _is_new: ctx1.session._is_new
     });
     
-    console.log('✅ Koa应用创建成功，中间件注册完成\n');
+    // 调试：检查session是否被标记为已修改
+    console.log('  - session._modified标志:', ctx1.session._modified);
+  });
 
-    // 测试3: 测试新session创建
-    console.log('测试3: 测试新session创建');
-    const ctx1 = new MockContext();
-    
-    await app.handleRequest(ctx1);
-    
-    // 等待session保存完成（模拟异步保存过程）
-    await new Promise(resolve => setTimeout(resolve, 50));
-    
-    if (ctx1.session) {
-      console.log('✅ 新session创建成功');
-      console.log('   session对象:', typeof ctx1.session);
-      console.log('   user_id:', ctx1.session.user_id);
-      console.log('   username:', ctx1.session.username);
-    } else {
-      throw new Error('session创建失败');
+  // 调试：检查第一次请求后session是否被正确保存
+  console.log('  - 第一次请求后检查session._modified标志:', ctx1.session._modified);
+
+  const session_id = ctx1.session.getId();
+  console.log('✓ 第一次请求session ID:', session_id);
+
+  return { ctx1, session_id };
+}
+
+/**
+ * 验证session恢复结果
+ * @param {object} ctx2 第二次请求的上下文
+ * @param {string} session_id session ID
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+async function verifySessionRecover(ctx2, session_id) {
+  if (ctx2.session && ctx2.session.test_data === 'persistent_data') {
+    console.log('✓ session数据恢复成功');
+    return true;
+  } else {
+    console.log('✗ session数据恢复失败');
+    console.log('  - ctx2.session:', ctx2.session);
+    if (ctx2.session) {
+      console.log('  - test_data:', ctx2.session.test_data);
+      console.log('  - session ID是否匹配:', ctx2.session.uuid === session_id);
+
+      // 调试：直接检查存储中是否有数据
+      const store = new Store();
+      const stored_data = await store.get(session_id);
+      console.log('  - 存储中的数据:', stored_data);
+
+      // 调试：检查第一次请求后存储中的数据
+      const stored_data_first = await store.get(session_id);
+      console.log('  - 第一次请求后存储中的数据:', stored_data_first);
     }
+    return false;
+  }
+}
 
-    // 测试4: 测试session保存和读取
-    console.log('\n测试4: 测试session保存和读取');
+/**
+ * 测试从cookie中恢复session
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionRecovery() {
+  console.log('\n3. 测试从cookie中恢复session');
+  try {
+    const session_mw = session();
     
-    // 检查cookie是否设置
-    const sessionCookie = ctx1.cookies.get('test_session');
-    if (sessionCookie) {
-      console.log('✅ session保存成功，cookie已设置');
-      console.log('   session ID:', sessionCookie);
-    } else {
-      console.log('⚠️  session保存但cookie未设置');
-    }
+    // 创建测试session
+    const { session_id } = await createTestSession(session_mw);
 
-    // 测试5: 测试session读取（模拟有cookie的情况）
-    console.log('\n测试5: 测试session读取');
+    // 第二次请求使用相同的session ID（通过cookie传递）
     const ctx2 = new MockContext();
-    
-    // 设置cookie模拟已有session
-    if (sessionCookie) {
-      ctx2.cookies.set('test_session', sessionCookie);
-    }
-    
-    await app.handleRequest(ctx2);
-    
-    if (ctx2.session) {
-      console.log('✅ session读取成功');
-      console.log('   session对象存在');
-      console.log('   user_id:', ctx2.session.user_id);
-      console.log('   username:', ctx2.session.username);
+    ctx2.cookies['mm:uuid'] = session_id;
+
+    await session_mw(ctx2, mock_next);
+
+    // 验证恢复结果
+    await verifySessionRecover(ctx2, session_id);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试session刷新功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionRefresh() {
+  console.log('\n4. 测试session刷新功能');
+  try {
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, async () => {
+      ctx.session.original_data = 'original';
+      ctx.session.refresh(); // 刷新session
+    });
+
+    console.log('✓ session刷新功能正常');
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试自定义配置
+ * @returns {Promise<void>} 测试结果
+ */
+async function testCustomConfig() {
+  console.log('\n5. 测试自定义配置');
+  try {
+    const custom_cfg = {
+      key_prefix: 'custom:session',
+      cookie_token: 'custom_token',
+      max_age: 3600 // 1小时
+    };
+
+    const session_mw = session(custom_cfg);
+    const ctx = new MockContext();
+
+    await session_mw(ctx, mock_next);
+
+    console.log('✓ 自定义配置生效');
+    console.log('  - session ID长度:', ctx.session.getId().length);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试Session类直接使用
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionClass() {
+  console.log('\n6. 测试Session类直接使用');
+  try {
+    const sess = new Session();
+    const ctx = new MockContext();
+
+    const session_obj = await sess.get(ctx);
+    console.log('✓ Session类get方法正常');
+    console.log('  - 获取的session对象:', session_obj);
+
+    // 测试保存session
+    await sess.save(ctx, session_obj);
+    console.log('✓ Session类save方法正常');
+
+    // 测试生成session ID
+    const new_sess_id = sess.genId(ctx);
+    console.log('✓ Session类genId方法正常');
+    console.log('  - 生成的session ID:', new_sess_id);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试Store类
+ * @returns {Promise<void>} 测试结果
+ */
+async function testStoreClass() {
+  console.log('\n7. 测试Store类');
+  try {
+    const store = new Store('test_prefix');
+    const test_data = { key: 'value', number: 42 };
+
+    // 测试设置数据
+    await store.set('test_key', test_data, 60);
+    console.log('✓ Store类set方法正常');
+
+    // 测试获取数据
+    const ret_data = await store.get('test_key');
+    if (ret_data && ret_data.key === 'value') {
+      console.log('✓ Store类get方法正常');
+      console.log('  - 获取的数据:', ret_data);
     } else {
-      console.log('⚠️  session读取失败（可能是新session）');
+      console.log('✗ Store类get方法异常');
     }
 
-    // 测试6: 测试Store类
-    console.log('\n测试6: 测试Store类');
-    const store = new Store('test');
-    
-    // 模拟获取session ID
-    const sessionId = await store.getID(ctx1);
-    console.log('✅ Store类测试成功');
-    console.log('   生成的session ID:', sessionId);
-
-    // 测试7: 测试session销毁
-    console.log('\n测试7: 测试session销毁');
-    const ctx3 = new MockContext();
-    
-    // 添加一个中间件来测试session销毁
-    const destroyApp = new MockKoaApp();
-    destroyApp.use(session.middleware());
-    destroyApp.use(async (ctx, next) => {
-      // 设置session为null触发销毁
-      ctx.session = null;
-      await next();
-    });
-    
-    await destroyApp.handleRequest(ctx3);
-    console.log('✅ session销毁逻辑测试完成');
+    // 测试删除数据
+    store.del('test_key');
+    console.log('✓ Store类del方法正常');
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
 
-    console.log('\n🎉 所有测试通过！session模块功能正常。');
+/**
+ * 测试session中间件
+ */
+async function testSession() {
+  console.log('=== 开始测试session中间件 ===\n');
 
-  } catch (error) {
-    console.error('❌ 测试失败:', error.message);
-    console.error(error.stack);
+  await testBasicSession();
+  await testSessionDataRW();
+  await testSessionRecovery();
+  await testSessionRefresh();
+  await testCustomConfig();
+  await testSessionClass();
+  await testStoreClass();
+
+  console.log('\n=== session中间件测试完成 ===');
+}
+
+/**
+ * 运行测试
+ */
+async function runTests() {
+  try {
+    await testSession();
+  } catch (err) {
+    console.error('测试执行出错:', err);
   }
 }
 
-// 运行测试
+// 如果直接运行此文件，则执行测试
 if (require.main === module) {
-  testSession().catch(console.error);
+  runTests();
 }
 
+setTimeout(() => {
+  process.exit(0);
+}, 5000);
+
 module.exports = {
   MockContext,
-  MockCookies,
-  testSession
+  mock_next,
+  testSession,
+  runTests
 };