sequel 4.46.0 → 4.49.0

data/spec/core/connection_pool_spec.rb

@@ -18,6 +18,16 @@ describe "An empty ConnectionPool" do
     @cpool = Sequel::ConnectionPool.get_pool(mock_db.call, CONNECTION_POOL_DEFAULTS)
   end
 
+  deprecated "should support :pool_class option with string" do
+    begin
+      c = Class.new(Sequel::ConnectionPool)
+      Sequel::ConnectionPool::CONNECTION_POOL__MAP[:foo] = c
+      Sequel::ConnectionPool.get_pool(mock_db.call, :pool_class=>:foo).must_be_instance_of c
+    ensure
+      Sequel::ConnectionPool::CONNECTION_POOL__MAP.delete(c)
+    end
+  end
+
   it "should have no available connections" do
     @cpool.available_connections.must_equal []
   end
@@ -26,9 +36,13 @@ describe "An empty ConnectionPool" do
     @cpool.allocated.must_equal({})
   end
 
-  it "should have a created_count of zero" do
+  deprecated "should have a created_count of zero" do
     @cpool.created_count.must_equal 0
   end
+
+  it "should have a size of zero" do
+    @cpool.size.must_equal 0
+  end
 end
 
 describe "ConnectionPool options" do
@@ -54,11 +68,11 @@ describe "A connection pool handling connections" do
     @cpool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){:got_connection}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size))
   end
 
-  it "#hold should increment #created_count" do
+  it "#hold should increment #size" do
     @cpool.hold do
-      @cpool.created_count.must_equal 1
-      @cpool.hold {@cpool.hold {@cpool.created_count.must_equal 1}}
-      Thread.new{@cpool.hold {_(@cpool.created_count).must_equal 2}}.join
+      @cpool.size.must_equal 1
+      @cpool.hold {@cpool.hold {@cpool.size.must_equal 1}}
+      Thread.new{@cpool.hold {_(@cpool.size).must_equal 2}}.join
     end
   end
 
@@ -100,7 +114,7 @@ describe "A connection pool handling connections" do
     q = Queue.new
     50.times{Thread.new{@cpool.hold{q.pop}}}
     50.times{q.push nil}
-    @cpool.created_count.must_be :<=,  @max_size
+    @cpool.size.must_be :<=,  @max_size
   end
 
   it "database's disconnect connection method should be called when a disconnect is detected" do
@@ -110,16 +124,16 @@ describe "A connection pool handling connections" do
   end
 
   it "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
     q, q1 = Queue.new, Queue.new
     @cpool.hold{Thread.new{@cpool.hold{q1.pop; q.push nil}; q1.pop; q.push nil}; q1.push nil; q.pop; q1.push nil; q.pop}
-    @cpool.created_count.must_equal 2
+    @cpool.size.must_equal 2
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 1
+    @cpool.size.must_equal 1
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
   end
 end
 
@@ -127,13 +141,13 @@ describe "A connection pool handling connection errors" do
   it "#hold should raise a Sequel::DatabaseConnectionError if an exception is raised by the connection_proc" do
     cpool = Sequel::ConnectionPool.get_pool(mock_db.call{raise Interrupt}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
-    cpool.created_count.must_equal 0
+    cpool.size.must_equal 0
   end
 
   it "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
     cpool = Sequel::ConnectionPool.get_pool(mock_db.call{nil}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
-    cpool.created_count.must_equal 0
+    cpool.size.must_equal 0
   end
 end
 
@@ -259,6 +273,23 @@ ThreadedConnectionPoolSpecs = shared_description do
     t.join
   end
 
+  it "should work when acquire fails and then succeeds" do
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
+    def pool._acquire(*)
+      if @called
+        super
+      else
+        @called = true
+        nil
+      end
+    end
+    c = nil
+    pool.hold do |c1|
+      c = c1
+    end
+    c.wont_be_nil
+  end
+
   it "should wait until a connection is available if all are checked out" do
     pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0.1, :pool_sleep_time=>0))
     q, q1 = Queue.new, Queue.new
@@ -1083,7 +1114,7 @@ AllConnectionPoolClassesSpecs = shared_description do
   end
 end
 
-Sequel::ConnectionPool::CONNECTION_POOL_MAP.keys.each do |k, v|
+Sequel::ConnectionPool::CONNECTION_POOL__MAP.keys.each do |k, v|
   opts = {:single_threaded=>k, :servers=>(v ? {} : nil)}
   describe "Connection pool with #{opts.inspect}" do
     before(:all) do

data/spec/core/database_spec.rb

