sequel_core 1.0

data/spec/connection_pool_spec.rb

@@ -0,0 +1,356 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "An empty ConnectionPool" do
+  setup do
+    @cpool = Sequel::ConnectionPool.new
+  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(@max_size) {:got_connection}
+  end
+
+  specify "#hold should increment #created_count" do
+    @cpool.hold do
+      @cpool.created_count.should == 1
+      @cpool.hold {@cpool.created_count.should == 1}
+    end
+  end
+
+  specify "#hold should add the connection to the #allocated hash" do
+    @cpool.hold do
+      @cpool.allocated.size.should == 1
+  
+      @cpool.allocated.values.should == [: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 {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 be rescue)" do
+    begin
+      @pool.hold {raise Exception}
+    rescue => e
+      e.should be_a_kind_of(RuntimeError)
+    end
+  end
+end
+
+context "ConnectionPool#connection_proc" do
+  setup do
+    @pool = Sequel::ConnectionPool.new
+  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(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(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
+    @pool.allocated.should == {threads[0] => 1, threads[1] => 2, threads[2] => 3,
+      threads[3] => 4, threads[4] => 5}
+    
+    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(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 {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

data/spec/core_ext_spec.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Enumerable#send_each" do
+  specify "should send the supplied method to each item" do
+    a = ['abbc', 'bbccdd', 'hebtre']
+    a.send_each(:gsub!, 'b', '_')
+    a.should == ['a__c', '__ccdd', 'he_tre']
+  end
+end
+
+context "Range#interval" do
+  specify "should return the interval between the beginning and end of the range" do
+    (1..10).interval.should == 9
+    
+    r = rand(100000) + 10
+    t1 = Time.now; t2 = t1 + r
+    (t1..t2).interval.should == r
+  end
+end
+
+context "Numeric extensions" do
+  setup do
+    Sequel::NumericExtensions.enable
+  end
+  
+  specify "should support conversion of minutes to seconds" do
+    1.minute.should == 60
+    3.minutes.should == 180
+  end
+  
+  specify "should support conversion of hours to seconds" do
+    1.hour.should == 3600
+    3.hours.should == 3600 * 3
+  end
+
+  specify "should support conversion of days to seconds" do
+    1.day.should == 86400
+    3.days.should == 86400 * 3
+  end
+
+  specify "should support conversion of weeks to seconds" do
+    1.week.should == 86400 * 7
+    3.weeks.should == 86400 * 7 * 3
+  end
+  
+  specify "should provide #ago functionality" do
+    t1 = Time.now
+    t2 = 1.day.ago
+    t1.should > t2
+    ((t1 - t2).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.before(t1)
+    t2.should == t1 - 1.day
+  end
+
+  specify "should provide #from_now functionality" do
+    t1 = Time.now
+    t2 = 1.day.from_now
+    t1.should < t2
+    ((t2 - t1).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.since(t1)
+    t2.should == t1 + 1.day
+  end
+end

data/spec/core_sql_spec.rb

@@ -0,0 +1,301 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Array#to_sql" do
+  specify "should concatenate multiple lines into a single string" do
+    "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
+      should == 'SELECT * FROM items WHERE a = 1'
+  end
+  
+  specify "should remove superfluous white space and line breaks" do
+    "\tSELECT * \n FROM items    ".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove ANSI SQL comments" do
+    "SELECT *   --comment\r\n  FROM items\r\n  --comment".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove C-style comments" do
+    "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+end
+
+context "String#to_sql" do
+  specify "should concatenate multiple lines into a single string" do
+    "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \
+      should == 'SELECT * FROM items WHERE a = 1'
+  end
+  
+  specify "should remove superfluous white space and line breaks" do
+    "\tSELECT * \r\n FROM items    ".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove ANSI SQL comments" do
+    "SELECT *   --comment \r\n FROM items\r\n  --comment".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove C-style comments" do
+    "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+end
+
+context "String#lit" do
+  specify "should return an LiteralString object" do
+    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
+    'xyz'.lit.to_s.should == 'xyz'
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".lit).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
+end
+
+context "String#expr" do
+  specify "should return an LiteralString object" do
+    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
+    'xyz'.expr.to_s.should == 'xyz'
+  end
+
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".expr).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
+end
+
+context "String#split_sql" do
+  specify "should split a string containing multiple statements" do
+    "DROP TABLE a; DROP TABLE c".split_sql.should == \
+      ['DROP TABLE a', 'DROP TABLE c']
+  end
+  
+  specify "should remove comments from the string" do
+    "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \
+      ['DROP TABLE a', 'DROP TABLE d']
+  end
+end
+
+context "#DESC/#desc" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a DESC clause for a column ref" do
+    :test.DESC.to_s(@ds).should == 'test DESC'
+    :test.desc.to_s(@ds).should == 'test DESC'
+    
+    :items__price.DESC.to_s(@ds).should == 'items.price DESC'
+    :items__price.desc.to_s(@ds).should == 'items.price DESC'
+  end
+
+  specify "should format a DESC clause for a function" do
+    :avg[:test].DESC.to_s(@ds).should == 'avg(test) DESC'
+    :avg[:test].desc.to_s(@ds).should == 'avg(test) DESC'
+  end
+  
+  specify "should format a DESC clause for a literal value" do
+    1.DESC.to_s(@ds).should == '1 DESC'
+    'abc'.desc.to_s(@ds).should == "'abc' DESC"
+  end
+end
+
+context "#ASC/#asc" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a ASC clause for a column ref" do
+    :test.ASC.to_s(@ds).should == 'test ASC'
+    :test.asc.to_s(@ds).should == 'test ASC'
+    
+    :items__price.ASC.to_s(@ds).should == 'items.price ASC'
+    :items__price.asc.to_s(@ds).should == 'items.price ASC'
+  end
+
+  specify "should format a ASC clause for a function" do
+    :avg[:test].ASC.to_s(@ds).should == 'avg(test) ASC'
+    :avg[:test].asc.to_s(@ds).should == 'avg(test) ASC'
+  end
+  
+  specify "should format a ASC clause for a literal value" do
+    1.ASC.to_s(@ds).should == '1 ASC'
+    'abc'.asc.to_s(@ds).should == "'abc' ASC"
+  end
+end
+
+context "#AS/#as" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a AS clause for a column ref" do
+    :test.AS(:t).to_s(@ds).should == 'test AS t'
+    :test.as(:t).to_s(@ds).should == 'test AS t'
+    
+    :items__price.AS(:p).to_s(@ds).should == 'items.price AS p'
+    :items__price.as(:p).to_s(@ds).should == 'items.price AS p'
+  end
+
+  specify "should format a AS clause for a function" do
+    :avg[:test].AS(:avg).to_s(@ds).should == 'avg(test) AS avg'
+    :avg[:test].as(:avg).to_s(@ds).should == 'avg(test) AS avg'
+  end
+  
+  specify "should format a AS clause for a literal value" do
+    1.AS(:one).to_s(@ds).should == '1 AS one'
+    'abc'.as(:abc).to_s(@ds).should == "'abc' AS abc"
+  end
+end
+
+context "Column references" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def quote_column_ref(c); "`#{c}`"; end
+    end
+    @ds = @c.new(nil)
+  end
+  
+  specify "should be quoted properly" do
+    @ds.literal(:xyz).should == "`xyz`"
+    @ds.literal(:xyz__abc).should == "xyz.`abc`"
+
+    @ds.literal(:xyz.as(:x)).should == "`xyz` AS `x`"
+    @ds.literal(:xyz__abc.as(:x)).should == "xyz.`abc` AS `x`"
+
+    @ds.literal(:xyz___x).should == "`xyz` AS `x`"
+    @ds.literal(:xyz__abc___x).should == "xyz.`abc` AS `x`"
+  end
+  
+  specify "should be quoted properly in SQL functions" do
+    @ds.literal(:avg[:xyz]).should == "avg(`xyz`)"
+    @ds.literal(:avg[:xyz, 1]).should == "avg(`xyz`, 1)"
+    @ds.literal(:avg[:xyz].as(:a)).should == "avg(`xyz`) AS `a`"
+  end
+
+  specify "should be quoted properly in ASC/DESC clauses" do
+    @ds.literal(:xyz.ASC).should == "`xyz` ASC"
+    @ds.literal(:avg[:xyz, 1].desc).should == "avg(`xyz`, 1) DESC"
+  end
+  
+  specify "should be quoted properly in a cast function" do
+    @ds.literal(:x.cast_as(:integer)).should == "cast(`x` AS integer)"
+    @ds.literal(:x__y.cast_as(:varchar[20])).should == "cast(x.`y` AS varchar(20))"
+  end
+end
+
+context "Symbol#ALL/#all" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a qualified wildcard" do
+    :xyz.ALL.to_s(@ds).should == 'xyz.*'
+    :abc.all.to_s(@ds).should == 'abc.*'
+  end
+end
+
+context "Symbol#to_column_ref" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should convert qualified symbol notation into dot notation" do
+    :abc__def.to_column_ref(@ds).should == 'abc.def'
+  end
+  
+  specify "should convert AS symbol notation into SQL AS notation" do
+    :xyz___x.to_column_ref(@ds).should == 'xyz AS x'
+    :abc__def___x.to_column_ref(@ds).should == 'abc.def AS x'
+  end
+  
+  specify "should support names with digits" do
+    :abc2.to_column_ref(@ds).should == 'abc2'
+    :xx__yy3.to_column_ref(@ds).should == 'xx.yy3'
+    :ab34__temp3_4ax.to_column_ref(@ds).should == 'ab34.temp3_4ax'
+    :x1___y2.to_column_ref(@ds).should == 'x1 AS y2'
+    :abc2__def3___ggg4.to_column_ref(@ds).should == 'abc2.def3 AS ggg4'
+  end
+  
+  specify "should support upper case and lower case" do
+    :ABC.to_column_ref(@ds).should == 'ABC'
+    :Zvashtoy__aBcD.to_column_ref(@ds).should == 'Zvashtoy.aBcD'
+  end
+end
+
+context "Symbol" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should support MIN for specifying min function" do
+    :abc__def.MIN.to_s(@ds).should == 'min(abc.def)'
+  end
+
+  specify "should support MAX for specifying max function" do
+    :abc__def.MAX.to_s(@ds).should == 'max(abc.def)'
+  end
+
+  specify "should support SUM for specifying sum function" do
+    :abc__def.SUM.to_s(@ds).should == 'sum(abc.def)'
+  end
+
+  specify "should support AVG for specifying avg function" do
+    :abc__def.AVG.to_s(@ds).should == 'avg(abc.def)'
+  end
+  
+  specify "should support COUNT for specifying count function" do
+    :abc__def.COUNT.to_s(@ds).should == 'count(abc.def)'
+  end
+  
+  specify "should support any other function using upper case letters" do
+    :abc__def.DADA.to_s(@ds).should == 'dada(abc.def)'
+  end
+  
+  specify "should support upper case outer functions" do
+    :COUNT['1'].to_s(@ds).should == "COUNT('1')"
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    ds.select(:COUNT['1']).sql.should == "SELECT COUNT('1') FROM t"
+  end
+  
+  specify "should support cast function" do
+    :abc.cast_as(:integer).to_s(@ds).should == "cast(abc AS integer)"
+  end
+  
+  specify "should raise NoMethodError for non-uppercase invalid methods" do
+    proc {:abc.dfaxs}.should raise_error(NoMethodError)
+  end
+  
+  specify "should support subscript access using | operator" do
+    (:abc|1).to_s(@ds).should == 'abc[1]'
+    (:abc|[1]).to_s(@ds).should == 'abc[1]'
+    (:abc|[1, 2]).to_s(@ds).should == 'abc[1, 2]'
+    (:abc|1|2).to_s(@ds).should == 'abc[1, 2]'
+  end
+end
+
+context "String#to_time" do
+  specify "should convert the string into a Time object" do
+    "2007-07-11".to_time.should == Time.parse("2007-07-11")
+    "06:30".to_time.should == Time.parse("06:30")
+  end
+  
+  specify "should raise Error::InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_time}.should raise_error(Sequel::Error::InvalidValue)
+  end
+end
+