sequel 2.2.0 → 2.3.0

data/spec/integration/schema_test.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Database schema parser" do
+  before do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+  end
+
+  specify "should be a hash with table_names as symbols" do
+    schema = INTEGRATION_DB.schema(nil, :reload=>true)
+    schema.should be_a_kind_of(Hash)
+    schema.should include(:items)
+  end
+
+  specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
+    INTEGRATION_DB.schema(nil, :reload=>true)
+    clear_sqls
+    INTEGRATION_DB.schema
+    sqls_should_be
+  end
+
+  specify "should give the same result for a single table regardless of whether schema was called for a single table" do
+    INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
+  end
+
+  specify "should return the schema correctly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    schema = INTEGRATION_DB.schema(:items, :reload=>true)
+    schema.should be_a_kind_of(Array)
+    schema.length.should == 1
+    col = schema.first
+    col.should be_a_kind_of(Array)
+    col.length.should == 2
+    col.first.should == :number
+    col_info = col.last
+    col_info.should be_a_kind_of(Hash)
+    col_info[:type].should == :integer
+    clear_sqls
+    INTEGRATION_DB.schema(:items)
+    sqls_should_be
+  end
+end
+
+describe "Database schema modifiers" do
+  before do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    @ds = INTEGRATION_DB[:items]
+    @ds.insert([10])
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+  end
+
+  specify "should create tables correctly" do
+    INTEGRATION_DB.table_exists?(:items).should == true
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.columns!.should == [:number]
+  end
+
+  specify "should add columns to tables correctly" do
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.columns!.should == [:number]
+    INTEGRATION_DB.alter_table(:items){add_column :name, :text}
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
+    @ds.columns!.should == [:number, :name]
+    unless INTEGRATION_DB.url =~ /sqlite/
+      INTEGRATION_DB.alter_table(:items){add_primary_key :id}
+      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id]
+      @ds.columns!.should == [:number, :name, :id]
+      unless INTEGRATION_DB.url =~ /mysql/
+        INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
+        INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
+        @ds.columns!.should == [:number, :name, :id, :item_id]
+      end
+    end
+  end
+
+  specify "should remove columns from tables correctly" do
+    INTEGRATION_DB.create_table!(:items) do
+      primary_key :id
+      text :name
+      integer :number
+      foreign_key :item_id, :items
+    end
+    @ds.insert(:number=>10)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number, :item_id]
+    @ds.columns!.should == [:id, :name, :number, :item_id]
+    INTEGRATION_DB.drop_column(:items, :number)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :item_id]
+    @ds.columns!.should == [:id, :name, :item_id]
+    INTEGRATION_DB.drop_column(:items, :name)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    INTEGRATION_DB.drop_column(:items, :item_id)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+  end
+end

data/spec/integration/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel'
+end
+require File.join(File.dirname(__FILE__), '../spec_config.rb')
+
+$sqls = []
+def clear_sqls
+  $sqls.clear
+end 
+
+if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRATION_URL']
+  unless defined?(INTEGRATION_DB)
+    url = defined?(INTEGRATION_URL) ? INTEGRATION_URL : ENV['SEQUEL_INTEGRATION_URL']
+    INTEGRATION_DB = Sequel.connect(url)
+  end
+  class Spec::Example::ExampleGroup
+    def sqls_should_be(*args)
+    end 
+  end
+else
+  sql_logger = Object.new
+  def sql_logger.info(str)
+    $sqls << str 
+  end
+  INTEGRATION_DB = Sequel.sqlite('', :loggers=>[sql_logger], :quote_identifiers=>false)
+  class Spec::Example::ExampleGroup
+    def sqls_should_be(*sqls)
+      sqls.zip($sqls).each do |should_be, is|
+        case should_be
+        when String
+          is.should == should_be
+        when Regexp
+          is.should =~ should_be
+        else
+          raise ArgumentError, "need String or RegExp"
+        end
+      end
+      $sqls.length.should == sqls.length
+      clear_sqls
+    end 
+  end
+end

