如何在Lambda函数测试中避免调用构造方法？

你遇到的核心问题很明确：类的构造函数直接执行了数据库连接逻辑，导致测试时不得不触发实际的数据库调用，还得等待连接关闭——这完全违背了单元测试“隔离依赖”的原则。下面我结合Sinon给你几个实用的解决方案，从临时修复到长期优化都有：

方案1：重构代码，用依赖注入（最推荐的长期方案） #

这是从根源上解决问题的方式，把数据库连接的创建逻辑从类的构造函数里抽出来，改为外部注入。这样生产环境用真实连接，测试时直接传模拟对象就行。

比如原来的类可能是这样：

class LambdaHandler {
  constructor() {
    this.dbConn = new Connection(); // 这里硬创建连接，测试必触发实际调用
  }

  async handleEvent(event) {
    // 用this.dbConn处理业务逻辑
  }
}

重构后改成依赖注入模式：

class LambdaHandler {
  constructor(dbConn) {
    this.dbConn = dbConn; // 外部传入连接，而非自己创建
  }

  async handleEvent(event) {
    // 业务逻辑不变，还是用this.dbConn
  }
}

// 生产环境中正常初始化真实连接
const prodHandler = new LambdaHandler(new Connection());

测试时就可以轻松传入模拟的连接对象：

const sinon = require('sinon');
const LambdaHandler = require('./your-handler');

describe('LambdaHandler', () => {
  it('处理事件时不依赖真实数据库', async () => {
    // 模拟数据库连接的核心方法
    const mockDb = {
      query: sinon.stub().resolves({ data: '测试数据' }),
      close: sinon.stub().resolves()
    };
    const handler = new LambdaHandler(mockDb);
    
    const result = await handler.handleEvent({});
    // 断言业务逻辑正确执行
    sinon.assert.calledOnce(mockDb.query);
  });
});

方案2：用Sinon直接Stub掉Connection类的构造函数 #

如果暂时没时间重构代码，可以直接拦截Connection类的构造逻辑，让它返回一个模拟对象，完全跳过真实的数据库连接过程。

假设你的Connection是从./db-utils模块导入的：

const sinon = require('sinon');
const { Connection } = require('./db-utils');
const LambdaHandler = require('./your-handler');

describe('LambdaHandler', () => {
  let connectionStub;

  beforeEach(() => {
    // 构造一个模拟的连接实例，包含你需要的方法
    const mockConnInstance = {
      query: sinon.stub().resolves({}),
      close: sinon.stub().resolves()
    };
    // Stub Connection构造函数，让它返回模拟实例
    connectionStub = sinon.stub().returns(mockConnInstance);
    // 替换模块中的Connection为Stub版本
    sinon.replace(require('./db-utils'), 'Connection', connectionStub);
  });

  afterEach(() => {
    // 测试结束后恢复原模块，避免影响其他测试用例
    sinon.restore();
  });

  it('不会创建真实的数据库连接', async () => {
    const handler = new LambdaHandler(); // 此时构造函数调用的是Stub的Connection
    await handler.handleEvent({});
    
    // 断言构造函数被调用，且模拟方法正常执行
    sinon.assert.calledOnce(connectionStub);
    sinon.assert.calledOnce(handler.dbConn.close);
  });
});

方案3：Stub掉Connection实例的连接方法 #

如果构造函数里是调用了Connection实例的某个连接方法（比如connect()），可以直接Stub这个方法，让它跳过实际的连接操作：

const sinon = require('sinon');
const { Connection } = require('./db-utils');
const LambdaHandler = require('./your-handler');

describe('LambdaHandler', () => {
  let connectStub;
  let mockConn;

  beforeEach(() => {
    mockConn = new Connection();
    // Stub connect方法，让它立即resolve，不执行真实连接逻辑
    connectStub = sinon.stub(mockConn, 'connect').resolves();
    // 让Connection构造函数返回这个被Stub的实例
    sinon.stub(require('./db-utils'), 'Connection').returns(mockConn);
  });

  afterEach(() => {
    sinon.restore();
  });

  it('跳过真实数据库连接步骤', async () => {
    const handler = new LambdaHandler();
    await handler.handleEvent({});
    
    sinon.assert.calledOnce(connectStub);
    // 其他业务逻辑断言
  });
});

小提醒 #

• 不管用哪种Stub方式，测试结束后一定要用sinon.restore()恢复被修改的模块或方法，不然会污染其他测试用例。
• 优先考虑依赖注入的方案，它不仅解决了测试问题，还让代码的耦合度更低，后续扩展和维护都会更轻松。

内容的提问来源于stack exchange，提问作者Arek Jaworski