@@ -12,6 +12,12 @@ describe "A new Database" do
     end
   end
   
+  deprecated "should support DatasetClass constant" do
+    dbc = Class.new(Sequel::Database)
+    dbc::DatasetClass = dsc = Class.new(Sequel::Dataset)
+    dbc.new.dataset.must_be_kind_of(dsc)
+  end
+
   deprecated "should allow dup/clone" do
     @db.dup.must_be_kind_of @db.class
     @db.clone.must_be_kind_of @db.class
@@ -511,6 +517,130 @@ describe "Database#extend_datasets" do
   end
 end
   
+describe "Database#extend_datasets custom methods" do
+  before do
+    @db = Sequel.mock
+  end
+
+  def ds
+    @db[:items]
+  end
+  
+  it "should have dataset_module support a where method" do
+    @db.extend_datasets{where :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items WHERE released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
+  end
+
+  it "should have dataset_module support a having method" do
+    @db.extend_datasets{having(:released){released}}
+    ds.released.sql.must_equal 'SELECT * FROM items HAVING released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING released'
+  end
+
+  it "should have dataset_module support an exclude method" do
+    @db.extend_datasets{exclude :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items WHERE NOT released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND NOT released)'
+  end
+
+  it "should have dataset_module support an exclude_having method" do
+    @db.extend_datasets{exclude_having :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items HAVING NOT released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING NOT released'
+  end
+
+  it "should have dataset_module support a distinct method" do
+    @db.extend_datasets{def supports_distinct_on?; true end; distinct :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a grep method" do
+    @db.extend_datasets{grep :foo, :baz, 'quux%'}
+    ds.foo.sql.must_equal 'SELECT * FROM items WHERE ((baz LIKE \'quux%\' ESCAPE \'\\\'))'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE (bar AND ((baz LIKE \'quux%\' ESCAPE \'\\\')))'
+  end
+
+  it "should have dataset_module support a group method" do
+    @db.extend_datasets{group :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_and_count method" do
+    @db.extend_datasets{group_and_count :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_append method" do
+    @db.extend_datasets{group_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    ds.group(:bar).foo.sql.must_equal 'SELECT * FROM items GROUP BY bar, baz'
+  end
+
+  it "should have dataset_module support a limit method" do
+    @db.extend_datasets{limit :foo, 1}
+    ds.foo.sql.must_equal 'SELECT * FROM items LIMIT 1'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar LIMIT 1'
+  end
+
+  it "should have dataset_module support a offset method" do
+    @db.extend_datasets{offset :foo, 1}
+    ds.foo.sql.must_equal 'SELECT * FROM items OFFSET 1'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar OFFSET 1'
+  end
+
+  it "should have dataset_module support a order method" do
+    @db.extend_datasets{order(:foo){:baz}}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz'
+  end
+
+  it "should have dataset_module support a order_append method" do
+    @db.extend_datasets{order_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY bar, baz'
+  end
+
+  it "should have dataset_module support a order_prepend method" do
+    @db.extend_datasets{order_prepend :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
+  end
+
+  it "should have dataset_module support a select method" do
+    @db.extend_datasets{select :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_all method" do
+    @db.extend_datasets{select_all :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz.* FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz.* FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_append method" do
+    @db.extend_datasets{select_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT *, baz FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT *, baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_group method" do
+    @db.extend_datasets{select_group :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a server method" do
+    @db.extend_datasets{server :foo, :baz}
+    ds.foo.opts[:server].must_equal :baz
+    ds.where(:bar).foo.opts[:server].must_equal :baz
+  end
+end
+
 describe "Database#disconnect_connection" do
   it "should call close on the connection" do
     o = Object.new
@@ -2251,6 +2381,31 @@ describe "Database#typecast_value" do
     end
   end
 
+  it "should have an underlying exception class available at cause" do
+    begin
+      @db.typecast_value(:date, 'a')
+      true.must_equal false
+    rescue Sequel::InvalidValue => e
+      e.cause.must_be_kind_of(ArgumentError)
+    end
+  end if RUBY_VERSION >= '2.1'
+
+  it "should have an underlying exception class available at cause when using nested exceptions" do
+    begin
+      begin
+        raise ArgumentError
+      rescue => e1
+        begin
+          raise RuntimeError
+        rescue => e2
+          @db.send(:raise_error, e1)
+        end
+      end
+    rescue Sequel::DatabaseError => e
+      e.cause.must_be_kind_of(ArgumentError)
+    end
+  end if RUBY_VERSION >= '2.1'
+
   it "should include underlying exception class in #inspect" do
     begin
       @db.typecast_value(:date, 'a')