data/spec/integration/type_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Supported types" do
+  def create_items_table_with_column(name, type)
+    INTEGRATION_DB.create_table!(:items){column name, type}
+    INTEGRATION_DB[:items]
+  end
+
+  specify "should support NULL correctly" do
+    ds = create_items_table_with_column(:number, :integer)
+    ds.insert(:number => nil)
+    ds.all.should == [{:number=>nil}]
+  end
+
+  specify "should support integer type" do
+    ds = create_items_table_with_column(:number, :integer)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+
+  specify "should support varchar type" do
+    ds = create_items_table_with_column(:name, 'varchar(255)'.lit)
+    ds.insert(:name => 'Test User')
+    ds.all.should == [{:name=>'Test User'}]
+  end
+  
+  specify "should support date type" do
+    ds = create_items_table_with_column(:dat, :date)
+    d = Date.today
+    ds.insert(:dat => d)
+    x = ds.first[:dat]
+    x = x.iso8601.to_date if Time === x
+    x.to_s.should == d.to_s
+  end
+  
+  specify "should support time type" do
+    ds = create_items_table_with_column(:tim, :time)
+    t = Time.now
+    ds.insert(:tim => t)
+    x = ds.first[:tim]
+    [t.strftime('%H:%M:%S'), t.iso8601].should include(x.respond_to?(:strftime) ? x.strftime('%H:%M:%S') : x.to_s)
+  end
+end

data/spec/rcov.opts

@@ -2,3 +2,5 @@
 gems
 --exclude
 spec
+--exclude
+00*

data/spec/sequel_core/connection_pool_spec.rb

