sqlpostgres 1.2.6 → 1.3.0

data/spec/cursor_spec.rb

@@ -0,0 +1,288 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module SqlPostgres
+
+  describe Cursor do
+
+    CURSOR_DOES_NOT_EXIST = [PG::Error, /cursor.*does not exist/]
+
+    let(:select_statement) do
+      sql = Select.new
+      sql.select('i')
+      sql.from('table1')
+      sql
+    end
+
+    let(:hold) {nil}
+    let(:scroll) {nil}
+
+    def make_cursor
+      cursor = Cursor.new('cursor1',
+                          select_statement,
+                          {
+                            :hold => hold,
+                            :scroll => scroll,
+                          },
+                          connection)
+    end
+
+    def make_cursor_in_transaction
+      cursor = nil
+      Transaction.new(connection) do
+        cursor = make_cursor
+      end
+      cursor
+    end
+
+    let(:cursor) {make_cursor}
+
+    shared_context 'table for cursor test' do |table_name|
+
+      include_context('temporary table',
+                      :table_name => table_name,
+                      :columns => ['i int'])
+
+      before(:each) do
+        5.times do |i|
+          sql = Insert.new(table_name, connection)
+          sql.insert('i', i)
+          sql.exec
+        end
+      end
+
+    end
+
+    shared_context 'table1 for cursor test' do
+      include_context 'table for cursor test', 'table1'
+    end
+
+    shared_context 'table2 for cursor test' do
+      include_context 'table for cursor test', 'table2'
+    end
+
+    describe 'scroll' do
+      
+      include_context 'table1 for cursor test'
+      include_context 'table2 for cursor test'
+
+      let(:select_statement) do
+        sql = Select.new
+        sql.select('i')
+        sql.from('table1')
+        sql.join_using('inner', 'table2', 'i')
+        sql.where('i % 2 = 0')
+        sql
+      end
+
+      shared_examples_for 'is a scroll cursor' do
+        test_connection do |test_connection|
+          let(:connection) {test_connection}
+          specify do
+            Transaction.new(connection) do
+              cursor.fetch.should == [{'i' => 0}]
+              cursor.fetch.should == [{'i' => 2}]
+              cursor.fetch('PRIOR').should == [{'i' => 0}]
+              cursor.fetch('PRIOR').should == []
+            end
+          end
+        end
+      end
+
+      shared_examples_for 'is a no scroll cursor' do
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+          specify do
+            Transaction.new(connection) do
+              expect {
+                cursor.fetch('PRIOR')
+              }.to raise_error PG::Error, /cursor can only scan forward/
+            end
+          end
+        end
+      end
+
+      context '(on)' do
+        let(:scroll) {true}
+        it_behaves_like 'is a scroll cursor'
+      end
+
+      context '(off)' do
+        let(:scroll) {false}
+        it_behaves_like 'is a no scroll cursor'
+      end
+
+      context '(default)' do
+        let(:scroll) {nil}
+        it_behaves_like 'is a no scroll cursor'
+      end
+
+    end
+
+    describe 'hold' do
+      
+      include_context 'table1 for cursor test'
+
+      let(:cursor) {make_cursor_in_transaction}
+
+      shared_examples 'cursor persists after transaction' do
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+          specify do
+            cursor = make_cursor_in_transaction
+            cursor.fetch.should == [{'i' => 0}]
+            cursor.close
+          end
+        end
+      end
+
+      shared_examples_for 'cursor closed when transaction ends' do
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+          specify do
+            cursor = make_cursor_in_transaction
+            expect {
+              cursor.fetch
+            }.to raise_error *CURSOR_DOES_NOT_EXIST
+          end
+        end
+      end
+
+      context '(on)' do
+        let(:hold) {true}
+        it_behaves_like 'cursor persists after transaction'
+      end
+
+      context '(off)' do
+        let(:hold) {false}
+        it_behaves_like 'cursor closed when transaction ends'
+      end
+
+      context '(default)' do
+        let(:hold) {nil}
+        it_behaves_like 'cursor closed when transaction ends'
+      end
+
+    end
+
+    describe '#initialize' do
+
+      context '(taking block)' do
+
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+
+          include_context 'table1 for cursor test', test_connection
+
+          specify do
+            Transaction.new(connection) do
+              Cursor.new('cursor1',
+                         select_statement,
+                         {},
+                         connection) do |cursor|
+                cursor.fetch.should == [{'i' => 0}]
+              end
+            end
+            
+          end
+
+        end
+
+      end
+
+    end
+
+    describe '#close' do
+
+      include_context 'table1 for cursor test'
+
+      test_connections.each do |test_context, test_connection|
+        context test_context do
+          let(:connection) {test_connection}
+
+          it 'cannot be used after being closed' do
+            Transaction.new(connection) do
+              cursor = make_cursor
+              cursor.close
+              expect {
+                cursor.fetch
+              }.to raise_error *CURSOR_DOES_NOT_EXIST
+            end
+          end
+
+        end
+      end
+
+
+    end
+
+    describe '#move' do
+
+      test_connections.each do |test_context, test_connection|
+        context test_context do
+          let(:connection) {test_connection}
+
+          include_context 'table1 for cursor test', test_connection
+
+          specify do
+            Transaction.new(connection) do
+              cursor = make_cursor
+              cursor.move('absolute 2')
+              cursor.fetch.should == [{'i' => 2}]
+            end
+          end
+
+        end
+      end
+
+    end
+
+    describe '#fetch' do
+
+      context '(default)' do
+
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+
+          include_context 'table1 for cursor test', test_connection
+
+          specify do
+            Transaction.new(connection) do
+              cursor.fetch.should == [{'i' => 0}]
+              cursor.fetch.should == [{'i' => 1}]
+              cursor.fetch.should == [{'i' => 2}]
+              cursor.fetch.should == [{'i' => 3}]
+              cursor.fetch.should == [{'i' => 4}]
+              cursor.fetch.should == []
+            end
+          end
+
+        end
+
+      end
+
+      context '(with count)' do
+
+        test_connection do |test_context|
+          let(:connection) {test_connection}
+
+          include_context 'table1 for cursor test', test_connection
+
+          specify do
+            Transaction.new(connection) do
+              cursor = Cursor.new('cursor1', select_statement, {}, connection)
+              cursor.fetch(2).should == [{'i' => 0}, {'i' => 1}]
+              cursor.fetch(2).should == [{'i' => 2}, {'i' => 3}]
+              cursor.fetch(2).should == [{'i' => 4}]
+              cursor.fetch.should == []
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/database_config.rb

