@incdevco/framework/pg/transaction/spec.js

node.js lambda framework

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

var Sql = require('../sql');
var Transaction = require('./index');

describe('pg transaction', function () {
  'use strict';
  
  var changes, connection, columns, data, 
    expected, forUpdate, limit, mock, orderBy, offset,
    returning, table, transaction, where;
  
  beforeEach(function () {
    
    connection = {};
    
    transaction = new Transaction(connection);
    
    expected = 'expected';
    
    data = {
      key: 'value'
    };
    
    returning = 'id';
    
    table = 'table';
    
    limit = 1;
    
    mock = new Mock();
    
    offset = 2;
    
    where = {
      key: 'value'
    };
    
  });
  
  describe('commit', function() {
    
    it('should call query on connection, then call release on connection and return passthrough', function (done) {
      
      var mocked = mock.mock(connection);
      
      mocked.expect('query')
        .with('COMMIT')
        .willResolve(true);
        
      mocked.expect('release')
        .willReturn(true);
      
      transaction.commit(expected)
      .then(function (actual) {
        
        Expect(actual).to.equal(expected, 'actual');
        
        mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
  describe('delete', function() {
    
    it('should', function () {
      
      var result = transaction.delete();
      
      Expect(result).to.be.instanceof(Sql.Delete,'query');
      
    });
    
  });
  
  describe('insert', function() {
    
    it('should', function () {
      
      var result = transaction.insert('data');
      
      Expect(result).to.be.instanceof(Sql.Insert,'query');
      
      Expect(result._data).to.equal('data', 'data');
      
    });
    
  });

  describe('query', function() {
    
    var sql = 'sql', inserts = [];
    
    it('should call select on connection', function (done) {
      
      mock.mock(connection).expect('query')
        .with(sql, inserts)
        .willReturn(expected);
        
      Expect(transaction.query(sql, inserts)).to.equal(expected, 'actual');
      
      mock.done(done);
      
    });
    
  });
  
  describe('select', function() {
    
    it('should', function () {
      
      var result = transaction.select('*');
      
      Expect(result).to.be.instanceof(Sql.Select,'query');
      
      Expect(result._select).to.equal('*', 'select');
      
    });
    
  });
  
  describe('update', function() {
    
    it('should', function () {
      
      var result = transaction.update('table');
      
      Expect(result).to.be.instanceof(Sql.Update, 'query');
      
      Expect(result._table).to.equal('table', 'table');
      
    });
    
  });
  
  describe('rollback', function() {
    
    it('should call query on connection, then call release on connection and throw exception', function (done) {
      
      var mocked = mock.mock(connection);
      
      mocked.expect('query')
        .with('ROLLBACK')
        .willResolve(true);
        
      mocked.expect('release')
        .willReturn(true);
      
      transaction.rollback(expected)
      .then(function () {
        
        throw new Error('succeeded');
        
      })
      .catch(function (actual) {
        
        Expect(actual).to.equal(expected, 'actual');
        
        mock.done(done);
        
      })
      .catch(done);
      
    });
    
  });
  
});