pg_helper 0.3.1 → 0.4.0

data/spec/lib/pg_helper_spec.rb

@@ -1,192 +1,238 @@
 require File.expand_path('../../spec_helper', __FILE__)
 include PgHelper
-describe QueryHelper do
+
+require 'pg'
+UNIQUE_TABLE_NAME = "pg_helper_test_#{(rand * 100_000_000).to_i}"
+REAL_PARAMS = { host: 'localhost' }
+RSpec.describe QueryHelper do
+  after(:all) do
+    conn = PGconn.open(REAL_PARAMS)
+    conn.exec("drop table if exists #{UNIQUE_TABLE_NAME} ") { true }
+    conn.finish
+  end
+
   describe 'connection params' do
-    let(:params) {
+    let(:params) do
       {
-        :host => 'my host',
-        :port => 1234,
-        :username => 'my user',
-        :password => 'my password',
-        :dbname => 'my base'
+        host: 'my host',
+        port: 1234,
+        username: 'my user',
+        password: 'my password',
+        dbname: 'my base'
       }
-    }
+    end
 
-    it 'are stored upon initializetion' do
-      PGconn.stub!(:open => true)
-      QueryHelper.new(params).connection_params.should == params
+    it 'are stored upon initialization' do
+      allow(PGconn).to receive(:open).and_return(true)
+      expect(QueryHelper.new(params).connection_params).to eq params
     end
 
     it 'are passed to pgconn' do
-      mock(:conn).tap do |conn|
-        PGconn.should_receive(:open).with(params).and_return(conn)
-        QueryHelper.new(params).pg_connection.should == conn
+      double(:conn).tap do |conn|
+        allow(PGconn).to receive(:open).with(params).and_return(conn)
+        expect(QueryHelper.new(params).pg_connection).to eq conn
       end
     end
   end
 
