Node.js 消防软管上的模拟记录不适用于aws sdk模拟

我试图在AWS Firehose对象上模拟putRecord方法，但模拟没有成功。代码最终在firehose对象上调用aws sdk api，该对象与实时aws服务进行通信。下面的代码有什么问题？为了避免此实时服务调用并使mock生效，需要更改哪些内容

有没有一种方法可以发送一个thenable对象，而不仅仅是普通对象，就像下面的回调一样？i、 e.如何使用我在测试代码中定义的callbackFunc之类的东西

最后我还需要检查mock是否被调用。我将如何实现这一点？我能否以某种方式使用sinon.stub来实现这一点，以便稍后进行验证？怎么做

下面是代码和测试代码部分。。。已修改为此发布的简单表单

作为文件一部分的代码，比如samplelogging.js

/*jshint strict:true */
/*jshint node:true */
/*jshint esversion:6 */
/*jshint mocha:true */
"use strict";

var Promise = require('bluebird');
var AWS = require('aws-sdk');
var uuid = require('uuid');

AWS.config.setPromisesDependency(Promise);

var Logger = {
    /**
     * Get's a AWS Firehose Instance 
     */
    getFirehoseInstance: function getFirehoseInstance() {
        if (!(this.firehose)) {
            this.firehose = new AWS.Firehose({apiVersion: "2015-08-04", region: "us-west-2"});
        }
        return this.firehose;
    },

    getLogger: function getLogger(options) {
        options = options || {};
        let self = this;

        self.class = options.class;
        self.firehose = self.getFirehoseInstance();

        return self;
    },


    logInfo: function logInfo(dataToLog, callback) { 
        this._log("info", dataToLog)        
            .then(function (data){
                if (callback) {
                    callback();
                }                
            });
        return;
    },

    /**
     * @api: private
     */
    _log: function _log(traceLevel, dataToLog) {

        return new Promise(function(resolve, reject) {
            var params = params || {};

            AWS.config.update({ logger: process.stdout });
            AWS.config.update({ retries: 3 });
            var recordParams = {
                type: params.type || 'LogEntry'
            };

            if (typeof dataToLog === 'string' || dataToLog instanceof String) {
                recordParams.data = { message: dataToLog };
            } else {
                recordParams.data = dataToLog;
            }

            recordParams.data.id = uuid.v1();
            recordParams.data.preciseTimestamp = Math.floor(new Date().getTime()/1000);
            recordParams.data.class = this.class;
            recordParams.data.traceLevel = traceLevel;

            var firehoseRecordParams = {
                DeliveryStreamName: "mystreamname",  //replace mystreamname with real stream name
                Record: {
                    Data: JSON.stringify(recordParams)+',\n'
                }
            };

            this.firehose.putRecord(firehoseRecordParams, function(err, recordId) {
                console.log("debug: recordId returned by putRecord = " + JSON.stringify(recordId));
                return resolve(recordId);
            });

        }.bind(this));
    }

};

module.exports = Logger;

这是我的测试代码，它是一个文件的一部分，比如sampleloggingtest.js

var expect = require('chai').expect;
var Promise = require("bluebird");
var sinon = require("sinon");
var AWSMock = require('aws-sdk-mock');

describe.only("Logging tests", function () {

        it.only("Test AWS firehose API invoked", function (done) {

            let mylogger = Logger.getLogger({class: "Unit Test"});
            let firehoseInstance = mylogger.getFirehoseInstance();

            // want to have a callback function that returns a thenable object and not just an object. Not sure how to use it though with mock
            // so for now this is just code that shows what i intend to do.
            let callBackFunc = function( err, recordId) {
                    console.log("debug: returend from putRecord, recordId = " + JSON.stringify(recordId));
                    return Promise.resolve(recordId);
                };

            // calling mock as per the documentation at https://github.com/dwyl/aws-sdk-mock
            AWSMock.mock('Firehose', 'putRecord', function(params, callback) {
                console.log("debug: callback to putRecord to be called");                
                callback(null, {"RecordId": "12345"} );
            });

            // calling a method that should call firehose logging but our mock should intercept it - though it doesn't.
            mylogger.logInfo({ prop1: "value1" }, function(){
                console.log("debug: in the callback that was passed to logInfo...");
                done();
            });

        });
});

---

分享我找到的答案，特别是因为另一个人（mmorrisson）也在尝试同样的方法

实际上，我将_setFirehoseInstance方法添加到我的logger类中，该类将仅从我的测试代码中调用，该测试代码将firehose实例（在生产代码中，该实例将调用新的AWS.firehose（））替换为我自己的简单模拟类

在我的测试代码中。。。 让firehoseMock={}

在beforeach（）中创建并设置模拟以替换实际的Firehose实例，并在afterEach（）中还原该实例

beforeEach(function (done) {
    logger = new Logger({class: "Unit Test"});
    firehose = logger.getFirehoseInstance();
    consoleMock = sinon.mock(console);

    firehoseMock.putRecord = function(params, callback) {
        let recordIdObj = {"RecordId": recordIdVal};
        callback(null, recordIdObj);
    };         
    logger._setFirehoseInstance(firehoseMock);    
    sinon.spy(firehoseMock, "putRecord");

    done();
});

afterEach(function (done) {
    firehoseMock.putRecord.restore();
    logger._setFirehoseInstance(firehose);
    consoleMock.restore();
    done();
});

在我们尝试记录的测试代码中，检查是否调用了firehoseMock.putRecord

it("Test AWS firehose API invoked", function (done) {

    logger.setMode("production");
    logger.setEnvironment("test");

    logger.logInfo({ prop1: "value1" }, function(data){
        expect(firehoseMock.putRecord.calledOnce).to.equal(true);  // should have been called once
        expect(data.RecordId).to.equal(recordIdVal);  // should have matching recordId

        done();
    });

});

在生产代码中，logger类中有firehose实例的getter和setter

/**
 * Get's a AWS Firehose Instance 
 */
getFirehoseInstance() {
    if (!(this.firehose)) {
        this.firehose = new AWS.Firehose({apiVersion: Config.apiVersion, region: Config.region});
    }
    return this.firehose;
}

/**
 * Set a AWS Firehose Instance - for TEST purose 
 */
_setFirehoseInstance(firehoseInstance) {
    if (firehoseInstance) {
        this.firehose = firehoseInstance;
    }
}

---

这对我有用。当logger在生产中调用firehose实例方法时，它将转到AWS服务，但在单元测试中，当我调用log方法时，它将调用模拟上的putRecord，因为我已将firehose实例替换为模拟。然后，我可以适当地测试mock上的putRecord是否被调用（使用sinon.spy）。

我正在尝试做同样的事情（mock Firehose）并看到相同的结果（mock未调用，只有真正的服务）。在aws sdk模拟文档中，他们的测试代码使用var aws=require（'aws-sdk-mock'），而不是AWSMock。我不知道这在幕后是如何工作的，但如果它通过替换变量来工作，那么名称可能很重要。所以我并不孤单。：-：-（希望听到有人使用它。或者希望听到AWS开发人员的声音…顺便说一句，变量的名称不应该改变结果。我确信您尝试过AWS，但它也不起作用。