@@ -0,0 +1,33 @@
+require 'forwardable'
+
+module TestSupport
+  class DatabaseConfig
+
+    extend Forwardable
+
+    def initialize
+      @config = load_config
+    end
+
+    def_delegator :@config, :map
+
+    private
+
+    PATH = File.expand_path('../config/database.yml',
+                            File.dirname(__FILE__))
+    TEMPLATE_PATH = PATH + '.template'
+
+    def load_config
+      YAML.load_file(PATH)
+    rescue Errno::ENOENT
+      print_config_instructions
+      raise 'Missing database config'
+    end
+
+    def print_config_instructions
+      puts "Missing config at #{PATH}"
+      puts "Please create it by copying and editing #{TEMPLATE_PATH}"
+    end
+
+  end
+end

data/spec/lib/database_server.rb

@@ -0,0 +1,42 @@
+require File.expand_path('postgres_template', File.dirname(__FILE__))
+require File.expand_path('test_database', File.dirname(__FILE__))
+
+module TestSupport
+  class DatabaseServer
+
+    attr_reader :test_databases
+
+    def initialize(name, connection_args, encodings)
+      @server_name = name
+      @encodings = encodings
+      @connection_args = connection_args
+      @template = PostgresTemplate.new(@server_name, connection_args)
+      @test_databases = test_databases
+    end
+
+    def test_connections
+      @test_databases.map(&:test_connections).flatten
+    end
+
+    def drop_databases
+      test_databases.each do |test_database|
+        test_database.drop(@template)
+      end
+    end
+
+    def create_databases
+      test_databases.each do |test_database|
+        test_database.create(@template)
+      end
+    end
+
+    private
+
+    def test_databases
+      @encodings.map do |encoding|
+        TestDatabase.new(@server_name, @connection_args, encoding)
+      end
+    end
+
+  end
+end

data/spec/lib/postgres_template.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../lib/sqlpostgres', File.dirname(__FILE__))
+require File.expand_path('test_database', File.dirname(__FILE__))
+
+module TestSupport
+  class PostgresTemplate
+
+    def initialize(server_name, connection_args)
+      @server_name = server_name
+      @connection_args = connection_args
+      @connection = template_connection
+    end
+
+    def create_database(db_name, database_encoding)
+      return if db_exists?(db_name)
+      puts "Creating database #{qualified_db_name(db_name)}"
+      create_db(db_name, database_encoding)
+    end
+
+    def drop_database(db_name)
+      return unless db_exists?(db_name)
+      unless db_name =~ /^#{TestDatabase::NAME_PREFIX}/
+        raise "Refusing to drop database #{qualified_db_name(db_name)}"
+      end
+      puts "Dropping database #{qualified_db_name(db_name)}"
+      @connection.exec("drop database #{db_name}")
+    end
+
+    private
+
+    def qualified_db_name(db_name)
+      [@server_name, db_name].join('/')
+    end
+
+    def db_exists?(db_name)
+      sql = SqlPostgres::Select.new(@connection)
+      sql.select_literal(1)
+      sql.from('pg_database')
+      sql.where(['datname = %s', db_name])
+      !sql.exec.empty?
+    end
+
+    def create_db(db_name, database_encoding)
+      statement = [
+        'create database', db_name,
+        "with encoding '#{database_encoding}'",
+        'template template0',
+      ].join(' ')
+      @connection.exec(statement)
+    end
+
+    def template_connection
+      SqlPostgres::Connection.new(template_connection_args)
+    end
+
+    def template_connection_args
+      @connection_args.merge(:db_name => 'template1')
+    end
+
+  end
+end

data/spec/lib/target_database_servers.rb

@@ -0,0 +1,55 @@
+require 'memoizer'
+require 'singleton'
+require File.expand_path('database_config', File.dirname(__FILE__))
+require File.expand_path('database_server', File.dirname(__FILE__))
+require File.expand_path('test_config', File.dirname(__FILE__))
+
+module TestSupport
+  class TargetDatabaseServers
+
+    include Memoizer
+    include Singleton
+
+    def test_connections
+      database_servers.map(&:test_connections).flatten.map do |test_connection|
+        [test_connection.context, test_connection.connection]
+      end
+    end
+    memoize :test_connections
+
+    def test_connection
+      test_connections.last
+    end
+
+    def create_databases
+      database_servers.each(&:create_databases)
+    end
+
+    def drop_databases
+      database_servers.each(&:drop_databases)
+    end
+
+    private
+
+    def database_servers
+      database_config.map do |config_name, config|
+        DatabaseServer.new(config_name, config, encodings)
+      end
+    end
+
+    def encodings
+      test_config['encodings']
+    end
+
+    def test_config
+      TestConfig.new
+    end
+    memoize :test_config
+
+    def database_config
+      DatabaseConfig.new
+    end
+    memoize :database_config
+
+  end
+end