-  def build_result(params={})
-    mock(:result,
-         {
-           :nfields => 1,
-           :ntuples => 1
-         }.merge(params)
+  def build_result(params = {})
+    double(:result,
+           {
+             nfields: 1,
+             ntuples: 1
+           }.merge(params)
       ).as_null_object
   end
-  
-  def mock_result(params = {}, *args)
-    build_result(params).tap do |result_mock|
+
+  def double_result(params = {}, *args)
+    build_result(params).tap do |result_double|
       if args.empty?
-        pg_helper.pg_connection.should_receive(:exec).and_return(result_mock)
+        allow(pg_helper.pg_connection)
+          .to receive(:exec).and_return(result_double)
       else
-        pg_helper.pg_connection.should_receive(:exec).with(*args).and_return(result_mock)
+        allow(pg_helper.pg_connection)
+          .to receive(:exec).with(*args).and_return(result_double)
       end
     end
   end
 
-  let(:pg_helper) { QueryHelper.new({:dbname => 'postgres', :host => 'localhost'})}
+  def pg_helper
+    @pg_helper ||= QueryHelper.new(REAL_PARAMS)
+  end
 
   describe 'single value' do
     it 'is returned as string' do
-      pg_helper.value('select 1').should == '1'
+      expect(pg_helper.value('select 1')).to eq '1'
     end
 
     it 'raises error if gets non array as params' do
-      lambda {
+      expect do
         pg_helper.value('select 1', 'bar')
-      }.should raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
+      end.to raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
     end
 
     it 'allows to pass params to query' do
       param = ["foo; > 'bar'"]
-      pg_helper.value('select $1::text', param).should == "foo; > 'bar'"
+      expect(pg_helper.value('select $1::text', param)).to eq "foo; > 'bar'"
     end
 
     it 'raises error if more than 1 row returned' do
-      lambda {
+      expect do
         pg_helper.value('select 1, 2')
-      }.should raise_error(PgHelperErrorInvalidColumnCount)
+      end.to raise_error(PgHelperErrorInvalidColumnCount)
     end
 
     it 'raises error if more than 1 row returned' do
-      lambda {
+      expect do
         pg_helper.value('select 1 union select 2')
-      }.should raise_error(PgHelperErrorInvalidRowCount)
+      end.to raise_error(PgHelperErrorInvalidRowCount)
     end
 
     it 'clears pg result on success' do
-      mock_result.should_receive(:clear)
-      pg_helper.value('foo')
+      expect(double_result).to receive(:clear)
+      pg_helper.value('select 1')
     end
 
     it 'clears pg result on failure' do
-      lambda {
-        mock_result({:nfields => 2}).should_receive(:clear)
+      expect(double_result(nfields: 2))
+        .to receive(:clear).and_return(true)
+      expect {
         pg_helper.value('foo')
-      }
+      }.to raise_error
     end
   end
 
   describe 'array of column values' do
     it 'returns values of column as array of stirngs' do
-      pg_helper.get_column( 'select 1 union (select 2 union select 3)').should == ['1','2','3']
+      expect(
+        pg_helper.get_column(
+          'select 1 union (select 2 union select 3)'
+        )
+      ).to eq %w(1 2 3)
     end
 
     it 'raises error if gets non array as params' do
-       lambda {
-         pg_helper.get_column('select 1', 'bar')
-       }.should raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
-     end
+      expect do
+        pg_helper.get_column('select 1', 'bar')
+      end.to raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
+    end
 
-     it 'allows to pass params to query' do
-       param = ['foo', ";'bar'"]
-       pg_helper.get_column('select $1::text as str union select $2::text as str order by str', param).should == [";'bar'", 'foo']
-     end
+    it 'allows to pass params to query' do
+      param = ['foo', ";'bar'"]
+      expect(
+        pg_helper.get_column(
+          'select $1::text as str union select $2::text as str order by str',
+          param
+        )
+      ).to eq [";'bar'", 'foo']
+    end
 
     it 'raises error if more than one column returned' do
-       lambda {
+      expect do
         pg_helper.get_column('select 1, 2')
-      }.should raise_error(PgHelperErrorInvalidColumnCount)
+      end.to raise_error(PgHelperErrorInvalidColumnCount)
     end
 
     it 'clears pg result on success' do
-      mock_result.should_receive(:clear)
+      expect(double_result).to receive(:clear)
       pg_helper.get_column('foo')
     end
 
     it 'clears pg result on failure' do
-      lambda {
-        mock_result({:nfields => 2}).should_receive(:clear)
+      lambda do
+        expect(double_result(nfields: 2)).to receive(:clear)
         pg_helper.get_column('foo')
-      }
+      end
     end
   end
 
   describe 'executing operation' do
-    it 'returns number of rows changed by query' do
-      pg_helper.modify('select 1').should == 0
+    before(:all) do
+      helper = pg_helper
+      helper.modify(<<-SQL)
+        CREATE TABLE IF NOT EXISTS #{UNIQUE_TABLE_NAME}
+        (
+          test_text text
+        )
+      SQL
+      helper.modify(
+        "INSERT INTO #{UNIQUE_TABLE_NAME} (test_text) values ('b')"
+      )
+    end
+
+    it 'returns number of rows inserted' do
+      expect(pg_helper.modify(<<-SQL)).to eq 12
+        INSERT INTO #{UNIQUE_TABLE_NAME} (test_text)
+        select n::text
+        FROM generate_series(1,12,1) as n
+      SQL
+    end
+
+    it 'returns number of rows updated by query' do
+      expect(pg_helper.modify(<<-SQL)).to eq 1
+        UPDATE #{UNIQUE_TABLE_NAME} SET test_text = 'c' where test_text = 'b'
+      SQL
     end
 
     it 'uses cmd_tuples of pg_result internally' do
-      mock(:value).tap do |value|
-        mock_result(:cmd_tuples => value)
-        pg_helper.modify('foo').should == value
+      double(:value).tap do |value|
+        double_result(cmd_tuples: value)
+        expect(pg_helper.modify('foo')).to eq value
       end
     end
 
     it 'raises error if gets non array as params' do
-      lambda {
+      expect do
         pg_helper.modify('select 1', 'bar')
-      }.should raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
+      end.to raise_error(PgHelperErrorParamsMustBeArrayOfStrings)
     end
 
     it 'allows to pass params to query' do
       sql = 'update foo set test_text =  $1::text'
-      mock(:value).tap do |result|
-        mock_result({:cmd_tuples => result}, sql, ['foo'])
-        pg_helper.modify(sql, ["foo"]).should == result
+      double(:value).tap do |result|
+        double_result({ cmd_tuples: result }, sql, ['foo'])
+        expect(pg_helper.modify(sql, ['foo'])).to eq result
       end
     end
 
-
     it 'clears pg result on success' do
-      mock_result.should_receive(:clear)
+      expect(double_result).to receive(:clear)
       pg_helper.modify('foo')
     end
 
     it 'clears pg result on failure' do
-      lambda {
-        mock_result.tap do |result|
-          result.should_receive(:cmd_tuples).and_raise(Exception)
-          result.should_receive(:clear)
+      lambda do
+        double_result.tap do |result|
+          expect(result).to receive(:cmd_tuples).and_raise(Exception)
+          expect(result).to receive(:clear)
         end
         pg_helper.modify('foo')
-      }
+      end
     end
   end
 
   describe 'transaction' do
     it 'raises error if no block given' do
-      lambda { pg_helper.transaction}.should raise_error(ArgumentError)
+      expect { pg_helper.transaction }.to raise_error(ArgumentError)
     end
 
     it 'allows to rollback' do
-      pg_helper.transaction do |t|
-        t.rollback!
-      end
+      pg_helper.transaction(&:rollback!)
     end
 
     it 'does not allow rollback if not in transaction' do
-      lambda {pg_helper.rollback!}.should raise_error(PgHelperErrorInvalidOutsideTransaction)
+      expect { pg_helper.rollback! }
+        .to raise_error(PgHelperErrorInvalidOutsideTransaction)
     end
 
-
     describe 'using temporary table' do
-      let(:test_table_name){'pg_helper_test_'+Time.now.to_i.to_s}
+      def test_table_name
+        @test_table_name ||= 'pg_helper_test_' + Time.now.to_i.to_s
+      end
 
       before(:all) do
         sql = <<SQL
-        CREATE TEMP TABLE #{test_table_name}
+        CREATE TABLE #{test_table_name}
         (
           test_text text
         )
@@ -199,14 +245,22 @@ SQL
       end
 
       it 'will rollback on failure' do
-        lambda {
+        expect do
           pg_helper.transaction do |t|
-            t.modify( "INSERT INTO #{test_table_name} VALUES ('one'), ('two'), ('three')" )
-            t.value("SELECT COUNT(*) FROM #{test_table_name}").should == '3'
-				    raise Exception.new('roll it back')
+            t.modify(
+              "INSERT INTO #{test_table_name} "\
+              "VALUES ('one'), ('two'), ('three')"
+            )
+            expect(
+              t.value("SELECT COUNT(*) FROM #{test_table_name}")
+            ).to eq '3'
+            fail Exception, 'roll it back'
           end
-        }.should raise_error('roll it back')
-        pg_helper.value("SELECT COUNT(*) FROM #{test_table_name}").should == '0'
+        end.to raise_error('roll it back')
+
+        expect(
+          pg_helper.value("SELECT COUNT(*) FROM #{test_table_name}")
+        ).to eq '0'
       end
 
       it 'will commit in the end' do
@@ -214,16 +268,20 @@ SQL
           t.modify("INSERT INTO #{test_table_name} VALUES ('pass')")
           t.modify("INSERT INTO #{test_table_name} VALUES ('correct')")
         end
-        pg_helper.get_column("SELECT test_text FROM #{test_table_name} order by test_text").should == ["correct", "pass"]
+        expect(
+          pg_helper.get_column(
+            "SELECT test_text FROM #{test_table_name} order by test_text"
+          )
+        ).to eq %w(correct pass)
       end
     end
 
     it 'will not allow nested transaction' do
-      lambda {
+      expect do
         pg_helper.transaction do |trans|
-          trans.transaction {nil}
+          trans.transaction { nil }
         end
-      }.should raise_error(PgHelperErrorNestedTransactionNotAllowed)
+      end.to raise_error(PgHelperErrorNestedTransactionNotAllowed)
     end
   end
 end

data/spec/lib/query_builder_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'pg_helper/query_builder.rb'
+
+include PgHelper
+RSpec.describe QueryBuilder do
+  subject { QueryBuilder.new('table_name') }
+
+  describe '#to_sql' do
+
+    it 'builds default' do
+      expect(subject.to_sql).to eq('SELECT * FROM table_name')
+    end
+
+    describe '#select' do
+      it 'for specific column' do
+        expect(
+            subject.select('a').to_sql
+        ).to eq 'SELECT a FROM table_name'
+      end
+
+      it 'for multiple columns' do
+        expect(
+            subject
+            .select('a as foo')
+            .select('b as bar, c')
+            .to_sql
+        ).to eq('SELECT a as foo,b as bar, c FROM table_name')
+      end
+    end
+
+    describe '#where' do
+      it 'using single condition' do
+        expect(
+            subject.where('a = b').to_sql
+        ).to eq('SELECT * FROM table_name WHERE a = b')
+      end
+
+      it 'ands multiple conditions' do
+        expect(
+            subject
+            .where('a = 1')
+            .where('b = 2')
+            .to_sql
+        ).to eq('SELECT * FROM table_name WHERE a = 1 AND b = 2')
+      end
+    end
+
+    describe '#with' do
+      it 'single CTE' do
+        expect(
+            subject
+            .with('foo', 'select bar from foo')
+            .to_sql
+        ).to eq('WITH foo AS (select bar from foo) SELECT * FROM table_name')
+      end
+
+      it 'multiple CTEs' do
+        expect(
+            subject
+            .with('foo', 'select 1')
+            .with('bar', 'select a')
+            .to_sql
+        ).to eq('WITH foo AS (select 1),'\
+                'bar AS (select a) '\
+                'SELECT * FROM table_name')
+      end
+    end
+
+    describe '#join' do
+      it 'can join single table' do
+        expect(
+            subject
+            .join('LEFT JOIN bar on bar.id = table_name.id')
+            .to_sql
+        ).to eq('SELECT * FROM table_name ' \
+                'LEFT JOIN bar on bar.id = table_name.id')
+      end
+
+      it 'can do multiple joins' do
+        expect(
+            subject
+            .join('CROSS JOIN bar')
+            .join('INNER JOIN foo using (buz)')
+            .to_sql
+        ).to eq('SELECT * FROM table_name '\
+          'CROSS JOIN bar ' \
+          'INNER JOIN foo using (buz)')
+      end
+    end
+  end
+end