@incdevco/framework/aws/dynamo-db/spec.js

node.js lambda framework

var Expect = require('chai').expect;
var Mock = require('../../mock');
var sinon = require('sinon');

var DynamoDB = require('./index');
var sandbox = sinon.sandbox.create();

describe('aws dynamodb', function () {
  'use strict';
  
  var ddb, expected, mock, params;
  
  beforeEach(function () {
    
    ddb = new DynamoDB();
    
    expected = 'expected';
    
    mock = new Mock();
    
    params = {};
    
  });
  
  afterEach(function () {
    
    mock.restore();
    
    sandbox.verifyAndRestore();
    
  });
  
  describe('delete', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.delete', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('delete')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.delete(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('get', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.get', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('get')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.get(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('put', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.put', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('put')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.put(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('query', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.query', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('query')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.query(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('queryThemAll', function() {
    
    it('should', function (done) {
      
      var firstParams = {};
      
      var firstResult = {
        Items: [
          'item1'
        ],
        LastEvaluatedKey: 'LastEvaluatedKey'
      };
      
      var secondParams = {
        ExclusiveStartKey: 'LastEvaluatedKey'
      };
      
      var secondResult = {
        Items: [
          'item2'
        ]
      };
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('query')
      .with(firstParams)
      .willResolve(firstResult);
      
      mocked
      .expect('query')
      .with(secondParams)
      .willResolve(secondResult);
      
      expected = {
        Items: [
          'item1',
          'item2'
        ]
      };
      
      ddb.queryThemAll(firstParams)
      .then(function (result) {
        
        Expect(result).to.deep.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('scan', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.scan', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('scan')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.scan(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('scanThemAll', function() {
    
    it('should', function (done) {
      
      var firstParams = {};
      
      var firstResult = {
        Items: [
          'item1'
        ],
        LastEvaluatedKey: 'LastEvaluatedKey'
      };
      
      var secondParams = {
        ExclusiveStartKey: 'LastEvaluatedKey'
      };
      
      var secondResult = {
        Items: [
          'item2'
        ]
      };
      
      var scan = sandbox.stub(ddb, 'scan');
      
      scan.withArgs(firstParams)
      .returns(Promise.resolve(firstResult));
      
      scan.withArgs(secondParams)
      .returns(Promise.resolve(secondResult));
      
      expected = {
        Items: [
          'item1',
          'item2'
        ]
      };
      
      ddb.scanThemAll(firstParams)
      .then(function (result) {
        
        Expect(result).to.deep.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('update', function() {
    
    it('should', function (done) {
      
      var mocked = mock.mock(ddb);
      
      mocked
      .expect('log')
      .with('dynamodb.update', JSON.stringify(params, null, 2))
      .willReturn(true);
      
      mock.mock(ddb.ddb)
      .expect('update')
      .with(params)
      .willReturnAwsPromiseResolve(expected);
      
      mocked
      .expect('log')
      .with('result', JSON.stringify(expected, null, 2))
      .willReturn(true);
      
      ddb.update(params)
      .then(function (result) {
        
        Expect(result).to.equal(expected, 'result');
        
        return mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
});