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

node.js lambda framework

var Expect = require('chai').expect;

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

describe('pg sql', function () {
  'use strict';
  
  describe('Delete', function() {
    
    it('should with where object', function () {
      
      var del = new Sql.Delete(), 
        inserts = [], result;
      
      del.from('table')
      .where({
        key: 'value'
      })
      .limit(1)
      .offset(10);
      
      result = del.build(inserts);
      
      Expect(result).to.equal('DELETE FROM "table" WHERE "key" = $1 LIMIT $2 OFFSET $3', 'sql');
      Expect(inserts).to.deep.equal([
        'value',
        1,
        10
      ], 'inserts');
      
    });
    
    it('should without where clause', function () {
      
      var del = new Sql.Delete(), 
        inserts = [], result;
      
      del.from('table');
      
      result = del.build(inserts);
      
      Expect(result).to.equal('DELETE FROM "table"', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
  });
  
  describe('Insert', function() {
    
    it('should with column names from row', function () {
      
      var insert = new Sql.Insert(),
        inserts = [], result;
      
      insert.into('table')
      .insert({
        key: 'value'
      });
      
      result = insert.build(inserts);
      
      Expect(result).to.equal('INSERT INTO "table" ("key") VALUES ($1)', 'sql');
      Expect(inserts).to.deep.equal([
        'value'
      ], 'inserts');
      
    });
    
    it('should with column names from rows', function () {
      
      var insert = new Sql.Insert(),
        inserts = [], result;
      
      insert.into('table')
      .insert([
        {
          key: 'value',
          key2: 'value2'
        },
        {
          key: 'value2',
          key2: 'value4'
        }
      ]);
      
      result = insert.build(inserts);
      
      Expect(result).to.equal('INSERT INTO "table" ("key","key2") VALUES ($1,$2),($3,$4)', 'sql');
      Expect(inserts).to.deep.equal([
        'value',
        'value2',
        'value2',
        'value4'
      ], 'inserts');
      
    });
    
    it('should with no data', function () {
      
      var insert = new Sql.Insert(), inserts = [], result;
      
      insert.into('table');
      
      result = insert.build(inserts);
      
      Expect(result).to.equal('INSERT INTO "table" () VALUES ', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
  });
  
  describe('Query', function() {
    
    describe('_buildWhere', function() {
      
      it('should do nothing if this._where is undefined', function () {
        
        var query = new Sql.Query();
        
        var inserts = [];
        
        var result = query._buildWhere(inserts);
        
        Expect(result).to.equal('', 'empty where');
        
        Expect(inserts).to.deep.equal([], 'inserts');
        
      });
      
      it('should append this._where when its a string', function () {
        
        var query = new Sql.Query();
        
        var inserts = [];
        
        query.where('append');
        
        var result = query._buildWhere(inserts);
        
        Expect(result).to.equal(' WHERE append', 'result');
        Expect(inserts).to.deep.equal([], 'inserts');
        
      });
      
      it('should loop through this._where when its an array of strings', function () {
        
        var query = new Sql.Query();
        
        var inserts = [];
        
        query.where([
          'string 1',
          'string 2'
        ]);
        
        var result = query._buildWhere(inserts);
        
        Expect(result).to.equal(' WHERE string 1 AND string 2', 'result');
        Expect(inserts).to.deep.equal([], 'inserts');
        
      });
      
      it('should loop through this._where when its an array of objects', function () {
        
        var inserts = [], query = new Sql.Query();
        
        query.where([
          {
            comparator: '>',
            key: 'key',
            value: 'value'
          },
          {
            key: 'key1',
            value: 'value1'
          }
        ]);
        
        var result = query._buildWhere(inserts);
        
        Expect(result).to.equal(' WHERE "key" > $1 AND "key1" = $2', 'result');
        Expect(inserts).to.deep.equal([
          'value',
          'value1'
        ], 'inserts');
        
      });
      
      it('should loop through keys when this._where is object of objects', function() {
        
        var inserts = [], query = new Sql.Query();
        
        query.where({
          key: {
            comparator: '>',
            value: 'value'
          },
          key1: {
            value: 'value2'
          }
        });
        
        var result = query._buildWhere(inserts);
        
        Expect(result).to.equal(' WHERE "key" > $1 AND "key1" = $2', 'sql');
        Expect(inserts).to.deep.equal([
          'value',
          'value2'
        ], 'inserts');
          
      });
        
    });
    
  });
  
  describe('Select', function() {
    
    it('should create an sql select statement and build where clause from an object', function () {
      
      var inserts = [], 
        select = new Sql.Select(), result;
      
      select.from('table')
      .where({
        key: 'value'
      });
      
      result = select.build(inserts);
      
      Expect(result).to.equal('SELECT * FROM "table" WHERE "key" = $1', 'sql');
      Expect(inserts).to.deep.equal([
        'value'
      ], 'inserts');
      
    });
    
    it('should create an sql select statement without where clause', function () {
      
      var select = new Sql.Select(), result;
      
      var inserts = [];
      
      select.from('table');
      
      result = select.build(inserts);
      
      Expect(result).to.equal('SELECT * FROM "table"', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
    it('should create an sql select statement and build columns from an array', function () {
      
      var select = new Sql.Select(), result;
      
      var inserts = [];
      
      select.from('table')
        .select([
          'id',
          'key'
        ]);
      
      result = select.build(inserts);
      
      Expect(result).to.equal('SELECT "id","key" FROM "table"', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
    it('should create an sql select statement and build columns from an object', function () {
      
      var select = new Sql.Select(), result;
      
      var inserts = [];
      
      select.from('table')
        .select({
          id: 'test',
          key: 'test2'
        });
      
      result = select.build(inserts);
      
      Expect(result).to.equal('SELECT "test" AS "id","test2" AS "key" FROM "table"', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
    it('should create an sql select statement with for FOR UPDATE at the end', function () {
      
      var select = new Sql.Select(), result;
      
      var inserts = [];
      
      select.from('table')
        .select({
          id: 'test',
          key: 'test2'
        })
        .forUpdate(true);
      
      result = select.build(inserts);
      
      Expect(result).to.equal('SELECT "test" AS "id","test2" AS "key" FROM "table" FOR UPDATE', 'sql');
      Expect(inserts).to.deep.equal([], 'inserts');
      
    });
    
  });
  
  describe('Update', function() {
    
    it('should create an sql update statement and build set clause from object and where clause from an object', function () {
      
      var query = new Sql.Update(), result;
      
      var inserts = [];
      
      query.update('table')
        .set({
          key1: 'value1',
          key2: 'value2'
        })
        .where({
          key: 'value'
        });
      
      result = query.build(inserts);
      
      Expect(result).to.equal('UPDATE "table" SET "key1" = $1,"key2" = $2 WHERE "key" = $3', 'sql');
      Expect(inserts).to.deep.equal([
        'value1',
        'value2',
        'value'
      ], 'inserts');
      
    });
    
    it('should create an sql update statement and build set clause from string and where clause from an object', function () {
      
      var query = new Sql.Update(), result;
      
      var inserts = [];
      
      query.update('table')
        .set('"key2" = \'value2\'')
        .where({
          key: 'value'
        });
      
      result = query.build(inserts);
      
      Expect(result).to.equal('UPDATE "table" SET "key2" = \'value2\' WHERE "key" = $1', 'sql');
      Expect(inserts).to.deep.equal([
        'value'
      ], 'inserts');
      
    });
    
    it('should create an sql update statement without where clause', function () {
      
      var query = new Sql.Update(), result;
      
      var inserts = [];
      
      query.update('table')
        .set({
          key1: 'value1',
          key2: 'value2'
        });
      
      result = query.build(inserts);
      
      Expect(result).to.equal('UPDATE "table" SET "key1" = $1,"key2" = $2', 'sql');
      Expect(inserts).to.deep.equal([
        'value1',
        'value2'
      ], 'inserts');
      
    });
    
  });
  
});