Sinon.Stub-Knoten im AWS-SDK

Haben wir einen aws-sdk-mock npm-Modul, das spottet aus allen AWS-SDK-Dienste und-Methoden. https://github.com/dwyl/aws-sdk-mock

Es ist wirklich einfach zu bedienen. Einfach anrufen AWS.mock mit der service-Methode und eine stub-Funktion.

AWS.mock('SQS', 'sendMessage', function(params, callback) {
    callback(null, 'success');
});

Dann wieder die Methoden, nachdem Sie Ihre tests durch aufrufen:

AWS.restore('SQS', 'sendMessage');

Können Sie stub die AWS-SDK-Methoden mit Sinon mit den folgenden

1. Wickeln Sie das AWS SDK-Instanz und lassen die dies extern:

   //Within say, SqsService.js
   var Aws = require('aws-sdk');
   
   exports.sqsClient = new Aws.SQS({
       region: <AWS_REGION>,
       apiVersion: <API_VERSION>,
       accessKeyId: <AWS_ACCESS_KEY_ID>,
       secretAccessKey: <AWS_SECRET_KEY>
   });

2. Bei der Verwendung der sqsClient, stellen Sie sicher, dass Sie die verpackte Instanz statt.

   var SqsService = require('./SqsService');
   
   function (message, callback) {
       //Do stuff..
       //Then send stuff..
       SqsService.sqsClient.sendMessage(message, callback);
   });

3. So ändern Sie Ihre test-Fall von oben, mit dem gewickelt AWS SDK:

   var request = require('superagent'),
       expect = require('chai').expect,
       assert = require('chai').assert,
       sinon = require('sinon'),
       SqsService = require('./SqsService'), //Import wrapper
       app = require("../../../../app");
   
   describe("Activities", function () {
   
       describe("POST /activities", function () {
   
           var sendMessageStub;
   
           beforeEach(function(done) {
               //Stub like so here
               sendMessageStub = sinon.stub(SqsService.sqsClient, 'sendMessage').callsArgWith(1, null, { MessageId: 'Your desired MessageId' });
   
               done();
           });
   
           afterEach(function(done) {
               sendMessageStub.restore();
   
               done();
           });
   
           it("should call SQS successfully", function (done) {
               var body = {
                   "custom_activity_node_id" : "1562",
                   "campaign_id" : "318"
               };
   
               reqest
                   .post('/v1/user/123/custom_activity')
                   .send(body)
                   .set('Content-Type', 'application/json')
                   .end(function(err, res) {
                       expect(res.status).to.equal(200)
   
                       assert(sendMessageStub.calledOnce);
                       assert(sendMessageStub.calledWith(body));
               });
           });
       });
   });

Können Sie es tun, ohne damit in irgendeiner extra-Bibliotheken mit so etwas wie dieses:

const mocha = require('mocha'),
    chai = require('chai'),
    expect = chai.expect,    //Using Expect style
    sinon = require('sinon'),
    AWS = require('aws-sdk');

describe('app', function () {
    var aws, sqs, app,
        sendMessageError = null,
        sendMessageData = { MessageId: "1" };
    before(() => {
        //Create a stub for the SQS lib
        sqs = sinon.stub({ sendMessage: Function() });
        //Make sure that when someone calls AWS.SQS they get our stub
        aws = sinon.stub(AWS, 'SQS');
        aws.returns(sqs);
        //Now include your app since it will `require` our stubbed version of AWS
        app = require('./app');
    });
    after(() => {
        aws.restore(); //Be kind to future tests
    });
    beforeEach(() => {
        //Reset callback behavior after each test
        sqs.sendMessage.reset();
        //Call the callback supplied to sendMessage in the 1st position with the arguments supplied
        sqs.sendMessage.callsArgWith(1, sendMessageError, sendMessageData);
    });
    it('sends messages', () => {
        //Pretend you're using Promises in your app, but callbacks are just as easy
        return app.sendMessage().then(() => {
            const args = sqs.sendMessage.getCall(0).args[0];
            expect(args.QueueUrl).to.be.eq('http://127.0.0.1/your/queue/url');
        });
    });
});

Ich wie zu verwenden verspricht, aufbauend auf @kdlcruz Antwort oben, ich habe etwas wie das hier tun:

import AWS from 'aws-sdk'
import sinon from 'sinon'

let sinonSandbox

const beforeEach = (done) => {
   sinonSandbox = sinon.sandbox.create()
   done()
}

const afterEach = done => {
   sinonSandbox.restore()
   done()
} 

function mockAWSCall(service, method, expectedArgs, response) {
    var stubDef = {};
    stubDef[method] = function(args) {
        if(expectedArgs) {
            expect(args).to.deep.equal(expectedArgs);
        }
        return {
            promise: () => {
                return new Promise(function (resolve, reject) {
                    if(response.startsWith("ERROR:")) {
                        reject(response);
                    } else {
                        resolve(response);
                    }
                });
            }
        };
    };

    sinonSandbox.stub(AWS, service).returns(stubDef);
}

lab.test('test name', (done) => {
    mockAWSCall('SQS', 'sendMessage', {
        MessageBody: 'foo', QueueUrl: 'http://xxx'
    }, 'ok');
    //Do something that triggers the call...
    done()
})