@@ -0,0 +1,363 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001,
+  :pool_reuse_connections=>:allow, :pool_convert_exceptions=>true, :max_connections=>4}
+
+context "An empty ConnectionPool" do
+  setup do
+    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
+  end
+
+  specify "should have no available connections" do
+    @cpool.available_connections.should == []
+  end
+
+  specify "should have no allocated connections" do
+    @cpool.allocated.should == {}
+  end
+
+  specify "should have a created_count of zero" do
+    @cpool.created_count.should == 0
+  end
+end
+
+context "A connection pool handling connections" do
+  setup do
+    @max_size = 2
+    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size)) {:got_connection}
+  end
+
+  specify "#hold should increment #created_count" do
+    @cpool.hold do
+      @cpool.created_count.should == 1
+      @cpool.hold {@cpool.hold {@cpool.created_count.should == 1}}
+      Thread.new{@cpool.hold {@cpool.created_count.should == 2}}.join
+    end
+  end
+
+  specify "#hold should add the connection to the #allocated array" do
+    @cpool.hold do
+      @cpool.allocated.size.should == 1
+  
+      @cpool.allocated.should == {Thread.current=>:got_connection}
+    end
+  end
+
+  specify "#hold should yield a new connection" do
+    @cpool.hold {|conn| conn.should == :got_connection}
+  end
+
+  specify "a connection should be de-allocated after it has been used in #hold" do
+    @cpool.hold {}
+    @cpool.allocated.size.should == 0
+  end
+
+  specify "#hold should return the value of its block" do
+    @cpool.hold {:block_return}.should == :block_return
+  end
+
+  specify "#make_new should not make more than max_size connections" do
+    @cpool.send(:make_new).should == :got_connection
+    @cpool.send(:make_new).should == :got_connection
+    @cpool.send(:make_new).should == nil
+    @cpool.created_count.should == 2
+  end
+end
+
+class DummyConnection
+  @@value = 0
+  def initialize
+    @@value += 1
+  end
+  
+  def value
+    @@value
+  end
+end
+
+context "ConnectionPool#hold" do
+  setup do
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
+  end
+  
+  specify "should pass the result of the connection maker proc to the supplied block" do
+    res = nil
+    @pool.hold {|c| res = c}
+    res.should be_a_kind_of(DummyConnection)
+    res.value.should == 1
+    @pool.hold {|c| res = c}
+    res.should be_a_kind_of(DummyConnection)
+    res.value.should == 1 # the connection maker is invoked only once
+  end
+  
+  specify "should be re-entrant by the same thread" do
+    cc = nil
+    @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
+    cc.should be_a_kind_of(DummyConnection)
+  end
+  
+  specify "should catch exceptions and reraise them" do
+    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
+  end
+  
+  specify "should handle Exception errors (normally not caught by rescue)" do
+    err = nil
+    begin
+      @pool.hold {raise Exception}
+    rescue => e
+      err = e
+    end
+    err.should be_a_kind_of(RuntimeError)
+  end
+end
+
+context "ConnectionPool#connection_proc" do
+  setup do
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
+  end
+  
+  specify "should be nil if no block is supplied to the pool" do
+    @pool.connection_proc.should be_nil
+    proc {@pool.hold {}}.should raise_error
+  end
+  
+  specify "should be mutable" do
+    @pool.connection_proc = proc {'herro'}
+    res = nil
+    proc {@pool.hold {|c| res = c}}.should_not raise_error
+    res.should == 'herro'
+  end
+end
+
+context "A connection pool with a max size of 1" do
+  setup do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1)) {@invoked_count += 1; 'herro'}
+  end
+  
+  specify "should let only one thread access the connection at any time" do
+    cc,c1, c2 = nil
+    
+    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
+    sleep 0.2
+    cc.should == 'herro'
+    c1.should == 'herro'
+    
+    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
+    sleep 0.2
+    
+    # connection held by t1
+    t1.should be_alive
+    t2.should be_alive
+    
+    cc.should == 'herro'
+    c1.should == 'herro'
+    c2.should be_nil
+    
+    @pool.available_connections.should be_empty
+    @pool.allocated.should == {t1=>cc}
+    
+    cc.gsub!('rr', 'll')
+    sleep 0.5
+    
+    # connection held by t2
+    t1.should_not be_alive
+    t2.should be_alive
+
+    c2.should == 'hello'
+
+    @pool.available_connections.should be_empty
+    @pool.allocated.should == {t2=>cc}
+    
+    cc.gsub!('ll', 'rr')
+    sleep 0.5
+    
+    #connection released
+    t2.should_not be_alive
+    
+    cc.should == 'herro'
+    
+    @invoked_count.should == 1
+    @pool.size.should == 1
+    @pool.available_connections.should == [cc]
+    @pool.allocated.should be_empty
+  end
+  
+  specify "should let the same thread reenter #hold" do
+    c1, c2, c3 = nil
+    @pool.hold do |c|
+      c1 = c
+      @pool.hold do |c|
+        c2 = c
+        @pool.hold do |c|
+          c3 = c
+        end
+      end
+    end
+    c1.should == 'herro'
+    c2.should == 'herro'
+    c3.should == 'herro'
+    
+    @invoked_count.should == 1
+    @pool.size.should == 1
+    @pool.available_connections.size.should == 1
+    @pool.allocated.should be_empty
+  end
+end
+
+context "A connection pool with a max size of 5" do
+  setup do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
+  end
+  
+  specify "should let five threads simultaneously access separate connections" do
+    cc = {}
+    threads = []
+    stop = nil
+    
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
+    sleep 0.2
+    threads.each {|t| t.should be_alive}
+    cc.size.should == 5
+    @invoked_count.should == 5
+    @pool.size.should == 5
+    @pool.available_connections.should be_empty
+    i = 0
+    h = {}
+    threads.each{|t| h[t] = (i+=1)}
+    @pool.allocated.should == h
+    
+    threads[0].raise "your'e dead"
+    sleep 0.1
+    threads[3].raise "your'e dead too"
+    
+    sleep 0.1
+    
+    @pool.available_connections.should == [1, 4]
+    @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
+    
+    stop = true
+    sleep 0.2
+    
+    @pool.available_connections.size.should == 5
+    @pool.allocated.should be_empty
+  end
+  
+  specify "should block threads until a connection becomes available" do
+    cc = {}
+    threads = []
+    stop = nil
+    
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
+    sleep 0.2
+    threads.each {|t| t.should be_alive}
+    @pool.available_connections.should be_empty
+
+    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
+    
+    sleep 0.2
+    threads[5].should be_alive
+    threads[6].should be_alive
+    threads[7].should be_alive
+    cc.size.should == 5
+    cc[5].should be_nil
+    cc[6].should be_nil
+    cc[7].should be_nil
+    
+    stop = true
+    sleep 0.3
+    
+    threads.each {|t| t.should_not be_alive}
+    
+    @pool.size.should == 5
+    @invoked_count.should == 5
+    @pool.available_connections.size.should == 5
+    @pool.allocated.should be_empty
+  end
+end
+
+context "ConnectionPool#disconnect" do
+  setup do
+    @count = 0
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {{:id => @count += 1}}
+  end
+  
+  specify "should invoke the given block for each available connection" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    @pool.available_connections.size.should == 5
+    @pool.available_connections.each {|c| c[:id].should_not be_nil}
+    conns = []
+    @pool.disconnect {|c| conns << c}
+    conns.size.should == 5
+  end
+  
+  specify "should remove all available connections" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    @pool.disconnect
+    @pool.size.should == 0
+  end
+
+  specify "should not touch connections in use" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    
+    @pool.hold do |conn|
+      @pool.available_connections.size.should == 4
+      @pool.available_connections.each {|c| c.should_not be(conn)}
+      conns = []
+      @pool.disconnect {|c| conns << c}
+      conns.size.should == 4
+    end
+    @pool.size.should == 1
+  end
+end
+
+context "SingleThreadedPool" do
+  setup do
+    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS){1234}
+  end
+  
+  specify "should provide a #hold method" do
+    conn = nil
+    @pool.hold {|c| conn = c}
+    conn.should == 1234
+  end
+  
+  specify "should provide a #disconnect method" do
+    @pool.hold {|c|}
+    @pool.conn.should == 1234
+    conn = nil
+    @pool.disconnect {|c| conn = c}
+    conn.should == 1234
+    @pool.conn.should be_nil
+  end
+end