node.js - 如何使用构造函数和依赖项测试无服务器 lambda 函数？

Question

如何 stub 构造函数以传递对已接收函数调用的构造对象的期望？

我使用的是无服务器，我有一个 lambda 函数，它具有依赖性并通过预定事件每分钟运行一次。我想关注 lambda 函数的行为，所以我希望我的测试之一如下 -> 它使消息队列中的消息出列。该测试将验证我的队列是否已接收到函数 dequeueMessages - 仅此而已。这是我的示例 lambda:

module.exports = function(event, context, callback) {
  var queue = new Queue();

  queue.dequeueMessages(params).then(messages => {
    var client = new DataFetcher();

    return client.fetchData(messages).then(data => {
      var database = new Database();

      return database.persist(data);
    })
  }
}

我知道那里还有其他依赖项，但我只想专注于让第一个测试通过，而且我正在努力清除 new Queue 以断言构造的对象，队列，已调用#dequeueMessages。我探索了 sinon我用 mocha 和 chai 设置了测试，但我只是不知道如何将所有工具放在一起来完成这个非常简单的测试。

Answer 1

由于您只想关注实现细节，因此非常简单。我附上了一个基于您的示例文件的工作示例，为了完整性做了一些调整。

lib.js

这是模拟第三方依赖项的模块 - 通常在您的代码中应该类似于 AWS 库等。

class Queue{
  constructor(){

  }

  dequeueMessages(params ){
    console.log('dequeueMessages()', params);

    const messages = [];
    return Promise.resolve(messages);
  }

}

class DataFetcher{
  constructor(){

  }

  fetchData(messages ){
    console.log('fetchData()', messages);
    const data = {};
    return Promise.resolve(data);
  }
}

class Database{
  constructor(){

  }

  persist(data ){
    console.log('persist()', data);

    return Promise.resolve();
  }
}

module.exports.Queue = Queue;
module.exports.Database = Database;
module.exports.DataFetcher = DataFetcher;

lambda.js

对其进行了一些改动，以便在完成时通知其调用者。

'use strict';

const Queue = require('./lib').Queue;
const DataFetcher = require('./lib').DataFetcher;
const Database = require('./lib').Database;


module.exports = function(event, context, callback) {
  var queue = new Queue();

  var params = {};

  queue.dequeueMessages(params).then(messages => {
    var client = new DataFetcher();

    return client.fetchData(messages).then(data => {
      var database = new Database();

      database.persist(data).then(() => {
        callback(null, {});
      });
    });
  }).catch((error) => {
    callback(error);
  });
};

测试.js

'use strict';

const chai = require('chai');
const sinon = require('sinon');
const SinonChai = require('sinon-chai');

var sinonStubPromise = require('sinon-stub-promise');
sinonStubPromise(sinon);

chai.use(SinonChai);
chai.should();

const lambda = require('./lambda');
const Queue = require('./lib').Queue;
const DataFetcher = require('./lib').DataFetcher;
const Database = require('./lib').Database;

context('Test', () => {


  beforeEach(() => {
    if (!this.sandbox) {
      this.sandbox = sinon.sandbox.create();
    } else {
      this.sandbox.restore();
    }
  });


  it('should pass the test',
    (done) => {

      const event = {};
      const ctx = {};

      const stubQueue = sinon.stub(Queue.prototype, 'dequeueMessages')
        .resolves(['1', '2']);
      const stubDataFetcher = sinon.stub(DataFetcher.prototype, 'fetchData')
        .resolves({});
      const stubDatabase = sinon.stub(Database.prototype, 'persist')
        .resolves();

      lambda(event, ctx, (error, result) => {

        try {
          // all stubs should have been called
          // one time each
          stubQueue.should.have.been.calledOnce;
          stubDataFetcher.should.have.been.calledOnce;
          stubDatabase.should.have.been.calledOnce;

          done();
        } catch (e) {
          done(e);
        }

      });
    });

});

您可以做的最简单的事情就是在原型(prototype)级别对所需的方法进行 stub ，并相应地控制它们的行为。在这个例子中，我们在 lambda 内部使用了 3 个感兴趣的方法，以便它们返回一个伪造的结果，以便沿着所需的路径驱动测试。

最后，由于 lambda 的性质是异步，我们强制它使用回调，以便我们可以在完成时优雅地运行我们的断言。

以此为骨架，您可以利用 Sinon 必须提供的所有功能来彻底验证您的实现逻辑。

最后但同样重要的是，@johni 分享的文章确实应该作为更复杂场景的引用。